#
# Copyright 1995-2008 Sun Microsystems, Inc.  All Rights Reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License version 2 only, as
# published by the Free Software Foundation.  Sun designates this
# particular file as subject to the "Classpath" exception as provided
# by Sun in the LICENSE file that accompanied this code.
#
# This code is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
# version 2 for more details (a copy is included in the LICENSE file that
# accompanied this code).
#
# You should have received a copy of the GNU General Public License version
# 2 along with this work; if not, write to the Free Software Foundation,
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
# CA 95054 USA or visit www.sun.com if you need additional information or
# have any questions.
#

#
# Makefile to specify compiler flags for programs and libraries
# targeted to Solaris.  Should not contain any rules.
#
# WARNING: This file is shared with other workspaces. 
#          So when it includes other files, it must use JDK_TOPDIR.
#

# Warning: the following variables are overridden by Defs.gmk. Set
# values will be silently ignored:
#   CFLAGS        (set $(OTHER_CFLAGS) instead)
#   CPPFLAGS      (set $(OTHER_CPPFLAGS) instead)
#   CXXFLAGS      (set $(OTHER_CXXFLAGS) instead)
#   LDFLAGS       (set $(OTHER_LDFAGS) instead)
#   LDLIBS        (set $(EXTRA_LIBS) instead)
#   LDLIBS_COMMON (set $(EXTRA_LIBS) instead)
#   LINTFLAGS     (set $(OTHER_LINTFLAGS) instead)
#
# Note: CPPFLAGS are used in C and C++ compiles.
#

# Get shared JDK settings
include $(JDK_MAKE_SHARED_DIR)/Defs.gmk

ifndef PLATFORM_SRC
PLATFORM_SRC = $(BUILDDIR)/../src/solaris
endif # PLATFORM_SRC

# Platform specific closed sources
ifndef OPENJDK
  ifndef CLOSED_PLATFORM_SRC
    CLOSED_PLATFORM_SRC = $(BUILDDIR)/../src/closed/solaris
  endif
endif

# platform specific include files
PLATFORM_INCLUDE_NAME = $(PLATFORM)
PLATFORM_INCLUDE      = $(INCLUDEDIR)/$(PLATFORM_INCLUDE_NAME)

# suffix used for make dependencies files
DEPEND_SUFFIX = d
# suffix used for lint files
LINT_SUFFIX = ln
# The suffix applied to the library name for FDLIBM
FDDLIBM_SUFFIX = a
# The suffix applied to scripts (.bat for windows, nothing for unix)
SCRIPT_SUFFIX =
# CC compiler object code output directive flag value
CC_OBJECT_OUTPUT_FLAG = -o #trailing blank required!
CC_PROGRAM_OUTPUT_FLAG = -o #trailing blank required!

#
# Default HPI libraries. Build will build only native unless
# overriden at the make command line. This makes it convenient for
# people doing, say, a pthreads port -- they can create a posix
# directory here, and say "gnumake HPIS=posix" at the top
# level.
#
HPIS = native

#
# Java default optimization (-x04/-O2) etc.  Applies to the VM.
#
ifndef OPTIMIZATION_LEVEL
  ifeq ($(PRODUCT), java)
    OPTIMIZATION_LEVEL = HIGHER
  else
    OPTIMIZATION_LEVEL = LOWER
  endif
endif
ifndef FASTDEBUG_OPTIMIZATION_LEVEL
  FASTDEBUG_OPTIMIZATION_LEVEL = LOWER
endif

#
# If -Xa is in CFLAGS_COMMON it will end up ahead of $(CC_OPT) for the
# optimized build, and that ordering of the flags completely freaks
# out cc.  Hence, -Xa is instead in each CFLAGS variant.
#
# The more unusual options to the Sun C compiler:
#	-v		Stricter type checking, more error checking
#			(To turn ALL warnings into fatals, use -errwarn=%all)
#	-xstrconst	Place string literals and constants in read-only area
#			(means you can't write on your string literals)
#	-xs		Force debug information (stabs) into the .so or a.out
#			(makes the library/executable debuggable without the
#			.o files needing to be around, but at a space cost)
#	-g & -O		If you add the -g option to the optimized compiles
#			you will get better stack retraces, the code is
#			still optimized. This includes a space cost too.
#       -xc99=%none     Do NOT allow for c99 extensions to be used.
#                       e.g. declarations must precede statements
#       -xCC            Allow the C++ style of comments in C: //
#                       Required with many of the source files.
#       -mt             Assume multi-threaded (important)
#
# The more unusual options to the Sun C compiler:
#       +w              Print more warnings
#       +w2             Maximum warnings
#

#
# Debug flag for C and C++ compiler
#
CFLAGS_DEBUG_OPTION    = -g $(CC_OPT/NONE)
CXXFLAGS_DEBUG_OPTION  = -g $(CXX_OPT/NONE)

# Turn off -g if we are doing tcov build
ifdef TCOV_BUILD
  CFLAGS_DEBUG_OPTION=
  CXXFLAGS_DEBUG_OPTION=
endif

# FASTDEBUG: Optimize the -g builds, gives us a faster debug java
#        If true adds -O to the debug compiles. This allows for any assert
#        tests to remain and debug checking. The resulting code is faster
#        but less debuggable.  Stack traces are still valid, although only
#        approximate line numbers are given. Printing of local variables
#        during a debugging session is not possible, but stepping and
#        printing of global or static variables should be possible.
#        Performance/size of files should be about the same, maybe smaller.
#
ifeq ($(FASTDEBUG), true)
  CFLAGS_DEBUG_OPTION    = -g  $(CC_OPT/$(FASTDEBUG_OPTIMIZATION_LEVEL))
  CXXFLAGS_DEBUG_OPTION  = -g0 $(CXX_OPT/$(FASTDEBUG_OPTIMIZATION_LEVEL))
endif

CFLAGS_COMMON   = -L$(OBJDIR)

# Do not allow C99 language features like declarations in code etc.
CFLAGS_COMMON  += -xc99=%none

# Allow C++ comments in C code
CFLAGS_COMMON  += -xCC

# Show error message tags on errors
CFLAGS_COMMON   += -errshort=tags
CXXFLAGS_COMMON += -errtags=yes

# Optimization flags
CFLAGS_OPT      = $(CC_OPT)

# Debug version flags
CFLAGS_DBG      = $(CFLAGS_DEBUG_OPTION)

# Required C compiler flags
CFLAGS_COMMON  += -Xa $(CFLAGS_REQUIRED)

# Maximum warnings all the time
CXXFLAGS_COMMON += +w
CFLAGS_COMMON   += -v

# Assume MT behavior all the time (important)
CXXFLAGS_COMMON += -mt
CFLAGS_COMMON   += -mt

# Assume no C++ exceptions are used
CXXFLAGS_COMMON += -features=no%except -DCC_NOEX

# For C++, these options tell it to assume nothing about locating libraries
#    either at compile time, or at runtime. Use of these options will likely
#    require the use of -L and -R options to indicate where libraries will
#    be found at compile time (-L) and at runtime (-R).
#    The /usr/lib location comes for free, so no need to specify that one.
#    Note: C is much simplier and there is no need for these options. This
#          is mostly needed to avoid dependencies on libraries in the
#          Compiler install area, also see LIBCXX and LIBM.
CXXFLAGS_COMMON += -norunpath -xnolib

#
# Treat compiler warnings as errors, if requested
#
ifeq ($(COMPILER_WARNINGS_FATAL),true)
  CFLAGS_COMMON += -errwarn=%all
  CXXFLAGS_COMMON += -errwarn=%all
endif

CXXFLAGS_OPT	= $(CXX_OPT)
CXXFLAGS_DBG	= $(CXXFLAGS_DEBUG_OPTION)
CXXFLAGS_COMMON += $(CFLAGS_REQUIRED)

# Add -xstrconst to the library compiles. This forces all string
#  literals into the read-only data section, which prevents them from
#  being written to and increases the runtime pages shared on the system.
#
ifdef LIBRARY
  CFLAGS_COMMON +=-xstrconst
endif

# Source browser database
#
# COMPILE_WITH_SB    
#        If defined adds -xsb to compiles and creates a
#        source browsing database during compilation.
#
ifdef COMPILE_WITH_SB
  ifeq ($(LIBRARY), java)
    CFLAGS_DBG +=   -xsb
  endif
endif

# Lint Flags:
#	-Xa			ANSI C plus K&R, favor ANSI rules
#	-fd			report on old style func defs
#	-errchk=structarg	report on 64bit struct args by value
#	-errchk=longptr64	report on 64bit to 32bit issues (ignores casts)
#	-errchk=parentheses	report on suggested use of extra parens
#	-v 			suppress unused args
#	-x			suppress unused externs
#	-u			suppress extern func/vars used/defined
#	-errfmt=simple		use one line errors with position info
#       $(LINT_XARCH_OPTION)    See Compiler-sun.gwk

LINTFLAGS_COMMON  = -Xa
LINTFLAGS_COMMON += -fd 
LINTFLAGS_COMMON += -errchk=structarg,longptr64,parentheses
LINTFLAGS_COMMON += -v
LINTFLAGS_COMMON += -x 
LINTFLAGS_COMMON += -u
LINTFLAGS_COMMON += -errfmt=simple 
LINTFLAGS_OPT   = 
LINTFLAGS_DBG   =

# The -W0,-noglobal tells the compiler to NOT generate mangled global
#    ELF data symbols for file local static data.
#    This can break fix&continue, but we'd rather do the same compilations
#    for deliverable bits as we do for non-deliverable bits
#    Tell the compilers to never generate globalized names, all the time.
CFLAGS_COMMON += -W0,-noglobal

# If we have a specific arch value to use, add it
CFLAGS_COMMON    += $(XARCH_OPTION)
CXXFLAGS_COMMON  += $(XARCH_OPTION)
ASFLAGS_COMMON   += $(AS_XARCH_OPTION)
EXTRA_LIBS       += $(XARCH_OPTION)
LINTFLAGS_COMMON += $(LINT_XARCH_OPTION)

#
# uncomment the following to build with PERTURBALOT set
#
# OTHER_CFLAGS += -DPERTURBALOT
#

CPPFLAGS_COMMON = -D__solaris__  -D$(ARCH_FAMILY)
CPPFLAGS_OPT    = -DNDEBUG
CPPFLAGS_DBG    = -DDEBUG

ifneq ($(PRODUCT), java)
  CPPFLAGS_DBG    += -DLOGGING -DDBINFO
endif

ifeq ($(ARCH_FAMILY), i586)
  # The macro _LITTLE_ENDIAN needs to be defined the same to avoid the
  #   Sun C compiler warning message: warning: macro redefined: _LITTLE_ENDIAN
  #   (The Solaris X86 system defines this in file /usr/include/sys/isa_defs.h).
  #   Note: -Dmacro         is the same as    #define macro 1
  #         -Dmacro=	    is the same as    #define macro
  #
  CPPFLAGS_COMMON +=  -DcpuIntel -D_LITTLE_ENDIAN= -D$(LIBARCH)
  # Turn off a superfluous compiler error message on Intel
  CFLAGS_COMMON += -erroff=E_BAD_PRAGMA_PACK_VALUE
endif

# Java memory management is based on memory mapping by default, but a
# system only assuming malloc/free can be built by adding -DUSE_MALLOC 

CPPFLAGS_COMMON	+= -DTRACING -DMACRO_MEMSYS_OPS -DBREAKPTS
CPPFLAGS_OPT	+= -DTRIMMED

LDFLAGS_DEFS_OPTION  = -z defs
LDFLAGS_COMMON  += $(LDFLAGS_DEFS_OPTION)

#
# -L paths for finding and -ljava
#
LDFLAGS_COMMON += -L$(LIBDIR)/$(LIBARCH)
LDFLAGS_OPT     =
LDFLAGS_DBG     =

#
# We never really want the incremental linker, ever
#    The -xildoff option tells Sun's compilers to NOT use incremental linker
#
LDFLAGS_COMMON  += -xildoff

ifdef LIBRARY
  # Libraries need to locate other libraries at runtime, and you can tell
  #   a library where to look by way of the dynamic runpaths (RPATH or RUNPATH)
  #   buried inside the .so. The $ORIGIN says to look relative to where
  #   the library itself is and it can be followed with relative paths from
  #   that. By default we always look in $ORIGIN, optionally we add relative
  #   paths if the Makefile sets LD_RUNPATH_EXTRAS to those relative paths.
  #   The environment variable LD_LIBRARY_PATH will over-ride these runpaths.
  #   Try: 'dump -Lv lib*.so' to see these settings in a library.
  #
  LDFLAGS_COMMON += -R\$$ORIGIN
  LDFLAGS_COMMON += $(LD_RUNPATH_EXTRAS:%=-R\$$ORIGIN/%)
endif

EXTRA_LIBS += -lc

# Postprocessing is done on the images directories only
#
ifeq ($(VARIANT), OPT)
  ifeq ($(PARTIAL_GPROF), true)
    NO_STRIP = true
  endif
  ifeq ($(GPROF), true)
    NO_STRIP = true
  endif
  ifneq ($(NO_STRIP), true)
    # Debug 'strip -x' leaves local function Elf symbols (better stack traces)
    POST_STRIP_PROCESS = $(STRIP) -x
  endif
endif
POST_MCS_PROCESS=$(MCS) -d -a "JDK $(FULL_VERSION)"

#
# Sun C compiler will take -M and pass it on to ld.
# Usage: ld $(LD_MAPFILE_FLAG) mapfile *.o
#
ifeq ($(CC_VERSION),gcc)
LD_MAPFILE_FLAG = -Xlinker -M -Xlinker
else
LD_MAPFILE_FLAG = -M
endif

#
# Variables globally settable from the make command line (default
# values in brackets):
#	GPROF (false)
# Eg: 	% gnumake GPROF=true
GPROF = false
ifeq ($(GPROF), true)
    CFLAGS_COMMON += -DGPROF -xpg
    EXTRA_LIBS += -xpg
endif

# PARTIAL_GPROF is to be used ONLY during compilation - it should not
# appear during linking of libraries or programs.  It also should
# prevent linking with -z defs to allow a symbol to remain undefined.
#
PARTIAL_GPROF = false
ifeq ($(PARTIAL_GPROF), true)
  CFLAGS_GPROF += -xpg
  LDFLAGS_DEFS_OPTION  = -z nodefs
endif

#
# For a TCOV build we add in the TCOV_OPTION
#
ifdef TCOV_BUILD
  TCOV_OPTION		= -xprofile=tcov
  LDFLAGS_COMMON 	+= $(TCOV_OPTION) -Kpic
  CFLAGS_COMMON  	+= $(TCOV_OPTION)
  CXXFLAGS_COMMON 	+= $(TCOV_OPTION)
  EXTRA_LIBS 	+= $(TCOV_OPTION)
  LDNOMAP=true
endif

#
# Solaris only uses native threads. 
#
THREADS_FLAG=	native
THREADS_DIR=	threads

#
# Support for Quantify.
#
ifdef QUANTIFY
  QUANTIFY_CMD = quantify
  QUANTIFY_OPTIONS = -cache-dir=/tmp/quantify -always-use-cache-dir=yes
  LINK_PRE_CMD = $(QUANTIFY_CMD) $(QUANTIFY_OPTIONS)
  ifdef LIBRARY
    CFLAGS_COMMON += -K PIC
  endif
endif

#
# Support for Purify.
#
ifdef PURIFY
  PURIFY_CMD = /net/suntools.eng/export/tools/sparc/bin/purify
  PURIFY_OPTIONS = -cache-dir=/tmp/quantify -always-use-cache-dir=yes
  LINK_PRE_CMD = $(PURIFY_CMD) $(PURIFY_OPTIONS)
  ifdef LIBRARY
    CFLAGS_COMMON += -K PIC
  endif
endif

#
# Different "levels" of optimization.
#
ifeq ($(CC_VERSION),gcc)
  
  CC_OPT/NONE     =
  CC_OPT/LOWER    = -O2
  CC_OPT/HIGHER   = -O3
  CC_OPT/HIGHEST  = -O3

  CXX_OPT/NONE    =
  CXX_OPT/LOWER   = -O2
  CXX_OPT/HIGHER  = -O3
  CXX_OPT/HIGHEST = -O3

  CFLAGS_REQUIRED_i586  += -fno-omit-frame-pointer
  CFLAGS_REQUIRED_amd64 += -fno-omit-frame-pointer
  
  # Automatic precompiled header option to use (if COMPILE_APPROACH=batch)
  #   (See Rules.gmk) May need to wait for gcc 5?
  AUTOMATIC_PCH_OPTION = 

else
  
  # Highest could be -xO5, but indications are that -xO5 should be reserved
  #    for a per-file use, on sources with known performance impacts.
  OPT_LEVEL/LOWER    = 2
  OPT_LEVEL/HIGHER   = 4
  OPT_LEVEL/HIGHEST  = 4
  
  CC_OPT/NONE     =
  CC_OPT/LOWER    = $(OPT_LEVEL/LOWER:%=-xO%)
  CC_OPT/HIGHER   = $(OPT_LEVEL/HIGHER:%=-xO%)
  CC_OPT/HIGHEST  = $(OPT_LEVEL/HIGHEST:%=-xO%)
  
  CXX_OPT/NONE    =
  CXX_OPT/LOWER   = $(OPT_LEVEL/LOWER:%=-xO%)
  CXX_OPT/HIGHER  = $(OPT_LEVEL/HIGHER:%=-xO%)
  CXX_OPT/HIGHEST = $(OPT_LEVEL/HIGHEST:%=-xO%)
    
  # We need stack frames at all times
  USE_XKEEPFRAME_OPTION = false
  ifeq ($(USE_XKEEPFRAME_OPTION),true)
    
    # Unknown spelling on this option at this time (Maybe in SS13?)
    CC_XKEEPFRAME_OPTIONS  = -xkeepframe
    CXX_XKEEPFRAME_OPTIONS = -xkeepframe
  
  else
  
    # On X86, make sure tail call optimization is off
    #    The z and y are the tail call optimizations.
    ifeq ($(ARCH_FAMILY), i586)
      ifeq ($(shell $(EXPR) $(CC_VER) \> 5.8), 1)
        # Somehow, tail call optimization is creeping in.
        #    Make sure it is off.
	# WARNING: These may cause compiler warnings about duplicate -O options
        CC_XKEEPFRAME_OPTIONS  += -Wu,-O$(OPT_LEVEL/$(OPTIMIZATION_LEVEL))~yz
        CXX_XKEEPFRAME_OPTIONS += -Qoption ube -O$(OPT_LEVEL/$(OPTIMIZATION_LEVEL))~yz
      endif
    endif
  
    #  On i586 we need to tell the code generator to ALWAYS use a
    #   frame pointer.
    ifeq ($(ARCH_FAMILY), i586)
      # Note that in 5.7, this is done with -xregs=no%frameptr
      ifeq ($(CC_VER), 5.5)
        # It's not exactly clear when this optimization kicks in, the
        #   current assumption is -xO4 or greater and for C++ with
        #   the -features=no%except option and -xO4 and greater.
        #   Bottom line is, we ALWAYS want a frame pointer!
        CC_XKEEPFRAME_OPTIONS  += -Wu,-Z~B
        CXX_XKEEPFRAME_OPTIONS += -Qoption ube -Z~B
      endif
      ifeq ($(shell $(EXPR) $(CC_VER) \> 5.6), 1)
        # Do NOT use frame pointer register as a general purpose opt register
        CC_OPT/NONE            += -xregs=no%frameptr
        CXX_OPT/NONE           += -xregs=no%frameptr
        CC_XKEEPFRAME_OPTIONS  += -xregs=no%frameptr
        CXX_XKEEPFRAME_OPTIONS += -xregs=no%frameptr
      endif
    endif
  
    #  Optimizer for sparc needs to be told not to do certain things
    #   related to frames or save instructions.
    ifeq ($(ARCH_FAMILY), sparc)
      #  Do not use save instructions instead of add instructions
      #  This was an optimization starting in SC5.0 that made it hard for us to
      #    find the "save" instruction (which got turned into an "add")
      CC_XKEEPFRAME_OPTIONS  += -Wc,-Qrm-s
      CXX_XKEEPFRAME_OPTIONS += -Qoption cg -Qrm-s
      # Don't allow tail call code optimization. Started in SC5.0.
      #    We don't like code of this form:
      #	save
      #	<code>
      #	call foo
      #	   restore
      #   because we can't tell if the method will have a stack frame
      #   and register windows or not.
      CC_XKEEPFRAME_OPTIONS  += -Wc,-Qiselect-T0
      CXX_XKEEPFRAME_OPTIONS += -Qoption cg -Qiselect-T0
    endif
  
  endif

  # Extra options used with HIGHEST
  #
  # WARNING: Use of OPTIMIZATION_LEVEL=HIGHEST in your Makefile needs to be
  #          done with care, there are some assumptions below that need to
  #          be understood about the use of pointers, and IEEE behavior.
  #
  # Use non-standard floating point mode (not IEEE 754)
  CC_HIGHEST_EXTRAS += -fns
  # Do some simplification of floating point arithmetic (not IEEE 754)
  CC_HIGHEST_EXTRAS += -fsimple
  # Use single precision floating point with 'float'
  CC_HIGHEST_EXTRAS += -fsingle
  # Assume memory references via basic pointer types do not alias
  #   (Source with excessing pointer casting and data access with mixed 
  #    pointer types are not recommended)
  CC_HIGHEST_EXTRAS += -xalias_level=basic
  # Use intrinsic or inline versions for math/std functions
  #   (If you expect perfect errno behavior, do not use this)
  CC_HIGHEST_EXTRAS += -xbuiltin=%all
  # Loop data dependency optimizations (need -xO3 or higher)
  CC_HIGHEST_EXTRAS += -xdepend
  # Pointer parameters to functions do not overlap
  #   (Similar to -xalias_level=basic usage, but less obvious sometimes.
  #    If you pass in multiple pointers to the same data, do not use this)
  CC_HIGHEST_EXTRAS += -xrestrict
  # Inline some library routines
  #   (If you expect perfect errno behavior, do not use this)
  CC_HIGHEST_EXTRAS += -xlibmil
  # Use optimized math routines
  #   (If you expect perfect errno behavior, do not use this)
  #  Can cause undefined external on Solaris 8 X86 on __sincos, removing for now
  #  CC_HIGHEST_EXTRAS += -xlibmopt
  ifeq ($(ARCH_FAMILY), sparc)
    # Assume at most 8byte alignment, raise SIGBUS on error
    ### Presents an ABI issue with customer JNI libs?
    ####CC_HIGHEST_EXTRAS  += -xmemalign=8s
    # Automatic prefetch instructions, explicit prefetch macros
    CC_HIGHEST_EXTRAS += -xprefetch=auto,explicit
    # Pick ultra as the chip to optimize to
    CC_HIGHEST_EXTRAS += -xchip=ultra
  endif
  ifeq ($(ARCH), i586)
    # Pick pentium as the chip to optimize to
    CC_HIGHEST_EXTRAS += -xchip=pentium
  endif
  ifdef LIBRARY
    # The Solaris CBE (Common Build Environment) requires that the use
    # of appl registers be disabled when compiling a public library (or
    # a library that's loaded by a public library) on sparc.
    CFLAGS_REQUIRED_sparc    += -xregs=no%appl
    CFLAGS_REQUIRED_sparcv9  += -xregs=no%appl
  endif
  ifeq ($(shell $(EXPR) $(CC_VER) \> 5.6), 1)
    # We MUST allow data alignment of 4 for sparc V8 (32bit)
    #     Presents an ABI issue with customer JNI libs? We must be able to
    #     to handle 4byte aligned objects? (rare occurance, but possible?)
    CFLAGS_REQUIRED_sparc += -xmemalign=4s
  endif
  # Just incase someone trys to use the SOS9 compilers
  ifeq ($(CC_VER), 5.6)
    # We MUST allow data alignment of 4 for sparc (sparcv9 is ok at 8s)
    CFLAGS_REQUIRED_sparc += -xmemalign=4s
  endif
  # Automatic precompiled header option to use (if COMPILE_APPROACH=batch)
  #   (See Rules.gmk) The SS11 -xpch=auto* options appear to be broken.
  AUTOMATIC_PCH_OPTION =
  
  # Add in keep frame options
  CC_OPT/LOWER    += $(CC_XKEEPFRAME_OPTIONS)
  CC_OPT/HIGHER   += $(CC_XKEEPFRAME_OPTIONS)
  CC_OPT/HIGHEST  += $(CC_XKEEPFRAME_OPTIONS)
  CXX_OPT/LOWER   += $(CXX_XKEEPFRAME_OPTIONS)
  CXX_OPT/HIGHER  += $(CXX_XKEEPFRAME_OPTIONS)
  CXX_OPT/HIGHEST += $(CXX_XKEEPFRAME_OPTIONS)
 
  # Add in highest optimization settings
  CC_OPT/HIGHEST  += $(CC_HIGHEST_EXTRAS)
  CXX_OPT/HIGHEST += $(CC_HIGHEST_EXTRAS)
  
endif

# Default optimization settings based on level.
CC_OPT  = $(CC_OPT/$(OPTIMIZATION_LEVEL))
CXX_OPT = $(CXX_OPT/$(OPTIMIZATION_LEVEL))

# Flags required all the time
CFLAGS_REQUIRED = $(CFLAGS_REQUIRED_$(ARCH))

#
# Path and option to link against the VM, if you have to.  Note that
# there are libraries that link against only -ljava, but they do get
# -L to the -ljvm, this is because -ljava depends on -ljvm, whereas
# the library itself should not.
#
VM_NAME         = server
JVMLIB          = -L$(LIBDIR)/$(LIBARCH)/$(VM_NAME) -ljvm
JAVALIB         = -ljava $(JVMLIB)

# Part of INCREMENTAL_BUILD mechanism.
#   Compiler emits things like:  path/file.o: file.h
#   We want something like: relative_path/file.o relative_path/file.d: file.h
#   In addition on Solaris, any include file starting with / is deleted,
#   this gets rid of things like /usr/include files, which never change.
CC_DEPEND	 = -xM1
CC_DEPEND_FILTER = $(SED) -e '/:[ 	]*[/]/d' -e 's!$*\.$(OBJECT_SUFFIX)!$(dir $@)& $(dir $@)$*.$(DEPEND_SUFFIX)!g' | $(SORT) -u

# Location of openwin libraries (do we really need this anymore?)
OPENWIN_HOME    = /usr/openwin
OPENWIN_LIB     = $(OPENWIN_HOME)/lib$(ISA_DIR)

# Runtime graphics library search paths...
OPENWIN_RUNTIME_LIB = /usr/openwin/lib$(ISA_DIR)
AWT_RUNPATH = -R/usr/dt/lib$(ISA_DIR) -R$(OPENWIN_RUNTIME_LIB)

# C++ Runtime library (libCrun.so), use instead of -lCrun.
#    Originally used instead of -lCrun to guarantee use of the system
#    .so version and not the .a or .so that came with the compilers.
#    With the newer compilers this could probably change back to -lCrun but
#    in general this is ok to continue to do.
LIBCXX = /usr/lib$(ISA_DIR)/libCrun.so.1

# Math Library (libm.so), do not use -lm.
#    There might be two versions of libm.so on the build system:
#    libm.so.1 and libm.so.2, and we want libm.so.1.
#    Depending on the Solaris release being used to build with,
#    /usr/lib/libm.so could point at a libm.so.2, so we are
#    explicit here so that the libjvm.so you have built will work on an
#    older Solaris release that might not have libm.so.2.
#    This is a critical factor in allowing builds on Solaris 10 or newer
#    to run on Solaris 8 or 9.
#
#    Note: Historically there was also a problem picking up a static version
#          of libm.a from the compiler area, but that problem has gone away
#          with the newer compilers. Use of libm.a would cause .so bloat.
#
LIBM = /usr/lib$(ISA_DIR)/libm.so.1

# Socket library
LIBSOCKET = -lsocket

# GLOBAL_KPIC: If set means all libraries are PIC, position independent code
#    EXCEPT for select compiles
#    If a .o file is compiled non-PIC then it should be forced
#	   into the RW data segment with a mapfile option. This is done
#    with object files which generated from .s files.
#    The -ztext enforces that no relocations remain in the text segment
#    so that it remains purely read-only for optimum system performance.
#    Some libraries may use a smaller size (13bit -Kpic) on sparc instead of 
#    (32 bit -KPIC) and will override GLOBAL_KPIC appropriately.
#
PIC_CODE_LARGE   = -KPIC
PIC_CODE_SMALL   = -Kpic
ifndef TCOV_BUILD
    GLOBAL_KPIC      = $(PIC_CODE_LARGE)
    CXXFLAGS_COMMON += $(GLOBAL_KPIC)
    CFLAGS_COMMON   += $(GLOBAL_KPIC)
    LDFLAGS_COMMON  += -ztext
endif # TCOV_BUILD

# If your platform has DPS, it will have Type1 fonts too, in which case
# it is best to enable DPS support until such time as 2D's rasteriser
# can fully handle Type1 fonts in all cases. Default is "yes".
# HAVE_DPS should only be "no" if the platform has no DPS headers or libs
# DPS (Displayable PostScript) is available on Solaris machines

HAVE_DPS = yes

#
# Japanese manpages
#
JA_SOURCE_ENCODING = eucJP
JA_TARGET_ENCODINGS = eucJP UTF-8 PCK

# Settings for the JDI - Serviceability Agent binding.
HOTSPOT_SALIB_PATH   = $(HOTSPOT_IMPORT_PATH)/jre/lib/$(LIBARCH)
SALIB_NAME = $(LIB_PREFIX)saproc.$(LIBRARY_SUFFIX)
INCLUDE_SA=true