llvm-6502/Makefile.rules
Reid Spencer 3ed469ccd7 For PR786:
Turn on -Wunused and -Wno-unused-parameter. Clean up most of the resulting
fall out by removing unused variables. Remaining warnings have to do with
unused functions (I didn't want to delete code without review) and unused
variables in generated code. Maintainers should clean up the remaining
issues when they see them. All changes pass DejaGnu tests and Olden.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@31380 91177308-0d34-0410-b5e6-96231b3b80d8
2006-11-02 20:25:50 +00:00

1673 lines
57 KiB
Makefile

#===-- Makefile.rules - Common make rules for LLVM ---------*- Makefile -*--===#
#
# The LLVM Compiler Infrastructure
#
# This file was developed by the LLVM research group and is distributed under
# the University of Illinois Open Source License. See LICENSE.TXT for details.
#
#===------------------------------------------------------------------------===#
#
# This file is included by all of the LLVM makefiles. For details on how to use
# it properly, please see the document MakefileGuide.html in the docs directory.
#
#===-----------------------------------------------------------------------====#
################################################################################
# TARGETS: Define standard targets that can be invoked
################################################################################
#--------------------------------------------------------------------
# Define the various target sets
#--------------------------------------------------------------------
RecursiveTargets := all clean clean-all install uninstall install-bytecode
LocalTargets := all-local clean-local clean-all-local check-local \
install-local printvars uninstall-local \
install-bytecode-local
TopLevelTargets := check dist dist-check dist-clean tags dist-gzip dist-bzip2 \
dist-zip
UserTargets := $(RecursiveTargets) $(LocalTargets) $(TopLevelTargets)
InternalTargets := preconditions distdir dist-hook
################################################################################
# INITIALIZATION: Basic things the makefile needs
################################################################################
#--------------------------------------------------------------------
# Set the VPATH so that we can find source files.
#--------------------------------------------------------------------
VPATH=$(PROJ_SRC_DIR)
#--------------------------------------------------------------------
# Reset the list of suffixes we know how to build
#--------------------------------------------------------------------
.SUFFIXES:
.SUFFIXES: .c .cpp .cc .h .hpp .y .l .lo .o .a .bc .td .ps .dot .ll
.SUFFIXES: $(SHLIBEXT) $(SUFFIXES)
#--------------------------------------------------------------------
# Mark all of these targets as phony to avoid implicit rule search
#--------------------------------------------------------------------
.PHONY: $(UserTargets) $(InternalTargets)
#--------------------------------------------------------------------
# Make sure all the user-target rules are double colon rules and
# they are defined first.
#--------------------------------------------------------------------
$(UserTargets)::
################################################################################
# PRECONDITIONS: that which must be built/checked first
################################################################################
SrcMakefiles := $(filter %Makefile %Makefile.tests,\
$(wildcard $(PROJ_SRC_DIR)/Makefile*))
ObjMakefiles := $(subst $(PROJ_SRC_DIR),$(PROJ_OBJ_DIR),$(SrcMakefiles))
ConfigureScript := $(PROJ_SRC_ROOT)/configure
ConfigStatusScript := $(PROJ_OBJ_ROOT)/config.status
MakefileConfigIn := $(strip $(wildcard $(PROJ_SRC_ROOT)/Makefile.config.in))
MakefileCommonIn := $(strip $(wildcard $(PROJ_SRC_ROOT)/Makefile.common.in))
MakefileConfig := $(PROJ_OBJ_ROOT)/Makefile.config
MakefileCommon := $(PROJ_OBJ_ROOT)/Makefile.common
PreConditions := $(ConfigStatusScript) $(ObjMakefiles)
ifneq ($(MakefileCommonIn),)
PreConditions += $(MakefileCommon)
endif
ifneq ($(MakefileConfigIn),)
PreConditions += $(MakefileConfig)
endif
preconditions: $(PreConditions)
#------------------------------------------------------------------------
# Make sure the BUILT_SOURCES are built first
#------------------------------------------------------------------------
$(filter-out clean clean-local,$(UserTargets)):: $(BUILT_SOURCES)
clean-local::
ifneq ($(strip $(BUILT_SOURCES)),)
-$(Verb) $(RM) -f $(BUILT_SOURCES)
endif
ifneq ($(PROJ_OBJ_ROOT),$(PROJ_SRC_ROOT))
spotless:
$(Verb) if test -x config.status ; then \
$(EchoCmd) Wiping out $(PROJ_OBJ_ROOT) ; \
$(MKDIR) .spotless.save ; \
$(MV) config.status .spotless.save ; \
$(MV) mklib .spotless.save ; \
$(MV) projects .spotless.save ; \
$(RM) -rf * ; \
$(MV) .spotless.save/config.status . ; \
$(MV) .spotless.save/mklib . ; \
$(MV) .spotless.save/projects . ; \
$(RM) -rf .spotless.save ; \
$(EchoCmd) Rebuilding configuration of $(PROJ_OBJ_ROOT) ; \
$(ConfigStatusScript) --recheck $(ConfigureScriptFLAGS) && \
$(ConfigStatusScript) ; \
else \
$(EchoCmd) "make spotless" can only be run from $(PROJ_OBJ_ROOT); \
fi
else
spotless:
$(EchoCmd) "spotless target not supported for objdir == srcdir"
endif
$(BUILT_SOURCES) : $(ObjMakefiles)
#------------------------------------------------------------------------
# Make sure we're not using a stale configuration
#------------------------------------------------------------------------
reconfigure:
$(Echo) Reconfiguring $(PROJ_OBJ_ROOT)
$(Verb) cd $(PROJ_OBJ_ROOT) && \
if test -w $(PROJ_OBJ_ROOT)/config.cache ; then \
$(RM) $(PROJ_OBJ_ROOT)/config.cache ; \
fi ; \
$(ConfigStatusScript) --recheck $(ConfigureScriptFLAGS) && \
$(ConfigStatusScript)
.PRECIOUS: $(ConfigStatusScript)
$(ConfigStatusScript): $(ConfigureScript)
$(Echo) Reconfiguring with $<
$(Verb) cd $(PROJ_OBJ_ROOT) && \
if test -w $(PROJ_OBJ_ROOT)/config.cache ; then \
$(RM) $(PROJ_OBJ_ROOT)/config.cache ; \
fi ; \
$(ConfigStatusScript) --recheck $(ConfigureScriptFLAGS) && \
$(ConfigStatusScript)
#------------------------------------------------------------------------
# Make sure the configuration makefile is up to date
#------------------------------------------------------------------------
ifneq ($(MakefileConfigIn),)
$(MakefileConfig): $(MakefileConfigIn) $(ConfigStatusScript)
$(Echo) Regenerating $@
$(Verb) cd $(PROJ_OBJ_ROOT) ; $(ConfigStatusScript) Makefile.config
endif
ifneq ($(MakefileCommonIn),)
$(MakefileCommon): $(MakefileCommonIn) $(ConfigStatusScript)
$(Echo) Regenerating $@
$(Verb) cd $(PROJ_OBJ_ROOT) ; $(ConfigStatusScript) Makefile.common
endif
#------------------------------------------------------------------------
# If the Makefile in the source tree has been updated, copy it over into the
# build tree. But, only do this if the source and object makefiles differ
#------------------------------------------------------------------------
ifneq ($(PROJ_OBJ_DIR),$(PROJ_SRC_DIR))
Makefile: $(PROJ_SRC_DIR)/Makefile
$(Echo) "Updating Makefile"
$(Verb) $(MKDIR) $(@D)
$(Verb) $(CP) -f $< $@
# Copy the Makefile.* files unless we're in the root directory which avoids
# the copying of Makefile.config.in or other things that should be explicitly
# taken care of.
$(PROJ_OBJ_DIR)/Makefile% : $(PROJ_SRC_DIR)/Makefile%
@case '$?' in \
*Makefile.rules) ;; \
*.in) ;; \
*) $(Echo) "Updating $(@F)" ; \
$(MKDIR) $(@D) ; \
$(CP) -f $< $@ ;; \
esac
endif
#------------------------------------------------------------------------
# Set up the basic dependencies
#------------------------------------------------------------------------
$(UserTargets):: $(PreConditions)
all:: all-local
clean:: clean-local
clean-all:: clean-local clean-all-local
install:: install-local
uninstall:: uninstall-local
install-local:: all-local
install-bytecode:: install-bytecode-local
###############################################################################
# VARIABLES: Set up various variables based on configuration data
###############################################################################
#--------------------------------------------------------------------
# Variables derived from configuration we are building
#--------------------------------------------------------------------
# OPTIMIZE_OPTION - The optimization level option we want to build LLVM with
# this can be overridden on the make command line.
ifneq ($(OS),MingW)
OPTIMIZE_OPTION := -O3
else
OPTIMIZE_OPTION := -O2
endif
ifdef ENABLE_PROFILING
BuildMode := Profile
CXX.Flags := $(OPTIMIZE_OPTION) -pg -g
C.Flags := $(OPTIMIZE_OPTION) -pg -g
LD.Flags := $(OPTIMIZE_OPTION) -pg -g
else
ifdef ENABLE_OPTIMIZED
BuildMode := Release
# Don't use -fomit-frame-pointer on Darwin or FreeBSD.
ifneq ($(OS),FreeBSD)
ifneq ($(OS),Darwin)
OmitFramePointer := -fomit-frame-pointer
endif
endif
# Darwin requires -fstrict-aliasing to be explicitly enabled.
ifeq ($(OS),Darwin)
EXTRA_OPTIONS += -fstrict-aliasing
endif
CXX.Flags := $(OPTIMIZE_OPTION) $(OmitFramePointer)
C.Flags := $(OPTIMIZE_OPTION) $(OmitFramePointer)
LD.Flags := $(OPTIMIZE_OPTION)
else
BuildMode := Debug
CXX.Flags := -g
C.Flags := -g
LD.Flags := -g
KEEP_SYMBOLS := 1
endif
endif
# IF REQUIRES_EH=1 is specified then don't disable exceptions
ifndef REQUIRES_EH
CXX.Flags += -fno-exceptions
endif
# If DISABLE_ASSERTIONS=1 is specified (make command line or configured),
# then disable assertions by defining the appropriate preprocessor symbols.
ifdef DISABLE_ASSERTIONS
BuildMode := $(BuildMode)-Asserts
CXX.Flags += -DNDEBUG
C.Flags += -DNDEBUG
else
CXX.Flags += -D_DEBUG
C.Flags += -D_DEBUG
endif
CXX.Flags += $(CXXFLAGS) -Woverloaded-virtual
C.Flags += $(CFLAGS)
CPP.BaseFlags += $(CPPFLAGS)
LD.Flags += $(LDFLAGS)
AR.Flags := cru
LibTool.Flags := --tag=CXX
# Make Floating point IEEE compliant on Alpha.
ifeq ($(ARCH),Alpha)
CXX.Flags += -mieee -fPIC
CPP.BaseFlags += -mieee -fPIC
endif
#--------------------------------------------------------------------
# Directory locations
#--------------------------------------------------------------------
ObjDir := $(PROJ_OBJ_DIR)/$(BuildMode)
LibDir := $(PROJ_OBJ_ROOT)/$(BuildMode)/lib
ToolDir := $(PROJ_OBJ_ROOT)/$(BuildMode)/bin
ExmplDir := $(PROJ_OBJ_ROOT)/$(BuildMode)/examples
LLVMLibDir := $(LLVM_OBJ_ROOT)/$(BuildMode)/lib
LLVMToolDir := $(LLVM_OBJ_ROOT)/$(BuildMode)/bin
LLVMExmplDir:= $(LLVM_OBJ_ROOT)/$(BuildMode)/examples
CFERuntimeLibDir := $(LLVMGCCDIR)/lib
#--------------------------------------------------------------------
# Full Paths To Compiled Tools and Utilities
#--------------------------------------------------------------------
EchoCmd = $(ECHO) llvm[$(MAKELEVEL)]:
Echo = @$(EchoCmd)
ifndef LIBTOOL
LIBTOOL := $(LLVM_OBJ_ROOT)/mklib
endif
ifndef LLVMAS
LLVMAS := $(LLVMToolDir)/llvm-as$(EXEEXT)
endif
ifndef TBLGEN
ifeq ($(LLVM_CROSS_COMPILING),1)
TBLGEN := $(LLVMToolDir)/tblgen$(BUILD_EXEEXT)
else
TBLGEN := $(LLVMToolDir)/tblgen$(EXEEXT)
endif
endif
LLVM_CONFIG := $(LLVMToolDir)/llvm-config
ifndef GCCAS
GCCAS := $(LLVMToolDir)/gccas$(EXEEXT)
endif
ifndef GCCLD
GCCLD := $(LLVMToolDir)/gccld$(EXEEXT)
endif
ifndef LLVMDIS
LLVMDIS := $(LLVMToolDir)/llvm-dis$(EXEEXT)
endif
ifndef LLI
LLI := $(LLVMToolDir)/lli$(EXEEXT)
endif
ifndef LLC
LLC := $(LLVMToolDir)/llc$(EXEEXT)
endif
ifndef LOPT
LOPT := $(LLVMToolDir)/opt$(EXEEXT)
endif
ifndef LBUGPOINT
LBUGPOINT := $(LLVMToolDir)/bugpoint$(EXEEXT)
endif
LLVMGCCWITHPATH := PATH="$(LLVMToolDir):$(PATH)" $(LLVMGCC)
LLVMGXXWITHPATH := PATH="$(LLVMToolDir):$(PATH)" $(LLVMGXX)
#--------------------------------------------------------------------
# Adjust to user's request
#--------------------------------------------------------------------
# Adjust LD.Flags and Libtool.Flags depending on the kind of library that is
# to be built. Note that if LOADABLE_MODULE is specified then the resulting
# shared library can be opened with dlopen. Also, LOADABLE_MODULE implies
# several other things so we force them to be defined/on.
ifdef LOADABLE_MODULE
SHARED_LIBRARY := 1
DONT_BUILD_RELINKED := 1
LINK_LIBS_IN_SHARED := 1
LD.Flags += -module
endif
ifdef SHARED_LIBRARY
LD.Flags += -rpath $(LibDir)
else
LibTool.Flags += --tag=disable-shared
endif
ifdef TOOL_VERBOSE
C.Flags += -v
CXX.Flags += -v
LD.Flags += -v
VERBOSE := 1
endif
# Adjust settings for verbose mode
ifndef VERBOSE
Verb := @
LibTool.Flags += --silent
AR.Flags += >/dev/null 2>/dev/null
ConfigureScriptFLAGS += >$(PROJ_OBJ_DIR)/configure.out 2>&1
else
ConfigureScriptFLAGS :=
endif
# By default, strip symbol information from executable
ifndef KEEP_SYMBOLS
Strip := $(PLATFORMSTRIPOPTS)
StripWarnMsg := "(without symbols)"
Install.StripFlag += -s
endif
# Adjust linker flags for building an executable
ifdef TOOLNAME
ifdef EXAMPLE_TOOL
LD.Flags += -rpath $(ExmplDir) -export-dynamic
else
LD.Flags += -rpath $(ToolDir) -export-dynamic
endif
endif
#----------------------------------------------------------
# Options To Invoke Tools
#----------------------------------------------------------
CompileCommonOpts := -pedantic -Wall -W -Wwrite-strings -Wno-long-long \
-Wunused -Wno-unused-parameter $(EXTRA_OPTIONS)
ifeq ($(OS),HP-UX)
CompileCommonOpts := -D_REENTRANT -D_HPUX_SOURCE
endif
# If we are building a universal binary on Mac OS/X, pass extra options. This
# is useful to people that want to link the LLVM libraries into their universal
# apps.
#
# The following can be optionally specified:
# UNIVERSAL_SDK_PATH variable can be specified as a path to the SDK to use.
# For Mac OS/X 10.4 Intel machines, the traditional one is:
# UNIVERSAL_SDK_PATH=/Developer/SDKs/MacOSX10.4u.sdk/
# UNIVERSAL_ARCH can be optionally specified to be a list of architectures
# to build for, e.g. UNIVERSAL_ARCH="i386 ppc ppc64". This defaults to
# i386/ppc only.
ifdef UNIVERSAL
ifndef UNIVERSAL_ARCH
UNIVERSAL_ARCH := i386 ppc
endif
UNIVERSAL_ARCH_OPTIONS := $(UNIVERSAL_ARCH:%=-arch %)
CompileCommonOpts += $(UNIVERSAL_ARCH_OPTIONS)
Relink.Flags := $(UNIVERSAL_ARCH_OPTIONS:%=-XCClinker %)
ifdef UNIVERSAL_SDK_PATH
CompileCommonOpts += -isysroot $(UNIVERSAL_SDK_PATH)
Relink.Flags += -XCClinker -isysroot -XCClinker $(UNIVERSAL_SDK_PATH)
endif
# Building universal cannot compute dependencies automatically.
DISABLE_AUTO_DEPENDENCIES=1
endif
LD.Flags += -L$(LibDir) -L$(LLVMLibDir)
CPP.BaseFlags += -D_GNU_SOURCE -D__STDC_LIMIT_MACROS
# All -I flags should go here, so that they don't confuse llvm-config.
CPP.Flags += -I$(PROJ_OBJ_DIR) -I$(PROJ_SRC_DIR) \
-I$(PROJ_OBJ_ROOT)/include \
-I$(PROJ_SRC_ROOT)/include \
-I$(LLVM_OBJ_ROOT)/include \
-I$(LLVM_SRC_ROOT)/include \
$(CPP.BaseFlags)
Compile.C = $(CC) $(CPP.Flags) $(C.Flags) $(CompileCommonOpts) -c
LTCompile.C = $(LIBTOOL) $(LibTool.Flags) --mode=compile $(Compile.C)
BCCompile.C = $(LLVMGCCWITHPATH) $(CPP.Flags) $(C.Flags) $(CompileCommonOpts)
Preprocess.C = $(CC) $(CPP.Flags) $(C.Flags) $(CompileCommonOpts) -E
Compile.CXX = $(CXX) $(CPP.Flags) $(CXX.Flags) $(CompileCommonOpts) -c
LTCompile.CXX = $(LIBTOOL) $(LibTool.Flags) --mode=compile $(Compile.CXX)
BCCompile.CXX = $(LLVMGXXWITHPATH) $(CPP.Flags) $(CXX.Flags) \
$(CompileCommonOpts)
Preprocess.CXX= $(CXX) $(CPP.Flags) $(CompileCommonOpts) $(CXX.Flags) -E
Link = $(CXX) $(CPP.Flags) $(CXX.Flags) $(CompileCommonOpts) \
$(LD.Flags) $(Strip)
LTLink = $(LIBTOOL) $(LibTool.Flags) --mode=link $(Link)
Relink = $(CXX) $(CPP.Flags) $(CXX.Flags) $(CompileCommonOpts) \
$(Relink.Flags)
LTRelink = $(LIBTOOL) $(LibTool.Flags) --mode=link $(Relink)
LTInstall = $(LIBTOOL) $(LibTool.Flags) --mode=install $(INSTALL) \
$(Install.Flags)
ProgInstall = $(INSTALL) $(Install.StripFlag) -m 0755
ScriptInstall = $(INSTALL) -m 0755
DataInstall = $(INSTALL) -m 0644
TableGen = $(TBLGEN) -I $(PROJ_SRC_DIR) -I$(PROJ_SRC_ROOT)/include \
-I $(PROJ_SRC_ROOT)/lib/Target
Archive = $(AR) $(AR.Flags)
LArchive = $(LLVMToolDir)/llvm-ar rcsf
ifdef RANLIB
Ranlib = $(RANLIB)
else
Ranlib = ranlib
endif
#----------------------------------------------------------
# Get the list of source files and compute object file
# names from them.
#----------------------------------------------------------
ifndef SOURCES
Sources := $(notdir $(wildcard $(PROJ_SRC_DIR)/*.cpp \
$(PROJ_SRC_DIR)/*.cc $(PROJ_SRC_DIR)/*.c $(PROJ_SRC_DIR)/*.y \
$(PROJ_SRC_DIR)/*.l))
else
Sources := $(SOURCES)
endif
ifdef BUILT_SOURCES
Sources += $(filter %.cpp %.c %.cc %.y %.l,$(BUILT_SOURCES))
endif
BaseNameSources := $(sort $(basename $(Sources)))
ObjectsO := $(BaseNameSources:%=$(ObjDir)/%.o)
ObjectsLO := $(BaseNameSources:%=$(ObjDir)/%.lo)
ObjectsBC := $(BaseNameSources:%=$(ObjDir)/%.bc)
###############################################################################
# DIRECTORIES: Handle recursive descent of directory structure
###############################################################################
#---------------------------------------------------------
# Provide rules to make install dirs. This must be early
# in the file so they get built before dependencies
#---------------------------------------------------------
$(PROJ_bindir): $(PROJ_bindir)/.dir
$(PROJ_libdir): $(PROJ_libdir)/.dir
$(PROJ_includedir): $(PROJ_includedir)/.dir
$(PROJ_etcdir): $(PROJ_etcdir)/.dir
# To create other directories, as needed, and timestamp their creation
%/.dir:
$(Verb) $(MKDIR) $* > /dev/null
$(Verb) $(DATE) > $@
.PRECIOUS: $(ObjDir)/.dir $(LibDir)/.dir $(ToolDir)/.dir $(ExmplDir)/.dir
.PRECIOUS: $(LLVMLibDir)/.dir $(LLVMToolDir)/.dir $(LLVMExmplDir)/.dir
#---------------------------------------------------------
# Handle the DIRS options for sequential construction
#---------------------------------------------------------
SubDirs :=
ifdef DIRS
SubDirs += $(DIRS)
ifneq ($(PROJ_SRC_ROOT),$(PROJ_OBJ_ROOT))
$(RecursiveTargets)::
$(Verb) for dir in $(DIRS); do \
if [ ! -f $$dir/Makefile ]; then \
$(MKDIR) $$dir; \
$(CP) $(PROJ_SRC_DIR)/$$dir/Makefile $$dir/Makefile; \
fi; \
($(MAKE) -C $$dir $@ ) || exit 1; \
done
else
$(RecursiveTargets)::
$(Verb) for dir in $(DIRS); do \
($(MAKE) -C $$dir $@ ) || exit 1; \
done
endif
endif
#---------------------------------------------------------
# Handle the EXPERIMENTAL_DIRS options ensuring success
# after each directory is built.
#---------------------------------------------------------
ifdef EXPERIMENTAL_DIRS
$(RecursiveTargets)::
$(Verb) for dir in $(EXPERIMENTAL_DIRS); do \
if [ ! -f $$dir/Makefile ]; then \
$(MKDIR) $$dir; \
$(CP) $(PROJ_SRC_DIR)/$$dir/Makefile $$dir/Makefile; \
fi; \
($(MAKE) -C $$dir $@ ) || exit 0; \
done
endif
#-----------------------------------------------------------
# Handle the PARALLEL_DIRS options for parallel construction
#-----------------------------------------------------------
ifdef PARALLEL_DIRS
SubDirs += $(PARALLEL_DIRS)
# Unfortunately, this list must be maintained if new recursive targets are added
all :: $(addsuffix /.makeall ,$(PARALLEL_DIRS))
clean :: $(addsuffix /.makeclean ,$(PARALLEL_DIRS))
clean-all:: $(addsuffix /.makeclean-all,$(PARALLEL_DIRS))
install :: $(addsuffix /.makeinstall ,$(PARALLEL_DIRS))
uninstall:: $(addsuffix /.makeuninstall,$(PARALLEL_DIRS))
install-bytecode :: $(addsuffix /.makeinstall-bytecode,$(PARALLEL_DIRS))
ParallelTargets := $(foreach T,$(RecursiveTargets),%/.make$(T))
$(ParallelTargets) :
$(Verb) if [ ! -f $(@D)/Makefile ]; then \
$(MKDIR) $(@D); \
$(CP) $(PROJ_SRC_DIR)/$(@D)/Makefile $(@D)/Makefile; \
fi; \
$(MAKE) -C $(@D) $(subst $(@D)/.make,,$@) ;
endif
#---------------------------------------------------------
# Handle the OPTIONAL_DIRS options for directores that may
# or may not exist.
#---------------------------------------------------------
ifdef OPTIONAL_DIRS
SubDirs += $(OPTIONAL_DIRS)
ifneq ($(PROJ_SRC_ROOT),$(PROJ_OBJ_ROOT))
$(RecursiveTargets)::
$(Verb) for dir in $(OPTIONAL_DIRS); do \
if [ -d $(PROJ_SRC_DIR)/$$dir ]; then\
if [ ! -f $$dir/Makefile ]; then \
$(MKDIR) $$dir; \
$(CP) $(PROJ_SRC_DIR)/$$dir/Makefile $$dir/Makefile; \
fi; \
($(MAKE) -C$$dir $@ ) || exit 1; \
fi \
done
else
$(RecursiveTargets)::
$(Verb) for dir in $(OPTIONAL_DIRS); do \
($(MAKE) -C$$dir $@ ) || exit 1; \
done
endif
endif
#---------------------------------------------------------
# Handle the CONFIG_FILES options
#---------------------------------------------------------
ifdef CONFIG_FILES
install-local:: $(PROJ_etcdir) $(CONFIG_FILES)
$(Echo) Installing Configuration Files To $(PROJ_etcdir)
$(Verb)for file in $(CONFIG_FILES); do \
if test -f $(PROJ_OBJ_DIR)/$${file} ; then \
$(DataInstall) $(PROJ_OBJ_DIR)/$${file} $(PROJ_etcdir) ; \
elif test -f $(PROJ_SRC_DIR)/$${file} ; then \
$(DataInstall) $(PROJ_SRC_DIR)/$${file} $(PROJ_etcdir) ; \
else \
$(ECHO) Error: cannot find config file $${file}. ; \
fi \
done
uninstall-local::
$(Echo) Uninstalling Configuration Files From $(PROJ_etcdir)
$(Verb)for file in $(CONFIG_FILES); do \
$(RM) -f $(PROJ_etcdir)/$${file} ; \
done
endif
###############################################################################
# Set up variables for building libararies
###############################################################################
#---------------------------------------------------------
# Define various command line options pertaining to the
# libraries needed when linking. There are "Proj" libs
# (defined by the user's project) and "LLVM" libs (defined
# by the LLVM project).
#---------------------------------------------------------
ifdef USEDLIBS
ProjLibsOptions := $(patsubst %.a.o, -l%, $(addsuffix .o, $(USEDLIBS)))
ProjLibsOptions := $(patsubst %.o, $(LibDir)/%.o, $(ProjLibsOptions))
ProjUsedLibs := $(patsubst %.a.o, lib%.a, $(addsuffix .o, $(USEDLIBS)))
ProjLibsPaths := $(addprefix $(LibDir)/,$(ProjUsedLibs))
endif
ifdef LLVMLIBS
LLVMLibsOptions := $(patsubst %.a.o, -l%, $(addsuffix .o, $(LLVMLIBS)))
LLVMLibsOptions := $(patsubst %.o, $(LLVMLibDir)/%.o, $(LLVMLibsOptions))
LLVMUsedLibs := $(patsubst %.a.o, lib%.a, $(addsuffix .o, $(LLVMLIBS)))
LLVMLibsPaths := $(addprefix $(LLVMLibDir)/,$(LLVMUsedLibs))
endif
ifeq ($(strip $(filter clean clean-local dist-clean,$(MAKECMDGOALS))),)
ifdef LINK_COMPONENTS
# If LLVM_CONFIG doesn't exist, build it. This can happen if you do a make
# clean in tools, then do a make in tools (instead of at the top level).
$(LLVM_CONFIG):
@echo "*** llvm-config doesn't exist - rebuilding it."
@$(MAKE) -C $(PROJ_OBJ_ROOT)/tools/llvm-config
$(ToolDir)/$(strip $(TOOLNAME))$(EXEEXT): $(LLVM_CONFIG)
ProjLibsOptions = $(shell $(LLVM_CONFIG) --libs $(LINK_COMPONENTS))
ProjLibsPaths = $(LLVM_CONFIG) \
$(shell $(LLVM_CONFIG) --libfiles $(LINK_COMPONENTS))
endif
endif
###############################################################################
# Library Build Rules: Four ways to build a library
###############################################################################
#---------------------------------------------------------
# Bytecode Module Targets:
# If the user set MODULE_NAME then they want to build a
# bytecode module from the sources. We compile all the
# sources and link it together into a single bytecode
# module.
#---------------------------------------------------------
ifdef MODULE_NAME
ifeq ($(strip $(LLVMGCC)),)
$(warning Modules require llvm-gcc but no llvm-gcc is available ****)
else
Module := $(LibDir)/$(MODULE_NAME).bc
LinkModule := $(GCCLD) -L$(CFERuntimeLibDir)
ifdef EXPORTED_SYMBOL_FILE
LinkModule += -internalize-public-api-file=$(EXPORTED_SYMBOL_FILE)
endif
$(Module): $(BUILT_SOURCES) $(ObjectsBC) $(LibDir)/.dir $(GCCLD)
$(Echo) Building $(BuildMode) Bytecode Module $(notdir $@)
$(Verb) $(LinkModule) -o $@ $(ObjectsBC)
all-local:: $(Module)
clean-local::
ifneq ($(strip $(Module)),)
-$(Verb) $(RM) -f $(Module)
endif
ifdef BYTECODE_DESTINATION
ModuleDestDir := $(BYTECODE_DESTINATION)
else
ModuleDestDir := $(PROJ_libdir)
endif
DestModule := $(ModuleDestDir)/$(MODULE_NAME).bc
install-module:: $(DestModule)
install-local:: $(DestModule)
$(DestModule): $(ModuleDestDir) $(Module)
$(Echo) Installing $(BuildMode) Bytecode Module $(DestModule)
$(Verb) $(DataInstall) $(Module) $(DestModule)
uninstall-local::
$(Echo) Uninstalling $(BuildMode) Bytecode Module $(DestModule)
-$(Verb) $(RM) -f $(DestModule)
endif
endif
# if we're building a library ...
ifdef LIBRARYNAME
# Make sure there isn't any extranous whitespace on the LIBRARYNAME option
LIBRARYNAME := $(strip $(LIBRARYNAME))
ifdef LOADABLE_MODULE
LibName.LA := $(LibDir)/$(LIBRARYNAME).la
else
LibName.LA := $(LibDir)/lib$(LIBRARYNAME).la
endif
LibName.A := $(LibDir)/lib$(LIBRARYNAME).a
LibName.O := $(LibDir)/$(LIBRARYNAME).o
LibName.BCA:= $(LibDir)/lib$(LIBRARYNAME).bca
#---------------------------------------------------------
# Shared Library Targets:
# If the user asked for a shared library to be built
# with the SHARED_LIBRARY variable, then we provide
# targets for building them.
#---------------------------------------------------------
ifdef SHARED_LIBRARY
all-local:: $(LibName.LA)
ifdef LINK_LIBS_IN_SHARED
ifdef LOADABLE_MODULE
SharedLibKindMessage := "Lodable Module"
else
SharedLibKindMessage := "Shared Library"
endif
$(LibName.LA): $(ObjectsLO) $(LibDir)/.dir
$(Echo) Linking $(BuildMode) $(SharedLibKindMessage) \
$(LIBRARYNAME)$(SHLIBEXT)
$(Verb) $(LTLink) -o $@ $(ObjectsLO) $(ProjLibsOptions) \
$(LLVMLibsOptions)
$(Verb) $(LTInstall) $@ $(LibDir)
else
$(LibName.LA): $(ObjectsLO) $(LibDir)/.dir
$(Echo) Linking $(BuildMode) Shared Library $(LIBRARYNAME)$(SHLIBEXT)
$(Verb) $(LTLink) -o $@ $(ObjectsLO)
$(Verb) $(LTInstall) $@ $(LibDir)
endif
clean-local::
ifneq ($(strip $(LibName.LA)),)
-$(Verb) $(RM) -f $(LibName.LA)
endif
DestSharedLib = $(PROJ_libdir)/lib$(LIBRARYNAME)$(SHLIBEXT)
install-local:: $(DestSharedLib)
$(DestSharedLib): $(PROJ_libdir) $(LibName.LA)
$(Echo) Installing $(BuildMode) Shared Library $(DestSharedLib)
$(Verb) $(LTInstall) $(LibName.LA) $(DestSharedLib)
$(Verb) $(LIBTOOL) --finish $(PROJ_libdir)
uninstall-local::
$(Echo) Uninstalling $(BuildMode) Shared Library $(DestSharedLib)
-$(Verb) $(RM) -f $(PROJ_libdir)/lib$(LIBRARYNAME).*
endif
#---------------------------------------------------------
# Bytecode Library Targets:
# If the user asked for a bytecode library to be built
# with the BYTECODE_LIBRARY variable, then we provide
# targets for building them.
#---------------------------------------------------------
ifdef BYTECODE_LIBRARY
ifeq ($(strip $(LLVMGCC)),)
$(warning Bytecode libraries require llvm-gcc which could not be found ****)
else
all-local:: $(LibName.BCA)
ifdef EXPORTED_SYMBOL_FILE
BCLinkLib = $(GCCLD) -L$(CFERuntimeLibDir) \
-internalize-public-api-file=$(EXPORTED_SYMBOL_FILE)
$(LibName.BCA): $(ObjectsBC) $(LibDir)/.dir $(GCCLD) \
$(LLVMToolDir)/llvm-ar
$(Echo) Building $(BuildMode) Bytecode Archive $(notdir $@) \
"(internalize)"
$(Verb) $(BCLinkLib) -o $(ObjDir)/$(LIBRARYNAME).o $(ObjectsBC)
$(Verb) $(RM) -f $@
$(Verb) $(LArchive) $@ $(ObjDir)/$(LIBRARYNAME).o
else
$(LibName.BCA): $(ObjectsBC) $(LibDir)/.dir \
$(LLVMToolDir)/llvm-ar
$(Echo) Building $(BuildMode) Bytecode Archive $(notdir $@)
$(Verb) $(RM) -f $@
$(Verb) $(LArchive) $@ $(ObjectsBC)
endif
clean-local::
ifneq ($(strip $(LibName.BCA)),)
-$(Verb) $(RM) -f $(LibName.BCA)
endif
ifdef BYTECODE_DESTINATION
BytecodeDestDir := $(BYTECODE_DESTINATION)
else
BytecodeDestDir := $(PROJ_libdir)
endif
DestBytecodeLib = $(BytecodeDestDir)/lib$(LIBRARYNAME).a
install-bytecode-local:: $(DestBytecodeLib)
install-local:: $(DestBytecodeLib)
$(DestBytecodeLib): $(BytecodeDestDir) $(LibName.BCA)
$(Echo) Installing $(BuildMode) Bytecode Archive $(DestBytecodeLib)
$(Verb) $(DataInstall) $(LibName.BCA) $(DestBytecodeLib)
uninstall-local::
$(Echo) Uninstalling $(BuildMode) Bytecode Archive $(DestBytecodeLib)
-$(Verb) $(RM) -f $(DestBytecodeLib)
endif
endif
#---------------------------------------------------------
# ReLinked Library Targets:
# If the user explicitly requests a relinked library with
# BUILD_RELINKED, provide it. Otherwise, if they specify
# neither of BUILD_ARCHIVE or DONT_BUILD_RELINKED, give
# them one.
#---------------------------------------------------------
ifndef BUILD_ARCHIVE
ifndef DONT_BUILD_RELINKED
BUILD_RELINKED = 1
endif
endif
ifdef BUILD_RELINKED
all-local:: $(LibName.O)
$(LibName.O): $(ObjectsO) $(LibDir)/.dir
$(Echo) Linking $(BuildMode) Object Library $(notdir $@)
$(Verb) $(LTRelink) -o $@ $(ObjectsO)
clean-local::
ifneq ($(strip $(LibName.O)),)
-$(Verb) $(RM) -f $(LibName.O)
endif
DestRelinkedLib = $(PROJ_libdir)/$(LIBRARYNAME).o
install-local:: $(DestRelinkedLib)
$(DestRelinkedLib): $(PROJ_libdir) $(LibName.O)
$(Echo) Installing $(BuildMode) Object Library $(DestRelinkedLib)
$(Verb) $(LTInstall) $(LibName.O) $(DestRelinkedLib)
uninstall-local::
$(Echo) Uninstalling $(BuildMode) Object Library $(DestRelinkedLib)
-$(Verb) $(RM) -f $(DestRelinkedLib)
endif
#---------------------------------------------------------
# Archive Library Targets:
# If the user wanted a regular archive library built,
# then we provide targets for building them.
#---------------------------------------------------------
ifdef BUILD_ARCHIVE
all-local:: $(LibName.A)
$(LibName.A): $(ObjectsO) $(LibDir)/.dir
$(Echo) Building $(BuildMode) Archive Library $(notdir $@)
-$(Verb) $(RM) -f $@
$(Verb) $(Archive) $@ $(ObjectsO)
$(Verb) $(Ranlib) $@
clean-local::
ifneq ($(strip $(LibName.A)),)
-$(Verb) $(RM) -f $(LibName.A)
endif
DestArchiveLib := $(PROJ_libdir)/lib$(LIBRARYNAME).a
install-local:: $(DestArchiveLib)
$(DestArchiveLib): $(PROJ_libdir) $(LibName.A)
$(Echo) Installing $(BuildMode) Archive Library $(DestArchiveLib)
$(Verb) $(MKDIR) $(PROJ_libdir)
$(Verb) $(LTInstall) $(LibName.A) $(DestArchiveLib)
uninstall-local::
$(Echo) Uninstalling $(BuildMode) Archive Library $(DestArchiveLib)
-$(Verb) $(RM) -f $(DestArchiveLib)
endif
# endif LIBRARYNAME
endif
###############################################################################
# Tool Build Rules: Build executable tool based on TOOLNAME option
###############################################################################
ifdef TOOLNAME
#---------------------------------------------------------
# Set up variables for building a tool.
#---------------------------------------------------------
ifdef EXAMPLE_TOOL
ToolBuildPath := $(ExmplDir)/$(strip $(TOOLNAME))$(EXEEXT)
else
ToolBuildPath := $(ToolDir)/$(strip $(TOOLNAME))$(EXEEXT)
endif
#---------------------------------------------------------
# Provide targets for building the tools
#---------------------------------------------------------
all-local:: $(ToolBuildPath)
clean-local::
ifneq ($(strip $(ToolBuildPath)),)
-$(Verb) $(RM) -f $(ToolBuildPath)
endif
ifdef EXAMPLE_TOOL
$(ToolBuildPath): $(ExmplDir)/.dir
else
$(ToolBuildPath): $(ToolDir)/.dir
endif
$(ToolBuildPath): $(ObjectsO) $(ProjLibsPaths) $(LLVMLibsPaths)
$(Echo) Linking $(BuildMode) executable $(TOOLNAME) $(StripWarnMsg)
$(Verb) $(LTLink) -o $@ $(TOOLLINKOPTS) $(ObjectsO) $(ProjLibsOptions) \
$(LLVMLibsOptions) $(ExtraLibs) $(TOOLLINKOPTSB) $(LIBS)
$(Echo) ======= Finished Linking $(BuildMode) Executable $(TOOLNAME) \
$(StripWarnMsg)
DestTool = $(PROJ_bindir)/$(TOOLNAME)
install-local:: $(DestTool)
$(DestTool): $(PROJ_bindir) $(ToolBuildPath)
$(Echo) Installing $(BuildMode) $(DestTool)
$(Verb) $(ProgInstall) $(ToolBuildPath) $(DestTool)
uninstall-local::
$(Echo) Uninstalling $(BuildMode) $(DestTool)
-$(Verb) $(RM) -f $(DestTool)
endif
###############################################################################
# Object Build Rules: Build object files based on sources
###############################################################################
# FIXME: This should be checking for "if not GCC or ICC", not for "if HP-UX"
ifeq ($(OS),HP-UX)
DISABLE_AUTO_DEPENDENCIES=1
endif
ifdef SHARED_LIBRARY
PIC_FLAG = "(PIC)"
MAYBE_PIC_Compile.CXX = $(LTCompile.CXX)
MAYBE_PIC_Compile.C = $(LTCompile.C)
else
MAYBE_PIC_Compile.CXX = $(Compile.CXX)
MAYBE_PIC_Compile.C = $(Compile.C)
endif
# Provide rule sets for when dependency generation is enabled
ifndef DISABLE_AUTO_DEPENDENCIES
#---------------------------------------------------------
# Create .lo files in the ObjDir directory from the .cpp and .c files...
#---------------------------------------------------------
$(ObjDir)/%.lo $(ObjDir)/%.o: %.cpp $(ObjDir)/.dir $(BUILT_SOURCES)
$(Echo) "Compiling $*.cpp for $(BuildMode) build " $(PIC_FLAG)
$(Verb) if $(MAYBE_PIC_Compile.CXX) -MD -MT $@ -MP -MF $(ObjDir)/$*.LACXXd $< -o $@ ;\
then $(MV) -f "$(ObjDir)/$*.LACXXd" "$(ObjDir)/$*.d"; \
else $(RM) -f "$(ObjDir)/$*.LACXXd"; exit 1; fi
$(ObjDir)/%.lo $(ObjDir)/%.o: %.cc $(ObjDir)/.dir $(BUILT_SOURCES)
$(Echo) "Compiling $*.cc for $(BuildMode) build" $(PIC_FLAG)
$(Verb) if $(MAYBE_PIC_Compile.CXX) -MD -MT $@ -MP -MF $(ObjDir)/$*.LACXXd $< -o $@ ;\
then $(MV) -f "$(ObjDir)/$*.LACXXd" "$(ObjDir)/$*.d"; \
else $(RM) -f "$(ObjDir)/$*.LACXXd"; exit 1; fi
$(ObjDir)/%.lo $(ObjDir)/%.o: %.c $(ObjDir)/.dir $(BUILT_SOURCES)
$(Echo) "Compiling $*.c for $(BuildMode) build" $(PIC_FLAG)
$(Verb) if $(MAYBE_PIC_Compile.C) -MD -MT $@ -MP -MF $(ObjDir)/$*.LACd $< -o $@ ; \
then $(MV) -f "$(ObjDir)/$*.LACd" "$(ObjDir)/$*.d"; \
else $(RM) -f "$(ObjDir)/$*.LACd"; exit 1; fi
#---------------------------------------------------------
# Create .bc files in the ObjDir directory from .cpp .cc and .c files...
#---------------------------------------------------------
$(ObjDir)/%.ll: %.cpp $(ObjDir)/.dir $(BUILT_SOURCES)
$(Echo) "Compiling $*.cpp for $(BuildMode) build (bytecode)"
$(Verb) if $(BCCompile.CXX) -MD -MT $@ -MP -MF "$(ObjDir)/$*.BCCXXd" \
$< -o $@ -S -emit-llvm ; \
then $(MV) -f "$(ObjDir)/$*.BCCXXd" "$(ObjDir)/$*.d"; \
else $(RM) -f "$(ObjDir)/$*.BCCXXd"; exit 1; fi
$(ObjDir)/%.ll: %.cc $(ObjDir)/.dir $(BUILT_SOURCES)
$(Echo) "Compiling $*.cc for $(BuildMode) build (bytecode)"
$(Verb) if $(BCCompile.CXX) -MD -MT $@ -MP -MF "$(ObjDir)/$*.BCCXXd" \
$< -o $@ -S -emit-llvm ; \
then $(MV) -f "$(ObjDir)/$*.BCCXXd" "$(ObjDir)/$*.d"; \
else $(RM) -f "$(ObjDir)/$*.BCCXXd"; exit 1; fi
$(ObjDir)/%.ll: %.c $(ObjDir)/.dir $(BUILT_SOURCES)
$(Echo) "Compiling $*.c for $(BuildMode) build (bytecode)"
$(Verb) if $(BCCompile.C) -MD -MT $@ -MP -MF "$(ObjDir)/$*.BCCd" \
$< -o $@ -S -emit-llvm ; \
then $(MV) -f "$(ObjDir)/$*.BCCd" "$(ObjDir)/$*.d"; \
else $(RM) -f "$(ObjDir)/$*.BCCd"; exit 1; fi
# Provide alternate rule sets if dependencies are disabled
else
$(ObjDir)/%.lo $(ObjDir)/%.o: %.cpp $(ObjDir)/.dir $(BUILT_SOURCES)
$(Echo) "Compiling $*.cpp for $(BuildMode) build" $(PIC_FLAG)
$(MAYBE_PIC_Compile.CXX) $< -o $@
$(ObjDir)/%.lo $(ObjDir)/%.o: %.cc $(ObjDir)/.dir $(BUILT_SOURCES)
$(Echo) "Compiling $*.cc for $(BuildMode) build" $(PIC_FLAG)
$(MAYBE_PIC_Compile.CXX) $< -o $@
$(ObjDir)/%.lo $(ObjDir)/%.o: %.c $(ObjDir)/.dir $(BUILT_SOURCES)
$(Echo) "Compiling $*.c for $(BuildMode) build" $(PIC_FLAG)
$(MAYBE_PIC_Compile.C) $< -o $@
$(ObjDir)/%.ll: %.cpp $(ObjDir)/.dir $(BUILT_SOURCES)
$(Echo) "Compiling $*.cpp for $(BuildMode) build (bytecode)"
$(BCCompile.CXX) $< -o $@ -S -emit-llvm
$(ObjDir)/%.ll: %.cc $(ObjDir)/.dir $(BUILT_SOURCES)
$(Echo) "Compiling $*.cc for $(BuildMode) build (bytecode)"
$(BCCompile.CXX) $< -o $@ -S -emit-llvm
$(ObjDir)/%.ll: %.c $(ObjDir)/.dir $(BUILT_SOURCES)
$(Echo) "Compiling $*.c for $(BuildMode) build (bytecode)"
$(BCCompile.C) $< -o $@ -S -emit-llvm
endif
## Rules for building preprocessed (.i/.ii) outputs.
$(BuildMode)/%.ii: %.cpp $(ObjDir)/.dir $(BUILT_SOURCES)
$(Echo) "Compiling $*.cpp for $(BuildMode) build to .ii file"
$(Verb) $(Preprocess.CXX) $< -o $@
$(BuildMode)/%.ii: %.cc $(ObjDir)/.dir $(BUILT_SOURCES)
$(Echo) "Compiling $*.cc for $(BuildMode) build to .ii file"
$(Verb) $(Preprocess.CXX) $< -o $@
$(BuildMode)/%.i: %.c $(ObjDir)/.dir $(BUILT_SOURCES)
$(Echo) "Compiling $*.c for $(BuildMode) build to .i file"
$(Verb) $(Preprocess.C) $< -o $@
$(ObjDir)/%.s: %.cpp $(ObjDir)/.dir $(BUILT_SOURCES)
$(Echo) "Compiling $*.cpp to asm for $(BuildMode) build" $(PIC_FLAG)
$(MAYBE_PIC_Compile.CXX) $< -o $@ -S
$(ObjDir)/%.s: %.cc $(ObjDir)/.dir $(BUILT_SOURCES)
$(Echo) "Compiling $*.cc to asm for $(BuildMode) build" $(PIC_FLAG)
$(MAYBE_PIC_Compile.CXX) $< -o $@ -S
$(ObjDir)/%.s: %.c $(ObjDir)/.dir $(BUILT_SOURCES)
$(Echo) "Compiling $*.c to asm for $(BuildMode) build" $(PIC_FLAG)
$(MAYBE_PIC_Compile.C) $< -o $@ -S
# make the C and C++ compilers strip debug info out of bytecode libraries.
ifdef DEBUG_RUNTIME
$(ObjectsBC): $(ObjDir)/%.bc: $(ObjDir)/%.ll $(GCCAS)
$(Echo) "Compiling $*.ll to $*.bc for $(BuildMode) build (bytecode)"
$(Verb) $(GCCAS) $< -o $@
else
$(ObjectsBC): $(ObjDir)/%.bc: $(ObjDir)/%.ll $(GCCAS)
$(Echo) "Compiling $*.ll to $*.bc for $(BuildMode) build (bytecode)"
$(Verb) $(GCCAS) -strip-debug $< -o $@
endif
#---------------------------------------------------------
# Provide rule to build .bc files from .ll sources,
# regardless of dependencies
#---------------------------------------------------------
$(ObjDir)/%.bc: %.ll $(ObjDir)/.dir $(LLVMAS)
$(Echo) "Compiling $*.ll for $(BuildMode) build"
$(Verb) $(LLVMAS) $< -f -o $@
###############################################################################
# TABLEGEN: Provide rules for running tblgen to produce *.inc files
###############################################################################
ifdef TARGET
TDFiles := $(strip $(wildcard $(PROJ_SRC_DIR)/*.td) \
$(LLVM_SRC_ROOT)/lib/Target/Target.td \
$(LLVM_SRC_ROOT)/lib/Target/TargetSelectionDAG.td \
$(LLVM_SRC_ROOT)/include/llvm/CodeGen/ValueTypes.td) \
$(wildcard $(LLVM_SRC_ROOT)/include/llvm/Intrinsics*.td)
INCFiles := $(filter %.inc,$(BUILT_SOURCES))
INCTMPFiles := $(INCFiles:%=$(ObjDir)/%.tmp)
.PRECIOUS: $(INCTMPFiles) $(INCFiles)
# All of these files depend on tblgen and the .td files.
$(INCTMPFiles) : $(TBLGEN) $(TDFiles)
# INCFiles rule: All of the tblgen generated files are emitted to
# $(ObjDir)/%.inc.tmp, instead of emitting them directly to %.inc. This allows
# us to only "touch" the real file if the contents of it change. IOW, if
# tblgen is modified, all of the .inc.tmp files are regereated, but no
# dependencies of the .inc files are, unless the contents of the .inc file
# changes.
$(INCFiles) : %.inc : $(ObjDir)/%.inc.tmp
$(Verb) $(CMP) -s $@ $< || $(CP) $< $@
$(TARGET:%=$(ObjDir)/%GenRegisterNames.inc.tmp): \
$(ObjDir)/%GenRegisterNames.inc.tmp : %.td $(ObjDir)/.dir
$(Echo) "Building $(<F) register names with tblgen"
$(Verb) $(TableGen) -gen-register-enums -o $@ $<
$(TARGET:%=$(ObjDir)/%GenRegisterInfo.h.inc.tmp): \
$(ObjDir)/%GenRegisterInfo.h.inc.tmp : %.td $(ObjDir)/.dir
$(Echo) "Building $(<F) register information header with tblgen"
$(Verb) $(TableGen) -gen-register-desc-header -o $@ $<
$(TARGET:%=$(ObjDir)/%GenRegisterInfo.inc.tmp): \
$(ObjDir)/%GenRegisterInfo.inc.tmp : %.td $(ObjDir)/.dir
$(Echo) "Building $(<F) register info implementation with tblgen"
$(Verb) $(TableGen) -gen-register-desc -o $@ $<
$(TARGET:%=$(ObjDir)/%GenInstrNames.inc.tmp): \
$(ObjDir)/%GenInstrNames.inc.tmp : %.td $(ObjDir)/.dir
$(Echo) "Building $(<F) instruction names with tblgen"
$(Verb) $(TableGen) -gen-instr-enums -o $@ $<
$(TARGET:%=$(ObjDir)/%GenInstrInfo.inc.tmp): \
$(ObjDir)/%GenInstrInfo.inc.tmp : %.td $(ObjDir)/.dir
$(Echo) "Building $(<F) instruction information with tblgen"
$(Verb) $(TableGen) -gen-instr-desc -o $@ $<
$(TARGET:%=$(ObjDir)/%GenAsmWriter.inc.tmp): \
$(ObjDir)/%GenAsmWriter.inc.tmp : %.td $(ObjDir)/.dir
$(Echo) "Building $(<F) assembly writer with tblgen"
$(Verb) $(TableGen) -gen-asm-writer -o $@ $<
$(TARGET:%=$(ObjDir)/%GenAsmWriter1.inc.tmp): \
$(ObjDir)/%GenAsmWriter1.inc.tmp : %.td $(ObjDir)/.dir
$(Echo) "Building $(<F) assembly writer #1 with tblgen"
$(Verb) $(TableGen) -gen-asm-writer -asmwriternum=1 -o $@ $<
$(TARGET:%=$(ObjDir)/%GenCodeEmitter.inc.tmp): \
$(ObjDir)/%GenCodeEmitter.inc.tmp: %.td $(ObjDir)/.dir
$(Echo) "Building $(<F) code emitter with tblgen"
$(Verb) $(TableGen) -gen-emitter -o $@ $<
$(TARGET:%=$(ObjDir)/%GenDAGISel.inc.tmp): \
$(ObjDir)/%GenDAGISel.inc.tmp : %.td $(ObjDir)/.dir
$(Echo) "Building $(<F) instruction selector implementation with tblgen"
$(Verb) $(TableGen) -gen-dag-isel -o $@ $<
$(TARGET:%=$(ObjDir)/%GenSubtarget.inc.tmp): \
$(ObjDir)/%GenSubtarget.inc.tmp : %.td $(ObjDir)/.dir
$(Echo) "Building $(<F) subtarget information with tblgen"
$(Verb) $(TableGen) -gen-subtarget -o $@ $<
clean-local::
-$(Verb) $(RM) -f $(INCFiles)
endif
###############################################################################
# LEX AND YACC: Provide rules for generating sources with lex and yacc
###############################################################################
#---------------------------------------------------------
# Provide rules for generating a .cpp source file from
# (f)lex input sources.
#---------------------------------------------------------
LexFiles := $(filter %.l,$(Sources))
ifneq ($(LexFiles),)
# Cancel built-in rules for lex
%.c: %.l
%.cpp: %.l
all:: $(LexFiles:%.l=$(PROJ_SRC_DIR)/%.cpp.cvs)
# Note the extra sed filtering here, used to cut down on the warnings emited
# by GCC. The last line is a gross hack to work around flex aparently not
# being able to resize the buffer on a large token input. Currently, for
# uninitialized string buffers in LLVM we can generate very long tokens, so
# this is a hack around it.
# FIXME. (f.e. char Buffer[10000] )
$(PROJ_SRC_DIR)/%.cpp: $(PROJ_SRC_DIR)/%.l
$(Echo) Flexing $*.l
$(Verb) $(FLEX) -t $(PROJ_SRC_DIR)/$*.l | \
$(SED) 's/void yyunput/inline void yyunput/' | \
$(SED) 's/void \*yy_flex_realloc/inline void *yy_flex_realloc/' | \
$(SED) 's/#define YY_BUF_SIZE 16384/#define YY_BUF_SIZE (16384*64)/' \
> $(PROJ_SRC_DIR)/$*.cpp
# IFF the .l file has changed since it was last checked into CVS, copy the .l
# file to .l.cvs and the generated .cpp file to .cpp.cvs. We use this mechanism
# so that people without flex can build LLVM by copying the .cvs files to the
# source location and building them.
$(LexFiles:%.l=$(PROJ_SRC_DIR)/%.cpp.cvs): \
$(PROJ_SRC_DIR)/%.cpp.cvs: $(PROJ_SRC_DIR)/%.cpp
$(Verb) $(CMP) -s $(PROJ_SRC_DIR)/$*.l $(PROJ_SRC_DIR)/$*.l.cvs || \
($(CP) $< $@; $(CP) $(PROJ_SRC_DIR)/$*.l $(PROJ_SRC_DIR)/$*.l.cvs)
$(LexFiles:%.l=$(ObjDir)/%.o) : \
$(ObjDir)/%.o : $(PROJ_SRC_DIR)/%.cpp
clean-local::
-$(Verb) $(RM) -f $(LexOutput)
endif
#---------------------------------------------------------
# Provide rules for generating a .cpp and .h source files
# from yacc (bison) input sources.
#---------------------------------------------------------
YaccFiles := $(filter %.y,$(Sources))
ifneq ($(YaccFiles),)
.PRECIOUS: $(YaccOutput)
all:: $(YaccFiles:%.y=$(PROJ_SRC_DIR)/%.cpp.cvs)
# Cancel built-in rules for yacc
%.c: %.y
%.cpp: %.y
%.h: %.y
# Rule for building the bison based parsers...
$(PROJ_SRC_DIR)/%.cpp $(PROJ_SRC_DIR)/%.h : $(PROJ_SRC_DIR)/%.y
ifneq ($(BISON),)
$(Echo) "Bisoning $*.y"
$(Verb) $(BISON) -v -d -p $(<F:%Parser.y=%) -o $*.tab.c $<
$(Verb) $(MV) -f $*.tab.c $(PROJ_SRC_DIR)/$*.cpp
$(Verb) $(MV) -f $*.tab.h $(PROJ_SRC_DIR)/$*.h
else
$(Echo) "Bison of $*.y SKIPPED -- bison not found"
endif
# IFF the .y file has changed since it was last checked into CVS, copy the .y
# file to .y.cvs and the generated .cpp/.h file to .cpp.cvs/.h.cvs. We use this
# mechanism so that people without flex can build LLVM by copying the .cvs files
# to the source location and building them.
$(YaccFiles:%.y=$(PROJ_SRC_DIR)/%.cpp.cvs): \
$(PROJ_SRC_DIR)/%.cpp.cvs: $(PROJ_SRC_DIR)/%.cpp
$(Verb) $(CMP) -s $(PROJ_SRC_DIR)/$*.y $(PROJ_SRC_DIR)/$*.y.cvs || \
($(CP) $< $@; \
$(CP) $(PROJ_SRC_DIR)/$*.y $(PROJ_SRC_DIR)/$*.y.cvs; \
$(CP) $(PROJ_SRC_DIR)/$*.h $(PROJ_SRC_DIR)/$*.h.cvs)
$(YaccFiles:%.y=$(ObjDir)/%.o): $(ObjDir)/%.o : $(PROJ_SRC_DIR)/%.cpp
YaccOutput := $(YaccFiles:%.y=%.output)
clean-local::
-$(Verb) $(RM) -f $(YaccOutput)
endif
###############################################################################
# OTHER RULES: Other rules needed
###############################################################################
# To create postscript files from dot files...
ifneq ($(DOT),false)
%.ps: %.dot
$(DOT) -Tps < $< > $@
else
%.ps: %.dot
$(Echo) "Cannot build $@: The program dot is not installed"
endif
# This rules ensures that header files that are removed still have a rule for
# which they can be "generated." This allows make to ignore them and
# reproduce the dependency lists.
%.h:: ;
%.hpp:: ;
# Define clean-local to clean the current directory. Note that this uses a
# very conservative approach ensuring that empty variables do not cause
# errors or disastrous removal.
clean-local::
ifneq ($(strip $(ObjDir)),)
-$(Verb) $(RM) -rf $(ObjDir)
endif
-$(Verb) $(RM) -f core core.[0-9][0-9]* *.o *.d *~ *.flc
ifneq ($(strip $(SHLIBEXT)),) # Extra paranoia - make real sure SHLIBEXT is set
-$(Verb) $(RM) -f *$(SHLIBEXT)
endif
clean-all-local::
-$(Verb) $(RM) -rf Debug Release Profile
# Build tags database for Emacs/Xemacs:
tags:: TAGS CTAGS
TAGS:
find $(PROJ_SRC_ROOT)/include $(PROJ_SRC_ROOT)/lib \
$(PROJ_SRC_ROOT)/tools $(PROJ_SRC_ROOT)/examples \
$(PROJ_OBJ_ROOT)/include $(PROJ_OBJ_ROOT)/lib \
$(PROJ_OBJ_ROOT)/tools $(PROJ_OBJ_ROOT)/examples \
-name '*.cpp' -o -name '*.h' | \
$(ETAGS) $(ETAGSFLAGS) -
CTAGS:
find $(PROJ_SRC_ROOT)/include $(PROJ_SRC_ROOT)/lib \
$(PROJ_SRC_ROOT)/tools $(PROJ_SRC_ROOT)/examples \
$(PROJ_OBJ_ROOT)/include $(PROJ_OBJ_ROOT)/lib \
$(PROJ_OBJ_ROOT)/tools $(PROJ_OBJ_ROOT)/examples \
\( -name '*.cpp' -o -name '*.h' \) -print | \
ctags -ImtT -o $(PROJ_OBJ_ROOT)/CTAGS -L -
###############################################################################
# DEPENDENCIES: Include the dependency files if we should
###############################################################################
ifndef DISABLE_AUTO_DEPENDENCIES
# If its not one of the cleaning targets
ifneq ($(strip $(filter-out clean clean-local dist-clean,$(MAKECMDGOALS)))),)
# Get the list of dependency files
DependFiles := $(basename $(filter %.cpp %.c %.cc, $(Sources)))
DependFiles := $(DependFiles:%=$(PROJ_OBJ_DIR)/$(BuildMode)/%.d)
-include /dev/null $(DependFiles)
endif
endif
###############################################################################
# CHECK: Running the test suite
###############################################################################
check::
$(Verb) if test -d "$(PROJ_OBJ_ROOT)/test" ; then \
if test -f "$(PROJ_OBJ_ROOT)/test/Makefile" ; then \
$(EchoCmd) Running test suite ; \
$(MAKE) -C $(PROJ_OBJ_ROOT)/test check-local \
TESTSUITE=$(TESTSUITE) ; \
else \
$(EchoCmd) No Makefile in test directory ; \
fi ; \
else \
$(EchoCmd) No test directory ; \
fi
###############################################################################
# DISTRIBUTION: Handle construction of a distribution tarball
###############################################################################
#------------------------------------------------------------------------
# Define distribution related variables
#------------------------------------------------------------------------
DistName := $(PROJECT_NAME)-$(PROJ_VERSION)
DistDir := $(PROJ_OBJ_ROOT)/$(DistName)
TopDistDir := $(PROJ_OBJ_ROOT)/$(DistName)
DistTarGZip := $(PROJ_OBJ_ROOT)/$(DistName).tar.gz
DistZip := $(PROJ_OBJ_ROOT)/$(DistName).zip
DistTarBZ2 := $(PROJ_OBJ_ROOT)/$(DistName).tar.bz2
DistAlways := CREDITS.TXT LICENSE.TXT README.txt README AUTHORS COPYING \
ChangeLog INSTALL NEWS Makefile Makefile.common Makefile.rules \
Makefile.config.in configure autoconf
DistOther := $(notdir $(wildcard \
$(PROJ_SRC_DIR)/*.h \
$(PROJ_SRC_DIR)/*.td \
$(PROJ_SRC_DIR)/*.def \
$(PROJ_SRC_DIR)/*.ll \
$(PROJ_SRC_DIR)/*.in))
DistSubDirs := $(SubDirs)
DistSources = $(Sources) $(EXTRA_DIST)
DistFiles = $(DistAlways) $(DistSources) $(DistOther)
#------------------------------------------------------------------------
# We MUST build distribution with OBJ_DIR != SRC_DIR
#------------------------------------------------------------------------
ifeq ($(PROJ_SRC_DIR),$(PROJ_OBJ_DIR))
dist dist-check dist-clean dist-gzip dist-bzip2 dist-zip ::
$(Echo) ERROR: Target $@ only available with OBJ_DIR != SRC_DIR
else
#------------------------------------------------------------------------
# Prevent attempt to run dist targets from anywhere but the top level
#------------------------------------------------------------------------
ifneq ($(LEVEL),.)
dist dist-check dist-clean dist-gzip dist-bzip2 dist-zip ::
$(Echo) ERROR: You must run $@ from $(PROJ_OBJ_ROOT)
else
#------------------------------------------------------------------------
# Provide the top level targets
#------------------------------------------------------------------------
dist-gzip:: $(DistTarGZip)
$(DistTarGZip) : $(TopDistDir)/.makedistdir
$(Echo) Packing gzipped distribution tar file.
$(Verb) cd $(PROJ_OBJ_ROOT) ; $(TAR) chf - "$(DistName)" | \
$(GZIP) -c > "$(DistTarGZip)"
dist-bzip2:: $(DistTarBZ2)
$(DistTarBZ2) : $(TopDistDir)/.makedistdir
$(Echo) Packing bzipped distribution tar file.
$(Verb) cd $(PROJ_OBJ_ROOT) ; $(TAR) chf - $(DistName) | \
$(BZIP2) -c >$(DistTarBZ2)
dist-zip:: $(DistZip)
$(DistZip) : $(TopDistDir)/.makedistdir
$(Echo) Packing zipped distribution file.
$(Verb) rm -f $(DistZip)
$(Verb) cd $(PROJ_OBJ_ROOT) ; $(ZIP) -rq $(DistZip) $(DistName)
dist :: $(DistTarGZip) $(DistTarBZ2) $(DistZip)
$(Echo) ===== DISTRIBUTION PACKAGING SUCESSFUL =====
DistCheckDir := $(PROJ_OBJ_ROOT)/_distcheckdir
dist-check:: $(DistTarGZip)
$(Echo) Checking distribution tar file.
$(Verb) if test -d $(DistCheckDir) ; then \
$(RM) -rf $(DistCheckDir) ; \
fi
$(Verb) $(MKDIR) $(DistCheckDir)
$(Verb) cd $(DistCheckDir) && \
$(MKDIR) $(DistCheckDir)/build && \
$(MKDIR) $(DistCheckDir)/install && \
gunzip -c $(DistTarGZip) | $(TAR) xf - && \
cd build && \
../$(DistName)/configure --prefix="$(DistCheckDir)/install" \
--srcdir=../$(DistName) $(DIST_CHECK_CONFIG_OPTIONS) && \
$(MAKE) all && \
$(MAKE) check && \
$(MAKE) install && \
$(MAKE) uninstall && \
$(MAKE) dist-clean && \
$(EchoCmd) ===== $(DistTarGZip) Ready For Distribution =====
dist-clean::
$(Echo) Cleaning distribution files
-$(Verb) $(RM) -rf $(DistTarGZip) $(DistTarBZ2) $(DistZip) $(DistName) \
$(DistCheckDir)
endif
#------------------------------------------------------------------------
# Provide the recursive distdir target for building the distribution directory
#------------------------------------------------------------------------
distdir: $(DistDir)/.makedistdir
$(DistDir)/.makedistdir: $(DistSources)
$(Verb) if test "$(DistDir)" = "$(TopDistDir)" ; then \
if test -d "$(DistDir)" ; then \
find $(DistDir) -type d ! -perm -200 -exec chmod u+w {} ';' || \
exit 1 ; \
fi ; \
$(EchoCmd) Removing old $(DistDir) ; \
$(RM) -rf $(DistDir); \
$(EchoCmd) Making 'all' to verify build ; \
$(MAKE) ENABLE_OPTIMIZED=1 all ; \
fi
$(Echo) Building Distribution Directory $(DistDir)
$(Verb) $(MKDIR) $(DistDir)
$(Verb) srcdirstrip=`echo "$(PROJ_SRC_DIR)" | sed 's|.|.|g'`; \
srcrootstrip=`echo "$(PROJ_SRC_ROOT)" | sed 's|.|.|g'`; \
for file in $(DistFiles) ; do \
case "$$file" in \
$(PROJ_SRC_DIR)/*) \
file=`echo "$$file" | sed "s#^$$srcdirstrip/##"` \
;; \
$(PROJ_SRC_ROOT)/*) \
file=`echo "$$file" | \
sed "s#^$$srcrootstrip/##"` \
;; \
esac; \
if test -f "$(PROJ_SRC_DIR)/$$file" || \
test -d "$(PROJ_SRC_DIR)/$$file" ; then \
from_dir="$(PROJ_SRC_DIR)" ; \
elif test -f "$$file" || test -d "$$file" ; then \
from_dir=. ; \
fi ; \
to_dir=`echo "$$file" | sed -e 's#/[^/]*$$##'` ; \
if test "$$to_dir" != "$$file" && test "$$to_dir" != "."; then \
to_dir="$(DistDir)/$$dir"; \
$(MKDIR) "$$to_dir" ; \
else \
to_dir="$(DistDir)"; \
fi; \
mid_dir=`echo "$$file" | sed -n -e 's#^\(.*\)/[^/]*$$#\1#p'`; \
if test -n "$$mid_dir" ; then \
$(MKDIR) "$$to_dir/$$mid_dir" || exit 1; \
fi ; \
if test -d "$$from_dir/$$file"; then \
if test -d "$(PROJ_SRC_DIR)/$$file" && \
test "$$from_dir" != "$(PROJ_SRC_DIR)" ; then \
cd $(PROJ_SRC_DIR) ; \
$(TAR) cf - $$file --exclude .svn --exclude CVS | \
( cd $$to_dir ; $(TAR) xf - ) ; \
cd $(PROJ_OBJ_DIR) ; \
else \
cd $$from_dir ; \
$(TAR) cf - $$file --exclude .svn --exclude CVS | \
( cd $$to_dir ; $(TAR) xf - ) ; \
cd $(PROJ_OBJ_DIR) ; \
fi; \
elif test -f "$$from_dir/$$file" ; then \
$(CP) -p "$$from_dir/$$file" "$(DistDir)/$$file" || exit 1; \
elif test -L "$$from_dir/$$file" ; then \
$(CP) -pd "$$from_dir/$$file" $(DistDir)/$$file || exit 1; \
elif echo "$(DistAlways)" | grep -v "$$file" >/dev/null ; then \
$(EchoCmd) "===== WARNING: Distribution Source " \
"$$from_dir/$$file Not Found!" ; \
elif test "$(Verb)" != '@' ; then \
$(EchoCmd) "Skipping non-existent $$from_dir/$$file" ; \
fi; \
done
$(Verb) for subdir in $(DistSubDirs) ; do \
if test "$$subdir" \!= "." ; then \
new_distdir="$(DistDir)/$$subdir" ; \
test -d "$$new_distdir" || $(MKDIR) "$$new_distdir" || exit 1; \
( cd $$subdir && $(MAKE) ENABLE_OPTIMIZED=1 \
DistDir="$$new_distdir" distdir ) || exit 1; \
fi; \
done
$(Verb) if test "$(DistDir)" = "$(TopDistDir)" ; then \
$(EchoCmd) Eliminating CVS/.svn directories from distribution ; \
$(RM) -rf `find $(TopDistDir) -type d \( -name CVS -o \
-name .svn \) -print` ;\
$(MAKE) dist-hook ; \
$(FIND) $(TopDistDir) -type d ! -perm -777 -exec chmod a+rwx {} \; \
-o ! -type d ! -perm -444 -links 1 -exec chmod a+r {} \; \
-o ! -type d ! -perm -400 -exec chmod a+r {} \; \
-o ! -type d ! -perm -444 -exec \
$(SHELL) $(INSTALL_SH) -c -m a+r {} {} \; \
|| chmod -R a+r $(DistDir) ; \
fi
# This is invoked by distdir target, define it as a no-op to avoid errors if not
# defined by user.
dist-hook::
endif
###############################################################################
# TOP LEVEL - targets only to apply at the top level directory
###############################################################################
ifeq ($(LEVEL),.)
#------------------------------------------------------------------------
# Install support for the project's include files:
#------------------------------------------------------------------------
install-local::
$(Echo) Installing include files
$(Verb) $(MKDIR) $(PROJ_includedir)
$(Verb) if test -d "$(PROJ_SRC_ROOT)/include" ; then \
cd $(PROJ_SRC_ROOT)/include && \
for hdr in `find . -type f '!' '(' -name '*~' -o -name '.cvsignore' \
-o -name '.#*' -o -name '*.in' ')' -print | grep -v CVS ` ; do \
instdir=`dirname "$(PROJ_includedir)/$$hdr"` ; \
if test \! -d "$$instdir" ; then \
$(EchoCmd) Making install directory $$instdir ; \
$(MKDIR) $$instdir ;\
fi ; \
$(DataInstall) $$hdr $(PROJ_includedir)/$$hdr ; \
done ; \
fi
ifneq ($(PROJ_SRC_ROOT),$(PROJ_OBJ_ROOT))
$(Verb) if test -d "$(PROJ_OBJ_ROOT)/include" ; then \
cd $(PROJ_OBJ_ROOT)/include && \
for hdr in `find . -type f -print | grep -v CVS` ; do \
$(DataInstall) $$hdr $(PROJ_includedir)/$$hdr ; \
done ; \
fi
endif
uninstall-local::
$(Echo) Uninstalling include files
$(Verb) if [ -d "$(PROJ_SRC_ROOT)/include" ] ; then \
cd $(PROJ_SRC_ROOT)/include && \
$(RM) -f `find . -path '*/Internal' -prune -o '(' -type f \
'!' '(' -name '*~' -o -name '.cvsignore' -o -name '.#*' \
-o -name '*.in' ')' -print ')' | \
grep -v CVS | sed 's#^#$(PROJ_includedir)/#'` ; \
cd $(PROJ_SRC_ROOT)/include && \
$(RM) -f `find . -path '*/Internal' -prune -o '(' -type f -name '*.in' \
-print ')' | sed 's#\.in$$##;s#^#$(PROJ_includedir)/#'` ; \
fi
endif
#------------------------------------------------------------------------
# Print out the directories used for building
#------------------------------------------------------------------------
printvars::
$(Echo) "BuildMode : " '$(BuildMode)'
$(Echo) "PROJ_SRC_ROOT: " '$(PROJ_SRC_ROOT)'
$(Echo) "PROJ_SRC_DIR : " '$(PROJ_SRC_DIR)'
$(Echo) "PROJ_OBJ_ROOT: " '$(PROJ_OBJ_ROOT)'
$(Echo) "PROJ_OBJ_DIR : " '$(PROJ_OBJ_DIR)'
$(Echo) "LLVM_SRC_ROOT: " '$(LLVM_SRC_ROOT)'
$(Echo) "LLVM_OBJ_ROOT: " '$(LLVM_OBJ_ROOT)'
$(Echo) "PROJ_prefix : " '$(PROJ_prefix)'
$(Echo) "PROJ_bindir : " '$(PROJ_bindir)'
$(Echo) "PROJ_libdir : " '$(PROJ_libdir)'
$(Echo) "PROJ_etcdir : " '$(PROJ_etcdir)'
$(Echo) "PROJ_includedir : " '$(PROJ_includedir)'
$(Echo) "UserTargets : " '$(UserTargets)'
$(Echo) "ObjMakefiles : " '$(ObjMakefiles)'
$(Echo) "SrcMakefiles : " '$(SrcMakefiles)'
$(Echo) "ObjDir : " '$(ObjDir)'
$(Echo) "LibDir : " '$(LibDir)'
$(Echo) "ToolDir : " '$(ToolDir)'
$(Echo) "ExmplDir : " '$(ExmplDir)'
$(Echo) "Sources : " '$(Sources)'
$(Echo) "TDFiles : " '$(TDFiles)'
$(Echo) "INCFiles : " '$(INCFiles)'
$(Echo) "INCTMPFiles : " '$(INCTMPFiles)'
$(Echo) "PreConditions: " '$(PreConditions)'
$(Echo) "Compile.CXX : " '$(Compile.CXX)'
$(Echo) "Compile.C : " '$(Compile.C)'
$(Echo) "Archive : " '$(Archive)'
$(Echo) "YaccFiles : " '$(YaccFiles)'
$(Echo) "LexFiles : " '$(LexFiles)'
$(Echo) "Module : " '$(Module)'
$(Echo) "FilesToConfig: " '$(FilesToConfigPATH)'
$(Echo) "SubDirs : " '$(SubDirs)'