include <bsd.init.mk>
include <bsd.shlib.mk>
include <bsd.gcc.mk>
include <bsd.sanitizer.mk>
# Pull in <bsd.sys.mk> here so we can override its .c.o rule
include <bsd.sys.mk>
LIBISMODULE?= no
LIBISPRIVATE?= no
LIBISCXX?= no
if ${LIBISMODULE} != "no"
_LIB_PREFIX?= # empty
MKDEBUGLIB:= no
MKPROFILE:= no
MKPICINSTALL:= no
MAKESTATICLIB?= no
MAKELINKLIB?= yes
_LINTINSTALL?= no
else
_LIB_PREFIX?= lib
endif
if ${LIBISPRIVATE} != "no"
MKDEBUGLIB:= no
MKPROFILE:= no
MKPICINSTALL:= no
if defined(NOSTATICLIB) && ${MKPICLIB} != "no"
MAKESTATICLIB?= no
elif ${LIBISPRIVATE} != "pic"
MKPIC:= no
endif
MAKELINKLIB?= no
_LINTINSTALL?= no
endif
##### LIB specific flags.
# XXX: This is needed for programs that link with .a libraries
# Perhaps a more correct solution is to always generate _pic.a
# files or always have a shared library.
# Another fix is to provide rcrt0.o like OpenBSD does and
# do relocations for static PIE.
if defined(MKPIE) && (${MKPIE} != "no") && !defined(NOPIE)
CFLAGS+= ${PIE_CFLAGS}
AFLAGS+= ${PIE_AFLAGS}
endif
# The -fPIC is needed for libraries that include other libraries
# The order matters here, PIC needs to be last
if ${LIBISPRIVATE} == "pic" && ${MKPIC} != "no"
CFLAGS+= -fPIC
AFLAGS+= -fPIC
endif
PGFLAGS+= -pg
if ${MKPIC} != "no"
PGFLAGS+= -fPIC
endif
##### Libraries that this may depend upon.
if defined(LIBDPLIBS) && ${MKPIC} != "no" # {
for _lib _dir in ${LIBDPLIBS}
if !defined(LIBDO.${_lib})
LIBDO.${_lib}!= cd "${_dir}" && ${PRINTOBJDIR}
MAKEOVERRIDES+=LIBDO.${_lib}
endif
if ${LIBDO.${_lib}} == "_external"
LDADD+= -l${_lib}
else
LDADD+= -L${LIBDO.${_lib}} -l${_lib}
if exists(${LIBDO.${_lib}}/lib${_lib}_pic.a)
DPADD+= ${LIBDO.${_lib}}/lib${_lib}_pic.a
elif exists(${LIBDO.${_lib}}/lib${_lib}.so)
DPADD+= ${LIBDO.${_lib}}/lib${_lib}.so
else
DPADD+= ${LIBDO.${_lib}}/lib${_lib}.a
endif
endif
endfor
endif # }
if ${LIBISPRIVATE} == "no"
if defined(SHLIB_MAJOR) && !empty(SHLIB_MAJOR) # {
if defined(SHLIB_MINOR) && !empty(SHLIB_MINOR)
if defined(SHLIB_TEENY) && !empty(SHLIB_TEENY)
SHLIB_FULLVERSION=${SHLIB_MAJOR}.${SHLIB_MINOR}.${SHLIB_TEENY}
else
SHLIB_FULLVERSION=${SHLIB_MAJOR}.${SHLIB_MINOR}
endif
else
SHLIB_FULLVERSION=${SHLIB_MAJOR}
endif
endif # }
endif
# add additional suffixes not exported.
# .po is used for profiling object files.
# .pico is used for PIC object files.
SUFFIXES: .out .a .ln .pico .po .go .o .s .S .c .cc .cpp .cxx .C .m .F .f .r .y .l .cl .p .h
SUFFIXES: .sh .m4 .m
# Set PICFLAGS to cc flags for producing position-independent code,
# if not already set.
# Data-driven table using make variables to control how shared libraries
# are built for different platforms and object formats.
# SHLIB_MAJOR, SHLIB_MINOR, SHLIB_TEENY: Major, minor, and teeny version
# numbers of shared library
# SHLIB_SOVERSION: version number to be compiled into a shared library
# via -soname. Usually ${SHLIB_MAJOR} on ELF.
# NetBSD/pmax used to use ${SHLIB_MAJOR}[.${SHLIB_MINOR}
# [.${SHLIB_TEENY}]]
# SHLIB_SHFLAGS: Flags to tell ${LD} to emit shared library.
# with ELF, also set shared-lib version for ld.so.
# SHLIB_LDSTARTFILE: support .o file, call C++ file-level constructors
# SHLIB_LDENDFILE: support .o file, call C++ file-level destructors
PICFLAGS ?= -fPIC
if ${MKPICLIB} != "no"
CSHLIBFLAGS+= ${PICFLAGS} ${SANITIZERFLAGS} ${LIBCSANITIZERFLAGS}
endif
if defined(CSHLIBFLAGS) && !empty(CSHLIBFLAGS)
MKSHLIBOBJS= yes
else
MKSHLIBOBJS= no
endif
# Avoid adding "-g" if we already have a "-g*" option.
if (${MKDEBUG:Uno} != "no" && !defined(NODEBUG)) && \
(!defined(CFLAGS) || empty(CFLAGS:M-g*)) && \
(!defined(CXXFLAGS) || empty(CXXFLAGS:M-g*))
# We only add -g to the shared library objects
# because we don't currently split .a archives.
CSHLIBFLAGS+= -g
if ${LIBISPRIVATE} != "no"
CFLAGS+= -g
endif
endif
# Declare a few variables to make our life easier later.
_LIB:=${_LIB_PREFIX}${LIB}
_LIB.a:=${_LIB}.a
_LIB_p.a:=${_LIB}_p.a
_LIB_g.a:=${_LIB}_g.a
_LIB_pic.a:=${_LIB}_pic.a
_LIB.ln:=llib-l${LIB}.ln
if ${MKPIC} != "no" && defined(SHLIB_FULLVERSION)
_LIB.so:=${_LIB}.so
_LIB.so.major:=${_LIB}.so.${SHLIB_MAJOR}
_LIB.so.full:=${_LIB}.so.${SHLIB_FULLVERSION}
_LIB.so.link:=${_LIB}.so.${SHLIB_FULLVERSION}.link
if ${MKDEBUG:Uno} != "no" && !defined(NODEBUG)
_LIB.so.debug:=${_LIB.so.full}.debug
endif
endif
if defined(LIB) # {
if ${_BUILDSTATICLIB} != "no"
_LIBS=${_LIB.a}
else
_LIBS=
endif
OBJS+=${SRCS:N*.h:N*.sh:R:S/$/.o/g}
STOBJS+=${OBJS}
LOBJS+=${LSRCS:.c=.ln} ${SRCS:M*.c:.c=.ln}
if ${LIBISPRIVATE} != "no"
# No installation is required
libinstall::
endif
if ${MKDEBUGLIB} != "no"
_LIBS+=${_LIB_g.a}
GOBJS+=${OBJS:.o=.go}
DEBUGFLAGS?=-DDEBUG
endif
if ${MKPROFILE} != "no"
_LIBS+=${_LIB_p.a}
POBJS+=${OBJS:.o=.po}
PROFFLAGS?=-DGPROF -DPROF
endif
if ${MKPIC} != "no" # {
if ${MKPICLIB} == "no"
if ${MKSHLIBOBJS} != "no"
# make _pic.a, which isn't really pic,
# since it's needed for making shared lib.
# but don't install it.
SOLIB=${_LIB_pic.a}
SOBJS+=${OBJS:.o=.pico}
else
SOLIB=${_LIB.a}
endif
else
SOLIB=${_LIB_pic.a}
_LIBS+=${SOLIB}
SOBJS+=${OBJS:.o=.pico}
endif
if defined(SHLIB_FULLVERSION)
_LIBS+=${_LIB.so.full}
endif
endif # }
if ${MKLINT} != "no" && !empty(LOBJS)
_LIBS+=${_LIB.ln}
endif
# If you change this, please consider reflecting the change in
# the override in sys/rump/Makefile.rump.
if !target(__archivebuild)
__archivebuild: .USE
${_MKTARGET_BUILD}
@rm -f ${.TARGET}
${AR} ${_ARFL} ${.TARGET} $$(NM=${NM} ${LORDER} ${.ALLSRC:M*o} | ${TSORT})
endif
# gcc -shared now adds -lc automatically. For libraries other than libc and
# libgcc* we add as a dependency the installed shared libc. For libc and
# libgcc* we avoid adding libc as a dependency by using -nostdlib. Note that
# -Xl,-nostdlib is not enough because we want to tell the compiler-driver not
# to add standard libraries, not the linker.
if !defined(LIB)
if !empty(LIBC_SO)
DPLIBC ?= ${DESTDIR}${LIBC_SO}
endif
else
if ${LIB} != "c" && ${LIB:Mgcc*} == ""
if !empty(LIBC_SO)
DPLIBC ?= ${DESTDIR}${LIBC_SO}
endif
else
LDLIBC ?= -nodefaultlibs
if ${HAVE_LIBGCC} == "yes" && ${LIB} == "c"
LDADD+= -lgcc
endif
endif
endif
if ${LIBISCXX} != "no"
LIBCC:= ${CXX}
if ${MKLIBCXX} == "yes"
LIBDPLIBS+= c++ ${.CURDIR}/../../../../../external/bsd/libc++/lib
else
LIBDPLIBS+= stdc++ ${.CURDIR}/../../../../../external/gpl3/${EXTERNAL_GCC_SUBDIR}/lib/libstdc++-v3
endif
else
LIBCC:= ${CC}
endif
# VERSION_MAP
#
# Path to an ld version script to use when linking the library.
# Resolved from .PATH like a target prerequisite.
#
# Implemented by adding -Wl,--version-script=${${VERSION_MAP}:P}
# to LDFLAGS, and by adding ${VERSION_MAP} to DPADD to make it a
# target prerequisite so :P works.
#
if !empty(VERSION_MAP)
DPADD+= ${VERSION_MAP}
LDFLAGS+= -Wl,--version-script=${${VERSION_MAP}:P}
endif
if defined(_LIB.so.debug)
${_LIB.so.debug}: ${_LIB.so.link}
${_MKTARGET_CREATE}
( ${OBJCOPY} --only-keep-debug --compress-debug-sections \
${_LIB.so.link} ${_LIB.so.debug} \
) || (rm -f ${.TARGET}; false)
${_LIB.so.full}: ${_LIB.so.link} ${_LIB.so.debug}
${_MKTARGET_CREATE}
( ${OBJCOPY} --strip-debug -p -R .gnu_debuglink \
--add-gnu-debuglink=${_LIB.so.debug} \
${_LIB.so.link} ${_LIB.so.full}.tmp && \
${MV} ${_LIB.so.full}.tmp ${_LIB.so.full} \
) || (rm -f ${.TARGET}; false)
${_LIB.so.link}: ${_MAINLIBDEPS}
else # aka no MKDEBUG
${_LIB.so.full}: ${_MAINLIBDEPS}
endif
${_MKTARGET_BUILD}
rm -f ${.TARGET}
${LIBCC} ${LDLIBC} -shared ${SHLIB_SHFLAGS} \
${_LDFLAGS.${_LIB}} -o ${.TARGET}.tmp ${_LIBLDOPTS} \
-Wl,--whole-archive ${SOLIB} \
-Wl,--no-whole-archive ${_LDADD.${_LIB}}
if ${MKSTRIPIDENT} != "no"
${OBJCOPY} -R .ident ${.TARGET}.tmp
endif
${MV} ${.TARGET}.tmp ${.TARGET}
# We don't use INSTALL_SYMLINK here because this is just
# happening inside the build directory/objdir. XXX Why does
# this spend so much effort on libraries that aren't live??? XXX
# XXX Also creates dead symlinks until the .full rule runs
# above and creates the main link
if defined(SHLIB_FULLVERSION) && defined(SHLIB_MAJOR) && \
"${SHLIB_FULLVERSION}" != "${SHLIB_MAJOR}"
${HOST_LN} -sf ${_LIB.so.full} ${_LIB.so.major}.tmp
${MV} ${_LIB.so.major}.tmp ${_LIB.so.major}
endif
${HOST_LN} -sf ${_LIB.so.full} ${_LIB.so}.tmp
${MV} ${_LIB.so}.tmp ${_LIB.so}
# If there's a file listing expected symbols, fail if the diff from it
# to the actual symbols is nonempty, and show the diff in that case.
if exists(${.CURDIR}/${LIB}.${LIBC_MACHINE_ARCH:U${MACHINE_ARCH}}.expsym)
LIB_EXPSYM?= ${LIB}.${LIBC_MACHINE_ARCH:U${MACHINE_ARCH}}.expsym
elif exists(${.CURDIR}/${LIB}.${LIBC_MACHINE_CPU:U${MACHINE_CPU}}.expsym)
LIB_EXPSYM?= ${LIB}.${LIBC_MACHINE_CPU:U${MACHINE_CPU}}.expsym
elif exists(${.CURDIR}/${LIB}.expsym)
LIB_EXPSYM?= ${LIB}.expsym
endif
# If we don't have a version map enumerating the exact symbols
# exported, skip various machine-dependent crud that the linker
# automatically exports (even though it appears to be unnecessary, as
# demonstrated by libraries with version scripts which don't export
# these symbols).
#
# This list has been gathered empirically -- I'm not sure it's written
# down anywhere and I'm not sure there's any way to ask the linker to
# simply not export the symbols.
if !empty(VERSION_MAP)
_EXPSYM_PIPE_GREP= # empty
else
_EXPSYM_PIPE_GREP= | grep -Fvx ${_EXPSYM_IGNORE:@_s_@-e ${_s_:Q}@}
_EXPSYM_IGNORE+= _end
_EXPSYM_IGNORE+= _fini
_EXPSYM_IGNORE+= _init
_EXPSYM_IGNORE.aarch64+= __bss_end__
_EXPSYM_IGNORE.aarch64+= __bss_start__
_EXPSYM_IGNORE.aarch64+= __end__
_EXPSYM_IGNORE.aarch64+= _bss_end__
_EXPSYM_IGNORE.hppa+= _GLOBAL_OFFSET_TABLE_
_EXPSYM_IGNORE.powerpc64+= ._fini
_EXPSYM_IGNORE.powerpc64+= ._init
_EXPSYM_IGNORE.sh3+= ___ctors
_EXPSYM_IGNORE.sh3+= ___ctors_end
_EXPSYM_IGNORE.sh3+= ___dtors
_EXPSYM_IGNORE.sh3+= ___dtors_end
_EXPSYM_IGNORE+= ${_EXPSYM_IGNORE.${MACHINE_ARCH}}
if ${MACHINE_ARCH} != ${MACHINE_CPU}
_EXPSYM_IGNORE+= ${_EXPSYM_IGNORE.${MACHINE_CPU}}
endif
endif
# Only intended to be invoked manually, not as part of dependall.
lint: ${LOBJS}
if defined(LOBJS) && !empty(LOBJS)
${LINT} ${LINTFLAGS} -Cmanual-lint ${LOBJS}
endif
# If the number of entries in CLEANFILES is too large, then the
# commands in bsd.clean.mk encounter errors like "exec(/bin/sh)
# failed (Argument list too long)". Avoid that by splitting the
# files to clean into several lists using different variable names.
# __cleanuse is an internal target in bsd.clean.mk; the way we
# use it here mimics the way it's used by the clean target in
# bsd.clean.mk.
#
clean: libclean1 libclean2 libclean3 libclean4 libclean5
libclean1: .PHONY .MADE __cleanuse LIBCLEANFILES1
libclean2: .PHONY .MADE __cleanuse LIBCLEANFILES2
libclean3: .PHONY .MADE __cleanuse LIBCLEANFILES3
libclean4: .PHONY .MADE __cleanuse LIBCLEANFILES4
libclean5: .PHONY .MADE __cleanuse LIBCLEANFILES5
CLEANFILES+= a.out [Ee]rrs mklog core *.core
LIBCLEANFILES1+= ${_LIB.a} ${STOBJS} ${STOBJS:=.tmp}
LIBCLEANFILES2+= ${_LIB_p.a} ${POBJS} ${POBJS:=.tmp}
LIBCLEANFILES3+= ${_LIB_g.a} ${GOBJS} ${GOBJS:=.tmp}
LIBCLEANFILES4+= ${_LIB_pic.a}
if ${MKPIC} != "no" && defined(SHLIB_FULLVERSION)
LIBCLEANFILES4+= ${_LIB.so}.* ${_LIB.so} ${_LIB.so.debug}
endif
LIBCLEANFILES4+= ${SOBJS} ${SOBJS:=.tmp}
LIBCLEANFILES5+= ${_LIB.ln} ${LOBJS} llib-lmanual-lint.ln
if !target(libinstall) # {
# Make sure it gets defined, in case MKPIC==no && MKLINKLIB==no
libinstall::
##### Pull in related .mk logic
LINKSOWN?= ${LIBOWN}
LINKSGRP?= ${LIBGRP}
LINKSMODE?= ${LIBMODE}
include <bsd.man.mk>
include <bsd.nls.mk>
include <bsd.files.mk>
include <bsd.inc.mk>
include <bsd.links.mk>
include <bsd.dep.mk>
include <bsd.clang-analyze.mk>
include <bsd.clean.mk>
