# -*- Mode: makefile -*-
#
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.

DEPTH		= @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 ($(OS_ARCH),ANDROID)
TEST_DIRS += jsapi-tests
endif

TEST_DIRS += tests

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

LIBS		= $(NSPR_LIBS)

# 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) \
		$(srcdir)/builtin \
		$(srcdir)/devtools \
		$(srcdir)/ds \
		$(srcdir)/frontend \
		$(srcdir)/gc \
		$(srcdir)/vm \
		$(NULL)

CPPSRCS		= \
		jsalloc.cpp \
		jsanalyze.cpp \
		jsapi.cpp \
		jsarray.cpp \
		jsatom.cpp \
		jsbool.cpp \
		jsclone.cpp \
		jscntxt.cpp \
		jscompartment.cpp \
		jsdate.cpp \
		jsdbgapi.cpp \
		jsdhash.cpp \
		jsdtoa.cpp \
		jsexn.cpp \
		jsfriendapi.cpp \
		jsfun.cpp \
		jsgc.cpp \
		jscrashreport.cpp \
		jsinfer.cpp \
		jsinterp.cpp \
		jsiter.cpp \
		jslog2.cpp \
		jsmath.cpp \
		jsmemorymetrics.cpp \
		jsnativestack.cpp \
		jsnum.cpp \
		jsobj.cpp \
		json.cpp \
		jsonparser.cpp \
		jsopcode.cpp \
		jsproxy.cpp \
		jsprf.cpp \
		jsprobes.cpp \
		jspropertycache.cpp \
		jspropertytree.cpp \
		jsreflect.cpp \
		jsscope.cpp \
		jsscript.cpp \
		jsstr.cpp \
		jstypedarray.cpp \
		jsutil.cpp \
		jswatchpoint.cpp \
		jsweakmap.cpp \
		jsworkers.cpp \
		jswrapper.cpp \
		jsxml.cpp \
		prmjtime.cpp \
		sharkctl.cpp \
		ArgumentsObject.cpp \
		ScopeObject.cpp \
		Debugger.cpp \
		GlobalObject.cpp \
		ObjectImpl.cpp \
		Stack.cpp \
		String.cpp \
		BytecodeCompiler.cpp \
		BytecodeEmitter.cpp \
		FoldConstants.cpp \
		NameFunctions.cpp \
		ParallelArray.cpp \
		ParseMaps.cpp \
		ParseNode.cpp \
		Parser.cpp \
		SPSProfiler.cpp \
		TokenStream.cpp \
		TestingFunctions.cpp \
		Profilers.cpp \
		LifoAlloc.cpp \
		Eval.cpp \
		MapObject.cpp \
		RegExpObject.cpp \
		RegExpStatics.cpp \
		RegExp.cpp \
		Marking.cpp \
		Memory.cpp \
		Statistics.cpp \
		StoreBuffer.cpp \
		StringBuffer.cpp \
		Unicode.cpp \
		Xdr.cpp \
		$(NULL)

# Changes to internal header files, used externally, massively slow down
# browser builds.  Don't add new files here unless you know what you're
# doing!
INSTALLED_HEADERS = \
		js-config.h \
		jscpucfg.h \
		js.msg \
		jsalloc.h \
		jsapi.h \
		jsclass.h \
		jsclist.h \
		jsdbgapi.h \
		jsdhash.h \
		jsfriendapi.h \
		jsgc.h \
		jslock.h \
		json.h \
		jsproxy.h \
		jsprf.h \
		jsprototypes.h \
		jsprvtd.h \
		jspubtd.h \
		jstypes.h \
		jsutil.h \
		jsversion.h \
		jswrapper.h \
		jsval.h \
		$(NULL)

######################################################
# BEGIN exported headers that are only exported
#       because of inclusion by an INSTALLED_HEADER
#
EXPORTS_NAMESPACES += ds gc

EXPORTS_ds = \
		BitArray.h \
		$(NULL)

EXPORTS_gc = \
		Barrier.h \
		Heap.h \
		Root.h \
		Statistics.h \
		StoreBuffer.h \
		$(NULL)

######################################################
# BEGIN include exported headers from the JS engine
#
#       Ultimately, after cleansing INSTALLED_HEADERS,
#       these will be the ONLY headers exported by
#       the js engine
#
VPATH		+= \
		$(srcdir)/../public \
		$(NULL)

EXPORTS_NAMESPACES += js

# If you add a header here, add it to js/src/jsapi-tests/testIntTypesABI.cpp so
# that we ensure we don't over-expose our internal integer typedefs.  Note that
# LegacyIntTypes.h below is deliberately exempted from this requirement.
EXPORTS_js = \
		HashTable.h \
		LegacyIntTypes.h \
		MemoryMetrics.h \
		TemplateLib.h \
		Utility.h \
		Vector.h \
		$(NULL)

###############################################
# BEGIN include sources for low-level code shared with mfbt
#
MFBT_ROOT = $(srcdir)/../../mfbt
VPATH += $(MFBT_ROOT)
include $(MFBT_ROOT)/exported_headers.mk

###############################################
# BEGIN enable non-releasable features
#
ifeq (,$(filter beta release esr,$(MOZ_UPDATE_CHANNEL)))
DEFINES += -DENABLE_TYPEDARRAY_MOVE
endif

ifdef ENABLE_TRACE_LOGGING

###############################################
# BEGIN include sources for trace logging
#
CPPSRCS += 	TraceLogging.cpp

endif

ifdef ENABLE_METHODJIT

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

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

# Ion
ifdef ENABLE_ION
VPATH +=	$(srcdir)/ion
VPATH +=	$(srcdir)/ion/shared

CPPSRCS +=	MIR.cpp \
		Bailouts.cpp \
		BitSet.cpp \
		C1Spewer.cpp \
		CodeGenerator.cpp \
		CodeGenerator-shared.cpp \
		Ion.cpp \
		IonAnalysis.cpp \
		IonBuilder.cpp \
		IonCaches.cpp \
		IonFrames.cpp \
		IonMacroAssembler.cpp \
		IonSpewer.cpp \
		JSONSpewer.cpp \
		LICM.cpp \
		LinearScan.cpp \
		LIR.cpp \
		Lowering.cpp \
		Lowering-shared.cpp \
		MCallOptimize.cpp \
		MIRGraph.cpp \
		MoveResolver.cpp \
		EdgeCaseAnalysis.cpp \
		Snapshots.cpp \
		Safepoints.cpp \
		TypeOracle.cpp \
		TypePolicy.cpp \
		ValueNumbering.cpp \
		RangeAnalysis.cpp \
		VMFunctions.cpp \
		AliasAnalysis.cpp \
		$(NULL)
endif #ENABLE_ION
ifeq (86, $(findstring 86,$(TARGET_CPU)))
ifdef ENABLE_ION
CPPSRCS +=	CodeGenerator-x86-shared.cpp
CPPSRCS +=	IonFrames-x86-shared.cpp
CPPSRCS +=	MoveEmitter-x86-shared.cpp
CPPSRCS +=	Assembler-x86-shared.cpp
CPPSRCS +=	Lowering-x86-shared.cpp
endif #ENABLE_ION
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
ifdef ENABLE_ION
VPATH +=	$(srcdir)/ion/x64
CPPSRCS += 	Lowering-x64.cpp \
		CodeGenerator-x64.cpp \
		Trampoline-x64.cpp \
		Assembler-x64.cpp \
		Bailouts-x64.cpp \
		MacroAssembler-x64.cpp \
		$(NULL)
endif #ENABLE_ION
else
ifdef ENABLE_ION
VPATH +=	$(srcdir)/ion/x86
CPPSRCS +=	Lowering-x86.cpp \
		CodeGenerator-x86.cpp \
		Trampoline-x86.cpp \
		Assembler-x86.cpp \
		Bailouts-x86.cpp \
		MacroAssembler-x86.cpp \
		$(NULL)
endif #ENABLE_ION
ifdef SOLARIS_SUNPRO_CXX
ASFILES +=	TrampolineSUNWX86.s
endif
endif
endif
ifdef ENABLE_ION
ifeq (arm, $(findstring arm, $(TARGET_CPU)))
ifdef ENABLE_ION
VPATH +=	$(srcdir)/ion/arm
CPPSRCS +=	Lowering-arm.cpp \
		CodeGenerator-arm.cpp \
		Trampoline-arm.cpp \
		Assembler-arm.cpp \
		Bailouts-arm.cpp \
		IonFrames-arm.cpp \
		MoveEmitter-arm.cpp \
		Architecture-arm.cpp \
		MacroAssembler-arm.cpp \
		$(NULL)
endif #ENABLE_ION
endif
endif #ENABLE_ION
ifeq (sparc, $(findstring sparc,$(TARGET_CPU)))
ASFILES +=	TrampolineSparc.s
endif
ifeq (mips, $(findstring mips,$(TARGET_CPU)))
CPPSRCS +=	TrampolineMIPS.cpp
endif
#
# END enclude sources for the method JIT
#############################################

endif

###############################################
# BEGIN include sources for the Nitro assembler
#

VPATH += 	$(srcdir)/assembler \
		$(srcdir)/assembler/wtf \
		$(srcdir)/assembler/jit \
		$(srcdir)/yarr \
		$(NONE)

CPPSRCS += 	ExecutableAllocator.cpp \
		PageBlock.cpp \
		YarrInterpreter.cpp \
		YarrPattern.cpp \
		YarrSyntaxChecker.cpp \
		$(NONE)

ifdef ENABLE_METHODJIT_SPEW
CPPSRCS += Logging.cpp
endif

ifneq (,$(filter-out OS2 WINNT,$(OS_ARCH)))
CPPSRCS += ExecutableAllocatorPosix.cpp \
           OSAllocatorPosix.cpp \
           $(NONE)
endif
ifeq ($(OS_ARCH),WINNT)
CPPSRCS += ExecutableAllocatorWin.cpp \
           OSAllocatorWin.cpp \
           $(NONE)
endif
ifeq ($(OS_ARCH),OS2)
CPPSRCS += ExecutableAllocatorOS2.cpp \
           OSAllocatorOS2.cpp \
           $(NONE)
endif

ifneq (,$(filter arm% sparc %86 x86_64 mips%,$(TARGET_CPU)))
ENABLE_YARR_JIT = 1
DEFINES += -DENABLE_YARR_JIT=1

VPATH += 	$(srcdir)/assembler/assembler \
		$(srcdir)/methodjit \
		$(NONE)

CPPSRCS +=	ARMAssembler.cpp \
		MacroAssemblerARM.cpp \
		MacroAssemblerX86Common.cpp \
		YarrJIT.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, $(findstring arm, $(TARGET_CPU)))
#CPPSRCS		+= only_on_arm.cpp
endif

endif

#
# END enclude sources for the Nitro assembler
#############################################

ifdef JS_HAS_CTYPES
VPATH += $(srcdir)/ctypes

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

ifdef MOZ_NATIVE_FFI
LOCAL_INCLUDES = $(MOZ_FFI_CFLAGS)
else
LOCAL_INCLUDES = -Ictypes/libffi/include
endif

LOCAL_INCLUDES += \
    -I. \
    $(NULL)


ifdef MOZ_NATIVE_FFI
EXTRA_DSO_LDOPTS += $(MOZ_FFI_LIBS)
else
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

endif # JS_HAS_CTYPES

LOCAL_INCLUDES += -I$(MFBT_ROOT)/double-conversion

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

EXPORTS = $(INSTALLED_HEADERS)

DASH_R		= -r

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

# for compiler bug (http://support.microsoft.com/kb/982107) for MSVC x64
ifdef _MSC_VER
ifneq (,$(filter 1400 1500,$(_MSC_VER)))
ifeq ($(OS_TEST),x86_64)
ASFILES += jswin64.asm
endif
endif
endif

include $(topsrcdir)/config/config.mk

ifeq (,$(MOZ_GLUE_PROGRAM_LDFLAGS))
# When building standalone, we need to include mfbt sources, and to declare
# "exported" mfbt symbols on its behalf when we use its headers.
include $(MFBT_ROOT)/sources.mk
DEFINES += -DIMPL_MFBT
endif

EXTRA_DSO_LDOPTS += $(NSPR_LIBS)

ifndef BUILD_OPT
MOCHAFILE	= 1
endif

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

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

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

GARBAGE += selfhosted.out.h

USE_HOST_CXX = 1

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

default::

ifneq (,$(CROSS_COMPILE)$(filter-out WINNT OS2,$(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

include $(topsrcdir)/config/rules.mk

ifdef JS_HAS_CTYPES
ifndef MOZ_NATIVE_FFI
# 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
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

ifdef MOZ_VALGRIND
ifndef MOZ_ASAN
JITTEST_VALGRIND_FLAG = --valgrind
endif
endif

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

check:: check-jit-test

# 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

# FIXME:
# We want to run check-jstests as part of |make check| on all platforms, on
# tinderbox. However, some configurations don't work quite right just yet.
# Rather than risking regressions in major configurations while fixing these
# secondary configuration, we work around them and fix the bugs later.
#
#   Bug 652154: On Windows, SM(!m !t) don't work because of path problems with
#				their unusual directory layout
#
#   Bug 652155: On Mac, SM(d) doesn't work for unknown reasons

ifeq ($(OS_ARCH),WINNT)
ifdef ENABLE_METHODJIT
endif
else
ifndef HAVE_DTRACE
#check:: check-jstests
endif
endif

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)

DEFINES		+= -DEXPORT_JS_API

INCLUDES	+= -I$(srcdir)

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_VERSION
DEFINES		+= -DJS_VERSION=$(JS_VERSION)
endif

# We do not want to have obsolete NSPR functionality in threadsafe builds.
DEFINES   += -DNO_NSPR_10_SUPPORT

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

ifdef MOZ_ETW
# This will get the ETW provider resources into the library mozjs.dll
RESFILE = ETWProvider.res
endif

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

CFLAGS += $(MOZ_ZLIB_CFLAGS)
EXTRA_LIBS += $(MOZ_ZLIB_LIBS)
# Enable zlib usage if zlib has been located. When building the browser on
# Windows, MOZ_ZLIB_LIBS is empty because zlib is part of libmozglue. We thus
# also enable zlib if mozglue is present.
ifneq (,$(MOZ_ZLIB_LIBS)$(MOZ_GLUE_LDFLAGS))
DEFINES += -DUSE_ZLIB
endif

# Prevent floating point errors caused by VC++ optimizations
ifdef _MSC_VER
# XXX We should add this to CXXFLAGS, too?
CFLAGS += -fp:precise

ifeq ($(CPU_ARCH),x86)
# Workaround compiler bug on PGO (Bug 721284)
MonoIC.$(OBJ_SUFFIX): CXXFLAGS += -GL-
Compiler.$(OBJ_SUFFIX): CXXFLAGS += -GL-
# Ditto (Bug 772303)
RegExp.$(OBJ_SUFFIX): CXXFLAGS += -GL-
endif
endif # _MSC_VER

ifeq ($(OS_ARCH),FreeBSD)
EXTRA_LIBS	+= -pthread
endif
ifeq ($(OS_ARCH),Linux)
EXTRA_LIBS	+= -ldl
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

# 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

# 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
	$(MAKE) -C shell install

# Extra dependencies and rules for auto-generated headers
host_jskwgen.$(OBJ_SUFFIX): jsversion.h vm/Keywords.h

# 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 MOZ_ETW
ETWProvider.h ETWProvider.rc ETWProvider.mof: ETWProvider.man
	$(MC) -um -mof $^

jsprobes.$(OBJ_SUFFIX): ETWProvider.h

ETWProvider.res: ETWProvider.rc
	$(RC) -r -i "$(SDKDIR)Include" $^

export:: ETWProvider.res

install:: ETWProvider.mof ETWProvider.man
	$(SYSINSTALL) $^ $(DESTDIR)$(bindir)

endif

ifdef HAVE_DTRACE
$(CURDIR)/javascript-trace.h: $(srcdir)/devtools/javascript-trace.d
	dtrace -h -s $(srcdir)/devtools/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 HAVE_LINUX_PERF_EVENT_H
pm_linux.$(OBJ_SUFFIX): CXXFLAGS += $(LINUX_HEADERS_INCLUDES)
endif

# Prepare self-hosted JS code for embedding
export:: selfhosted.out.h

selfhosting_srcs := \
  $(srcdir)/builtin/array.js \
  $(NULL)

selfhosted_out_h_deps := \
  $(selfhosting_srcs) \
  $(srcdir)/js.msg \
  $(srcdir)/builtin/macros.py \
  $(srcdir)/builtin/js2c.py \
  $(srcdir)/builtin/embedjs.py

ifeq ($(MOZ_DEBUG),1)
selfhosting_embed_flags += -d
endif

selfhosted.out.h: $(selfhosted_out_h_deps)
	$(PYTHON) $(srcdir)/builtin/embedjs.py $(selfhosting_embed_flags) $@ \
	  $(srcdir)/js.msg $(srcdir)/builtin/macros.py $(selfhosting_srcs)

###############################################
# 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

ifneq (,$(ENABLE_YARR_JIT)$(ENABLE_METHODJIT))
CXXFLAGS +=  -DENABLE_JIT=1
endif

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) \
		ExecutableAllocator.$(OBJ_SUFFIX) \
		ARMAssembler.$(OBJ_SUFFIX) \
		MacroAssemblerARM.$(OBJ_SUFFIX) \
		TestMain.$(OBJ_SUFFIX) \
		jsutil.$(OBJ_SUFFIX) \
		jslog2.$(OBJ_SUFFIX)

ifeq ($(OS_ARCH),WINNT)
TESTMAIN_OBJS += ExecutableAllocatorWin.$(OBJ_SUFFIX)
else
TESTMAIN_OBJS += ExecutableAllocatorPosix.$(OBJ_SUFFIX)
endif

TestMain$(HOST_BIN_SUFFIX): $(TESTMAIN_OBJS)
	$(CXX) -o TestMain$(HOST_BIN_SUFFIX) $(TESTMAIN_OBJS)
endif

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