7113349: Initial changeset for Macosx port to jdk
Reviewed-by: jjh, alanb, dholmes, anthony, ohrstrom, ksrini, jrose, weijun, smarks
Contributed-by: Alan Bateman <alan.bateman@oracle.com>, Alexander Potochkin <alexander.potochkin@oracle.com>, Alexander Zuev <alexander.zuev@oracle.com>, Andrew Brygin <andrew.brygin@oracle.com>, Artem Ananiev <artem.ananiev@oracle.com>, Alex Strange <astrange@apple.com>, Bino George <bino@apple.com>, Christine Lu <christine.lu@oracle.com>, David Katleman <david.katleman@oracle.com>, David Durrence <david_durrence@apple.com>, Dmitry Cherepanov <dmitry.cherepanov@oracle.com>, Greg Lewis <glewis@eyesbeyond.com>, Kevin Miller <kevin_m_miller@apple.com>, Kurt Miller <kurt@intricatesoftware.com>, Landon Fuller <landonf@plausiblelabs.com>, Leonid Romanov <leonid.romanov@oracle.com>, Loefty Walkowiak <loefty@apple.com>, Mark Reinhold <mark.reinhold@oracle.com>, Naoto Sato <naoto.sato@oracle.com>, Philip Race <philip.race@oracle.com>, Roger Hoover <rhoover@apple.com>, Scott Kovatch <scott.kovatch@oracle.com>, Sergey ByloKhov <sergey.bylokhov@oracle.com>, Mike Swingler <swingler@apple.com>, Tomas Hurka <tomas.hurka@oracle.com>
## Copyright (c) 1995, 2011, Oracle and/or its affiliates. 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. Oracle designates this# particular file as subject to the "Classpath" exception as provided# by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA# or visit www.oracle.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 settingsinclude $(JDK_MAKE_SHARED_DIR)/Defs.gmkifndef PLATFORM_SRCPLATFORM_SRC = $(BUILDDIR)/../src/solarisendif # PLATFORM_SRC# Platform specific closed sourcesifndef OPENJDK ifndef CLOSED_PLATFORM_SRC CLOSED_PLATFORM_SRC = $(BUILDDIR)/../src/closed/solaris endifendif# platform specific include filesPLATFORM_INCLUDE_NAME = $(PLATFORM)PLATFORM_INCLUDE = $(INCLUDEDIR)/$(PLATFORM_INCLUDE_NAME)# suffix used for make dependencies filesDEPEND_SUFFIX = d# suffix used for lint filesLINT_SUFFIX = ln# The suffix applied to the library name for FDLIBMFDDLIBM_SUFFIX = a# The suffix applied to scripts (.bat for windows, nothing for unix)SCRIPT_SUFFIX =# CC compiler object code output directive flag valueCC_OBJECT_OUTPUT_FLAG = -o #trailing blank required!ifdef ENABLE_FULL_DEBUG_SYMBOLS# Only check for Full Debug Symbols support on Solaris if it is# specifically enabled. Hopefully, it can be enabled by default# once the .debuginfo size issues are worked out.# Default OBJCOPY comes from the SUNWbinutils package:DEF_OBJCOPY=/usr/sfw/bin/gobjcopyifeq ($(PLATFORM)-$(LIBARCH), solaris-amd64) # On Solaris AMD64/X64, gobjcopy is not happy and fails: # # usr/sfw/bin/gobjcopy --add-gnu-debuglink=<lib>.debuginfo <lib>.so # BFD: stKPaiop: Not enough room for program headers, try linking with -N # /usr/sfw/bin/gobjcopy: stKPaiop: Bad value # BFD: stKPaiop: Not enough room for program headers, try linking with -N # /usr/sfw/bin/gobjcopy: libsaproc.debuginfo: Bad value # BFD: stKPaiop: Not enough room for program headers, try linking with -N # /usr/sfw/bin/gobjcopy: stKPaiop: Bad value _JUNK_ := $(shell \ echo >&2 "INFO: $(DEF_OBJCOPY) is not working on Solaris AMD64/X64") OBJCOPY=else OBJCOPY=$(shell test -x $(DEF_OBJCOPY) && echo $(DEF_OBJCOPY)) ifneq ($(ALT_OBJCOPY),) _JUNK_ := $(shell echo >&2 "INFO: ALT_OBJCOPY=$(ALT_OBJCOPY)") # disable .debuginfo support by setting ALT_OBJCOPY to a non-existent path OBJCOPY=$(shell test -x $(ALT_OBJCOPY) && echo $(ALT_OBJCOPY)) endifendififdef LIBRARY_SUPPORTS_FULL_DEBUG_SYMBOLS# The setting of OBJCOPY above enables the JDK build to import# .debuginfo files from the HotSpot build. However, adding FDS# support to the JDK build will occur in phases so a different# make variable is used to indicate that a particular library# supports FDS.ifeq ($(OBJCOPY),) _JUNK_ := $(shell \ echo >&2 "INFO: no objcopy cmd found so cannot create .debuginfo files.")else _JUNK_ := $(shell \ echo >&2 "INFO: $(OBJCOPY) cmd found so will create .debuginfo files.") # Library stripping policies for .debuginfo configs: # all_strip - strips everything from the library # min_strip - strips most stuff from the library; leaves minimum symbols # no_strip - does not strip the library at all # # Oracle security policy requires "all_strip". A waiver was granted on # 2011.09.01 that permits using "min_strip" in the Java JDK and Java JRE. # DEF_STRIP_POLICY="min_strip" ifeq ($(ALT_STRIP_POLICY),) STRIP_POLICY=$(DEF_STRIP_POLICY) else STRIP_POLICY=$(ALT_STRIP_POLICY) endif _JUNK_ := $(shell \ echo >&2 "INFO: STRIP_POLICY=$(STRIP_POLICY)")endifendifendif## Java default optimization (-x04/-O2) etc. Applies to the VM.#ifndef OPTIMIZATION_LEVEL ifeq ($(PRODUCT), java) OPTIMIZATION_LEVEL = HIGHER else OPTIMIZATION_LEVEL = LOWER endifendififndef FASTDEBUG_OPTIMIZATION_LEVEL FASTDEBUG_OPTIMIZATION_LEVEL = LOWERendif## 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 buildifdef 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))endifCFLAGS_COMMON = -L$(OBJDIR)# Do not allow C99 language features like declarations in code etc.CFLAGS_COMMON += -xc99=%none# Allow C++ comments in C codeCFLAGS_COMMON += -xCC# Show error message tags on errorsCFLAGS_COMMON += -errshort=tagsCXXFLAGS_COMMON += -errtags=yes# Optimization flagsCFLAGS_OPT = $(CC_OPT)# Debug version flagsCFLAGS_DBG = $(CFLAGS_DEBUG_OPTION)# Required C compiler flagsCFLAGS_COMMON += -Xa $(CFLAGS_REQUIRED)# Maximum warnings all the timeCXXFLAGS_COMMON += +wCFLAGS_COMMON += -v# Assume MT behavior all the time (important)CXXFLAGS_COMMON += -mtCFLAGS_COMMON += -mt# Assume no C++ exceptions are usedCXXFLAGS_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=%allendifCXXFLAGS_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 +=-xstrconstendif# 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 endifendif# 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.gwkLINTFLAGS_COMMON = -XaLINTFLAGS_COMMON += -fd LINTFLAGS_COMMON += -errchk=structarg,longptr64,parenthesesLINTFLAGS_COMMON += -vLINTFLAGS_COMMON += -x LINTFLAGS_COMMON += -uLINTFLAGS_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 itCFLAGS_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 = -DNDEBUGCPPFLAGS_DBG = -DDEBUGifneq ($(PRODUCT), java) CPPFLAGS_DBG += -DLOGGING -DDBINFOendififeq ($(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_VALUEendif# 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 -DBREAKPTSCPPFLAGS_OPT += -DTRIMMEDLDFLAGS_DEFS_OPTION = -z defsLDFLAGS_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 += -xildoffifdef 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/%)endifEXTRA_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 endifendifPOST_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 -XlinkerelseLD_MAPFILE_FLAG = -Mendif## Variables globally settable from the make command line (default# values in brackets):# GPROF (false)# Eg: % gnumake GPROF=trueGPROF = falseifeq ($(GPROF), true) CFLAGS_COMMON += -DGPROF -xpg EXTRA_LIBS += -xpgendif# 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 = falseifeq ($(PARTIAL_GPROF), true) CFLAGS_GPROF += -xpg LDFLAGS_DEFS_OPTION = -z nodefsendif## 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=trueendif## Solaris only uses native threads. #THREADS_FLAG= nativeTHREADS_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 endifendif## 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 endifendif## 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) CC_NEWER_THAN_58 := \ $(shell $(EXPR) $(CC_MAJORVER) \> 5 \| \ \( $(CC_MAJORVER) = 5 \& $(CC_MINORVER) \> 8 \) ) ifeq ($(CC_NEWER_THAN_58),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 CC_NEWER_THAN_56 := \ $(shell $(EXPR) $(CC_MAJORVER) \> 5 \| \ \( $(CC_MAJORVER) = 5 \& $(CC_MINORVER) \> 6 \) ) ifeq ($(CC_NEWER_THAN_56),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 CC_NEWER_THAN_56 := \ $(shell $(EXPR) $(CC_MAJORVER) \> 5 \| \ \( $(CC_MAJORVER) = 5 \& $(CC_MINORVER) \> 6 \) ) ifeq ($(CC_NEWER_THAN_56),1) # 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 timeCFLAGS_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 = serverJVMLIB = -L$(LIBDIR)/$(LIBARCH)/$(VM_NAME) -ljvmJAVALIB = -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 = -xM1CC_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/openwinOPENWIN_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# JDK now requires Solaris 10, so pick up libm.so.2LIBM = /usr/lib$(ISA_DIR)/libm.so.2# Socket libraryLIBSOCKET = -lsocket# Network Services libraryLIBNSL = -lnsl# service configuration facility libraryLIBSCF = -lscf# Dynamic Loading libraryLIBDL = -ldl# 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 = -KPICPIC_CODE_SMALL = -Kpicifndef TCOV_BUILD GLOBAL_KPIC = $(PIC_CODE_LARGE) CXXFLAGS_COMMON += $(GLOBAL_KPIC) CFLAGS_COMMON += $(GLOBAL_KPIC) LDFLAGS_COMMON += -ztextendif # 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 machinesHAVE_DPS = yes## Japanese manpages#JA_SOURCE_ENCODING = eucJPJA_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)SA_DEBUGINFO_NAME = $(LIB_PREFIX)saproc.debuginfoINCLUDE_SA=true