mirror of
https://github.com/intel/llvm.git
synced 2026-01-18 16:50:51 +08:00
6c0bbfc0c9
Summary: This patch is the MVP version of importing the std module into the expression parser to improve C++ debugging. What happens in this patch is that we inject a `@import std` into our expression source code. We also modify our internal Clang instance for parsing this expression to work with modules and debug info at the same time (which is the main change in terms of LOC). We implicitly build the `std` module on the first use. The C++ include paths for building are extracted from the debug info, which means that this currently only works if the program is compiled with `-glldb -fmodules` and uses the std module. The C include paths are currently specified by LLDB. I enabled the tests currently only for libc++ and Linux because I could test this locally. I'll enable the tests for other platforms once this has landed and doesn't break any bots (and I implemented the platform-specific C include paths for them). With this patch we can now: * Build a libc++ as a module and import it into the expression parser. * Read from the module while also referencing declarations from the debug info. E.g. `std::abs(local_variable)`. What doesn't work (yet): * Merging debug info and C++ module declarations. E.g. `std::vector<CustomClass>` doesn't work. * Pretty much anything that involves the ASTImporter and templated code. As the ASTImporter is used for saving the result declaration, this means that we can't call yet any function that returns a non-trivial type. * Use libstdc++ for this, as it requires multiple include paths and Clang only emits one include path per module. Also libstdc++ doesn't support Clang modules without patches. Reviewers: aprantl, jingham, shafik, friss, davide, serge-sans-paille Reviewed By: aprantl Subscribers: labath, mgorny, abidh, jdoerfert, lldb-commits Tags: #c_modules_in_lldb, #lldb Differential Revision: https://reviews.llvm.org/D58125 llvm-svn: 355939
768 lines
25 KiB
Makefile
768 lines
25 KiB
Makefile
#----------------------------------------------------------------------
|
|
# Clients fill in the source files to build
|
|
#----------------------------------------------------------------------
|
|
# C_SOURCES := main.c
|
|
# CXX_SOURCES :=
|
|
# OBJC_SOURCES :=
|
|
# OBJCXX_SOURCES :=
|
|
# DYLIB_C_SOURCES :=
|
|
# DYLIB_OBJC_SOURCES :=
|
|
# DYLIB_CXX_SOURCES :=
|
|
#
|
|
# Specifying DYLIB_ONLY has the effect of building dylib only, skipping
|
|
# the building of the a.out executable program. For example,
|
|
# DYLIB_ONLY := YES
|
|
#
|
|
# Also might be of interest:
|
|
# FRAMEWORK_INCLUDES (Darwin only) :=
|
|
# CFLAGS_EXTRAS :=
|
|
# LD_EXTRAS :=
|
|
# SPLIT_DEBUG_SYMBOLS := YES
|
|
# CROSS_COMPILE :=
|
|
#
|
|
# And test/functionalities/archives/Makefile:
|
|
# MAKE_DSYM := NO
|
|
# ARCHIVE_NAME := libfoo.a
|
|
# ARCHIVE_C_SOURCES := a.c b.c
|
|
|
|
# Uncomment line below for debugging shell commands
|
|
# SHELL = /bin/sh -x
|
|
|
|
SRCDIR := $(shell dirname $(firstword $(MAKEFILE_LIST)))/
|
|
BUILDDIR := $(shell pwd)
|
|
THIS_FILE_DIR := $(shell dirname $(lastword $(MAKEFILE_LIST)))/
|
|
LLDB_BASE_DIR := $(THIS_FILE_DIR)../../../../../
|
|
|
|
#----------------------------------------------------------------------
|
|
# If OS is not defined, use 'uname -s' to determine the OS name.
|
|
#
|
|
# uname on Windows gives "windows32" or "server version windows32", but most
|
|
# environments standardize on "Windows_NT", so we'll make it consistent here.
|
|
# When running tests from Visual Studio, the environment variable isn't
|
|
# inherited all the way down to the process spawned for make.
|
|
#----------------------------------------------------------------------
|
|
HOST_OS = $(shell uname -s)
|
|
ifneq (,$(findstring windows32,$(HOST_OS)))
|
|
HOST_OS = Windows_NT
|
|
endif
|
|
ifeq "$(OS)" ""
|
|
OS = $(HOST_OS)
|
|
endif
|
|
|
|
#----------------------------------------------------------------------
|
|
# If OS is Windows, force SHELL to be cmd
|
|
#
|
|
# Some versions of make on Windows will search for other shells such as
|
|
# C:\cygwin\bin\sh.exe. This shell fails for numerous different reasons
|
|
# so default to using cmd.exe.
|
|
#----------------------------------------------------------------------
|
|
ifeq "$(OS)" "Windows_NT"
|
|
SHELL = $(WINDIR)\system32\cmd.exe
|
|
endif
|
|
|
|
#----------------------------------------------------------------------
|
|
# If the OS is Windows use double-quotes in commands
|
|
#
|
|
# For other operating systems, single-quotes work fine, but on Windows
|
|
# we strictly required double-quotes
|
|
#----------------------------------------------------------------------
|
|
ifeq "$(HOST_OS)" "Windows_NT"
|
|
JOIN_CMD = &
|
|
QUOTE = "
|
|
FIXUP_SYNTAX_HIGHLIGHTING_IN_MY_EDITOR = "
|
|
else
|
|
JOIN_CMD = ;
|
|
QUOTE = '
|
|
FIXUP_SYNTAX_HIGHLIGHTING_IN_MY_EDITOR = '
|
|
endif
|
|
|
|
#----------------------------------------------------------------------
|
|
# If TRIPLE is not defined try to set the ARCH, CC, CFLAGS, and more
|
|
# from the triple alone
|
|
#----------------------------------------------------------------------
|
|
ARCH_CFLAGS :=
|
|
ifneq "$(TRIPLE)" ""
|
|
triple_space = $(subst -, ,$(TRIPLE))
|
|
ARCH =$(word 1, $(triple_space))
|
|
TRIPLE_VENDOR =$(word 2, $(triple_space))
|
|
triple_os_and_version =$(shell echo $(word 3, $(triple_space)) | sed 's/\([a-z]*\)\(.*\)/\1 \2/')
|
|
TRIPLE_OS =$(word 1, $(triple_os_and_version))
|
|
TRIPLE_VERSION =$(word 2, $(triple_os_and_version))
|
|
ifeq "$(TRIPLE_VENDOR)" "apple"
|
|
ifeq "$(TRIPLE_OS)" "ios"
|
|
CODESIGN := codesign
|
|
ifeq "$(SDKROOT)" ""
|
|
# Set SDKROOT if it wasn't set
|
|
ifneq (,$(findstring arm,$(ARCH)))
|
|
SDKROOT = $(shell xcrun --sdk iphoneos --show-sdk-path)
|
|
ifeq "$(TRIPLE_VERSION)" ""
|
|
TRIPLE_VERSION =$(shell echo $(notdir $(SDKROOT)) | sed -e 's/.*\([0-9]\.[0-9]\).*/\1/')
|
|
endif
|
|
ARCH_CFLAGS :=-mios-version-min=$(TRIPLE_VERSION) -isysroot "$(SDKROOT)"
|
|
else
|
|
SDKROOT = $(shell xcrun --sdk iphonesimulator --show-sdk-path)
|
|
ifeq "$(TRIPLE_VERSION)" ""
|
|
TRIPLE_VERSION =$(shell echo $(notdir $(SDKROOT)) | sed -e 's/.*\([0-9]\.[0-9]\).*/\1/')
|
|
endif
|
|
ARCH_CFLAGS :=-mios-simulator-version-min=$(TRIPLE_VERSION) -isysroot "$(SDKROOT)"
|
|
endif
|
|
endif
|
|
endif
|
|
ifeq "$(TRIPLE_OS)" "watchos"
|
|
CODESIGN := codesign
|
|
ifeq "$(SDKROOT)" ""
|
|
# Set SDKROOT if it wasn't set
|
|
ifneq (,$(findstring arm,$(ARCH)))
|
|
SDKROOT = $(shell xcrun --sdk watchos --show-sdk-path)
|
|
ifeq "$(TRIPLE_VERSION)" ""
|
|
TRIPLE_VERSION =$(shell echo $(notdir $(SDKROOT)) | sed -e 's/.*\([0-9]\.[0-9]\).*/\1/')
|
|
endif
|
|
ARCH_CFLAGS :=-mwatchos-version-min=$(TRIPLE_VERSION) -isysroot "$(SDKROOT)"
|
|
else
|
|
SDKROOT = $(shell xcrun --sdk watchsimulator --show-sdk-path)
|
|
ifeq "$(TRIPLE_VERSION)" ""
|
|
TRIPLE_VERSION =$(shell echo $(notdir $(SDKROOT)) | sed -e 's/.*\([0-9]\.[0-9]\).*/\1/')
|
|
endif
|
|
ARCH_CFLAGS :=-mwatchos-simulator-version-min=$(TRIPLE_VERSION) -isysroot "$(SDKROOT)"
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
ifeq "$(OS)" "Android"
|
|
include $(THIS_FILE_DIR)/Android.rules
|
|
endif
|
|
|
|
#----------------------------------------------------------------------
|
|
# If ARCH is not defined, default to x86_64.
|
|
#----------------------------------------------------------------------
|
|
ifeq "$(ARCH)" ""
|
|
ifeq "$(OS)" "Windows_NT"
|
|
ARCH = x86
|
|
else
|
|
ARCH = x86_64
|
|
endif
|
|
endif
|
|
|
|
#----------------------------------------------------------------------
|
|
# CC defaults to clang.
|
|
#
|
|
# If you change the defaults of CC, be sure to also change it in the file
|
|
# test/plugins/builder_base.py, which provides a Python way to return the
|
|
# value of the make variable CC -- getCompiler().
|
|
#
|
|
# See also these functions:
|
|
# o cxx_compiler
|
|
# o cxx_linker
|
|
#----------------------------------------------------------------------
|
|
CC ?= clang
|
|
ifeq "$(CC)" "cc"
|
|
ifneq "$(shell which clang)" ""
|
|
CC = clang
|
|
else ifneq "$(shell which clang-3.5)" ""
|
|
CC = clang-3.5
|
|
else ifneq "$(shell which gcc)" ""
|
|
CC = gcc
|
|
endif
|
|
endif
|
|
|
|
#----------------------------------------------------------------------
|
|
# Handle SDKROOT on Darwin
|
|
#----------------------------------------------------------------------
|
|
|
|
ifeq "$(OS)" "Darwin"
|
|
ifeq "$(SDKROOT)" ""
|
|
# We haven't otherwise set the SDKROOT, so set it now to macosx
|
|
SDKROOT := $(shell xcrun --sdk macosx --show-sdk-path)
|
|
endif
|
|
endif
|
|
|
|
#----------------------------------------------------------------------
|
|
# ARCHFLAG is the flag used to tell the compiler which architecture
|
|
# to compile for. The default is the flag that clang accepts.
|
|
#----------------------------------------------------------------------
|
|
ARCHFLAG ?= -arch
|
|
|
|
#----------------------------------------------------------------------
|
|
# Change any build/tool options needed
|
|
#----------------------------------------------------------------------
|
|
ifeq "$(OS)" "Darwin"
|
|
DS := $(DSYMUTIL)
|
|
DSFLAGS =
|
|
DSYM = $(EXE).dSYM
|
|
AR := $(CROSS_COMPILE)libtool
|
|
ARFLAGS := -static -o
|
|
else
|
|
AR := $(CROSS_COMPILE)ar
|
|
# On non-Apple platforms, -arch becomes -m
|
|
ARCHFLAG := -m
|
|
|
|
# i386, i686, x86 -> 32
|
|
# amd64, x86_64, x64 -> 64
|
|
ifeq "$(ARCH)" "amd64"
|
|
override ARCH := $(subst amd64,64,$(ARCH))
|
|
endif
|
|
ifeq "$(ARCH)" "x86_64"
|
|
override ARCH := $(subst x86_64,64,$(ARCH))
|
|
endif
|
|
ifeq "$(ARCH)" "x64"
|
|
override ARCH := $(subst x64,64,$(ARCH))
|
|
endif
|
|
ifeq "$(ARCH)" "x86"
|
|
override ARCH := $(subst x86,32,$(ARCH))
|
|
endif
|
|
ifeq "$(ARCH)" "i386"
|
|
override ARCH := $(subst i386,32,$(ARCH))
|
|
endif
|
|
ifeq "$(ARCH)" "i686"
|
|
override ARCH := $(subst i686,32,$(ARCH))
|
|
endif
|
|
ifeq "$(ARCH)" "powerpc"
|
|
override ARCH := $(subst powerpc,32,$(ARCH))
|
|
endif
|
|
ifeq "$(ARCH)" "powerpc64"
|
|
override ARCH := $(subst powerpc64,64,$(ARCH))
|
|
endif
|
|
ifeq "$(ARCH)" "powerpc64le"
|
|
override ARCH := $(subst powerpc64le,64,$(ARCH))
|
|
endif
|
|
ifeq "$(ARCH)" "aarch64"
|
|
override ARCH :=
|
|
override ARCHFLAG :=
|
|
endif
|
|
ifeq "$(ARCH)" "arm"
|
|
override ARCH :=
|
|
override ARCHFLAG :=
|
|
endif
|
|
ifeq "$(ARCH)" "s390x"
|
|
override ARCH :=
|
|
override ARCHFLAG :=
|
|
endif
|
|
ifeq "$(findstring mips,$(ARCH))" "mips"
|
|
override ARCHFLAG := -
|
|
endif
|
|
|
|
ifeq "$(SPLIT_DEBUG_SYMBOLS)" "YES"
|
|
DSYM = $(EXE).debug
|
|
endif
|
|
endif
|
|
|
|
LIMIT_DEBUG_INFO_FLAGS =
|
|
NO_LIMIT_DEBUG_INFO_FLAGS =
|
|
MODULE_DEBUG_INFO_FLAGS =
|
|
ifneq (,$(findstring clang,$(CC)))
|
|
LIMIT_DEBUG_INFO_FLAGS += -flimit-debug-info
|
|
NO_LIMIT_DEBUG_INFO_FLAGS += -fno-limit-debug-info
|
|
MODULE_DEBUG_INFO_FLAGS += -gmodules
|
|
endif
|
|
|
|
DEBUG_INFO_FLAG ?= -g
|
|
|
|
CFLAGS ?= $(DEBUG_INFO_FLAG) -O0 -fno-builtin
|
|
|
|
ifeq "$(OS)" "Darwin"
|
|
ifneq "$(SDKROOT)" ""
|
|
CFLAGS += -isysroot "$(SDKROOT)"
|
|
endif
|
|
endif
|
|
|
|
ifeq "$(OS)" "Darwin"
|
|
CFLAGS += $(ARCHFLAG) $(ARCH) $(FRAMEWORK_INCLUDES) -I$(LLDB_BASE_DIR)include
|
|
else
|
|
CFLAGS += $(ARCHFLAG)$(ARCH) $(FRAMEWORK_INCLUDES) -I$(LLDB_BASE_DIR)include
|
|
endif
|
|
|
|
CFLAGS += -I$(SRCDIR) -I$(THIS_FILE_DIR)
|
|
|
|
ifndef NO_TEST_COMMON_H
|
|
CFLAGS += -include $(THIS_FILE_DIR)test_common.h
|
|
endif
|
|
|
|
CFLAGS += $(NO_LIMIT_DEBUG_INFO_FLAGS) $(ARCH_CFLAGS) $(CFLAGS_EXTRAS)
|
|
|
|
# If the OS is Windows, we need to pass -gdwarf to clang, otherwise it will build
|
|
# with codeview by default but all the tests rely on dwarf.
|
|
ifeq "$(OS)" "Windows_NT"
|
|
CFLAGS += -gdwarf
|
|
endif
|
|
|
|
# Use this one if you want to build one part of the result without debug information:
|
|
ifeq "$(OS)" "Darwin"
|
|
CFLAGS_NO_DEBUG = -O0 $(ARCHFLAG) $(ARCH) $(FRAMEWORK_INCLUDES) $(ARCH_CFLAGS) $(CFLAGS_EXTRAS)
|
|
else
|
|
CFLAGS_NO_DEBUG = -O0 $(ARCHFLAG)$(ARCH) $(FRAMEWORK_INCLUDES) $(ARCH_CFLAGS) $(CFLAGS_EXTRAS)
|
|
endif
|
|
|
|
ifeq "$(MAKE_DWO)" "YES"
|
|
CFLAGS += -gsplit-dwarf
|
|
endif
|
|
|
|
# Use a shared module cache when building in the default test build directory.
|
|
CLANG_MODULE_CACHE_DIR := $(shell echo "$(BUILDDIR)" | sed $(QUOTE)s/lldb-test-build.noindex.*/lldb-test-build.noindex\/module-cache-clang/$(QUOTE))
|
|
|
|
ifeq "$(findstring lldb-test-build.noindex, $(BUILDDIR))" ""
|
|
CLANG_MODULE_CACHE_DIR := $(BUILDDIR)/module-cache
|
|
$(warning failed to set the shared clang module cache dir)
|
|
endif
|
|
|
|
MODULE_BASE_FLAGS := -fmodules -gmodules -fmodules-cache-path=$(CLANG_MODULE_CACHE_DIR)
|
|
MANDATORY_MODULE_BUILD_CFLAGS := $(MODULE_BASE_FLAGS) -gmodules
|
|
# Build flags for building with C++ modules.
|
|
# -glldb is necessary for emitting information about what modules were imported.
|
|
MANDATORY_CXXMODULE_BUILD_CFLAGS := $(MODULE_BASE_FLAGS) -fcxx-modules -glldb
|
|
|
|
ifeq "$(OS)" "Darwin"
|
|
MANDATORY_MODULE_BUILD_CFLAGS += -fcxx-modules
|
|
endif
|
|
|
|
ifeq "$(MAKE_GMODULES)" "YES"
|
|
CFLAGS += $(MANDATORY_MODULE_BUILD_CFLAGS)
|
|
CXXFLAGS += $(MANDATORY_MODULE_BUILD_CFLAGS)
|
|
endif
|
|
|
|
CXXFLAGS += -std=c++11 $(CFLAGS) $(ARCH_CXXFLAGS)
|
|
LD = $(CC)
|
|
LDFLAGS ?= $(CFLAGS)
|
|
LDFLAGS += $(LD_EXTRAS) $(ARCH_LDFLAGS)
|
|
ifneq (,$(LLVM_LIBS_DIR))
|
|
ifeq ($(OS),NetBSD)
|
|
LDFLAGS += -L$(LLVM_LIBS_DIR) -Wl,-rpath,$(LLVM_LIBS_DIR)
|
|
endif
|
|
endif
|
|
ifeq (,$(filter $(OS), Windows_NT Android Darwin))
|
|
ifneq (,$(filter YES,$(ENABLE_THREADS)))
|
|
LDFLAGS += -pthread
|
|
endif
|
|
endif
|
|
OBJECTS =
|
|
EXE ?= a.out
|
|
|
|
ifneq "$(DYLIB_NAME)" ""
|
|
ifeq "$(OS)" "Darwin"
|
|
DYLIB_FILENAME = lib$(DYLIB_NAME).dylib
|
|
DYLIB_EXECUTABLE_PATH ?= @executable_path
|
|
else ifeq "$(OS)" "Windows_NT"
|
|
DYLIB_FILENAME = $(DYLIB_NAME).dll
|
|
else
|
|
DYLIB_FILENAME = lib$(DYLIB_NAME).so
|
|
endif
|
|
endif
|
|
|
|
# Function that returns the counterpart C++ compiler, given $(CC) as arg.
|
|
cxx_compiler_notdir = $(if $(findstring icc,$(1)), \
|
|
$(subst icc,icpc,$(1)), \
|
|
$(if $(findstring llvm-gcc,$(1)), \
|
|
$(subst llvm-gcc,llvm-g++,$(1)), \
|
|
$(if $(findstring gcc,$(1)), \
|
|
$(subst gcc,g++,$(1)), \
|
|
$(subst cc,c++,$(1)))))
|
|
cxx_compiler = $(if $(findstring /,$(1)),$(join $(dir $(1)), $(call cxx_compiler_notdir,$(notdir $(1)))),$(call cxx_compiler_notdir,$(1)))
|
|
|
|
# Function that returns the C++ linker, given $(CC) as arg.
|
|
cxx_linker_notdir = $(if $(findstring icc,$(1)), \
|
|
$(subst icc,icpc,$(1)), \
|
|
$(if $(findstring llvm-gcc,$(1)), \
|
|
$(subst llvm-gcc,llvm-g++,$(1)), \
|
|
$(if $(findstring gcc,$(1)), \
|
|
$(subst gcc,g++,$(1)), \
|
|
$(subst cc,c++,$(1)))))
|
|
cxx_linker = $(if $(findstring /,$(1)),$(join $(dir $(1)), $(call cxx_linker_notdir,$(notdir $(1)))),$(call cxx_linker_notdir,$(1)))
|
|
|
|
ifneq "$(OS)" "Darwin"
|
|
CLANG_OR_GCC := $(strip $(if $(findstring clang,$(CC)), \
|
|
$(findstring clang,$(CC)), \
|
|
$(if $(findstring gcc,$(CC)), \
|
|
$(findstring gcc,$(CC)), \
|
|
cc)))
|
|
|
|
CC_LASTWORD := $(strip $(lastword $(subst -, ,$(CC))))
|
|
|
|
replace_with = $(strip $(if $(findstring $(3),$(CC_LASTWORD)), \
|
|
$(subst $(3),$(1),$(2)), \
|
|
$(subst $(3),$(1),$(subst -$(CC_LASTWORD),,$(2)))))
|
|
|
|
ifeq "$(notdir $(CC))" "$(CC)"
|
|
replace_cc_with = $(call replace_with,$(1),$(CC),$(CLANG_OR_GCC))
|
|
else
|
|
replace_cc_with = $(join $(dir $(CC)),$(call replace_with,$(1),$(notdir $(CC)),$(CLANG_OR_GCC)))
|
|
endif
|
|
|
|
OBJCOPY ?= $(call replace_cc_with,objcopy)
|
|
ARCHIVER ?= $(call replace_cc_with,ar)
|
|
override AR = $(ARCHIVER)
|
|
endif
|
|
|
|
ifdef PIE
|
|
LDFLAGS += -pie
|
|
endif
|
|
|
|
#----------------------------------------------------------------------
|
|
# Windows specific options
|
|
#----------------------------------------------------------------------
|
|
ifeq "$(OS)" "Windows_NT"
|
|
ifneq (,$(findstring clang,$(CC)))
|
|
# Clang for Windows doesn't support C++ Exceptions
|
|
CXXFLAGS += -fno-exceptions
|
|
CXXFLAGS += -D_HAS_EXCEPTIONS=0
|
|
|
|
# MSVC 2015 or higher is required, which depends on c++14, so
|
|
# append these values unconditionally.
|
|
CXXFLAGS += -fms-compatibility-version=19.0
|
|
override CXXFLAGS := $(subst -std=c++11,-std=c++14,$(CXXFLAGS))
|
|
|
|
# The MSVC linker doesn't understand long section names
|
|
# generated by the clang compiler.
|
|
LDFLAGS += -fuse-ld=lld
|
|
endif
|
|
endif
|
|
|
|
#----------------------------------------------------------------------
|
|
# C++ standard library options
|
|
#----------------------------------------------------------------------
|
|
ifeq (1,$(USE_LIBSTDCPP))
|
|
# Clang requires an extra flag: -stdlib=libstdc++
|
|
ifneq (,$(findstring clang,$(CC)))
|
|
CXXFLAGS += -stdlib=libstdc++ -DLLDB_USING_LIBSTDCPP
|
|
LDFLAGS += -stdlib=libstdc++
|
|
endif
|
|
endif
|
|
|
|
ifeq (1,$(USE_LIBCPP))
|
|
CXXFLAGS += -DLLDB_USING_LIBCPP
|
|
ifeq "$(OS)" "Linux"
|
|
ifneq (,$(findstring clang,$(CC)))
|
|
CXXFLAGS += -stdlib=libc++
|
|
LDFLAGS += -stdlib=libc++
|
|
else
|
|
CXXFLAGS += -isystem /usr/include/c++/v1
|
|
LDFLAGS += -lc++
|
|
endif
|
|
else ifeq "$(OS)" "Android"
|
|
# Nothing to do, this is already handled in
|
|
# Android.rules.
|
|
else
|
|
CXXFLAGS += -stdlib=libc++
|
|
LDFLAGS += -stdlib=libc++
|
|
endif
|
|
endif
|
|
|
|
#----------------------------------------------------------------------
|
|
# Additional system libraries
|
|
#----------------------------------------------------------------------
|
|
ifeq (1,$(USE_LIBDL))
|
|
ifneq ($(OS),NetBSD)
|
|
LDFLAGS += -ldl
|
|
endif
|
|
endif
|
|
|
|
#----------------------------------------------------------------------
|
|
# dylib settings
|
|
#----------------------------------------------------------------------
|
|
ifneq "$(strip $(DYLIB_C_SOURCES))" ""
|
|
DYLIB_OBJECTS +=$(strip $(DYLIB_C_SOURCES:.c=.o))
|
|
endif
|
|
|
|
ifneq "$(strip $(DYLIB_OBJC_SOURCES))" ""
|
|
DYLIB_OBJECTS +=$(strip $(DYLIB_OBJC_SOURCES:.m=.o))
|
|
endif
|
|
|
|
ifneq "$(strip $(DYLIB_CXX_SOURCES))" ""
|
|
DYLIB_OBJECTS +=$(strip $(DYLIB_CXX_SOURCES:.cpp=.o))
|
|
CXX = $(call cxx_compiler,$(CC))
|
|
LD = $(call cxx_linker,$(CC))
|
|
endif
|
|
|
|
#----------------------------------------------------------------------
|
|
# Check if we have a precompiled header
|
|
#----------------------------------------------------------------------
|
|
ifneq "$(strip $(PCH_CXX_SOURCE))" ""
|
|
PCH_OUTPUT = $(PCH_CXX_SOURCE:.h=.h.pch)
|
|
PCHFLAGS = -include $(PCH_CXX_SOURCE)
|
|
endif
|
|
|
|
#----------------------------------------------------------------------
|
|
# Check if we have any C source files
|
|
#----------------------------------------------------------------------
|
|
ifneq "$(strip $(C_SOURCES))" ""
|
|
OBJECTS +=$(strip $(C_SOURCES:.c=.o))
|
|
endif
|
|
|
|
#----------------------------------------------------------------------
|
|
# Check if we have any C++ source files
|
|
#----------------------------------------------------------------------
|
|
ifneq "$(strip $(CXX_SOURCES))" ""
|
|
OBJECTS +=$(strip $(CXX_SOURCES:.cpp=.o))
|
|
CXX = $(call cxx_compiler,$(CC))
|
|
LD = $(call cxx_linker,$(CC))
|
|
endif
|
|
|
|
#----------------------------------------------------------------------
|
|
# Check if we have any ObjC source files
|
|
#----------------------------------------------------------------------
|
|
ifneq "$(strip $(OBJC_SOURCES))" ""
|
|
OBJECTS +=$(strip $(OBJC_SOURCES:.m=.o))
|
|
LDFLAGS +=-lobjc
|
|
endif
|
|
|
|
#----------------------------------------------------------------------
|
|
# Check if we have any ObjC++ source files
|
|
#----------------------------------------------------------------------
|
|
ifneq "$(strip $(OBJCXX_SOURCES))" ""
|
|
OBJECTS +=$(strip $(OBJCXX_SOURCES:.mm=.o))
|
|
CXX = $(call cxx_compiler,$(CC))
|
|
LD = $(call cxx_linker,$(CC))
|
|
ifeq "$(findstring lobjc,$(LDFLAGS))" ""
|
|
LDFLAGS +=-lobjc
|
|
endif
|
|
endif
|
|
|
|
#----------------------------------------------------------------------
|
|
# Check if we have any C source files for archive
|
|
#----------------------------------------------------------------------
|
|
ifneq "$(strip $(ARCHIVE_C_SOURCES))" ""
|
|
ARCHIVE_OBJECTS +=$(strip $(ARCHIVE_C_SOURCES:.c=.o))
|
|
endif
|
|
|
|
#----------------------------------------------------------------------
|
|
# Check if we have any C++ source files for archive
|
|
#----------------------------------------------------------------------
|
|
ifneq "$(strip $(ARCHIVE_CXX_SOURCES))" ""
|
|
ARCHIVE_OBJECTS +=$(strip $(ARCHIVE_CXX_SOURCES:.cpp=.o))
|
|
CXX = $(call cxx_compiler,$(CC))
|
|
LD = $(call cxx_linker,$(CC))
|
|
endif
|
|
|
|
#----------------------------------------------------------------------
|
|
# Check if we have any ObjC source files for archive
|
|
#----------------------------------------------------------------------
|
|
ifneq "$(strip $(ARCHIVE_OBJC_SOURCES))" ""
|
|
ARCHIVE_OBJECTS +=$(strip $(ARCHIVE_OBJC_SOURCES:.m=.o))
|
|
LDFLAGS +=-lobjc
|
|
endif
|
|
|
|
#----------------------------------------------------------------------
|
|
# Check if we have any ObjC++ source files for archive
|
|
#----------------------------------------------------------------------
|
|
ifneq "$(strip $(ARCHIVE_OBJCXX_SOURCES))" ""
|
|
ARCHIVE_OBJECTS +=$(strip $(ARCHIVE_OBJCXX_SOURCES:.mm=.o))
|
|
CXX = $(call cxx_compiler,$(CC))
|
|
LD = $(call cxx_linker,$(CC))
|
|
ifeq "$(findstring lobjc,$(LDFLAGS))" ""
|
|
LDFLAGS +=-lobjc
|
|
endif
|
|
endif
|
|
|
|
#----------------------------------------------------------------------
|
|
# Check if we are compiling with gcc 4.6
|
|
#----------------------------------------------------------------------
|
|
ifneq "$(strip $(CXX_SOURCES) $(OBJCXX_SOURCES))" ""
|
|
ifneq "$(filter g++,$(CXX))" ""
|
|
CXXVERSION = $(shell $(CXX) -dumpversion | cut -b 1-3)
|
|
ifeq "$(CXXVERSION)" "4.6"
|
|
# GCC 4.6 cannot handle -std=c++11, so replace it with -std=c++0x
|
|
# instead. FIXME: remove once GCC version is upgraded.
|
|
override CXXFLAGS := $(subst -std=c++11,-std=c++0x,$(CXXFLAGS))
|
|
endif
|
|
endif
|
|
endif
|
|
|
|
ifeq ($(findstring clang, $(CXX)), clang)
|
|
CXXFLAGS += --driver-mode=g++
|
|
endif
|
|
|
|
ifneq "$(CXX)" ""
|
|
ifeq ($(findstring clang, $(LD)), clang)
|
|
LDFLAGS += --driver-mode=g++
|
|
endif
|
|
endif
|
|
|
|
#----------------------------------------------------------------------
|
|
# DYLIB_ONLY variable can be used to skip the building of a.out.
|
|
# See the sections below regarding dSYM file as well as the building of
|
|
# EXE from all the objects.
|
|
#----------------------------------------------------------------------
|
|
|
|
#----------------------------------------------------------------------
|
|
# Compile the executable from all the objects.
|
|
#----------------------------------------------------------------------
|
|
ifneq "$(DYLIB_NAME)" ""
|
|
ifeq "$(DYLIB_ONLY)" ""
|
|
$(EXE) : $(OBJECTS) $(ARCHIVE_NAME) $(DYLIB_FILENAME)
|
|
$(LD) $(OBJECTS) $(ARCHIVE_NAME) -L. -l$(DYLIB_NAME) $(LDFLAGS) -o "$(EXE)"
|
|
else
|
|
EXE = $(DYLIB_FILENAME)
|
|
endif
|
|
else
|
|
$(EXE) : $(OBJECTS) $(ARCHIVE_NAME)
|
|
$(LD) $(OBJECTS) $(LDFLAGS) $(ARCHIVE_NAME) -o "$(EXE)"
|
|
ifneq "$(CODESIGN)" ""
|
|
$(CODESIGN) -s - "$(EXE)"
|
|
endif
|
|
endif
|
|
|
|
#----------------------------------------------------------------------
|
|
# Make the dSYM file from the executable if $(MAKE_DSYM) != "NO"
|
|
#----------------------------------------------------------------------
|
|
$(DSYM) : $(EXE)
|
|
ifeq "$(OS)" "Darwin"
|
|
ifneq "$(MAKE_DSYM)" "NO"
|
|
"$(DS)" $(DSFLAGS) -o "$(DSYM)" "$(EXE)"
|
|
else
|
|
endif
|
|
else
|
|
ifeq "$(SPLIT_DEBUG_SYMBOLS)" "YES"
|
|
$(OBJCOPY) --only-keep-debug "$(EXE)" "$(DSYM)"
|
|
$(OBJCOPY) --strip-debug --add-gnu-debuglink="$(DSYM)" "$(EXE)" "$(EXE)"
|
|
endif
|
|
endif
|
|
|
|
#----------------------------------------------------------------------
|
|
# Make the archive
|
|
#----------------------------------------------------------------------
|
|
ifneq "$(ARCHIVE_NAME)" ""
|
|
ifeq "$(OS)" "Darwin"
|
|
$(ARCHIVE_NAME) : $(ARCHIVE_OBJECTS)
|
|
$(AR) $(ARFLAGS) $(ARCHIVE_NAME) $(ARCHIVE_OBJECTS)
|
|
$(RM) $(ARCHIVE_OBJECTS)
|
|
else
|
|
$(ARCHIVE_NAME) : $(foreach ar_obj,$(ARCHIVE_OBJECTS),$(ARCHIVE_NAME)($(ar_obj)))
|
|
endif
|
|
endif
|
|
|
|
#----------------------------------------------------------------------
|
|
# Make the dylib
|
|
#----------------------------------------------------------------------
|
|
$(DYLIB_OBJECTS) : CFLAGS += -DCOMPILING_LLDB_TEST_DLL
|
|
|
|
ifneq "$(OS)" "Windows_NT"
|
|
$(DYLIB_OBJECTS) : CFLAGS += -fPIC
|
|
$(DYLIB_OBJECTS) : CXXFLAGS += -fPIC
|
|
endif
|
|
|
|
$(DYLIB_FILENAME) : $(DYLIB_OBJECTS)
|
|
ifeq "$(OS)" "Darwin"
|
|
$(LD) $(DYLIB_OBJECTS) $(LDFLAGS) -install_name "$(DYLIB_EXECUTABLE_PATH)/$(DYLIB_FILENAME)" -dynamiclib -o "$(DYLIB_FILENAME)"
|
|
ifneq "$(CODESIGN)" ""
|
|
$(CODESIGN) -s - "$(DYLIB_FILENAME)"
|
|
endif
|
|
ifneq "$(MAKE_DSYM)" "NO"
|
|
ifneq "$(DS)" ""
|
|
"$(DS)" $(DSFLAGS) "$(DYLIB_FILENAME)"
|
|
endif
|
|
endif
|
|
else
|
|
$(LD) $(DYLIB_OBJECTS) $(LDFLAGS) -shared -o "$(DYLIB_FILENAME)"
|
|
ifeq "$(SPLIT_DEBUG_SYMBOLS)" "YES"
|
|
$(OBJCOPY) --only-keep-debug "$(DYLIB_FILENAME)" "$(DYLIB_FILENAME).debug"
|
|
$(OBJCOPY) --strip-debug --add-gnu-debuglink="$(DYLIB_FILENAME).debug" "$(DYLIB_FILENAME)" "$(DYLIB_FILENAME)"
|
|
endif
|
|
endif
|
|
|
|
#----------------------------------------------------------------------
|
|
# Make the precompiled header and compile C++ sources against it
|
|
#----------------------------------------------------------------------
|
|
|
|
#ifneq "$(PCH_OUTPUT)" ""
|
|
$(PCH_OUTPUT) : $(PCH_CXX_SOURCE)
|
|
$(CXX) $(CXXFLAGS) -x c++-header -o $@ $<
|
|
%.o : %.cpp $(PCH_OUTPUT)
|
|
$(CXX) $(PCHFLAGS) $(CXXFLAGS) -c -o $@ $<
|
|
#endif
|
|
|
|
#----------------------------------------------------------------------
|
|
# Automatic variables based on items already entered. Below we create
|
|
# an object's lists from the list of sources by replacing all entries
|
|
# that end with .c with .o, and we also create a list of prerequisite
|
|
# files by replacing all .c files with .d.
|
|
#----------------------------------------------------------------------
|
|
PREREQS := $(OBJECTS:.o=.d)
|
|
DWOS := $(OBJECTS:.o=.dwo) $(ARCHIVE_OBJECTS:.o=.dwo)
|
|
ifneq "$(DYLIB_NAME)" ""
|
|
DYLIB_PREREQS := $(DYLIB_OBJECTS:.o=.d)
|
|
DYLIB_DWOS := $(DYLIB_OBJECTS:.o=.dwo)
|
|
endif
|
|
|
|
#----------------------------------------------------------------------
|
|
# Rule for Generating Prerequisites Automatically using .d files and
|
|
# the compiler -MM option. The -M option will list all system headers,
|
|
# and the -MM option will list all non-system dependencies.
|
|
#----------------------------------------------------------------------
|
|
%.d: %.c
|
|
@rm -f $@ $(JOIN_CMD) \
|
|
$(CC) -M $(CFLAGS) $< > $@.tmp && \
|
|
sed $(QUOTE)s,\($*\)\.o[ :]*,\1.o $@ : ,g$(QUOTE) < $@.tmp > $@ $(JOIN_CMD) \
|
|
rm -f $@.tmp
|
|
|
|
%.d: %.cpp
|
|
@rm -f $@ $(JOIN_CMD) \
|
|
$(CXX) -M $(CXXFLAGS) $< > $@.tmp && \
|
|
sed $(QUOTE)s,\($*\)\.o[ :]*,\1.o $@ : ,g$(QUOTE) < $@.tmp > $@ $(JOIN_CMD) \
|
|
rm -f $@.tmp
|
|
|
|
%.d: %.m
|
|
@rm -f $@ $(JOIN_CMD) \
|
|
$(CC) -M $(CFLAGS) $< > $@.tmp && \
|
|
sed $(QUOTE)s,\($*\)\.o[ :]*,\1.o $@ : ,g$(QUOTE) < $@.tmp > $@ $(JOIN_CMD) \
|
|
rm -f $@.tmp
|
|
|
|
%.d: %.mm
|
|
@rm -f $@ $(JOIN_CMD) \
|
|
$(CXX) -M $(CXXFLAGS) $< > $@.tmp && \
|
|
sed $(QUOTE)s,\($*\)\.o[ :]*,\1.o $@ : ,g$(QUOTE) < $@.tmp > $@ $(JOIN_CMD) \
|
|
rm -f $@.tmp
|
|
|
|
#----------------------------------------------------------------------
|
|
# Include all of the makefiles for each source file so we don't have
|
|
# to manually track all of the prerequisites for each source file.
|
|
#----------------------------------------------------------------------
|
|
sinclude $(PREREQS)
|
|
ifneq "$(DYLIB_NAME)" ""
|
|
sinclude $(DYLIB_PREREQS)
|
|
endif
|
|
|
|
# Define a suffix rule for .mm -> .o
|
|
.SUFFIXES: .mm .o
|
|
.mm.o:
|
|
$(CXX) $(CXXFLAGS) -c $<
|
|
|
|
.PHONY: clean
|
|
dsym: $(DSYM)
|
|
all: $(EXE) $(DSYM)
|
|
clean::
|
|
$(RM) -rf $(OBJECTS) $(PREREQS) $(PREREQS:.d=.d.tmp) $(DWOS) $(ARCHIVE_NAME) $(ARCHIVE_OBJECTS) $(CLANG_MODULE_CACHE_DIR)
|
|
ifneq "$(DYLIB_NAME)" ""
|
|
$(RM) -r $(DYLIB_FILENAME).dSYM
|
|
$(RM) $(DYLIB_OBJECTS) $(DYLIB_PREREQS) $(DYLIB_PREREQS:.d=.d.tmp) $(DYLIB_DWOS) $(DYLIB_FILENAME) $(DYLIB_FILENAME).debug
|
|
endif
|
|
ifneq "$(PCH_OUTPUT)" ""
|
|
$(RM) $(PCH_OUTPUT)
|
|
endif
|
|
ifneq "$(DSYM)" ""
|
|
$(RM) -r "$(DSYM)"
|
|
endif
|
|
ifeq "$(OS)" "Windows_NT"
|
|
# http://llvm.org/pr24589
|
|
IF EXIST "$(EXE)" del "$(EXE)"
|
|
$(RM) $(wildcard *.manifest *.pdb *.ilk)
|
|
ifneq "$(DYLIB_NAME)" ""
|
|
$(RM) $(DYLIB_NAME).lib $(DYLIB_NAME).exp
|
|
endif
|
|
else
|
|
$(RM) "$(EXE)"
|
|
endif
|
|
|
|
#----------------------------------------------------------------------
|
|
# From http://blog.melski.net/tag/debugging-makefiles/
|
|
#
|
|
# Usage: make print-CC print-CXX print-LD
|
|
#----------------------------------------------------------------------
|
|
print-%:
|
|
@echo '$*=$($*)'
|
|
@echo ' origin = $(origin $*)'
|
|
@echo ' flavor = $(flavor $*)'
|
|
@echo ' value = $(value $*)'
|
|
|
|
### Local Variables: ###
|
|
### mode:makefile ###
|
|
### End: ###
|