# -*- Mode: makefile -*-
#
# ***** BEGIN LICENSE BLOCK *****
# Version: MPL 1.1/GPL 2.0/LGPL 2.1
#
# The contents of this file are subject to the Mozilla Public License Version
# 1.1 (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
# http://www.mozilla.org/MPL/
#
# Software distributed under the License is distributed on an "AS IS" basis,
# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
# for the specific language governing rights and limitations under the
# License.
#
# The Original Code is Mozilla Communicator client code, released
# March 31, 1998.
#
# The Initial Developer of the Original Code is
# Netscape Communications Corporation.
# Portions created by the Initial Developer are Copyright (C) 1998
# the Initial Developer. All Rights Reserved.
#
# Contributor(s):
#
# Alternatively, the contents of this file may be used under the terms of
# either of the GNU General Public License Version 2 or later (the "GPL"),
# or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
# in which case the provisions of the GPL or the LGPL are applicable instead
# of those above. If you wish to allow use of your version of this file only
# under the terms of either the GPL or the LGPL, and not to allow others to
# use your version of this file under the terms of the MPL, indicate your
# decision by deleting the provisions above and replace them with the notice
# and other provisions required by the GPL or the LGPL. If you do not delete
# the provisions above, a recipient may use your version of this file under
# the terms of any one of the MPL, the GPL or the LGPL.
#
# ***** END LICENSE BLOCK *****

DEPTH		= .
topsrcdir	= @top_srcdir@
srcdir		= @srcdir@

run_for_side_effects := $(shell echo "MAKE: $(MAKE)")
include $(DEPTH)/config/autoconf.mk

DIRS		= config

ifdef DEHYDRA_PATH
DIRS += analysis-tests
endif

ifdef JS_NATIVE_EDITLINE
DIRS += editline
endif

# editline needs to get built before the shell
ifndef JS_DISABLE_SHELL
DIRS += shell
endif

# FIXME: bug 530688 covers getting these working on Android
ifneq (,$(filter-out ANDROID,$(OS_ARCH)))
ifdef ENABLE_TESTS
DIRS += jsapi-tests
endif
endif

ifdef ENABLE_TESTS
DIRS += tests
endif

MODULE		    = js
LIBRARY_NAME	    = mozjs
STATIC_LIBRARY_NAME = js_static
GRE_MODULE	    = 1

LIBS		= $(NSPR_LIBS) 

ifdef GNU_CXX
ifdef INTEL_CXX
# icc gets special optimize flags
ifdef MOZ_PROFILE_GENERATE
MODULE_OPTIMIZE_FLAGS = -O0
else
MODULE_OPTIMIZE_FLAGS = -O2 -ip
endif
else # not INTEL_CXX

MODULE_OPTIMIZE_FLAGS = -O3 -fstrict-aliasing -fno-stack-protector

# We normally want -fomit-frame-pointer, but we want an explicit
# -fno-omit-frame-pointer if we're using a sampling profiler.
ifndef MOZ_PROFILING
MODULE_OPTIMIZE_FLAGS += -fomit-frame-pointer
else
MODULE_OPTIMIZE_FLAGS += -fno-omit-frame-pointer
endif

endif
else # not GNU_CXX
ifeq ($(OS_ARCH),SunOS)
MODULE_OPTIMIZE_FLAGS = -xO4
endif
ifeq ($(OS_ARCH),WINNT)
MODULE_OPTIMIZE_FLAGS = -O2
endif
endif

ifeq ($(OS_ARCH),WINNT)
NO_PROFILE_GUIDED_OPTIMIZE = 1
endif

# JavaScript must be built shared, even for static builds, as it is used by
# other modules which are always built shared. Failure to do so results in
# the js code getting copied into xpinstall and jsd as well as mozilla-bin,
# and then the static data cells used for locking no longer work.
#
# In fact, we now build both a static and a shared library, as the
# JS shell would like to link to the static library.

ifdef JS_SHARED_LIBRARY
FORCE_SHARED_LIB = 1
endif
FORCE_STATIC_LIB = 1
DIST_INSTALL = 1

VPATH		= $(srcdir)

CPPSRCS		= \
		jsanalyze.cpp \
		jsapi.cpp \
		jsarena.cpp \
		jsarray.cpp \
		jsatom.cpp \
		jsbool.cpp \
		jsclone.cpp \
		jscntxt.cpp \
		jscompartment.cpp \
		jsdate.cpp \
		jsdbgapi.cpp \
		jsdhash.cpp \
		jsdtoa.cpp \
		jsemit.cpp \
		jsexn.cpp \
		jsfriendapi.cpp \
		jsfun.cpp \
		jsgc.cpp \
		jsgcchunk.cpp \
		jsgcstats.cpp \
		jshash.cpp \
		jsinterp.cpp \
		jsinvoke.cpp \
		jsiter.cpp \
		jslock.cpp \
		jslog2.cpp \
		jsmath.cpp \
		jsnativestack.cpp \
		jsnum.cpp \
		jsobj.cpp \
		json.cpp \
		jsonparser.cpp \
		jsopcode.cpp \
		jsparse.cpp \
		jsproxy.cpp \
		jsprf.cpp \
		jsprobes.cpp \
		jspropertycache.cpp \
		jspropertytree.cpp \
		jsreflect.cpp \
		jsregexp.cpp \
		jsscan.cpp \
		jsscope.cpp \
		jsscript.cpp \
		jsstr.cpp \
		jstypedarray.cpp \
		jsutil.cpp \
		jswrapper.cpp \
		jsxdrapi.cpp \
		jsxml.cpp \
		prmjtime.cpp \
		sharkctl.cpp \
		$(NULL)

INSTALLED_HEADERS = \
		js-config.h \
		jsautocfg.h \
		$(CURDIR)/jsautokw.h \
		js.msg \
		jsanalyze.h \
		jsapi.h \
		jsarray.h \
		jsarena.h \
		jsatom.h \
		jsbit.h \
		jsbool.h \
		jsclist.h \
		jsclone.h \
		jscntxt.h \
		jscompat.h \
		jsdate.h \
		jsdbgapi.h \
		jsdhash.h \
		jsdtoa.h \
		jsemit.h \
		jsfun.h \
		jsfriendapi.h \
		jsgc.h \
		jscell.h \
		jsgcchunk.h \
		jsgcstats.h \
		jscompartment.h \
		jshash.h \
		jsinterp.h \
		jsinttypes.h \
		jsiter.h \
		jslock.h \
		jslong.h \
		jsmath.h \
		jsnum.h \
		jsobj.h \
		jsobjinlines.h \
		json.h \
		jsonparser.h \
		jsopcode.tbl \
		jsopcode.h \
		jsopcodeinlines.h \
		jsotypes.h \
		jsparse.h \
		jsproxy.h \
		jsprf.h \
		jsprobes.h \
		jspropertycache.h \
		jspropertycacheinlines.h \
		jspropertytree.h \
		jsproto.tbl \
		jsprvtd.h \
		jspubtd.h \
		jsreflect.h \
		jsregexp.h \
		jsscan.h \
		jsscope.h \
		jsscript.h \
		jsscriptinlines.h \
		jsstaticcheck.h \
		jsstdint.h \
		jsstr.h \
		jstracer.h \
		jshotloop.h \
		jstypedarray.h \
		jstypes.h \
		jsutil.h \
		jsvector.h \
		jstl.h \
		jshashtable.h \
		jsversion.h \
		jswrapper.h \
		jsxdrapi.h \
		jsxml.h \
		jsval.h \
		jsvalue.h \
		prmjtime.h \
		$(NULL)

###############################################
# BEGIN include sources for low-level code shared with Gecko
#
VPATH		+= \
		$(srcdir)/../../mfbt \
		$(NULL)

EXPORTS_NAMESPACES = mozilla

EXPORTS_mozilla = \
		Util.h          \
		$(NULL)

ifdef ENABLE_TRACEJIT
VPATH		+= \
		$(srcdir)/tracejit \
		$(srcdir)/nanojit \

INSTALLED_HEADERS += \
		jsbuiltins.h    \
		Assembler.h     \
		Allocator.h     \
		CodeAlloc.h     \
		Containers.h    \
		LIR.h		\
		LIRopcode.tbl \
		avmplus.h	\
		Fragmento.h	\
		Native.h	\
		NativeCommon.h	\
		Native$(NANOJIT_ARCH).h \
		njconfig.h      \
		njcpudetect.h   \
		RegAlloc.h	\
		nanojit.h	\
		VMPI.h		\
		Writer.h	\
		$(NULL)

CPPSRCS += \
		jstracer.cpp \
		Assembler.cpp  \
		Allocator.cpp  \
		CodeAlloc.cpp  \
		Containers.cpp \
		Fragmento.cpp  \
		LIR.cpp        \
		njconfig.cpp   \
		RegAlloc.cpp   \
		avmplus.cpp    \
		Native$(NANOJIT_ARCH).cpp \
		jsbuiltins.cpp \
		VMPI.cpp       \
		Writer.cpp     \
		$(NULL)

endif # ENABLE_TRACEJIT
ifdef ENABLE_METHODJIT

###############################################
# BEGIN include sources for the method JIT
#
VPATH += 	$(srcdir)/methodjit

CPPSRCS += 	MethodJIT.cpp \
		StubCalls.cpp \
		Compiler.cpp \
		FrameState.cpp \
		FastArithmetic.cpp \
		FastOps.cpp \
		StubCompiler.cpp \
		MonoIC.cpp \
		PolyIC.cpp \
		ImmutableSync.cpp \
		InvokeHelpers.cpp \
		Retcon.cpp \
		TrampolineCompiler.cpp \
		$(NULL)
#		PICStubCompiler.cpp \

ifeq (86, $(findstring 86,$(TARGET_CPU)))
ifeq (x86_64, $(TARGET_CPU))
ifdef _MSC_VER
ASFILES +=	TrampolineMasmX64.asm
endif
ifeq ($(OS_ARCH),WINNT)
ifdef GNU_CC
ASFILES +=	TrampolineMingwX64.s
endif
endif
ifdef SOLARIS_SUNPRO_CXX
ASFILES +=	TrampolineSUNWX64.s
endif
#CPPSRCS		+= only_on_x86_64.cpp
else
#CPPSRCS		+= only_on_x86.cpp
ifdef SOLARIS_SUNPRO_CXX
ASFILES +=	TrampolineSUNWX86.s
endif
endif
endif
ifeq (arm, $(TARGET_CPU))
#CPPSRCS		+= only_on_arm.cpp
endif
#
# END enclude sources for the method JIT
#############################################

endif

###############################################
# BEGIN include sources for V8 dtoa
#
VPATH += 	$(srcdir)/v8-dtoa \
		$(NONE)

CPPSRCS += 	checks.cc \
		conversions.cc \
		diy-fp.cc \
		v8-dtoa.cc \
		fast-dtoa.cc \
		platform.cc \
		utils.cc \
		$(NONE)

#
# END enclude sources for V8 dtoa
#############################################

ifeq (,$(filter-out powerpc sparc,$(TARGET_CPU)))

VPATH +=	$(srcdir)/assembler \
		$(srcdir)/assembler/wtf \
		$(srcdir)/yarr/pcre \
		$(NULL)

CPPSRCS += 	pcre_compile.cpp \
                pcre_exec.cpp \
                pcre_tables.cpp \
                pcre_xclass.cpp \
                pcre_ucp_searchfuncs.cpp \
		$(NULL)
else

###############################################
# BEGIN include sources for the Nitro assembler
#
VPATH += 	$(srcdir)/assembler \
		$(srcdir)/assembler/wtf \
		$(srcdir)/assembler/jit \
		$(srcdir)/assembler/assembler \
		$(srcdir)/methodjit \
		$(srcdir)/yarr \
		$(srcdir)/yarr/yarr \
		$(srcdir)/yarr/pcre \
		$(srcdir)/yarr/wtf \
		$(NONE)

CPPSRCS += 	Assertions.cpp \
		ExecutableAllocatorPosix.cpp \
		ExecutableAllocatorWin.cpp \
		ExecutableAllocatorOS2.cpp \
		ExecutableAllocator.cpp \
		ARMAssembler.cpp \
                Logging.cpp \
		MacroAssemblerARM.cpp \
		MacroAssemblerX86Common.cpp \
		RegexCompiler.cpp \
		RegexJIT.cpp \
		pcre_compile.cpp \
                pcre_exec.cpp \
                pcre_tables.cpp \
                pcre_xclass.cpp \
                pcre_ucp_searchfuncs.cpp \
		$(NONE)

ifeq (86, $(findstring 86,$(TARGET_CPU)))
ifeq (x86_64, $(TARGET_CPU))
#CPPSRCS		+= only_on_x86_64.cpp
else
#CPPSRCS		+= only_on_x86.cpp
endif
endif
ifeq (arm, $(TARGET_CPU))
#CPPSRCS		+= only_on_arm.cpp
endif
#
# END enclude sources for the Nitro assembler
#############################################

endif

ifdef JS_HAS_CTYPES
VPATH += $(srcdir)/ctypes

CPPSRCS += \
    CTypes.cpp \
    Library.cpp \
    $(NULL)

LOCAL_INCLUDES = \
    -Ictypes/libffi/include \
    -I. \
    $(NULL)

ifeq ($(OS_ARCH),OS2)
SHARED_LIBRARY_LIBS += \
    ctypes/libffi/.libs/ffi.a \
    $(NULL)
else
SHARED_LIBRARY_LIBS += \
    ctypes/libffi/.libs/libffi.$(LIB_SUFFIX) \
    $(NULL)
endif

endif # JS_HAS_CTYPES

ifdef HAVE_DTRACE
INSTALLED_HEADERS += \
		$(CURDIR)/javascript-trace.h \
		$(NULL)
endif

# PerfMeasurement is available regardless of low-level support for it;
# it just doesn't necessarily do anything useful.  There is one
# implementation source file per supported operating system, plus a stub
# for unsupported OSes, plus the Javascript wrapper.
VPATH += $(srcdir)/perf
INSTALLED_HEADERS += jsperf.h
CPPSRCS += jsperf.cpp
ifdef HAVE_LINUX_PERF_EVENT_H
CPPSRCS += pm_linux.cpp
else
CPPSRCS += pm_stub.cpp
endif

ifeq (,$(filter-out WINNT,$(OS_ARCH)))
INSTALLED_HEADERS += jscpucfg.h
endif

EXPORTS = $(INSTALLED_HEADERS)

DASH_R		= -r

ifneq (,$(filter OS2 WINNT,$(OS_ARCH)))
SDK_LIBRARY = $(IMPORT_LIBRARY)
else
SDK_LIBRARY = $(SHARED_LIBRARY)
endif

include $(topsrcdir)/config/config.mk

EXTRA_DSO_LDOPTS += $(NSPR_LIBS)

ifndef BUILD_OPT
MOCHAFILE	= 1
endif

# Define keyword generator before rules.mk, see bug 323979 comment 50

HOST_SIMPLE_PROGRAMS += host_jskwgen$(HOST_BIN_SUFFIX)
GARBAGE += jsautokw.h host_jskwgen$(HOST_BIN_SUFFIX)

HOST_SIMPLE_PROGRAMS += host_jsoplengen$(HOST_BIN_SUFFIX)
GARBAGE += jsautooplen.h host_jsoplengen$(HOST_BIN_SUFFIX)

USE_HOST_CXX = 1

ifdef HAVE_DTRACE
ifneq ($(OS_ARCH),Darwin)
DTRACE_PROBE_OBJ = $(LIBRARY_NAME)-dtrace.$(OBJ_SUFFIX)
endif
MOZILLA_DTRACE_SRC = $(srcdir)/javascript-trace.d
endif

default::

ifneq (,$(CROSS_COMPILE)$(filter-out WINNT OS2,$(OS_ARCH)))
ifneq (,$(filter-out SYMBIAN,$(OS_ARCH)))
# nsinstall doesn't get built until we enter config/ in the exports phase,
# so we'll have to manually ensure it gets built here if we want to use
# $(EXPORTS)
export:: config/nsinstall$(HOST_BIN_SUFFIX)
$(PUBLIC) $(SDK_PUBLIC): config/nsinstall$(HOST_BIN_SUFFIX)

config/nsinstall$(HOST_BIN_SUFFIX): $(srcdir)/config/nsinstall.c $(srcdir)/config/pathsub.c
	$(MAKE) -C config/ nsinstall$(HOST_BIN_SUFFIX)
endif
endif

include $(topsrcdir)/config/rules.mk

ifdef JS_HAS_CTYPES
# Build libffi proper as part of the 'exports' target, so things get built
# in the right order.
export::
		$(call SUBMAKE,,ctypes/libffi)

distclean clean::
		$(call SUBMAKE,$@,ctypes/libffi)
endif

# Because the SpiderMonkey can be distributed and built independently
# of the Mozilla source tree, it contains its own copies of many of
# the files used by the top-level Mozilla build process, from the
# 'config' and 'build' subtrees.
#
# To make it simpler to keep the copies in sync, we follow the policy
# that the SpiderMonkey copies must always be exact copies of those in
# the containing Mozilla tree.  If you've made a change in one, it
# belongs in the other as well.  If the change isn't right for both
# places, then that's something to bring up with the other developers.
#
# Some files are reasonable to diverge; for  example,
# js/config/autoconf.mk.in doesn't need most of the stuff in
# config/autoconf.mk.in.
check-sync-dirs-cmd = $(PYTHON) $(srcdir)/config/check-sync-dirs.py
check-sync-dirs:
	$(check-sync-dirs-cmd) $(srcdir)/config $(MOZ_SYNC_BUILD_FILES)/config
	$(check-sync-dirs-cmd) $(srcdir)/build $(MOZ_SYNC_BUILD_FILES)/build

ifdef MOZ_SYNC_BUILD_FILES
check:: check-sync-dirs
endif

# The "find any vanilla new/new[] calls" script is tailored to Linux, so
# only run it there.  That should be enough to catch any such calls that
# creep in.
check-vanilla-new:
	$(srcdir)/config/find_vanilla_new_calls $(LIBRARY)

ifeq ($(OS_ARCH),Linux)
check:: check-vanilla-new
endif

# Help ensure that the number of OOM errors in SpiderMonkey doesn't increase.
# If the number of OOM errors changes, update the number below. We intend this
# number to go down over time, by fixing OOMs.
check-ooms:
	$(wildcard $(RUN_TEST_PROGRAM)) $(PYTHON) -u $(srcdir)/config/find_OOM_errors.py --regression 125

ifeq ($(MOZ_DEBUG),1)
#check:: check-ooms
endif

## Prevent regressing in our deprecation of non-preferred memory management functions.
# We use all the files in the distribution so that different configurations
# don't give different results. We skip the contents of objdirs using |find|
# (it can't be done with %-expansion, because the files we want to skip aren't
# in the vpath).
ALL_FILES=$(shell find $(srcdir) \( -name "*.cpp" -o -name "*.h" \) -not -path "*/dist/*")
check-malloc-function-usage: $(filter-out %jsutil.h %jscntxt.h, $(ALL_FILES))

	# js_malloc and friends are only used by other memory managers, and should
	# never be used elsewhere directly.
	$(srcdir)/config/check_source_count.py "\bjs_malloc\b" 0 \
		"in Makefile.in" "cx->malloc_ or rt->malloc_" $^
	$(srcdir)/config/check_source_count.py "\bjs_calloc\b" 0 \
		"in Makefile.in" "cx->calloc_ or rt->calloc_" $^
	$(srcdir)/config/check_source_count.py "\bjs_realloc\b" 0 \
		"in Makefile.in" "cx->realloc_ or rt->realloc_" $^
	$(srcdir)/config/check_source_count.py "\bjs_free\b" 0 \
		"in Makefile.in" "cx->free_" $^

	# We desire these numbers to go down, not up. See "User guide to memory
	# management within SpiderMonkey" in jsutil.h.
	$(srcdir)/config/check_source_count.py OffTheBooks:: 54 \
		"in Makefile.in" "{cx,rt}->{new_,new_array,malloc_,calloc_,realloc_}" $^
	# This should go to zero, if possible.
	$(srcdir)/config/check_source_count.py UnwantedForeground:: 35 \
		"in Makefile.in" "{cx,rt}->{free_,delete_,array_delete}" $^

ifneq ($(OS_ARCH),WINNT) # FIXME: this should be made work on Windows too.
check:: check-malloc-function-usage
endif

JITFLAGS = ,m,j,mj,mjp,am,amj,amjp,amd
check-jit-test::
	$(wildcard $(RUN_TEST_PROGRAM)) $(PYTHON) -u $(srcdir)/jit-test/jit_test.py \
	        --no-slow --no-progress --tinderbox --jitflags=$(JITFLAGS) $(DIST)/bin/js$(BIN_SUFFIX)

check-jit-test-valgrind::
	$(wildcard $(RUN_TEST_PROGRAM)) $(PYTHON) -u $(srcdir)/jit-test/jit_test.py \
	        --valgrind --no-slow --no-progress --tinderbox --jitflags=$(JITFLAGS) $(DIST)/bin/js$(BIN_SUFFIX)


# jstests doesn't have a --jitflags option, so we need to loop, updating the
# exit code (RC) after each invocation.
# FIXME: MethodJIT doesn't work for 1 test case (bug 644393), so
# --no-extensions is set to skip that test. Remove as soon as possible.
check-jstests:
	RC=0; \
	for f in `echo "$(JITFLAGS)" | tr ',' '\n'`; \
		do \
			$(wildcard $(RUN_TEST_PROGRAM)) $(PYTHON) -u $(srcdir)/tests/jstests.py \
				--tinderbox --no-progress \
				--no-extensions \
				--timeout 300 \
				--args="`echo $$f | sed 's/\(.\)/ -\1/g'`" \
				$(DIST)/bin/js$(BIN_SUFFIX); \
			RC=$$(( $$RC || $$?)); \
		done; \
	exit $$RC


check:: check-jit-test
#check:: check-jstests
check-valgrind:: check-jit-test-valgrind

DIST_GARBAGE = config.cache config.log config.status \
   config/autoconf.mk \
   unallmakefiles js-config js-config.h js-confdefs.h

distclean::
	cat unallmakefiles | $(XARGS) rm -f
	$(RM) $(DIST_GARBAGE)

# our build system doesn't handle subdir srcs very gracefully today
export::
	$(MKDIR) -p nanojit

DEFINES		+= -DEXPORT_JS_API

# Some platforms that have stdint.h include it in system headers.  So
# to reliably get limit macros defined, we'd always have to define the
# one below before including any header, but that's obscure and
# fragile, so we do it here.
DEFINES		+= -D__STDC_LIMIT_MACROS

INCLUDES	+= -I$(srcdir)

GARBAGE		+= jscpucfg.o jsautocfg.h jsautocfg.tmp jscpucfg

ifneq (,$(CROSS_COMPILE)$(filter-out WINNT,$(OS_ARCH)))
TARGETS		+= jscpucfg$(HOST_BIN_SUFFIX)
endif

ifdef JS_THREADSAFE
DEFINES		+= -DJS_THREADSAFE
endif

ifdef JS_HAS_CTYPES
DEFINES		+= -DJS_HAS_CTYPES
DEFINES         += -DDLL_PREFIX=\"$(DLL_PREFIX)\" -DDLL_SUFFIX=\"$(DLL_SUFFIX)\"
endif

ifdef JS_NO_THIN_LOCKS
DEFINES		+= -DJS_USE_ONLY_NSPR_LOCKS
endif

ifdef JS_VERSION
DEFINES		+= -DJS_VERSION=$(JS_VERSION)
endif

ifneq ($(findstring -L,$(NSPR_LIBS)),)
NSPR_STATIC_PATH = $(subst -L,,$(findstring -L,$(NSPR_LIBS)))
else
NSPR_STATIC_PATH = $(DIST)/lib
endif

ifdef MOZ_VTUNE
CXXFLAGS += -IC:/Program\ Files/Intel/VTune/Analyzer/Include
EXTRA_DSO_LDOPTS += C:/Program\ Files/Intel/VTune/Analyzer/Lib/VtuneApi.lib
LIBS +=  C:/Program\ Files/Intel/VTune/Analyzer/Lib/VtuneApi.lib
endif

# HP-UX does not require the extra linking of "-lm"
ifeq (,$(filter HP-UX WINNT OS2,$(OS_ARCH)))
EXTRA_LIBS	+= -lm
endif

# Prevent floating point errors caused by VC++ optimizations
ifeq ($(OS_ARCH)_$(GNU_CC),WINNT_)
ifeq (,$(filter-out 1200 1300 1310,$(_MSC_VER)))
CFLAGS += -Op
else
CFLAGS += -fp:precise
endif
endif # WINNT

ifeq ($(OS_ARCH),FreeBSD)
EXTRA_LIBS	+= -pthread
endif
ifeq ($(OS_ARCH),IRIX)
ifdef USE_N32
DASH_R		+= -n32
endif
endif
ifeq ($(OS_ARCH),Linux)
EXTRA_LIBS	+= -ldl
endif
ifeq ($(OS_ARCH),OSF1)
EXTRA_LIBS	+= -lc_r
endif
# Silence warnings on AIX/HP-UX from non-GNU compilers
ifndef GNU_CC
ifeq ($(OS_ARCH),AIX)
# Suppress warnings from xlC
# 1540-1281: offsetof() on null non-POD types
# 1540-1608: anonymous unions using static data members
CFLAGS		+= -qsuppress=1540-1281 -qsuppress=1540-1608
CXXFLAGS	+= -qsuppress=1540-1281 -qsuppress=1540-1608
endif
ifeq ($(OS_ARCH),HP-UX)
# Suppress warnings from aCC
# 3055: anonymous unions declaring types
# 4189: offsetof() on non-POD types
CFLAGS		+= +W3055,4189
CXXFLAGS	+= +W3055,4189
endif
endif
ifeq ($(OS_ARCH),SunOS)
ifeq ($(TARGET_CPU),sparc)

ifdef GNU_CC
CFLAGS   += -mcpu=v9
CXXFLAGS += -mcpu=v9
endif # GNU_CC

endif
ifeq ($(OS_RELEASE),4.1)
EXTRA_LIBS	+= -ldl -lnsl
else
EXTRA_LIBS	+= -lposix4 -ldl -lnsl -lsocket
endif
endif

ifdef MOZ_MEMORY
ifeq ($(OS_ARCH),Darwin)
LDFLAGS += -ljemalloc
endif
endif

ifdef SOLARIS_SUNPRO_CXX
ifeq ($(TARGET_CPU),sparc)
# Sun Studio SPARC doesn't work well with gcc inline asm, use lock_SunOS_sparc*.il
jslock.o: jslock.cpp Makefile.in lock_sparcv8plus.il lock_sparcv9.il
	$(REPORT_BUILD)
	@$(MAKE_DEPS_AUTO_CXX)
ifeq (sparcv9,$(findstring sparcv9,$(OS_TEST)))
	$(CXX) -o $@ -c $(COMPILE_CFLAGS) $(srcdir)/lock_sparcv9.il $<
else
	$(CXX) -o $@ -c $(COMPILE_CFLAGS) $(srcdir)/lock_sparcv8plus.il $<
endif # sparcv9
endif # sparc
endif # SOLARIS_SUNPRO_CXX

ifeq ($(OS_ARCH),IRIX)
ifndef GNU_CC
_COMPILE_CFLAGS  = $(patsubst -O%,-O1,$(COMPILE_CFLAGS))
jsapi.o jsxdrapi.o jsarena.o jsarray.o jsatom.o jsemit.o jsfun.o jsinterp.o jsreflect.o jsregexp.o jsparse.o jsopcode.o jsscript.o: %.o: %.cpp Makefile.in
	$(REPORT_BUILD)
	@$(MAKE_DEPS_AUTO_CXX)
	$(CXX) -o $@ -c $(_COMPILE_CFLAGS) $<
endif
endif

# An AIX Optimization bug causes PR_dtoa() & JS_dtoa to produce wrong result.
# This suppresses optimization for this single compilation unit.
ifeq ($(OS_ARCH),AIX)
jsatom.o: jsatom.cpp Makefile.in
	$(REPORT_BUILD)
	@$(MAKE_DEPS_AUTO_CXX)
	$(CXX) -o $@ -c $(filter-out $(MOZ_OPTIMIZE_FLAGS), $(COMPILE_CFLAGS)) $<
jsdtoa.o: jsdtoa.cpp Makefile.in
	$(REPORT_BUILD)
	@$(MAKE_DEPS_AUTO_CXX)
	$(CXX) -o $@ -c $(filter-out $(MOZ_OPTIMIZE_FLAGS), $(COMPILE_CFLAGS)) $<
endif

export:: jsautocfg.h

ifeq (,$(CROSS_COMPILE)$(GNU_CC)$(filter-out WINNT,$(OS_ARCH)))
jsautocfg.h:
	$(TOUCH) $@
else
jsautocfg.h: jscpucfg$(HOST_BIN_SUFFIX)
	@$(RM) $@ jsautocfg.tmp
	./jscpucfg > jsautocfg.tmp
	mv jsautocfg.tmp $@
endif

# jscpucfg is a strange target
# Needs to be built with the host compiler but needs to include
# the mdcpucfg for the target so it needs the appropriate target defines
ifdef HOST_NSPR_MDCPUCFG
HOST_CXX := $(HOST_CXX) -DMDCPUCFG=$(TARGET_NSPR_MDCPUCFG)
HOST_CXXFLAGS := $(patsubst -DXP_%,,$(HOST_CXXFLAGS))
endif

ifdef CROSS_COMPILE
# jscpucfg needs to know when it's supposed to produce a config for the target
JSCPUCFG_DEFINES = $(ACDEFINES)
endif

ifeq ($(OS_ARCH),QNX)
ifneq ($(OS_TARGET),NTO)
# QNX's compiler apparently can't build a binary directly from a source file.
jscpucfg.o: jscpucfg.cpp Makefile.in
	$(HOST_CXX) $(HOST_CXXFLAGS) -c $(JSCPUCFG_DEFINES) $(DEFINES) $(NSPR_CFLAGS) -o $@ $<

jscpucfg: jscpucfg.o
	$(HOST_CXX) $(HOST_CXXFLAGS) $(JSCPUCFG_DEFINES) $(DEFINES) -o $@ $<
endif
else
jscpucfg$(HOST_BIN_SUFFIX): jscpucfg.cpp Makefile.in
	$(HOST_CXX) $(HOST_CXXFLAGS) $(JSCPUCFG_DEFINES) $(DEFINES) $(NSPR_CFLAGS) $(HOST_OUTOPTION)$@ $<
endif

# Compute the linker flags that programs linking against SpiderMonkey should
# pass to get SpiderMonkey and its dependencies, beyond just the -L and -l
# for the SpiderMonkey library itself.
# - EXTRA_DSO_LDOPTS includes the NSPR -L and -l flags.
# - OS_LIBS includes libraries selected by the configure script.
# - EXTRA_LIBS includes libraries selected by this Makefile.
JS_CONFIG_LIBS=$(EXTRA_DSO_LDOPTS) $(OS_LIBS) $(EXTRA_LIBS) 

# The configure script invokes this rule explicitly at configure time!
# It's important that js-config be ready by the time we're done
# configuring, because we may be running other configure scripts that
# would like to run js-config themselves, before js is built.
#
# This file and rules.mk go through a certain amount of work to decide
# which libraries to build, what to name them, and what flags to pass
# when linking them (and thus what flags its own clients must pass).
# All this information needs to go into the js-config script.  To
# avoid trying to re-compute all that in the configure script, we just
# have the configure script generate this Makefile, and then invoke
# this rule.
at=@
js-config: js-config.in Makefile $(DEPTH)/config/autoconf.mk $(topsrcdir)/config/config.mk $(topsrcdir)/config/rules.mk
	$(RM) js-config.tmp
	sed < $< > js-config.tmp \
	-e 's|$(at)prefix$(at)|$(prefix)|' \
	-e 's|$(at)exec_prefix$(at)|$(exec_prefix)|' \
	-e 's|$(at)includedir$(at)|$(includedir)|' \
	-e 's|$(at)libdir$(at)|$(libdir)|' \
	-e 's|$(at)MOZILLA_VERSION$(at)|$(MOZILLA_VERSION)|' \
	-e 's|$(at)LIBRARY_NAME$(at)|$(LIBRARY_NAME)|' \
	-e 's|$(at)NSPR_CFLAGS$(at)|$(NSPR_CFLAGS)|' \
	-e 's|$(at)JS_CONFIG_LIBS$(at)|$(JS_CONFIG_LIBS)|' \
	-e 's|$(at)MOZ_JS_LIBS$(at)|$(MOZ_JS_LIBS)|' \
	&& mv js-config.tmp $@ && chmod +x $@

SCRIPTS = js-config
SDK_BINARY = js-config

install:: $(INSTALLED_HEADERS)
	$(SYSINSTALL) $^ $(DESTDIR)$(includedir)/$(MODULE)

install:: $(SCRIPTS)
	$(SYSINSTALL) $^ $(DESTDIR)$(bindir)

install:: $(LIBRARY) $(SHARED_LIBRARY) $(IMPORT_LIBRARY)
ifneq (,$(LIBRARY))
	$(SYSINSTALL) $(LIBRARY) $(DESTDIR)$(libdir)
endif
ifneq (,$(SHARED_LIBRARY))
	$(SYSINSTALL) $(SHARED_LIBRARY) $(DESTDIR)$(libdir)
endif
ifneq (,$(IMPORT_LIBRARY))
	$(SYSINSTALL) $(IMPORT_LIBRARY) $(DESTDIR)$(libdir)
endif

# Extra dependancies and rules for auto-generated headers
host_jskwgen.$(OBJ_SUFFIX): jsversion.h jskeyword.tbl

# Use CURDIR to avoid finding a jsautokw.h in the source tree (from a
# previous build?) via VPATH when we're building in a separate tree.
$(CURDIR)/jsautokw.h: host_jskwgen$(HOST_BIN_SUFFIX)
	./host_jskwgen$(HOST_BIN_SUFFIX) $@

host_jsoplengen.$(OBJ_SUFFIX): jsopcode.tbl

# Use CURDIR to avoid finding a jsautooplen.h in the source tree (from
# a previous build?) via VPATH when we're building in a separate tree.
$(CURDIR)/jsautooplen.h: host_jsoplengen$(HOST_BIN_SUFFIX)
	./host_jsoplengen$(HOST_BIN_SUFFIX) $@

# Force auto-header generation before compiling any source that may use them
$(patsubst %.cc,%.$(OBJ_SUFFIX),$(CPPSRCS:%.cpp=%.$(OBJ_SUFFIX))): $(CURDIR)/jsautokw.h $(CURDIR)/jsautooplen.h

ifdef HAVE_DTRACE
$(CURDIR)/javascript-trace.h: $(srcdir)/javascript-trace.d
	dtrace -h -s $(srcdir)/javascript-trace.d -o javascript-trace.h.in
	sed -e 's/if _DTRACE_VERSION/ifdef INCLUDE_MOZILLA_DTRACE/' \
	    -e '/const/!s/char \*/const char */g' \
	    javascript-trace.h.in > javascript-trace.h

# We can't automatically generate dependencies on auto-generated headers;
# we have to list them explicitly.
$(addsuffix .$(OBJ_SUFFIX),jsprobes jsinterp jsobj): $(CURDIR)/javascript-trace.h
endif

ifdef ENABLE_TRACEJIT
# Imacro compilation.
$(CURDIR)/imacros.c.out: $(srcdir)/imacro_asm.py $(srcdir)/imacros.jsasm jsopcode.tbl
	$(PYTHON) $< $(srcdir)/imacros.jsasm $(CURDIR)/imacros.c.out
$(addsuffix .$(OBJ_SUFFIX),jstracer): $(CURDIR)/imacros.c.out

# Code for importing the nanojit subtree from its repository.
NANOJIT_CENTRAL_REV=$(shell cat $(srcdir)/nanojit-import-rev)
NANOJIT_CENTRAL_REPO=http://hg.mozilla.org/projects/nanojit-central
NANOJIT_CENTRAL_LOCAL=$(CURDIR)/nanojit-central
CUR_REPO=$(srcdir)/../..

update-nanojit:
	$(RM) -r $(NANOJIT_CENTRAL_LOCAL) import-splicemap import-revmap
	hg clone $(NANOJIT_CENTRAL_REPO) $(NANOJIT_CENTRAL_LOCAL)
	python $(srcdir)/find-child.py \
	                   --src=$(NANOJIT_CENTRAL_LOCAL) \
	                   --dst=$(CUR_REPO) \
	                   --start=$(NANOJIT_CENTRAL_REV) \
	                   --filemap=$(srcdir)/nanojit-import-filemap \
	                   >import-splicemap
	hg convert --config convert.hg.saverev=True \
	           --config convert.hg.startrev=`cut -d ' ' -f 1 import-splicemap` \
	           --filemap=$(srcdir)/nanojit-import-filemap \
	           --splicemap=import-splicemap \
	           $(NANOJIT_CENTRAL_LOCAL) \
	           $(CUR_REPO) \
	           import-revmap
	(cd $(srcdir) && hg up)
	(cd $(NANOJIT_CENTRAL_LOCAL) && hg log -r tip --template "{node}\n") >$(srcdir)/nanojit-import-rev
	(cd $(srcdir) && hg commit --message="Update nanojit-import-rev stamp." nanojit-import-rev)

.PHONY: update-nanojit
endif

###############################################
# BEGIN kludges for the Nitro assembler
#

# Needed to "configure" it correctly.  Unfortunately these
# flags wind up being applied to all code in js/src, not just
# the code in js/src/assembler.
CXXFLAGS += -DUSE_SYSTEM_MALLOC=1 -DENABLE_ASSEMBLER=1 -DENABLE_JIT=1

INCLUDES +=	-I$(srcdir)/assembler -I$(srcdir)/yarr

ifdef ENABLE_METHODJIT
# Build a standalone test program that exercises the assembler
# sources a bit.
TESTMAIN_OBJS = \
		Assertions.$(OBJ_SUFFIX) \
		ExecutableAllocatorPosix.$(OBJ_SUFFIX) \
		ExecutableAllocatorWin.$(OBJ_SUFFIX) \
		ExecutableAllocator.$(OBJ_SUFFIX) \
		ARMAssembler.$(OBJ_SUFFIX) \
		MacroAssemblerARM.$(OBJ_SUFFIX) \
		TestMain.$(OBJ_SUFFIX) \
		jsutil.$(OBJ_SUFFIX) \
		jslog2.$(OBJ_SUFFIX)
TestMain$(HOST_BIN_SUFFIX): $(TESTMAIN_OBJS)
	$(CXX) -o TestMain$(HOST_BIN_SUFFIX) $(TESTMAIN_OBJS)
endif

#
# END kludges for the Nitro assembler
###############################################