1# $FreeBSD$ 2# 3# This file contains common settings used for building FreeBSD 4# sources. 5 6# Enable various levels of compiler warning checks. These may be 7# overridden (e.g. if using a non-gcc compiler) by defining MK_WARNS=no. 8 9# for 4.2.1 GCC: http://gcc.gnu.org/onlinedocs/gcc-4.2.1/gcc/Warning-Options.html 10# for current GCC: https://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html 11# for clang: https://clang.llvm.org/docs/DiagnosticsReference.html 12 13.include <bsd.compiler.mk> 14 15# the default is gnu99 for now 16CSTD?= gnu99 17 18.if ${CSTD} == "c89" || ${CSTD} == "c90" 19CFLAGS+= -std=iso9899:1990 20.elif ${CSTD} == "c94" || ${CSTD} == "c95" 21CFLAGS+= -std=iso9899:199409 22.elif ${CSTD} == "c99" 23CFLAGS+= -std=iso9899:1999 24.else # CSTD 25CFLAGS+= -std=${CSTD} 26.endif # CSTD 27 28.if !empty(CXXSTD) 29CXXFLAGS+= -std=${CXXSTD} 30.endif 31 32# 33# Turn off -Werror for gcc 4.2.1. The compiler is on the glide path out of the 34# system, and any warnings specific to it are no longer relevant as there are 35# too many false positives. 36# 37.if ${COMPILER_VERSION} < 50000 38NO_WERROR.gcc= yes 39.endif 40 41# -pedantic is problematic because it also imposes namespace restrictions 42#CFLAGS+= -pedantic 43.if defined(WARNS) 44.if ${WARNS} >= 1 45CWARNFLAGS+= -Wsystem-headers 46.if !defined(NO_WERROR) && !defined(NO_WERROR.${COMPILER_TYPE}) 47CWARNFLAGS+= -Werror 48.endif # !NO_WERROR && !NO_WERROR.${COMPILER_TYPE} 49.endif # WARNS >= 1 50.if ${WARNS} >= 2 51CWARNFLAGS+= -Wall -Wno-format-y2k 52.endif # WARNS >= 2 53.if ${WARNS} >= 3 54CWARNFLAGS+= -W -Wno-unused-parameter -Wstrict-prototypes\ 55 -Wmissing-prototypes -Wpointer-arith 56.endif # WARNS >= 3 57.if ${WARNS} >= 4 58CWARNFLAGS+= -Wreturn-type -Wcast-qual -Wwrite-strings -Wswitch -Wshadow\ 59 -Wunused-parameter 60.if !defined(NO_WCAST_ALIGN) && !defined(NO_WCAST_ALIGN.${COMPILER_TYPE}) 61CWARNFLAGS+= -Wcast-align 62.endif # !NO_WCAST_ALIGN !NO_WCAST_ALIGN.${COMPILER_TYPE} 63.endif # WARNS >= 4 64.if ${WARNS} >= 6 65CWARNFLAGS+= -Wchar-subscripts -Winline -Wnested-externs -Wredundant-decls\ 66 -Wold-style-definition 67.if !defined(NO_WMISSING_VARIABLE_DECLARATIONS) 68CWARNFLAGS.clang+= -Wmissing-variable-declarations 69.endif 70.if !defined(NO_WTHREAD_SAFETY) 71CWARNFLAGS.clang+= -Wthread-safety 72.endif 73.endif # WARNS >= 6 74.if ${WARNS} >= 2 && ${WARNS} <= 4 75# XXX Delete -Wuninitialized by default for now -- the compiler doesn't 76# XXX always get it right. 77CWARNFLAGS+= -Wno-uninitialized 78.endif # WARNS >=2 && WARNS <= 4 79CWARNFLAGS+= -Wno-pointer-sign 80# Clang has more warnings enabled by default, and when using -Wall, so if WARNS 81# is set to low values, these have to be disabled explicitly. 82.if ${WARNS} <= 6 83CWARNFLAGS.clang+= -Wno-empty-body -Wno-string-plus-int 84.if ${COMPILER_TYPE} == "clang" && ${COMPILER_VERSION} >= 30400 85CWARNFLAGS.clang+= -Wno-unused-const-variable 86.endif 87.endif # WARNS <= 6 88.if ${WARNS} <= 3 89CWARNFLAGS.clang+= -Wno-tautological-compare -Wno-unused-value\ 90 -Wno-parentheses-equality -Wno-unused-function -Wno-enum-conversion 91.if ${COMPILER_TYPE} == "clang" && ${COMPILER_VERSION} >= 30600 92CWARNFLAGS.clang+= -Wno-unused-local-typedef 93.endif 94.if ${COMPILER_TYPE} == "clang" && ${COMPILER_VERSION} >= 40000 95CWARNFLAGS.clang+= -Wno-address-of-packed-member 96.endif 97.if ${COMPILER_TYPE} == "clang" && ${COMPILER_VERSION} >= 70000 && \ 98 ${MACHINE_CPUARCH} == "arm" && !${MACHINE_ARCH:Marmv[67]*} 99CWARNFLAGS.clang+= -Wno-atomic-alignment 100.endif 101.endif # WARNS <= 3 102.if ${WARNS} <= 2 103CWARNFLAGS.clang+= -Wno-switch -Wno-switch-enum -Wno-knr-promoted-parameter 104.endif # WARNS <= 2 105.if ${WARNS} <= 1 106CWARNFLAGS.clang+= -Wno-parentheses 107.endif # WARNS <= 1 108.if defined(NO_WARRAY_BOUNDS) 109CWARNFLAGS.clang+= -Wno-array-bounds 110.endif # NO_WARRAY_BOUNDS 111.endif # WARNS 112 113.if defined(FORMAT_AUDIT) 114WFORMAT= 1 115.endif # FORMAT_AUDIT 116.if defined(WFORMAT) 117.if ${WFORMAT} > 0 118#CWARNFLAGS+= -Wformat-nonliteral -Wformat-security -Wno-format-extra-args 119CWARNFLAGS+= -Wformat=2 -Wno-format-extra-args 120.if ${WARNS} <= 3 121CWARNFLAGS.clang+= -Wno-format-nonliteral 122.endif # WARNS <= 3 123.if !defined(NO_WERROR) && !defined(NO_WERROR.${COMPILER_TYPE}) 124CWARNFLAGS+= -Werror 125.endif # !NO_WERROR && !NO_WERROR.${COMPILER_TYPE} 126.endif # WFORMAT > 0 127.endif # WFORMAT 128.if defined(NO_WFORMAT) || defined(NO_WFORMAT.${COMPILER_TYPE}) 129CWARNFLAGS+= -Wno-format 130.endif # NO_WFORMAT || NO_WFORMAT.${COMPILER_TYPE} 131 132# GCC 5.2.0 133.if ${COMPILER_TYPE} == "gcc" && ${COMPILER_VERSION} >= 50200 134CWARNFLAGS+= -Wno-error=address \ 135 -Wno-error=array-bounds \ 136 -Wno-error=attributes \ 137 -Wno-error=bool-compare \ 138 -Wno-error=cast-align \ 139 -Wno-error=clobbered \ 140 -Wno-error=deprecated-declarations \ 141 -Wno-error=enum-compare \ 142 -Wno-error=extra \ 143 -Wno-error=inline \ 144 -Wno-error=logical-not-parentheses \ 145 -Wno-error=strict-aliasing \ 146 -Wno-error=uninitialized \ 147 -Wno-error=unused-but-set-variable \ 148 -Wno-error=unused-function \ 149 -Wno-error=unused-value 150.endif 151 152# GCC 6.1.0 153.if ${COMPILER_TYPE} == "gcc" && ${COMPILER_VERSION} >= 60100 154CWARNFLAGS+= -Wno-error=misleading-indentation \ 155 -Wno-error=nonnull-compare \ 156 -Wno-error=shift-negative-value \ 157 -Wno-error=tautological-compare \ 158 -Wno-error=unused-const-variable 159.endif 160 161# GCC 7.1.0 162.if ${COMPILER_TYPE} == "gcc" && ${COMPILER_VERSION} >= 70100 163CWARNFLAGS+= -Wno-error=bool-operation \ 164 -Wno-error=deprecated \ 165 -Wno-error=expansion-to-defined \ 166 -Wno-error=format-overflow \ 167 -Wno-error=format-truncation \ 168 -Wno-error=implicit-fallthrough \ 169 -Wno-error=int-in-bool-context \ 170 -Wno-error=memset-elt-size \ 171 -Wno-error=noexcept-type \ 172 -Wno-error=nonnull \ 173 -Wno-error=pointer-compare \ 174 -Wno-error=stringop-overflow 175.endif 176 177# GCC 8.1.0 178.if ${COMPILER_TYPE} == "gcc" && ${COMPILER_VERSION} >= 80100 179CWARNFLAGS+= -Wno-error=aggressive-loop-optimizations \ 180 -Wno-error=cast-function-type \ 181 -Wno-error=catch-value \ 182 -Wno-error=multistatement-macros \ 183 -Wno-error=restrict \ 184 -Wno-error=sizeof-pointer-memaccess \ 185 -Wno-error=stringop-truncation 186.endif 187 188# How to handle FreeBSD custom printf format specifiers. 189.if ${COMPILER_TYPE} == "clang" && ${COMPILER_VERSION} >= 30600 190FORMAT_EXTENSIONS= -D__printf__=__freebsd_kprintf__ 191.else 192FORMAT_EXTENSIONS= -fformat-extensions 193.endif 194 195.if defined(IGNORE_PRAGMA) 196CWARNFLAGS+= -Wno-unknown-pragmas 197.endif # IGNORE_PRAGMA 198 199# This warning is utter nonsense 200CFLAGS+= -Wno-format-zero-length 201 202CLANG_OPT_SMALL= -mstack-alignment=8 -mllvm -inline-threshold=3\ 203 -mllvm -simplifycfg-dup-ret 204.if ${COMPILER_VERSION} >= 30500 && ${COMPILER_VERSION} < 30700 205CLANG_OPT_SMALL+= -mllvm -enable-gvn=false 206.else 207CLANG_OPT_SMALL+= -mllvm -enable-load-pre=false 208.endif 209CFLAGS.clang+= -Qunused-arguments 210.if ${MACHINE_CPUARCH} == "sparc64" 211# Don't emit .cfi directives, since we must use GNU as on sparc64, for now. 212CFLAGS.clang+= -fno-dwarf2-cfi-asm 213.endif # SPARC64 214# The libc++ headers use c++11 extensions. These are normally silenced because 215# they are treated as system headers, but we explicitly disable that warning 216# suppression when building the base system to catch bugs in our headers. 217# Eventually we'll want to start building the base system C++ code as C++11, 218# but not yet. 219CXXFLAGS.clang+= -Wno-c++11-extensions 220 221.if ${MK_SSP} != "no" && \ 222 ${MACHINE_CPUARCH} != "arm" && ${MACHINE_CPUARCH} != "mips" 223.if (${COMPILER_TYPE} == "clang" && ${COMPILER_VERSION} >= 30500) || \ 224 (${COMPILER_TYPE} == "gcc" && \ 225 (${COMPILER_VERSION} == 40201 || ${COMPILER_VERSION} >= 40900)) 226# Don't use -Wstack-protector as it breaks world with -Werror. 227SSP_CFLAGS?= -fstack-protector-strong 228.else 229SSP_CFLAGS?= -fstack-protector 230.endif 231CFLAGS+= ${SSP_CFLAGS} 232.endif # SSP && !ARM && !MIPS 233 234# Additional flags passed in CFLAGS and CXXFLAGS when MK_DEBUG_FILES is 235# enabled. 236DEBUG_FILES_CFLAGS?= -g 237 238# Allow user-specified additional warning flags, plus compiler and file 239# specific flag overrides, unless we've overridden this... 240.if ${MK_WARNS} != "no" 241CFLAGS+= ${CWARNFLAGS:M*} ${CWARNFLAGS.${COMPILER_TYPE}} 242CFLAGS+= ${CWARNFLAGS.${.IMPSRC:T}} 243CXXFLAGS+= ${CXXWARNFLAGS:M*} ${CXXWARNFLAGS.${COMPILER_TYPE}} 244CXXFLAGS+= ${CXXWARNFLAGS.${.IMPSRC:T}} 245.endif 246 247CFLAGS+= ${CFLAGS.${COMPILER_TYPE}} 248CXXFLAGS+= ${CXXFLAGS.${COMPILER_TYPE}} 249 250AFLAGS+= ${AFLAGS.${.IMPSRC:T}} 251AFLAGS+= ${AFLAGS.${.TARGET:T}} 252ACFLAGS+= ${ACFLAGS.${.IMPSRC:T}} 253ACFLAGS+= ${ACFLAGS.${.TARGET:T}} 254CFLAGS+= ${CFLAGS.${.IMPSRC:T}} 255CXXFLAGS+= ${CXXFLAGS.${.IMPSRC:T}} 256 257LDFLAGS+= ${LDFLAGS.${LINKER_TYPE}} 258 259# Only allow .TARGET when not using PROGS as it has the same syntax 260# per PROG which is ambiguous with this syntax. This is only needed 261# for PROG_VARS vars. 262.if !defined(_RECURSING_PROGS) 263.if ${MK_WARNS} != "no" 264CFLAGS+= ${CWARNFLAGS.${.TARGET:T}} 265.endif 266CFLAGS+= ${CFLAGS.${.TARGET:T}} 267CXXFLAGS+= ${CXXFLAGS.${.TARGET:T}} 268LDFLAGS+= ${LDFLAGS.${.TARGET:T}} 269LDADD+= ${LDADD.${.TARGET:T}} 270LIBADD+= ${LIBADD.${.TARGET:T}} 271.endif 272 273.if defined(SRCTOP) 274# Prevent rebuilding during install to support read-only objdirs. 275.if ${.TARGETS:M*install*} == ${.TARGETS} && empty(.MAKE.MODE:Mmeta) 276CFLAGS+= ERROR-tried-to-rebuild-during-make-install 277.endif 278.endif 279 280# Tell bmake not to mistake standard targets for things to be searched for 281# or expect to ever be up-to-date. 282PHONY_NOTMAIN = analyze afterdepend afterinstall all beforedepend beforeinstall \ 283 beforelinking build build-tools buildconfig buildfiles \ 284 buildincludes check checkdpadd clean cleandepend cleandir \ 285 cleanobj configure depend distclean distribute exe \ 286 files html includes install installconfig installdirs \ 287 installfiles installincludes lint obj objlink objs objwarn \ 288 realinstall tags whereobj 289 290# we don't want ${PROG} to be PHONY 291.PHONY: ${PHONY_NOTMAIN:N${PROG:U}} 292.NOTMAIN: ${PHONY_NOTMAIN:Nall} 293 294.if ${MK_STAGING} != "no" 295.if defined(_SKIP_BUILD) || (!make(all) && !make(clean*) && !make(*clean)) 296_SKIP_STAGING?= yes 297.endif 298.if ${_SKIP_STAGING:Uno} == "yes" 299staging stage_libs stage_files stage_as stage_links stage_symlinks: 300.else 301# allow targets like beforeinstall to be leveraged 302DESTDIR= ${STAGE_OBJTOP} 303.export DESTDIR 304 305.if target(beforeinstall) 306.if !empty(_LIBS) || (${MK_STAGING_PROG} != "no" && !defined(INTERNALPROG)) 307staging: beforeinstall 308.endif 309.endif 310 311# normally only libs and includes are staged 312.if ${MK_STAGING_PROG} != "no" && !defined(INTERNALPROG) 313STAGE_DIR.prog= ${STAGE_OBJTOP}${BINDIR} 314 315.if !empty(PROG) 316.if defined(PROGNAME) 317STAGE_AS_SETS+= prog 318STAGE_AS_${PROG}= ${PROGNAME} 319stage_as.prog: ${PROG} 320.else 321STAGE_SETS+= prog 322stage_files.prog: ${PROG} 323STAGE_TARGETS+= stage_files 324.endif 325.endif 326.endif 327 328.if !empty(_LIBS) && !defined(INTERNALLIB) 329.if defined(SHLIBDIR) && ${SHLIBDIR} != ${LIBDIR} && ${_LIBS:Uno:M*.so.*} != "" 330STAGE_SETS+= shlib 331STAGE_DIR.shlib= ${STAGE_OBJTOP}${SHLIBDIR} 332STAGE_FILES.shlib+= ${_LIBS:M*.so.*} 333stage_files.shlib: ${_LIBS:M*.so.*} 334.endif 335 336.if defined(SHLIB_LINK) && commands(${SHLIB_LINK:R}.ld) 337STAGE_AS_SETS+= ldscript 338STAGE_AS.ldscript+= ${SHLIB_LINK:R}.ld 339stage_as.ldscript: ${SHLIB_LINK:R}.ld 340STAGE_DIR.ldscript = ${STAGE_LIBDIR} 341STAGE_AS_${SHLIB_LINK:R}.ld:= ${SHLIB_LINK} 342NO_SHLIB_LINKS= 343.endif 344 345.if target(stage_files.shlib) 346stage_libs: ${_LIBS} 347.if defined(DEBUG_FLAGS) && target(${SHLIB_NAME}.symbols) 348stage_files.shlib: ${SHLIB_NAME}.symbols 349.endif 350.else 351stage_libs: ${_LIBS} 352.endif 353.if defined(SHLIB_NAME) && defined(DEBUG_FLAGS) && target(${SHLIB_NAME}.symbols) 354stage_libs: ${SHLIB_NAME}.symbols 355.endif 356 357.endif 358 359.if !empty(INCS) || !empty(INCSGROUPS) && target(buildincludes) 360.if !defined(NO_BEFOREBUILD_INCLUDES) 361stage_includes: buildincludes 362beforebuild: stage_includes 363.endif 364.endif 365 366.for t in stage_libs stage_files stage_as 367.if target($t) 368STAGE_TARGETS+= $t 369.endif 370.endfor 371 372.if !empty(STAGE_AS_SETS) 373STAGE_TARGETS+= stage_as 374.endif 375 376.if !empty(STAGE_TARGETS) || (${MK_STAGING_PROG} != "no" && !defined(INTERNALPROG)) 377 378.if !empty(LINKS) 379STAGE_TARGETS+= stage_links 380.if ${MAKE_VERSION} < 20131001 381stage_links.links: ${_LIBS} ${PROG} 382.endif 383STAGE_SETS+= links 384STAGE_LINKS.links= ${LINKS} 385.endif 386 387.if !empty(SYMLINKS) 388STAGE_TARGETS+= stage_symlinks 389STAGE_SETS+= links 390STAGE_SYMLINKS.links= ${SYMLINKS} 391.endif 392 393.endif 394 395.include <meta.stage.mk> 396.endif 397.endif 398 399.if defined(META_TARGETS) 400.for _tgt in ${META_TARGETS} 401.if target(${_tgt}) 402${_tgt}: ${META_DEPS} 403.endif 404.endfor 405.endif 406