RepoMirrors
/
musl
mirror of git://git.musl-libc.org/musl
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
musl/Makefile

237 lines
7.3 KiB
Makefile
Raw Normal View History

initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
#
# Makefile for musl (requires GNU make)
#
# This is how simple every makefile should be...
# No, I take that back - actually most should be less than half this size.
#
# Use config.mak to override any of the following variables.
# Do not make changes here.
#
support out-of-tree build this change adds support for building musl outside of the source tree. the implementation is similar to autotools where running configure in a different directory creates config.mak in the current working directory and symlinks the makefile, which contains the logic for creating all necessary directories and resolving paths relative to the source directory. to support both in-tree and out-of-tree builds with implicit make rules, all object files are now placed into a separate directory.
2015-11-18 20:07:32 +00:00
srcdir = .
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
exec_prefix = /usr/local
bindir = $(exec_prefix)/bin
prefix = /usr/local/musl
includedir = $(prefix)/include
libdir = $(prefix)/lib
cleanup shared library build system to be more $HOME-local-install friendly the path for the dynamic linker is now configurable, and failure to install the symlink for it will not stop the build.
2011-06-28 01:38:11 +00:00
syslibdir = /lib
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
add framework for arch-provided makefile fragments, compat source dirs the immediate usage case for this is to let 32-bit archs moving to 64-bit time_t via symbol redirection pull in wrapper shims that provide the old symbol names. in the future it may be used for other types of compatibility-only source files that are not relevant to all archs.
2019-10-21 00:03:20 +00:00
SRC_DIRS = $(addprefix $(srcdir)/,src/* crt ldso $(COMPAT_SRC_DIRS))
adjust makefile to make crt/ and ldso/ sources arch-replaceable prior to commit 2f853dd6b9a95d5b13ee8f9df762125e0588df5d which overhauled the makefile for out-of-tree builds, crt/*.c files were replaceable by crt/$(ARCH)/*.s, and top-level ldso/ did not exist (its files were under src/ldso). since then, crti.o and crtn.o have been hard-coded as arch-specific, but none of the other files in crt/ or ldso/ were replaceable at all. in preparation for easy integration with midipix, which has a port of musl to windows, it needs to be possible to override the ELF-specific code in these files. making the same arch-replacements system work throughout the whole source tree also improves consistency and removes the need for some file-specific rules (crti.o and crtn.o) in the makefile.
2016-02-17 18:56:27 +00:00
BASE_GLOBS = $(addsuffix /*.c,$(SRC_DIRS))
ARCH_GLOBS = $(addsuffix /$(ARCH)/*.[csS],$(SRC_DIRS))
BASE_SRCS = $(sort $(wildcard $(BASE_GLOBS)))
ARCH_SRCS = $(sort $(wildcard $(ARCH_GLOBS)))
add support for arch-provided replacement files as .c or .S previously, replacement files provided in $(ARCH) dirs under src/ had to be .s files. in order to replace a file with C source, an empty .s file was needed there to suppress the original file, and a separate .c file was needed in arch/$(ARCH)/src/. support for .S is new and is aimed at short-term use eliminating .sub files. asm source files are still expected not to make any heavy preprocessor use, just simple conditionals on subarch. eventually most affected files may be replaced with C source files with minimal inline asm instead of asm source files.
2016-01-19 23:19:01 +00:00
BASE_OBJS = $(patsubst $(srcdir)/%,%.o,$(basename $(BASE_SRCS)))
ARCH_OBJS = $(patsubst $(srcdir)/%,%.o,$(basename $(ARCH_SRCS)))
remove support for subarch .sub files from the makefile as of commit af21a82ccc8687aa16e85def7db95efeae4cf72e, .sub files are no longer in use. removing the makefile machinery to handle them not only cleans up and simplifies the makefile, but also significantly reduces make's startup time.
2016-01-20 02:49:32 +00:00
REPLACED_OBJS = $(sort $(subst /$(ARCH)/,/,$(ARCH_OBJS)))
adjust makefile to make crt/ and ldso/ sources arch-replaceable prior to commit 2f853dd6b9a95d5b13ee8f9df762125e0588df5d which overhauled the makefile for out-of-tree builds, crt/*.c files were replaceable by crt/$(ARCH)/*.s, and top-level ldso/ did not exist (its files were under src/ldso). since then, crti.o and crtn.o have been hard-coded as arch-specific, but none of the other files in crt/ or ldso/ were replaceable at all. in preparation for easy integration with midipix, which has a port of musl to windows, it needs to be possible to override the ELF-specific code in these files. making the same arch-replacements system work throughout the whole source tree also improves consistency and removes the need for some file-specific rules (crti.o and crtn.o) in the makefile.
2016-02-17 18:56:27 +00:00
ALL_OBJS = $(addprefix obj/, $(filter-out $(REPLACED_OBJS), $(sort $(BASE_OBJS) $(ARCH_OBJS))))
add framework for arch-provided makefile fragments, compat source dirs the immediate usage case for this is to let 32-bit archs moving to 64-bit time_t via symbol redirection pull in wrapper shims that provide the old symbol names. in the future it may be used for other types of compatibility-only source files that are not relevant to all archs.
2019-10-21 00:03:20 +00:00
LIBC_OBJS = $(filter obj/src/%,$(ALL_OBJS)) $(filter obj/compat/%,$(ALL_OBJS))
adjust makefile to make crt/ and ldso/ sources arch-replaceable prior to commit 2f853dd6b9a95d5b13ee8f9df762125e0588df5d which overhauled the makefile for out-of-tree builds, crt/*.c files were replaceable by crt/$(ARCH)/*.s, and top-level ldso/ did not exist (its files were under src/ldso). since then, crti.o and crtn.o have been hard-coded as arch-specific, but none of the other files in crt/ or ldso/ were replaceable at all. in preparation for easy integration with midipix, which has a port of musl to windows, it needs to be possible to override the ELF-specific code in these files. making the same arch-replacements system work throughout the whole source tree also improves consistency and removes the need for some file-specific rules (crti.o and crtn.o) in the makefile.
2016-02-17 18:56:27 +00:00
LDSO_OBJS = $(filter obj/ldso/%,$(ALL_OBJS:%.o=%.lo))
CRT_OBJS = $(filter obj/crt/%,$(ALL_OBJS))
AOBJS = $(LIBC_OBJS)
LOBJS = $(LIBC_OBJS:.o=.lo)
deduplicate __NR_* and SYS_* syscall number definitions
2016-05-12 05:34:05 +00:00
GENH = obj/include/bits/alltypes.h obj/include/bits/syscall.h
support out-of-tree build this change adds support for building musl outside of the source tree. the implementation is similar to autotools where running configure in a different directory creates config.mak in the current working directory and symlinks the makefile, which contains the logic for creating all necessary directories and resolving paths relative to the source directory. to support both in-tree and out-of-tree builds with implicit make rules, all object files are now placed into a separate directory.
2015-11-18 20:07:32 +00:00
GENH_INT = obj/src/internal/version.h
increase limit on locale name length from 15 to 23 bytes the old limit was one byte too short to support locale names of the form xx_XX.UTF-8@modifier where modifier is more than 3 bytes, a form which various real-world locale names take. the problem could be avoided by omitting the useless ".UTF-8" part, but users may need to have it present when operating on mixed-libc systems or when it will be carried over (e.g. across ssh) to other systems. the new limit is chosen sufficient for existing/reasonable locale names while still keeping the size of setlocale's static buffer small. also add locale_impl.h to the Makefile's list of headers which force rebuild of source files, to prevent dangerously inconsistent object files from getting used after this change.
2017-03-21 16:13:59 +00:00
IMPH = $(addprefix $(srcdir)/, src/internal/stdio_impl.h src/internal/pthread_impl.h src/internal/locale_impl.h src/internal/libc.h)
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
keep user-provided CFLAGS/LDFLAGS separate from those added by configure this way, overriding these variables on the make command line (or just re-passing the originally-passed values when invoking make) won't suppress use of the flags added by configure.
2015-11-02 21:58:14 +00:00
LDFLAGS =
LDFLAGS_AUTO =
abstract out compiler runtime library for linking libc.so this allows config.mak to override the default -lgcc for building with other compilers such as pcc/clang/etc.
2012-08-03 01:05:43 +00:00
LIBCC = -lgcc
reorganize Makefile to support "least surprise" config/make semantics the major change here is that CFLAGS is now a variable that can be changed entirely under user control, without causing essential flags to be lost. previously, "CFLAGS += ..." was valid in config.mak, but using "CFLAGS = ..." in config.mak would have badly broken the build process unless the user took care to copy the necessary flags out of the main Makefile. I have also added a distclean target that removes config.mak.
2012-05-01 23:30:03 +00:00
CPPFLAGS =
keep user-provided CFLAGS/LDFLAGS separate from those added by configure this way, overriding these variables on the make command line (or just re-passing the originally-passed values when invoking make) won't suppress use of the flags added by configure.
2015-11-02 21:58:14 +00:00
CFLAGS =
CFLAGS_AUTO = -Os -pipe
reorganize Makefile to support "least surprise" config/make semantics the major change here is that CFLAGS is now a variable that can be changed entirely under user control, without causing essential flags to be lost. previously, "CFLAGS += ..." was valid in config.mak, but using "CFLAGS = ..." in config.mak would have badly broken the build process unless the user took care to copy the necessary flags out of the main Makefile. I have also added a distclean target that removes config.mak.
2012-05-01 23:30:03 +00:00
CFLAGS_C99FSE = -std=c99 -ffreestanding -nostdinc
CFLAGS_ALL = $(CFLAGS_C99FSE)
overhaul internally-public declarations using wrapper headers commits leading up to this one have moved the vast majority of libc-internal interface declarations to appropriate internal headers, allowing them to be type-checked and setting the stage to limit their visibility. the ones that have not yet been moved are mostly namespace-protected aliases for standard/public interfaces, which exist to facilitate implementing plain C functions in terms of POSIX functionality, or C or POSIX functionality in terms of extensions that are not standardized. some don't quite fit this description, but are "internally public" interfacs between subsystems of libc. rather than create a number of newly-named headers to declare these functions, and having to add explicit include directives for them to every source file where they're needed, I have introduced a method of wrapping the corresponding public headers. parallel to the public headers in $(srcdir)/include, we now have wrappers in $(srcdir)/src/include that come earlier in the include path order. they include the public header they're wrapping, then add declarations for namespace-protected versions of the same interfaces and any "internally public" interfaces for the subsystem they correspond to. along these lines, the wrapper for features.h is now responsible for the definition of the hidden, weak, and weak_alias macros. this means source files will no longer need to include any special headers to access these features. over time, it is my expectation that the scope of what is "internally public" will expand, reducing the number of source files which need to include *_impl.h and related headers down to those which are actually implementing the corresponding subsystems, not just using them.
2018-09-11 03:26:40 +00:00
CFLAGS_ALL += -D_XOPEN_SOURCE=700 -I$(srcdir)/arch/$(ARCH) -I$(srcdir)/arch/generic -Iobj/src/internal -I$(srcdir)/src/include -I$(srcdir)/src/internal -Iobj/include -I$(srcdir)/include
keep user-provided CFLAGS/LDFLAGS separate from those added by configure this way, overriding these variables on the make command line (or just re-passing the originally-passed values when invoking make) won't suppress use of the flags added by configure.
2015-11-02 21:58:14 +00:00
CFLAGS_ALL += $(CPPFLAGS) $(CFLAGS_AUTO) $(CFLAGS)
reorganize Makefile to support "least surprise" config/make semantics the major change here is that CFLAGS is now a variable that can be changed entirely under user control, without causing essential flags to be lost. previously, "CFLAGS += ..." was valid in config.mak, but using "CFLAGS = ..." in config.mak would have badly broken the build process unless the user took care to copy the necessary flags out of the main Makefile. I have also added a distclean target that removes config.mak.
2012-05-01 23:30:03 +00:00
keep user-provided CFLAGS/LDFLAGS separate from those added by configure this way, overriding these variables on the make command line (or just re-passing the originally-passed values when invoking make) won't suppress use of the flags added by configure.
2015-11-02 21:58:14 +00:00
LDFLAGS_ALL = $(LDFLAGS_AUTO) $(LDFLAGS)
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
AR = $(CROSS_COMPILE)ar
RANLIB = $(CROSS_COMPILE)ranlib
support out-of-tree build this change adds support for building musl outside of the source tree. the implementation is similar to autotools where running configure in a different directory creates config.mak in the current working directory and symlinks the makefile, which contains the logic for creating all necessary directories and resolving paths relative to the source directory. to support both in-tree and out-of-tree builds with implicit make rules, all object files are now placed into a separate directory.
2015-11-18 20:07:32 +00:00
INSTALL = $(srcdir)/tools/install.sh
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
support out-of-tree build this change adds support for building musl outside of the source tree. the implementation is similar to autotools where running configure in a different directory creates config.mak in the current working directory and symlinks the makefile, which contains the logic for creating all necessary directories and resolving paths relative to the source directory. to support both in-tree and out-of-tree builds with implicit make rules, all object files are now placed into a separate directory.
2015-11-18 20:07:32 +00:00
ARCH_INCLUDES = $(wildcard $(srcdir)/arch/$(ARCH)/bits/*.h)
add arch/generic include fallback to build rules this sets the stage for the first phase of the bits deduplication. bits headers which are identical for "most" archs will be moved to arch/generic/bits.
2016-01-28 00:31:15 +00:00
GENERIC_INCLUDES = $(wildcard $(srcdir)/arch/generic/bits/*.h)
support out-of-tree build this change adds support for building musl outside of the source tree. the implementation is similar to autotools where running configure in a different directory creates config.mak in the current working directory and symlinks the makefile, which contains the logic for creating all necessary directories and resolving paths relative to the source directory. to support both in-tree and out-of-tree builds with implicit make rules, all object files are now placed into a separate directory.
2015-11-18 20:07:32 +00:00
INCLUDES = $(wildcard $(srcdir)/include/*.h $(srcdir)/include/*/*.h)
add arch/generic include fallback to build rules this sets the stage for the first phase of the bits deduplication. bits headers which are identical for "most" archs will be moved to arch/generic/bits.
2016-01-28 00:31:15 +00:00
ALL_INCLUDES = $(sort $(INCLUDES:$(srcdir)/%=%) $(GENH:obj/%=%) $(ARCH_INCLUDES:$(srcdir)/arch/$(ARCH)/%=include/%) $(GENERIC_INCLUDES:$(srcdir)/arch/generic/%=include/%))
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
various changes in preparation for dynamic linking support prefer using visibility=hidden for __libc internal data, rather than an accessor function, if the compiler has visibility. optimize with -O3 for PIC targets (shared library). without heavy inlining, reloading the GOT register in small functions kills performance. 20-30% size increase for a single libc.so is not a big deal, compared to comparaible size increase in every static binaries. use -Bsymbolic-functions, not -Bsymbolic. global variables are subject to COPY relocations, and thus binding their addresses in the library at link time will cause library functions to read the wrong (original) copies instead of the copies made in the main program's bss section. add entry point, _start, for dynamic linker.
2011-02-24 21:37:21 +00:00
EMPTY_LIB_NAMES = m rt pthread crypt util xnet resolv dl
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
EMPTY_LIBS = $(EMPTY_LIB_NAMES:%=lib/lib%.a)
generate list of crt files to install instead of hard-coding in makefile this follows the principle of having the source tree layout define build semantics. it also makes it possible for crt/$(ARCH) to define additional installable files, which may be needed for midipix and other future targets.
2016-02-19 19:16:33 +00:00
CRT_LIBS = $(addprefix lib/,$(notdir $(CRT_OBJS)))
reorganize Makefile to support "least surprise" config/make semantics the major change here is that CFLAGS is now a variable that can be changed entirely under user control, without causing essential flags to be lost. previously, "CFLAGS += ..." was valid in config.mak, but using "CFLAGS = ..." in config.mak would have badly broken the build process unless the user took care to copy the necessary flags out of the main Makefile. I have also added a distclean target that removes config.mak.
2012-05-01 23:30:03 +00:00
STATIC_LIBS = lib/libc.a
cleanup shared library build system to be more $HOME-local-install friendly the path for the dynamic linker is now configurable, and failure to install the symlink for it will not stop the build.
2011-06-28 01:38:11 +00:00
SHARED_LIBS = lib/libc.so
new gcc wrapper, entirely specfile based the _concept_ of this wrapper has been tested extensively, but the integration with the build/install system, and using a persistent specfile rather than one generated at build-time, have not been heavily tested and may need minor tweaks. this approach should be a lot more robust (and easier to improve) than writing a shell script that's responsible for trying to mimic gcc's logic about whether it's compiling or linking, building shared libs or executable files, etc. it's also lighter weight and should result in mildly faster builds when using the wrapper.
2012-04-22 18:32:49 +00:00
TOOL_LIBS = lib/musl-gcc.specs
reorganize Makefile to support "least surprise" config/make semantics the major change here is that CFLAGS is now a variable that can be changed entirely under user control, without causing essential flags to be lost. previously, "CFLAGS += ..." was valid in config.mak, but using "CFLAGS = ..." in config.mak would have badly broken the build process unless the user took care to copy the necessary flags out of the main Makefile. I have also added a distclean target that removes config.mak.
2012-05-01 23:30:03 +00:00
ALL_LIBS = $(CRT_LIBS) $(STATIC_LIBS) $(SHARED_LIBS) $(EMPTY_LIBS) $(TOOL_LIBS)
support out-of-tree build this change adds support for building musl outside of the source tree. the implementation is similar to autotools where running configure in a different directory creates config.mak in the current working directory and symlinks the makefile, which contains the logic for creating all necessary directories and resolving paths relative to the source directory. to support both in-tree and out-of-tree builds with implicit make rules, all object files are now placed into a separate directory.
2015-11-18 20:07:32 +00:00
ALL_TOOLS = obj/musl-gcc
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
build: overhaul wrapper script system for multiple wrapper support this overhauls part of the build system in order to support multiple toolchain wrapper scripts, as opposed to solely the musl-gcc wrapper as before. it thereby replaces --enable-gcc-wrapper with --enable-wrapper=..., which has the options 'auto' (the default, detect whether to use wrappers), 'all' (build and install all wrappers), 'no' (don't build any) and finally the options named after the individual compiler scripts (currently only 'gcc' is available) to build and install only that wrapper. the old --enable-gcc-wrapper is removed from --help, but still available. it also modifies the wrappers to use the C compiler specified to the build system as 'inner' compiler, when applicable. as wrapper detection works by probing this compiler, it may not work with any other.
2015-06-28 21:08:19 +00:00
WRAPCC_GCC = gcc
add musl-clang, a wrapper for system clang installs musl-clang allows the user to compile musl-powered programs using their already existent clang install, without the need of a special cross compiler. it achieves this by wrapping around both the system clang install and the linker and passing them special flags to re-target musl at runtime. it does only affect invocations done through the special musl-clang wrapper script, so that the user setup remains fully intact otherwise. the clang wrapper consists of the compiler frontend wrapper script, musl-clang, and the linker wrapper script, ld.musl-clang. musl-clang makes sure clang invokes ld.musl-clang to link objects; neither script needs to be in PATH for the wrapper to work.
2015-06-28 21:08:21 +00:00
WRAPCC_CLANG = clang
build: overhaul wrapper script system for multiple wrapper support this overhauls part of the build system in order to support multiple toolchain wrapper scripts, as opposed to solely the musl-gcc wrapper as before. it thereby replaces --enable-gcc-wrapper with --enable-wrapper=..., which has the options 'auto' (the default, detect whether to use wrappers), 'all' (build and install all wrappers), 'no' (don't build any) and finally the options named after the individual compiler scripts (currently only 'gcc' is available) to build and install only that wrapper. the old --enable-gcc-wrapper is removed from --help, but still available. it also modifies the wrappers to use the C compiler specified to the build system as 'inner' compiler, when applicable. as wrapper detection works by probing this compiler, it may not work with any other.
2015-06-28 21:08:19 +00:00
add build system support for arch endian & float abi variants
2013-07-19 00:30:58 +00:00
LDSO_PATHNAME = $(syslibdir)/ld-musl-$(ARCH)$(SUBARCH).so.1
cleanup shared library build system to be more $HOME-local-install friendly the path for the dynamic linker is now configurable, and failure to install the symlink for it will not stop the build.
2011-06-28 01:38:11 +00:00
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
-include config.mak
fix failure to build time32 compat shims with out-of-tree builds commit de90f38e3b105802655d19d965d66335d25d59ef omitted $(srcdir) from the makefile include pathname it added. since the include directive was prefixed with - to make it optional (for archs that don't use it), the failure to find arch/$(ARCH)/arch.mak was silent.
2019-11-04 06:47:38 +00:00
-include $(srcdir)/arch/$(ARCH)/arch.mak
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
support out-of-tree build this change adds support for building musl outside of the source tree. the implementation is similar to autotools where running configure in a different directory creates config.mak in the current working directory and symlinks the makefile, which contains the logic for creating all necessary directories and resolving paths relative to the source directory. to support both in-tree and out-of-tree builds with implicit make rules, all object files are now placed into a separate directory.
2015-11-18 20:07:32 +00:00
ifeq ($(ARCH),)
support clean/distclean make targets in unconfigured tree commit 2f853dd6b9a95d5b13ee8f9df762125e0588df5d moved the error handling for $(ARCH) not being set such that it applied to all targets, including clean and distclean. previously these targets worked even in an unconfigured tree. to restore the old behavior, make most of the makefile body conditional on $(ARCH) being set/non-empty and produce the error via a fake "all" target in the conditional branch for the case where $(ARCH) is empty.
2016-02-17 21:11:45 +00:00
all:
@echo "Please set ARCH in config.mak before running make."
@exit 1
else
support out-of-tree build this change adds support for building musl outside of the source tree. the implementation is similar to autotools where running configure in a different directory creates config.mak in the current working directory and symlinks the makefile, which contains the logic for creating all necessary directories and resolving paths relative to the source directory. to support both in-tree and out-of-tree builds with implicit make rules, all object files are now placed into a separate directory.
2015-11-18 20:07:32 +00:00
fix a few bugs from last dynamic linking build system commit some cruft was left and DESTDIR was not being used correctly.
2011-06-28 12:27:38 +00:00
all: $(ALL_LIBS) $(ALL_TOOLS)
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
adjust makefile to make crt/ and ldso/ sources arch-replaceable prior to commit 2f853dd6b9a95d5b13ee8f9df762125e0588df5d which overhauled the makefile for out-of-tree builds, crt/*.c files were replaceable by crt/$(ARCH)/*.s, and top-level ldso/ did not exist (its files were under src/ldso). since then, crti.o and crtn.o have been hard-coded as arch-specific, but none of the other files in crt/ or ldso/ were replaceable at all. in preparation for easy integration with midipix, which has a port of musl to windows, it needs to be possible to override the ELF-specific code in these files. making the same arch-replacements system work throughout the whole source tree also improves consistency and removes the need for some file-specific rules (crti.o and crtn.o) in the makefile.
2016-02-17 18:56:27 +00:00
OBJ_DIRS = $(sort $(patsubst %/,%,$(dir $(ALL_LIBS) $(ALL_TOOLS) $(ALL_OBJS) $(GENH) $(GENH_INT))) obj/include)
support out-of-tree build this change adds support for building musl outside of the source tree. the implementation is similar to autotools where running configure in a different directory creates config.mak in the current working directory and symlinks the makefile, which contains the logic for creating all necessary directories and resolving paths relative to the source directory. to support both in-tree and out-of-tree builds with implicit make rules, all object files are now placed into a separate directory.
2015-11-18 20:07:32 +00:00
adjust makefile to make crt/ and ldso/ sources arch-replaceable prior to commit 2f853dd6b9a95d5b13ee8f9df762125e0588df5d which overhauled the makefile for out-of-tree builds, crt/*.c files were replaceable by crt/$(ARCH)/*.s, and top-level ldso/ did not exist (its files were under src/ldso). since then, crti.o and crtn.o have been hard-coded as arch-specific, but none of the other files in crt/ or ldso/ were replaceable at all. in preparation for easy integration with midipix, which has a port of musl to windows, it needs to be possible to override the ELF-specific code in these files. making the same arch-replacements system work throughout the whole source tree also improves consistency and removes the need for some file-specific rules (crti.o and crtn.o) in the makefile.
2016-02-17 18:56:27 +00:00
$(ALL_LIBS) $(ALL_TOOLS) $(ALL_OBJS) $(ALL_OBJS:%.o=%.lo) $(GENH) $(GENH_INT): | $(OBJ_DIRS)
support out-of-tree build this change adds support for building musl outside of the source tree. the implementation is similar to autotools where running configure in a different directory creates config.mak in the current working directory and symlinks the makefile, which contains the logic for creating all necessary directories and resolving paths relative to the source directory. to support both in-tree and out-of-tree builds with implicit make rules, all object files are now placed into a separate directory.
2015-11-18 20:07:32 +00:00
$(OBJ_DIRS):
mkdir -p $@
obj/include/bits/alltypes.h: $(srcdir)/arch/$(ARCH)/bits/alltypes.h.in $(srcdir)/include/alltypes.h.in $(srcdir)/tools/mkalltypes.sed
sed -f $(srcdir)/tools/mkalltypes.sed $(srcdir)/arch/$(ARCH)/bits/alltypes.h.in $(srcdir)/include/alltypes.h.in > $@
preparing build system to handle ports - step 1
2011-02-15 05:33:23 +00:00
deduplicate __NR_* and SYS_* syscall number definitions
2016-05-12 05:34:05 +00:00
obj/include/bits/syscall.h: $(srcdir)/arch/$(ARCH)/bits/syscall.h.in
cp $< $@
sed -n -e s/__NR_/SYS_/p < $< >> $@
support out-of-tree build this change adds support for building musl outside of the source tree. the implementation is similar to autotools where running configure in a different directory creates config.mak in the current working directory and symlinks the makefile, which contains the logic for creating all necessary directories and resolving paths relative to the source directory. to support both in-tree and out-of-tree builds with implicit make rules, all object files are now placed into a separate directory.
2015-11-18 20:07:32 +00:00
obj/src/internal/version.h: $(wildcard $(srcdir)/VERSION $(srcdir)/.git)
printf '#define VERSION "%s"\n' "$$(cd $(srcdir); sh tools/version.sh)" > $@
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
support out-of-tree build this change adds support for building musl outside of the source tree. the implementation is similar to autotools where running configure in a different directory creates config.mak in the current working directory and symlinks the makefile, which contains the logic for creating all necessary directories and resolving paths relative to the source directory. to support both in-tree and out-of-tree builds with implicit make rules, all object files are now placed into a separate directory.
2015-11-18 20:07:32 +00:00
obj/src/internal/version.o obj/src/internal/version.lo: obj/src/internal/version.h
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
move dynamic linker to its own top-level directory, ldso this eliminates the last need for the SHARED macro to control how files in the src tree are compiled. the same code is used for both libc.a and libc.so, with additional code for the dynamic linker (from the new ldso tree) being added to libc.so but not libc.a. separate .o and .lo object files still exist for the src tree, but the only difference is that the .lo files are built as PIC. in the future, if/when we add dlopen support for static-linked programs, much of the code in dynlink.c may be moved back into the src tree, but properly factored into separate source files. in that case, the code in the ldso tree will be reduced to just the dynamic linker entry point, self-relocation, and loading of libraries needed by the main application.
2016-01-26 00:29:55 +00:00
obj/crt/rcrt1.o obj/ldso/dlstart.lo obj/ldso/dynlink.lo: $(srcdir)/src/internal/dynlink.h $(srcdir)/arch/$(ARCH)/reloc.h
add infrastructure to record and report the version of libc.so this is still experimental and subject to change. for git checkouts, an attempt is made to record the exact revision to aid in bug reports and debugging. no version information is recorded in the static libc.a or binaries it's linked into.
2013-12-01 22:27:25 +00:00
move dynamic linker to its own top-level directory, ldso this eliminates the last need for the SHARED macro to control how files in the src tree are compiled. the same code is used for both libc.a and libc.so, with additional code for the dynamic linker (from the new ldso tree) being added to libc.so but not libc.a. separate .o and .lo object files still exist for the src tree, but the only difference is that the .lo files are built as PIC. in the future, if/when we add dlopen support for static-linked programs, much of the code in dynlink.c may be moved back into the src tree, but properly factored into separate source files. in that case, the code in the ldso tree will be reduced to just the dynamic linker entry point, self-relocation, and loading of libraries needed by the main application.
2016-01-26 00:29:55 +00:00
obj/crt/crt1.o obj/crt/scrt1.o obj/crt/rcrt1.o obj/ldso/dlstart.lo: $(srcdir)/arch/$(ARCH)/crt_arch.h
add infrastructure to record and report the version of libc.so this is still experimental and subject to change. for git checkouts, an attempt is made to record the exact revision to aid in bug reports and debugging. no version information is recorded in the static libc.a or binaries it's linked into.
2013-12-01 22:27:25 +00:00
move dynamic linker to its own top-level directory, ldso this eliminates the last need for the SHARED macro to control how files in the src tree are compiled. the same code is used for both libc.a and libc.so, with additional code for the dynamic linker (from the new ldso tree) being added to libc.so but not libc.a. separate .o and .lo object files still exist for the src tree, but the only difference is that the .lo files are built as PIC. in the future, if/when we add dlopen support for static-linked programs, much of the code in dynlink.c may be moved back into the src tree, but properly factored into separate source files. in that case, the code in the ldso tree will be reduced to just the dynamic linker entry point, self-relocation, and loading of libraries needed by the main application.
2016-01-26 00:29:55 +00:00
obj/crt/rcrt1.o: $(srcdir)/ldso/dlstart.c
make dynlink.lo depend on reloc.h in makefile this is mainly a development convenience but will also ensure users building from latest git always get up-to-date arch-specific dynamic linker code without having to "make clean".
2012-08-05 16:32:20 +00:00
support out-of-tree build this change adds support for building musl outside of the source tree. the implementation is similar to autotools where running configure in a different directory creates config.mak in the current working directory and symlinks the makefile, which contains the logic for creating all necessary directories and resolving paths relative to the source directory. to support both in-tree and out-of-tree builds with implicit make rules, all object files are now placed into a separate directory.
2015-11-18 20:07:32 +00:00
obj/crt/Scrt1.o obj/crt/rcrt1.o: CFLAGS_ALL += -fPIC
add additional Makefile dependency rules for rcrt1.o PIE start file
2015-06-03 06:00:44 +00:00
support out-of-tree build this change adds support for building musl outside of the source tree. the implementation is similar to autotools where running configure in a different directory creates config.mak in the current working directory and symlinks the makefile, which contains the logic for creating all necessary directories and resolving paths relative to the source directory. to support both in-tree and out-of-tree builds with implicit make rules, all object files are now placed into a separate directory.
2015-11-18 20:07:32 +00:00
OPTIMIZE_SRCS = $(wildcard $(OPTIMIZE_GLOBS:%=$(srcdir)/src/%))
$(OPTIMIZE_SRCS:$(srcdir)/%.c=obj/%.o) $(OPTIMIZE_SRCS:$(srcdir)/%.c=obj/%.lo): CFLAGS += -O3
enhance build process to allow selective -O3 optimization the motivation for this patch is that the vast majority of libc is code that does not benefit at all from optimizations, but that certain components like string/memory operations can be major performance bottlenecks. at the same time, the old -falign-*=1 options are removed, since they were only beneficial for avoiding bloat when global -O3 was used, and in that case, they may have prevented some of the performance gains. to be the most useful, this patch will need further tuning. in particular, research is needed to determine which components should be built with -O3 by default, and it may be desirable to remove the hard-coded -O3 and instead allow more customization of the optimization level used for selected modules.
2013-07-23 01:22:04 +00:00
adjust makefile target-specific CFLAGS rules to be more robust & complete previously, MEMOPS_SRCS failed to include arch-specific replacement files for memcpy, etc., omitting CFLAGS_MEMOPS and thereby potentially causing build failure if an arch provided C (rather than asm) replacements for these files. instead of trying to explicitly include all the files that might have arch replacements, which is prone to human error, extract final names to be used out of $(LIBC_OBJS), where the rules for arch replacements have already been applied. do the same for NOSSP_OBJS, using CRT_OBJS and LDSO_OBJS rather than repeating ourselves with $(wildcard...) and explicit pathnames again.
2018-03-25 02:47:36 +00:00
MEMOPS_OBJS = $(filter %/memcpy.o %/memmove.o %/memcmp.o %/memset.o, $(LIBC_OBJS))
$(MEMOPS_OBJS) $(MEMOPS_OBJS:%.o=%.lo): CFLAGS_ALL += $(CFLAGS_MEMOPS)
NOSSP_OBJS = $(CRT_OBJS) $(LDSO_OBJS) $(filter \
%/__libc_start_main.o %/__init_tls.o %/__stack_chk_fail.o \
%/__set_thread_area.o %/memset.o %/memcpy.o \
, $(LIBC_OBJS))
$(NOSSP_OBJS) $(NOSSP_OBJS:%.o=%.lo): CFLAGS_ALL += $(CFLAGS_NOSSP)
allow libc itself to be built with stack protector enabled this was already essentially possible as a result of the previous commits changing the dynamic linker/thread pointer bootstrap process. this commit mainly adds build system infrastructure: configure no longer attempts to disable stack protector. instead it simply determines how so the makefile can disable stack protector for a few translation units used during early startup. stack protector is also disabled for memcpy and memset since compilers (incorrectly) generate calls to them on some archs to implement struct initialization and assignment, and such calls may creep into early initialization. no explicit attempt to enable stack protector is made by configure at this time; any stack protector option supported by the compiler can be passed to configure in CFLAGS, and if the compiler uses stack protector by default, this default is respected.
2015-04-14 00:13:10 +00:00
adjust makefile to make crt/ and ldso/ sources arch-replaceable prior to commit 2f853dd6b9a95d5b13ee8f9df762125e0588df5d which overhauled the makefile for out-of-tree builds, crt/*.c files were replaceable by crt/$(ARCH)/*.s, and top-level ldso/ did not exist (its files were under src/ldso). since then, crti.o and crtn.o have been hard-coded as arch-specific, but none of the other files in crt/ or ldso/ were replaceable at all. in preparation for easy integration with midipix, which has a port of musl to windows, it needs to be possible to override the ELF-specific code in these files. making the same arch-replacements system work throughout the whole source tree also improves consistency and removes the need for some file-specific rules (crti.o and crtn.o) in the makefile.
2016-02-17 18:56:27 +00:00
$(CRT_OBJS): CFLAGS_ALL += -DCRT
add optional global visibility override this is implemented via the build system and does not affect source files. the idea is to use protected or hidden visibility to prevent the compiler from pessimizing function calls within a shared (or position-independent static) libc in the form of overhead setting up for a call through the PLT. the ld-time symbol binding via the -Bsymbolic-functions option already optimized out the PLT itself, but not the code in the caller needed to support a call through the PLT. on some archs this overhead can be substantial; on others it's trivial.
2015-04-20 02:05:29 +00:00
move dynamic linker to its own top-level directory, ldso this eliminates the last need for the SHARED macro to control how files in the src tree are compiled. the same code is used for both libc.a and libc.so, with additional code for the dynamic linker (from the new ldso tree) being added to libc.so but not libc.a. separate .o and .lo object files still exist for the src tree, but the only difference is that the .lo files are built as PIC. in the future, if/when we add dlopen support for static-linked programs, much of the code in dynlink.c may be moved back into the src tree, but properly factored into separate source files. in that case, the code in the ldso tree will be reduced to just the dynamic linker entry point, self-relocation, and loading of libraries needed by the main application.
2016-01-26 00:29:55 +00:00
$(LOBJS) $(LDSO_OBJS): CFLAGS_ALL += -fPIC
eliminate separate static/shared CFLAGS vars in makefile this allows the rules for .o and .lo files to be identical, with -fPIC and -DSHARED added for .lo files via target-specific variable append. this is arguably cleaner now and will allow more cleanup and removal of redundant rule bodies after other prerequisite changes are made.
2016-01-20 00:08:52 +00:00
deduplicate compiler invocation command line in makefile also clean up duplication of CFLAGS passing to assembler.
2016-01-20 02:58:29 +00:00
CC_CMD = $(CC) $(CFLAGS_ALL) -c -o $@ $<
Build process uses script to add CFI directives to x86 asm Some functions implemented in asm need to use EBP for purposes other than acting as a frame pointer. (Notably, it is used for the 6th argument to syscalls with 6 arguments.) Without frame pointers, GDB can only show backtraces if it gets CFI information from a .debug_frame or .eh_frame ELF section. Rather than littering our asm with ugly .cfi directives, use an awk script to insert them in the right places during the build process, so GDB can keep track of where the current stack frame is relative to the stack pointer. This means GDB can produce beautiful stack traces at any given point when single-stepping through asm functions. Additionally, when registers are saved on the stack and later overwritten, emit ..cfi directives so GDB will know where they were saved relative to the stack pointer. This way, when you look back up the stack from within an asm function, you can still reliably print the values of local variables in the caller. If this awk script were to understand every possible wild and crazy contortion that an asm programmer can do with the stack and registers, and always emit the exact ..cfi directives needed for GDB to know what the register values were in the preceding stack frame, it would necessarily be as complex as a full x86 emulator. That way lies madness. Hence, we assume that the stack pointer will _only_ ever be adjusted using push/pop or else add/sub with a constant. We do not attempt to detect every possible way that a register value could be saved for later use, just the simple and common ways. Thanks to Szabolcs Nagy for suggesting numerous improvements to this code.
2015-07-10 13:03:24 +00:00
# Choose invocation of assembler to be used
ifeq ($(ADD_CFI),yes)
eliminate separate static/shared CFLAGS vars in makefile this allows the rules for .o and .lo files to be identical, with -fPIC and -DSHARED added for .lo files via target-specific variable append. this is arguably cleaner now and will allow more cleanup and removal of redundant rule bodies after other prerequisite changes are made.
2016-01-20 00:08:52 +00:00
AS_CMD = LC_ALL=C awk -f $(srcdir)/tools/add-cfi.common.awk -f $(srcdir)/tools/add-cfi.$(ARCH).awk $< | $(CC) $(CFLAGS_ALL) -x assembler -c -o $@ -
Build process uses script to add CFI directives to x86 asm Some functions implemented in asm need to use EBP for purposes other than acting as a frame pointer. (Notably, it is used for the 6th argument to syscalls with 6 arguments.) Without frame pointers, GDB can only show backtraces if it gets CFI information from a .debug_frame or .eh_frame ELF section. Rather than littering our asm with ugly .cfi directives, use an awk script to insert them in the right places during the build process, so GDB can keep track of where the current stack frame is relative to the stack pointer. This means GDB can produce beautiful stack traces at any given point when single-stepping through asm functions. Additionally, when registers are saved on the stack and later overwritten, emit ..cfi directives so GDB will know where they were saved relative to the stack pointer. This way, when you look back up the stack from within an asm function, you can still reliably print the values of local variables in the caller. If this awk script were to understand every possible wild and crazy contortion that an asm programmer can do with the stack and registers, and always emit the exact ..cfi directives needed for GDB to know what the register values were in the preceding stack frame, it would necessarily be as complex as a full x86 emulator. That way lies madness. Hence, we assume that the stack pointer will _only_ ever be adjusted using push/pop or else add/sub with a constant. We do not attempt to detect every possible way that a register value could be saved for later use, just the simple and common ways. Thanks to Szabolcs Nagy for suggesting numerous improvements to this code.
2015-07-10 13:03:24 +00:00
else
deduplicate compiler invocation command line in makefile also clean up duplication of CFLAGS passing to assembler.
2016-01-20 02:58:29 +00:00
AS_CMD = $(CC_CMD)
Build process uses script to add CFI directives to x86 asm Some functions implemented in asm need to use EBP for purposes other than acting as a frame pointer. (Notably, it is used for the 6th argument to syscalls with 6 arguments.) Without frame pointers, GDB can only show backtraces if it gets CFI information from a .debug_frame or .eh_frame ELF section. Rather than littering our asm with ugly .cfi directives, use an awk script to insert them in the right places during the build process, so GDB can keep track of where the current stack frame is relative to the stack pointer. This means GDB can produce beautiful stack traces at any given point when single-stepping through asm functions. Additionally, when registers are saved on the stack and later overwritten, emit ..cfi directives so GDB will know where they were saved relative to the stack pointer. This way, when you look back up the stack from within an asm function, you can still reliably print the values of local variables in the caller. If this awk script were to understand every possible wild and crazy contortion that an asm programmer can do with the stack and registers, and always emit the exact ..cfi directives needed for GDB to know what the register values were in the preceding stack frame, it would necessarily be as complex as a full x86 emulator. That way lies madness. Hence, we assume that the stack pointer will _only_ ever be adjusted using push/pop or else add/sub with a constant. We do not attempt to detect every possible way that a register value could be saved for later use, just the simple and common ways. Thanks to Szabolcs Nagy for suggesting numerous improvements to this code.
2015-07-10 13:03:24 +00:00
endif
support out-of-tree build this change adds support for building musl outside of the source tree. the implementation is similar to autotools where running configure in a different directory creates config.mak in the current working directory and symlinks the makefile, which contains the logic for creating all necessary directories and resolving paths relative to the source directory. to support both in-tree and out-of-tree builds with implicit make rules, all object files are now placed into a separate directory.
2015-11-18 20:07:32 +00:00
obj/%.o: $(srcdir)/%.s
deduplicate compiler invocation command line in makefile also clean up duplication of CFLAGS passing to assembler.
2016-01-20 02:58:29 +00:00
$(AS_CMD)
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
add support for arch-provided replacement files as .c or .S previously, replacement files provided in $(ARCH) dirs under src/ had to be .s files. in order to replace a file with C source, an empty .s file was needed there to suppress the original file, and a separate .c file was needed in arch/$(ARCH)/src/. support for .S is new and is aimed at short-term use eliminating .sub files. asm source files are still expected not to make any heavy preprocessor use, just simple conditionals on subarch. eventually most affected files may be replaced with C source files with minimal inline asm instead of asm source files.
2016-01-19 23:19:01 +00:00
obj/%.o: $(srcdir)/%.S
deduplicate compiler invocation command line in makefile also clean up duplication of CFLAGS passing to assembler.
2016-01-20 02:58:29 +00:00
$(CC_CMD)
add support for arch-provided replacement files as .c or .S previously, replacement files provided in $(ARCH) dirs under src/ had to be .s files. in order to replace a file with C source, an empty .s file was needed there to suppress the original file, and a separate .c file was needed in arch/$(ARCH)/src/. support for .S is new and is aimed at short-term use eliminating .sub files. asm source files are still expected not to make any heavy preprocessor use, just simple conditionals on subarch. eventually most affected files may be replaced with C source files with minimal inline asm instead of asm source files.
2016-01-19 23:19:01 +00:00
support out-of-tree build this change adds support for building musl outside of the source tree. the implementation is similar to autotools where running configure in a different directory creates config.mak in the current working directory and symlinks the makefile, which contains the logic for creating all necessary directories and resolving paths relative to the source directory. to support both in-tree and out-of-tree builds with implicit make rules, all object files are now placed into a separate directory.
2015-11-18 20:07:32 +00:00
obj/%.o: $(srcdir)/%.c $(GENH) $(IMPH)
deduplicate compiler invocation command line in makefile also clean up duplication of CFLAGS passing to assembler.
2016-01-20 02:58:29 +00:00
$(CC_CMD)
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
support out-of-tree build this change adds support for building musl outside of the source tree. the implementation is similar to autotools where running configure in a different directory creates config.mak in the current working directory and symlinks the makefile, which contains the logic for creating all necessary directories and resolving paths relative to the source directory. to support both in-tree and out-of-tree builds with implicit make rules, all object files are now placed into a separate directory.
2015-11-18 20:07:32 +00:00
obj/%.lo: $(srcdir)/%.s
deduplicate compiler invocation command line in makefile also clean up duplication of CFLAGS passing to assembler.
2016-01-20 02:58:29 +00:00
$(AS_CMD)
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
add support for arch-provided replacement files as .c or .S previously, replacement files provided in $(ARCH) dirs under src/ had to be .s files. in order to replace a file with C source, an empty .s file was needed there to suppress the original file, and a separate .c file was needed in arch/$(ARCH)/src/. support for .S is new and is aimed at short-term use eliminating .sub files. asm source files are still expected not to make any heavy preprocessor use, just simple conditionals on subarch. eventually most affected files may be replaced with C source files with minimal inline asm instead of asm source files.
2016-01-19 23:19:01 +00:00
obj/%.lo: $(srcdir)/%.S
deduplicate compiler invocation command line in makefile also clean up duplication of CFLAGS passing to assembler.
2016-01-20 02:58:29 +00:00
$(CC_CMD)
add support for arch-provided replacement files as .c or .S previously, replacement files provided in $(ARCH) dirs under src/ had to be .s files. in order to replace a file with C source, an empty .s file was needed there to suppress the original file, and a separate .c file was needed in arch/$(ARCH)/src/. support for .S is new and is aimed at short-term use eliminating .sub files. asm source files are still expected not to make any heavy preprocessor use, just simple conditionals on subarch. eventually most affected files may be replaced with C source files with minimal inline asm instead of asm source files.
2016-01-19 23:19:01 +00:00
support out-of-tree build this change adds support for building musl outside of the source tree. the implementation is similar to autotools where running configure in a different directory creates config.mak in the current working directory and symlinks the makefile, which contains the logic for creating all necessary directories and resolving paths relative to the source directory. to support both in-tree and out-of-tree builds with implicit make rules, all object files are now placed into a separate directory.
2015-11-18 20:07:32 +00:00
obj/%.lo: $(srcdir)/%.c $(GENH) $(IMPH)
deduplicate compiler invocation command line in makefile also clean up duplication of CFLAGS passing to assembler.
2016-01-20 02:58:29 +00:00
$(CC_CMD)
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
move dynamic linker to its own top-level directory, ldso this eliminates the last need for the SHARED macro to control how files in the src tree are compiled. the same code is used for both libc.a and libc.so, with additional code for the dynamic linker (from the new ldso tree) being added to libc.so but not libc.a. separate .o and .lo object files still exist for the src tree, but the only difference is that the .lo files are built as PIC. in the future, if/when we add dlopen support for static-linked programs, much of the code in dynlink.c may be moved back into the src tree, but properly factored into separate source files. in that case, the code in the ldso tree will be reduced to just the dynamic linker entry point, self-relocation, and loading of libraries needed by the main application.
2016-01-26 00:29:55 +00:00
lib/libc.so: $(LOBJS) $(LDSO_OBJS)
eliminate separate static/shared CFLAGS vars in makefile this allows the rules for .o and .lo files to be identical, with -fPIC and -DSHARED added for .lo files via target-specific variable append. this is arguably cleaner now and will allow more cleanup and removal of redundant rule bodies after other prerequisite changes are made.
2016-01-20 00:08:52 +00:00
$(CC) $(CFLAGS_ALL) $(LDFLAGS_ALL) -nostdlib -shared \
don't suppress shared libc when linker lacks -Bsymbolic-functions previous work overhauling the dynamic linker made it so that linking libc with -Bsymbolic-functions was no longer mandatory, but the configure logic that forced --disable-shared when ld failed to accept the option was left in place. this commit removes the hard-coded -Bsymbolic-functions from the Makefile and changes the configure test to one that simply adds it to the auto-detected LDFLAGS on success.
2016-01-31 05:40:33 +00:00
-Wl,-e,_dlstart -o $@ $(LOBJS) $(LDSO_OBJS) $(LIBCC)
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
use same object files for libc.a and libc.so if compiler produces PIC now that .lo and .o files differ only by whether -fPIC is passed (and no longer at the source level based on the SHARED macro), it's possible to use the same object files for both static and shared libc when the compiler would produce PIC for the static files anyway. this happens if the user has included -fPIC in their CFLAGS or if the compiler has been configured to produce PIE by default. we use the .lo files for both, and still append -fPIC to the CFLAGS, rather than using the .o files so that libc.so does not break catastrophically if the user later removes -fPIC from CFLAGS in config.mak or on the make command line. this also ensures that we get full -fPIC in case -fpic, -fPIE, or some other lesser-PIC option was passed in CFLAGS.
2016-01-26 00:57:38 +00:00
lib/libc.a: $(AOBJS)
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
rm -f $@
use same object files for libc.a and libc.so if compiler produces PIC now that .lo and .o files differ only by whether -fPIC is passed (and no longer at the source level based on the SHARED macro), it's possible to use the same object files for both static and shared libc when the compiler would produce PIC for the static files anyway. this happens if the user has included -fPIC in their CFLAGS or if the compiler has been configured to produce PIE by default. we use the .lo files for both, and still append -fPIC to the CFLAGS, rather than using the .o files so that libc.so does not break catastrophically if the user later removes -fPIC from CFLAGS in config.mak or on the make command line. this also ensures that we get full -fPIC in case -fpic, -fPIE, or some other lesser-PIC option was passed in CFLAGS.
2016-01-26 00:57:38 +00:00
$(AR) rc $@ $(AOBJS)
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
$(RANLIB) $@
new solution for empty lib dir (old one had some problems)
2011-02-17 22:12:52 +00:00
$(EMPTY_LIBS):
rm -f $@
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
$(AR) rc $@
adjust makefile to make crt/ and ldso/ sources arch-replaceable prior to commit 2f853dd6b9a95d5b13ee8f9df762125e0588df5d which overhauled the makefile for out-of-tree builds, crt/*.c files were replaceable by crt/$(ARCH)/*.s, and top-level ldso/ did not exist (its files were under src/ldso). since then, crti.o and crtn.o have been hard-coded as arch-specific, but none of the other files in crt/ or ldso/ were replaceable at all. in preparation for easy integration with midipix, which has a port of musl to windows, it needs to be possible to override the ELF-specific code in these files. making the same arch-replacements system work throughout the whole source tree also improves consistency and removes the need for some file-specific rules (crti.o and crtn.o) in the makefile.
2016-02-17 18:56:27 +00:00
lib/%.o: obj/crt/$(ARCH)/%.o
support out-of-tree build this change adds support for building musl outside of the source tree. the implementation is similar to autotools where running configure in a different directory creates config.mak in the current working directory and symlinks the makefile, which contains the logic for creating all necessary directories and resolving paths relative to the source directory. to support both in-tree and out-of-tree builds with implicit make rules, all object files are now placed into a separate directory.
2015-11-18 20:07:32 +00:00
cp $< $@
adjust makefile to make crt/ and ldso/ sources arch-replaceable prior to commit 2f853dd6b9a95d5b13ee8f9df762125e0588df5d which overhauled the makefile for out-of-tree builds, crt/*.c files were replaceable by crt/$(ARCH)/*.s, and top-level ldso/ did not exist (its files were under src/ldso). since then, crti.o and crtn.o have been hard-coded as arch-specific, but none of the other files in crt/ or ldso/ were replaceable at all. in preparation for easy integration with midipix, which has a port of musl to windows, it needs to be possible to override the ELF-specific code in these files. making the same arch-replacements system work throughout the whole source tree also improves consistency and removes the need for some file-specific rules (crti.o and crtn.o) in the makefile.
2016-02-17 18:56:27 +00:00
lib/%.o: obj/crt/%.o
support out-of-tree build this change adds support for building musl outside of the source tree. the implementation is similar to autotools where running configure in a different directory creates config.mak in the current working directory and symlinks the makefile, which contains the logic for creating all necessary directories and resolving paths relative to the source directory. to support both in-tree and out-of-tree builds with implicit make rules, all object files are now placed into a separate directory.
2015-11-18 20:07:32 +00:00
cp $< $@
lib/musl-gcc.specs: $(srcdir)/tools/musl-gcc.specs.sh config.mak
new gcc wrapper, entirely specfile based the _concept_ of this wrapper has been tested extensively, but the integration with the build/install system, and using a persistent specfile rather than one generated at build-time, have not been heavily tested and may need minor tweaks. this approach should be a lot more robust (and easier to improve) than writing a shell script that's responsible for trying to mimic gcc's logic about whether it's compiling or linking, building shared libs or executable files, etc. it's also lighter weight and should result in mildly faster builds when using the wrapper.
2012-04-22 18:32:49 +00:00
sh $< "$(includedir)" "$(libdir)" "$(LDSO_PATHNAME)" > $@
support out-of-tree build this change adds support for building musl outside of the source tree. the implementation is similar to autotools where running configure in a different directory creates config.mak in the current working directory and symlinks the makefile, which contains the logic for creating all necessary directories and resolving paths relative to the source directory. to support both in-tree and out-of-tree builds with implicit make rules, all object files are now placed into a separate directory.
2015-11-18 20:07:32 +00:00
obj/musl-gcc: config.mak
build: overhaul wrapper script system for multiple wrapper support this overhauls part of the build system in order to support multiple toolchain wrapper scripts, as opposed to solely the musl-gcc wrapper as before. it thereby replaces --enable-gcc-wrapper with --enable-wrapper=..., which has the options 'auto' (the default, detect whether to use wrappers), 'all' (build and install all wrappers), 'no' (don't build any) and finally the options named after the individual compiler scripts (currently only 'gcc' is available) to build and install only that wrapper. the old --enable-gcc-wrapper is removed from --help, but still available. it also modifies the wrappers to use the C compiler specified to the build system as 'inner' compiler, when applicable. as wrapper detection works by probing this compiler, it may not work with any other.
2015-06-28 21:08:19 +00:00
printf '#!/bin/sh\nexec "$${REALGCC:-$(WRAPCC_GCC)}" "$$@" -specs "%s/musl-gcc.specs"\n' "$(libdir)" > $@
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
chmod +x $@
add musl-clang, a wrapper for system clang installs musl-clang allows the user to compile musl-powered programs using their already existent clang install, without the need of a special cross compiler. it achieves this by wrapping around both the system clang install and the linker and passing them special flags to re-target musl at runtime. it does only affect invocations done through the special musl-clang wrapper script, so that the user setup remains fully intact otherwise. the clang wrapper consists of the compiler frontend wrapper script, musl-clang, and the linker wrapper script, ld.musl-clang. musl-clang makes sure clang invokes ld.musl-clang to link objects; neither script needs to be in PATH for the wrapper to work.
2015-06-28 21:08:21 +00:00
support out-of-tree build this change adds support for building musl outside of the source tree. the implementation is similar to autotools where running configure in a different directory creates config.mak in the current working directory and symlinks the makefile, which contains the logic for creating all necessary directories and resolving paths relative to the source directory. to support both in-tree and out-of-tree builds with implicit make rules, all object files are now placed into a separate directory.
2015-11-18 20:07:32 +00:00
obj/%-clang: $(srcdir)/tools/%-clang.in config.mak
add musl-clang, a wrapper for system clang installs musl-clang allows the user to compile musl-powered programs using their already existent clang install, without the need of a special cross compiler. it achieves this by wrapping around both the system clang install and the linker and passing them special flags to re-target musl at runtime. it does only affect invocations done through the special musl-clang wrapper script, so that the user setup remains fully intact otherwise. the clang wrapper consists of the compiler frontend wrapper script, musl-clang, and the linker wrapper script, ld.musl-clang. musl-clang makes sure clang invokes ld.musl-clang to link objects; neither script needs to be in PATH for the wrapper to work.
2015-06-28 21:08:21 +00:00
sed -e 's!@CC@!$(WRAPCC_CLANG)!g' -e 's!@PREFIX@!$(prefix)!g' -e 's!@INCDIR@!$(includedir)!g' -e 's!@LIBDIR@!$(libdir)!g' -e 's!@LDSO@!$(LDSO_PATHNAME)!g' $< > $@
chmod +x $@
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
support out-of-tree build this change adds support for building musl outside of the source tree. the implementation is similar to autotools where running configure in a different directory creates config.mak in the current working directory and symlinks the makefile, which contains the logic for creating all necessary directories and resolving paths relative to the source directory. to support both in-tree and out-of-tree builds with implicit make rules, all object files are now placed into a separate directory.
2015-11-18 20:07:32 +00:00
$(DESTDIR)$(bindir)/%: obj/%
replace system's install command with a shell script the historical (non-standardized) install command is really inappropriate for installing binaries/libraries on a system that utilizes memory-mapped executable files. rather than replacing an existing file atomically, it overwrites the existing file. this can cause running programs to see a partially-modified version of the file, resulting in unpredictable behavior, or SIGBUS. a MAP_COPY mode for mmap would get around this problem, but Linux lacks MAP_COPY. the shell script added with this commit works around the problem by writing temporary files and moving them into place. unlike the historical install utility, it also support a -l option for installing a symbolic link atomically, via the same method.
2013-08-18 02:21:11 +00:00
$(INSTALL) -D $< $@
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
cleanup shared library build system to be more $HOME-local-install friendly the path for the dynamic linker is now configurable, and failure to install the symlink for it will not stop the build.
2011-06-28 01:38:11 +00:00
$(DESTDIR)$(libdir)/%.so: lib/%.so
replace system's install command with a shell script the historical (non-standardized) install command is really inappropriate for installing binaries/libraries on a system that utilizes memory-mapped executable files. rather than replacing an existing file atomically, it overwrites the existing file. this can cause running programs to see a partially-modified version of the file, resulting in unpredictable behavior, or SIGBUS. a MAP_COPY mode for mmap would get around this problem, but Linux lacks MAP_COPY. the shell script added with this commit works around the problem by writing temporary files and moving them into place. unlike the historical install utility, it also support a -l option for installing a symbolic link atomically, via the same method.
2013-08-18 02:21:11 +00:00
$(INSTALL) -D -m 755 $< $@
cleanup shared library build system to be more $HOME-local-install friendly the path for the dynamic linker is now configurable, and failure to install the symlink for it will not stop the build.
2011-06-28 01:38:11 +00:00
adapt build/install/gcc-wrapper systems for dynamic linking support
2011-06-24 02:13:47 +00:00
$(DESTDIR)$(libdir)/%: lib/%
replace system's install command with a shell script the historical (non-standardized) install command is really inappropriate for installing binaries/libraries on a system that utilizes memory-mapped executable files. rather than replacing an existing file atomically, it overwrites the existing file. this can cause running programs to see a partially-modified version of the file, resulting in unpredictable behavior, or SIGBUS. a MAP_COPY mode for mmap would get around this problem, but Linux lacks MAP_COPY. the shell script added with this commit works around the problem by writing temporary files and moving them into place. unlike the historical install utility, it also support a -l option for installing a symbolic link atomically, via the same method.
2013-08-18 02:21:11 +00:00
$(INSTALL) -D -m 644 $< $@
initial check-in, version 0.5.0
2011-02-12 05:22:29 +00:00
support out-of-tree build this change adds support for building musl outside of the source tree. the implementation is similar to autotools where running configure in a different directory creates config.mak in the current working directory and symlinks the makefile, which contains the logic for creating all necessary directories and resolving paths relative to the source directory. to support both in-tree and out-of-tree builds with implicit make rules, all object files are now placed into a separate directory.
2015-11-18 20:07:32 +00:00
$(DESTDIR)$(includedir)/bits/%: $(srcdir)/arch/$(ARCH)/bits/%
$(INSTALL) -D -m 644 $< $@
add arch/generic include fallback to build rules this sets the stage for the first phase of the bits deduplication. bits headers which are identical for "most" archs will be moved to arch/generic/bits.
2016-01-28 00:31:15 +00:00
$(DESTDIR)$(includedir)/bits/%: $(srcdir)/arch/generic/bits/%
$(INSTALL) -D -m 644 $< $@
support out-of-tree build this change adds support for building musl outside of the source tree. the implementation is similar to autotools where running configure in a different directory creates config.mak in the current working directory and symlinks the makefile, which contains the logic for creating all necessary directories and resolving paths relative to the source directory. to support both in-tree and out-of-tree builds with implicit make rules, all object files are now placed into a separate directory.
2015-11-18 20:07:32 +00:00
$(DESTDIR)$(includedir)/bits/%: obj/include/bits/%
replace system's install command with a shell script the historical (non-standardized) install command is really inappropriate for installing binaries/libraries on a system that utilizes memory-mapped executable files. rather than replacing an existing file atomically, it overwrites the existing file. this can cause running programs to see a partially-modified version of the file, resulting in unpredictable behavior, or SIGBUS. a MAP_COPY mode for mmap would get around this problem, but Linux lacks MAP_COPY. the shell script added with this commit works around the problem by writing temporary files and moving them into place. unlike the historical install utility, it also support a -l option for installing a symbolic link atomically, via the same method.
2013-08-18 02:21:11 +00:00
$(INSTALL) -D -m 644 $< $@
fix Makefile so "make install" works before include/bits symlink exists previously, determination of the list of header files for installation depended on the include/bits symlink (to the arch-specific files) already having been created. in other words, running "make install" immediately after configure without first running "make" caused the bits headers not to be installed. the solution I have applied is to pull the list of headers directly from arch/$(ARCH)/bits rather than include/bits, and likewise to install directly from arch/$(ARCH)/bits rather than via the symlink. at this point, the only purpose served by keeping the symlink around is that it enables use of the in-tree headers and libs directly via -I and -L, which can be useful when testing against a new version of the library before installing it. on the other hand, removing the bits symlink would be beneficial if we ever want to support building multiple archs in the same source tree.
2013-07-01 17:43:43 +00:00
support out-of-tree build this change adds support for building musl outside of the source tree. the implementation is similar to autotools where running configure in a different directory creates config.mak in the current working directory and symlinks the makefile, which contains the logic for creating all necessary directories and resolving paths relative to the source directory. to support both in-tree and out-of-tree builds with implicit make rules, all object files are now placed into a separate directory.
2015-11-18 20:07:32 +00:00
$(DESTDIR)$(includedir)/%: $(srcdir)/include/%
replace system's install command with a shell script the historical (non-standardized) install command is really inappropriate for installing binaries/libraries on a system that utilizes memory-mapped executable files. rather than replacing an existing file atomically, it overwrites the existing file. this can cause running programs to see a partially-modified version of the file, resulting in unpredictable behavior, or SIGBUS. a MAP_COPY mode for mmap would get around this problem, but Linux lacks MAP_COPY. the shell script added with this commit works around the problem by writing temporary files and moving them into place. unlike the historical install utility, it also support a -l option for installing a symbolic link atomically, via the same method.
2013-08-18 02:21:11 +00:00
$(INSTALL) -D -m 644 $< $@
adapt build/install/gcc-wrapper systems for dynamic linking support
2011-06-24 02:13:47 +00:00
fix atomicity and other issues installing dynamic linker symlink ln -sf is non-atomic; it unlinks the destination first. instead, make a temporary link and rename it into place. this commit also fixes some of the dependency tracking behavior for the link. depending on the directory it's to be installed in is not reasonable; it causes a new link to be attempted if the library directory has been modified, but does not attempt to make a new link just because libc has been updated. instead, depend on the target to be linked to. this will ensure that, if prefix has changed but syslibdir has not, the link will be updated to point to the new prefix.
2013-08-16 21:51:38 +00:00
$(DESTDIR)$(LDSO_PATHNAME): $(DESTDIR)$(libdir)/libc.so
fix regression in creation of ldso symlink DESTDIR was wrongly included in the symlink contents.
2013-08-31 15:36:56 +00:00
$(INSTALL) -D -l $(libdir)/libc.so $@ || true
improve the build rules for installing /lib/ld-musl-$ARCH.so these new rules should avoid spurious error messages when the directory (usually /lib) and the dynamic linker symlink already exist, and minimize the spam when they can't be created.
2012-05-05 01:54:57 +00:00
split up installation target patch by Luca Barbato (lu_zero)
2012-08-17 23:32:24 +00:00
install-libs: $(ALL_LIBS:lib/%=$(DESTDIR)$(libdir)/%) $(if $(SHARED_LIBS),$(DESTDIR)$(LDSO_PATHNAME),)
install-headers: $(ALL_INCLUDES:include/%=$(DESTDIR)$(includedir)/%)
support out-of-tree build this change adds support for building musl outside of the source tree. the implementation is similar to autotools where running configure in a different directory creates config.mak in the current working directory and symlinks the makefile, which contains the logic for creating all necessary directories and resolving paths relative to the source directory. to support both in-tree and out-of-tree builds with implicit make rules, all object files are now placed into a separate directory.
2015-11-18 20:07:32 +00:00
install-tools: $(ALL_TOOLS:obj/%=$(DESTDIR)$(bindir)/%)
split up installation target patch by Luca Barbato (lu_zero)
2012-08-17 23:32:24 +00:00
support clean/distclean make targets in unconfigured tree commit 2f853dd6b9a95d5b13ee8f9df762125e0588df5d moved the error handling for $(ARCH) not being set such that it applied to all targets, including clean and distclean. previously these targets worked even in an unconfigured tree. to restore the old behavior, make most of the makefile body conditional on $(ARCH) being set/non-empty and produce the error via a fake "all" target in the conditional branch for the case where $(ARCH) is empty.
2016-02-17 21:11:45 +00:00
install: install-libs install-headers install-tools
add tarball-producing targets to Makefile for ease of release my old, out-of-tree release script that performed a clone rather than using git archive checked the VERSION file to make sure that it matched before doing a release. I believe there should be a way to do the same with git commands (without resorting to checking out the desired tag) but I have not yet found a way, so care should be taken when using these targets that the correctness of the VERSION file is not overlooked.
2014-06-25 20:14:37 +00:00
musl-git-%.tar.gz: .git
support out-of-tree build this change adds support for building musl outside of the source tree. the implementation is similar to autotools where running configure in a different directory creates config.mak in the current working directory and symlinks the makefile, which contains the logic for creating all necessary directories and resolving paths relative to the source directory. to support both in-tree and out-of-tree builds with implicit make rules, all object files are now placed into a separate directory.
2015-11-18 20:07:32 +00:00
git --git-dir=$(srcdir)/.git archive --format=tar.gz --prefix=$(patsubst %.tar.gz,%,$@)/ -o $@ $(patsubst musl-git-%.tar.gz,%,$@)
split up installation target patch by Luca Barbato (lu_zero)
2012-08-17 23:32:24 +00:00
add tarball-producing targets to Makefile for ease of release my old, out-of-tree release script that performed a clone rather than using git archive checked the VERSION file to make sure that it matched before doing a release. I believe there should be a way to do the same with git commands (without resorting to checking out the desired tag) but I have not yet found a way, so care should be taken when using these targets that the correctness of the VERSION file is not overlooked.
2014-06-25 20:14:37 +00:00
musl-%.tar.gz: .git
support out-of-tree build this change adds support for building musl outside of the source tree. the implementation is similar to autotools where running configure in a different directory creates config.mak in the current working directory and symlinks the makefile, which contains the logic for creating all necessary directories and resolving paths relative to the source directory. to support both in-tree and out-of-tree builds with implicit make rules, all object files are now placed into a separate directory.
2015-11-18 20:07:32 +00:00
git --git-dir=$(srcdir)/.git archive --format=tar.gz --prefix=$(patsubst %.tar.gz,%,$@)/ -o $@ v$(patsubst musl-%.tar.gz,%,$@)
split up installation target patch by Luca Barbato (lu_zero)
2012-08-17 23:32:24 +00:00
support clean/distclean make targets in unconfigured tree commit 2f853dd6b9a95d5b13ee8f9df762125e0588df5d moved the error handling for $(ARCH) not being set such that it applied to all targets, including clean and distclean. previously these targets worked even in an unconfigured tree. to restore the old behavior, make most of the makefile body conditional on $(ARCH) being set/non-empty and produce the error via a fake "all" target in the conditional branch for the case where $(ARCH) is empty.
2016-02-17 21:11:45 +00:00
endif
clean:
rm -rf obj lib
distclean: clean
rm -f config.mak
split up installation target patch by Luca Barbato (lu_zero)
2012-08-17 23:32:24 +00:00
.PHONY: all clean install install-libs install-headers install-tools