diff --git a/UPDATING b/UPDATING index c60143c6184e..ddcbbf43d387 100644 --- a/UPDATING +++ b/UPDATING @@ -27,6 +27,18 @@ NOTE TO PEOPLE WHO THINK THAT FreeBSD 16.x IS SLOW: world, or to merely disable the most expensive debugging functionality at runtime, run "ln -s 'abort:false,junk:false' /etc/malloc.conf".) +20260531: + On powerpc64le, long double is now IEEE 754 binary128 (quad + precision, 113-bit mantissa) instead of 64-bit double. This is an + ABI-incompatible change with no symbol versioning: all C and C++ + code that passes, returns, or stores long double (or long double + complex) -- including printf/scanf "%Lf", strtold, and the libm + *l() routines -- must be rebuilt against the new world. Mixing old + and new objects that exchange long double values will silently + corrupt data. Rebuild all installed ports and any out-of-tree + software after upgrading. Big-endian powerpc and powerpc64 are + unaffected and keep 64-bit long double. + 20260412: The /etc/rc.d/NETWORKING script no longer provides the legacy NETWORK alias. Third-party or local RC scripts that still use diff --git a/contrib/llvm-project/clang/lib/Basic/Targets/PPC.h b/contrib/llvm-project/clang/lib/Basic/Targets/PPC.h index 9f3a4cd2da71..78f2815291fe 100644 --- a/contrib/llvm-project/clang/lib/Basic/Targets/PPC.h +++ b/contrib/llvm-project/clang/lib/Basic/Targets/PPC.h @@ -468,7 +468,11 @@ class LLVM_LIBRARY_VISIBILITY PPC64TargetInfo : public PPCTargetInfo { DataLayout += "-i64:64-i128:128-n32:64"; } - if (Triple.isOSFreeBSD() || Triple.isOSOpenBSD() || Triple.isMusl()) { + if (Triple.isOSFreeBSD() && Triple.getArch() == llvm::Triple::ppc64le && + Triple.getOSMajorVersion() >= 16) { + LongDoubleWidth = LongDoubleAlign = 128; + LongDoubleFormat = &llvm::APFloat::IEEEquad(); + } else if (Triple.isOSFreeBSD() || Triple.isOSOpenBSD() || Triple.isMusl()) { LongDoubleWidth = LongDoubleAlign = 64; LongDoubleFormat = &llvm::APFloat::IEEEdouble(); } diff --git a/contrib/llvm-project/clang/lib/CodeGen/CGBuiltin.cpp b/contrib/llvm-project/clang/lib/CodeGen/CGBuiltin.cpp index 5f2eb76e7bac..80dbe0f73c85 100644 --- a/contrib/llvm-project/clang/lib/CodeGen/CGBuiltin.cpp +++ b/contrib/llvm-project/clang/lib/CodeGen/CGBuiltin.cpp @@ -228,7 +228,10 @@ llvm::Constant *CodeGenModule::getBuiltinLibFunction(const FunctionDecl *FD, else { // TODO: This mutation should also be applied to other targets other than // PPC, after backend supports IEEE 128-bit style libcalls. - if (getTriple().isPPC64() && + // The *ieee128 names are glibc's mechanism for coexisting IBM double-double + // and IEEE-128 long double in one library; targets with a single IEEE-128 + // long double format (e.g. FreeBSD) use the unsuffixed names. + if (getTriple().isPPC64() && getTriple().isGNUEnvironment() && &getTarget().getLongDoubleFormat() == &llvm::APFloat::IEEEquad() && F128Builtins.contains(BuiltinID)) Name = F128Builtins[BuiltinID]; diff --git a/contrib/llvm-project/clang/lib/Driver/ToolChain.cpp b/contrib/llvm-project/clang/lib/Driver/ToolChain.cpp index 07a3ae925f96..1171b2abb590 100644 --- a/contrib/llvm-project/clang/lib/Driver/ToolChain.cpp +++ b/contrib/llvm-project/clang/lib/Driver/ToolChain.cpp @@ -193,6 +193,10 @@ bool ToolChain::useRelaxRelocations() const { } bool ToolChain::defaultToIEEELongDouble() const { + if (getTriple().isOSFreeBSD() && + getTriple().getArch() == llvm::Triple::ppc64le && + getTriple().getOSMajorVersion() >= 16) + return true; return PPC_LINUX_DEFAULT_IEEELONGDOUBLE && getTriple().isOSLinux(); } diff --git a/lib/libc/powerpc64/Makefile.inc b/lib/libc/powerpc64/Makefile.inc index 734afe95f243..1289a48baa06 100644 --- a/lib/libc/powerpc64/Makefile.inc +++ b/lib/libc/powerpc64/Makefile.inc @@ -1,3 +1,9 @@ +.if ${MACHINE_ARCH} == "powerpc64le" +# Long double is IEEE binary128 +GDTOASRCS+=strtorQ.c +SRCS+=machdep_ldisQ.c +.else # Long double is 64-bits SRCS+=machdep_ldisd.c +.endif SYM_MAPS+=${LIBC_SRCTOP}/powerpc64/Symbol.map diff --git a/lib/libc/powerpc64/_fpmath.h b/lib/libc/powerpc64/_fpmath.h index 9bc7450aacaf..ad640cb3ad41 100644 --- a/lib/libc/powerpc64/_fpmath.h +++ b/lib/libc/powerpc64/_fpmath.h @@ -28,25 +28,43 @@ union IEEEl2bits { long double e; - struct { #if _BYTE_ORDER == _LITTLE_ENDIAN - unsigned int manl :32; - unsigned int manh :20; - unsigned int exp :11; + struct { + unsigned long manl :64; + unsigned long manh :48; + unsigned int exp :15; unsigned int sign :1; + } bits; + struct { + unsigned long manl :64; + unsigned long manh :48; + unsigned int expsign :16; + } xbits; #else /* _BYTE_ORDER == _LITTLE_ENDIAN */ + struct { unsigned int sign :1; unsigned int exp :11; unsigned int manh :20; unsigned int manl :32; -#endif } bits; +#endif }; #define mask_nbit_l(u) ((void)0) #define LDBL_IMPLICIT_NBIT #define LDBL_NBIT 0 +#if _BYTE_ORDER == _LITTLE_ENDIAN +#define LDBL_MANH_SIZE 48 +#define LDBL_MANL_SIZE 64 + +#define LDBL_TO_ARRAY32(u, a) do { \ + (a)[0] = (uint32_t)(u).bits.manl; \ + (a)[1] = (uint32_t)((u).bits.manl >> 32); \ + (a)[2] = (uint32_t)(u).bits.manh; \ + (a)[3] = (uint32_t)((u).bits.manh >> 32); \ +} while(0) +#else /* _BYTE_ORDER == _LITTLE_ENDIAN */ #define LDBL_MANH_SIZE 20 #define LDBL_MANL_SIZE 32 @@ -54,3 +72,4 @@ union IEEEl2bits { (a)[0] = (uint32_t)(u).bits.manl; \ (a)[1] = (uint32_t)(u).bits.manh; \ } while(0) +#endif /* _BYTE_ORDER == _LITTLE_ENDIAN */ diff --git a/lib/libc/powerpc64/gd_qnan.h b/lib/libc/powerpc64/gd_qnan.h index 3e78a83adc71..37867d2015e5 100644 --- a/lib/libc/powerpc64/gd_qnan.h +++ b/lib/libc/powerpc64/gd_qnan.h @@ -10,13 +10,13 @@ #define d_QNAN0 0x0 #define d_QNAN1 0x7ff80000 #define ld_QNAN0 0x0 -#define ld_QNAN1 0x7ff80000 +#define ld_QNAN1 0x0 #define ld_QNAN2 0x0 -#define ld_QNAN3 0x0 +#define ld_QNAN3 0x7fff8000 #define ldus_QNAN0 0x0 #define ldus_QNAN1 0x0 #define ldus_QNAN2 0x0 -#define ldus_QNAN3 0x7ff8 +#define ldus_QNAN3 0x0 #define ldus_QNAN4 0x0 #else #define d_QNAN0 0x7ff80000 diff --git a/lib/libc/tests/gen/Makefile b/lib/libc/tests/gen/Makefile index 054b1b426b3d..14cb01aadb30 100644 --- a/lib/libc/tests/gen/Makefile +++ b/lib/libc/tests/gen/Makefile @@ -53,6 +53,7 @@ CFLAGS+= -DTEST_LONG_DOUBLE .if ${MACHINE_CPUARCH} == "aarch64" || \ ${MACHINE_CPUARCH} == "amd64" || \ ${MACHINE_CPUARCH} == "i386" || \ + ${MACHINE_ARCH} == "powerpc64le" || \ ${MACHINE_CPUARCH} == "riscv" CFLAGS+= -D__HAVE_LONG_DOUBLE .endif diff --git a/lib/libc/tests/stdlib/Makefile b/lib/libc/tests/stdlib/Makefile index a714a8cab774..0dbe059e5264 100644 --- a/lib/libc/tests/stdlib/Makefile +++ b/lib/libc/tests/stdlib/Makefile @@ -30,6 +30,7 @@ CFLAGS+= -D__HAVE_FENV .if ${MACHINE_CPUARCH} == "aarch64" || \ ${MACHINE_CPUARCH} == "amd64" || \ ${MACHINE_CPUARCH} == "i386" || \ + ${MACHINE_ARCH} == "powerpc64le" || \ ${MACHINE_CPUARCH} == "riscv" CFLAGS+= -D__HAVE_LONG_DOUBLE .endif diff --git a/lib/libcompiler_rt/Makefile.inc b/lib/libcompiler_rt/Makefile.inc index 57cfdee95541..187b1ebee76d 100644 --- a/lib/libcompiler_rt/Makefile.inc +++ b/lib/libcompiler_rt/Makefile.inc @@ -4,6 +4,12 @@ CRTARCH= ${MACHINE_CPUARCH:C/amd64/x86_64/:C/powerpc/ppc/} CRTSRC= ${SRCTOP}/contrib/llvm-project/compiler-rt/lib/builtins +.if ${MACHINE_ARCH} == "powerpc64le" +# Long double is IEEE binary128. Search the generic builtins first so the +# IEEE-128 sources win over the IBM double-double versions of the same file +# names in the ppc/ directory. +.PATH: ${CRTSRC} +.endif .PATH: ${CRTSRC}/${CRTARCH} .PATH: ${CRTSRC} @@ -207,6 +213,59 @@ SRCF+= trunctfhf2 SRCF+= trunctfsf2 .endif +# +# IEEE binary128 long double support for powerpc64le. PowerPC names the +# IEEE-128 soft-float builtins with a "kf" infix (KFmode) instead of the +# generic "tf" (see clang's PPCSystemLibrary in RuntimeLibcalls.td), so build +# the generic IEEE-128 sources but rename each exported symbol to its kf name. +# The .PATH reordering above makes these resolve to the generic implementations +# rather than the IBM double-double versions in ppc/. +# +.if ${MACHINE_ARCH} == "powerpc64le" +.for _f _old _new in \ + addtf3 __addtf3 __addkf3 \ + subtf3 __subtf3 __subkf3 \ + multf3 __multf3 __mulkf3 \ + divtf3 __divtf3 __divkf3 \ + powitf2 __powitf2 __powikf2 \ + extendsftf2 __extendsftf2 __extendsfkf2 \ + extenddftf2 __extenddftf2 __extenddfkf2 \ + trunctfsf2 __trunctfsf2 __trunckfsf2 \ + trunctfdf2 __trunctfdf2 __trunckfdf2 \ + fixtfsi __fixtfsi __fixkfsi \ + fixtfdi __fixtfdi __fixkfdi \ + fixtfti __fixtfti __fixkfti \ + fixunstfsi __fixunstfsi __fixunskfsi \ + fixunstfdi __fixunstfdi __fixunskfdi \ + fixunstfti __fixunstfti __fixunskfti \ + floatsitf __floatsitf __floatsikf \ + floatditf __floatditf __floatdikf \ + floattitf __floattitf __floattikf \ + floatunsitf __floatunsitf __floatunsikf \ + floatunditf __floatunditf __floatundikf \ + floatuntitf __floatuntitf __floatuntikf +SRCF+= ${_f} +CFLAGS.${_f}.c+= -D${_old}=${_new} +.endfor + +# subtf3.c implements __subtf3 as __addtf3(a, -b), so its hardcoded call to +# __addtf3 must also be renamed to resolve to the kf-named add. +CFLAGS.subtf3.c+= -D__addtf3=__addkf3 + +# Complex IEEE-128 multiply/divide keep the generic tf names: PowerPC does not +# override MUL_C128/DIV_C128, so clang emits __multc3/__divtc3 for IEEE-128. +SRCF+= divtc3 +SRCF+= multc3 + +# The kf comparisons cannot use a -D rename of comparetf2.c because its internal +# COMPILER_RT_ALIAS stringizes the (unrenamed) target name; provide them here. +# comparekf2.c is FreeBSD-local, so put its directory on .PATH: this fragment is +# also .include'd by libgcc_s/libgcc_eh, whose .CURDIR differs from ours. +.PATH: ${SRCTOP}/lib/libcompiler_rt +SRCS+= comparekf2.c +CFLAGS.comparekf2.c+= -I${CRTSRC} +.endif + # These are already shipped by libc.a on some architectures. .if ${MACHINE_CPUARCH} != "riscv" SRCF+= adddf3 diff --git a/lib/libcompiler_rt/comparekf2.c b/lib/libcompiler_rt/comparekf2.c new file mode 100644 index 000000000000..bee74911c5db --- /dev/null +++ b/lib/libcompiler_rt/comparekf2.c @@ -0,0 +1,43 @@ +//===-- comparekf2.c - IEEE-128 comparisons for powerpc64le -----*- C -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// PowerPC names the IEEE binary128 comparison soft-float routines with a "kf" +// infix instead of the generic "tf". The semantics are identical to the +// generic comparetf2.c routines; only the exported names differ. We provide +// them here because comparetf2.c cannot be reused via a -D rename: its libgcc +// compatibility aliases stringize the (unrenamed) target symbol name. +// +// __lekf2(a,b) returns -1 if a < b, 0 if a == b, 1 if a > b, 1 if NaN +// __gekf2(a,b) returns -1 if a < b, 0 if a == b, 1 if a > b, -1 if NaN +// __unordkf2(a,b) returns 1 if either operand is NaN, 0 otherwise +// +//===----------------------------------------------------------------------===// + +#define QUAD_PRECISION +#include "fp_lib.h" + +#if defined(CRT_HAS_TF_MODE) +#include "fp_compare_impl.inc" + +COMPILER_RT_ABI CMP_RESULT __eqkf2(fp_t a, fp_t b) { return __leXf2__(a, b); } + +COMPILER_RT_ABI CMP_RESULT __nekf2(fp_t a, fp_t b) { return __leXf2__(a, b); } + +COMPILER_RT_ABI CMP_RESULT __ltkf2(fp_t a, fp_t b) { return __leXf2__(a, b); } + +COMPILER_RT_ABI CMP_RESULT __lekf2(fp_t a, fp_t b) { return __leXf2__(a, b); } + +COMPILER_RT_ABI CMP_RESULT __gtkf2(fp_t a, fp_t b) { return __geXf2__(a, b); } + +COMPILER_RT_ABI CMP_RESULT __gekf2(fp_t a, fp_t b) { return __geXf2__(a, b); } + +COMPILER_RT_ABI CMP_RESULT __unordkf2(fp_t a, fp_t b) { + return __unordXf2__(a, b); +} + +#endif diff --git a/lib/libcxxrt/Makefile b/lib/libcxxrt/Makefile index 0f203b3a7cb1..4a61e84be79f 100644 --- a/lib/libcxxrt/Makefile +++ b/lib/libcxxrt/Makefile @@ -33,11 +33,19 @@ VERSION_MAP= Version-32.map VERSION_MAP= Version-64.map .endif +# On powerpc64le long double is IEEE binary128, which clang mangles as +# u9__ieee128 ("__ieee128" demangled) instead of the generic "long double" (e). +# Rewrite the typeinfo entries so the version script matches the emitted symbols. +LDBL_SED= +.if ${MACHINE_ARCH} == "powerpc64le" +LDBL_SED= -e 's/long double/__ieee128/g' +.endif + Version-32.map: Version.map - sed 's/%%NEW_DELETE_TYPE%%/int/' ${.ALLSRC} > ${.TARGET} + sed -e 's/%%NEW_DELETE_TYPE%%/int/' ${LDBL_SED} ${.ALLSRC} > ${.TARGET} Version-64.map: Version.map - sed 's/%%NEW_DELETE_TYPE%%/long/' ${.ALLSRC} > ${.TARGET} + sed -e 's/%%NEW_DELETE_TYPE%%/long/' ${LDBL_SED} ${.ALLSRC} > ${.TARGET} .endif .include diff --git a/lib/msun/powerpc/Makefile.inc b/lib/msun/powerpc/Makefile.inc index 2ae9bacdaab0..d0e6078e358c 100644 --- a/lib/msun/powerpc/Makefile.inc +++ b/lib/msun/powerpc/Makefile.inc @@ -1 +1,8 @@ +.if ${MACHINE_ARCH} == "powerpc64le" +LDBL_PREC = 113 +ARCH_SRCS = ld128_compat.c +CFLAGS.ld128_compat.c+= -fno-builtin +SYM_MAPS+= ${.CURDIR}/${ARCH_SUBDIR}/Symbol_f128.map +.else LDBL_PREC = 53 +.endif diff --git a/lib/msun/powerpc/Symbol_f128.map b/lib/msun/powerpc/Symbol_f128.map new file mode 100644 index 000000000000..b81feb838007 --- /dev/null +++ b/lib/msun/powerpc/Symbol_f128.map @@ -0,0 +1,35 @@ +/* + */ +FBSD_1.9 { + acosf128; + asinf128; + atanf128; + atan2f128; + ceilf128; + cosf128; + coshf128; + expf128; + exp2f128; + floorf128; + fmaf128; + fmaxf128; + fminf128; + fmodf128; + ldexpf128; + llroundf128; + logf128; + log10f128; + log2f128; + lroundf128; + modff128; + nearbyintf128; + powf128; + rintf128; + sincosf128; + sinf128; + sinhf128; + sqrtf128; + tanf128; + tanhf128; + truncf128; +}; diff --git a/lib/msun/powerpc/ld128_compat.c b/lib/msun/powerpc/ld128_compat.c new file mode 100644 index 000000000000..b60885c2883d --- /dev/null +++ b/lib/msun/powerpc/ld128_compat.c @@ -0,0 +1,42 @@ +/* + * On powerpc64le, long double is IEEE binary128, which the compiler treats as + * _Float128. clang lowers long double libm calls to the f128-suffixed entry + * points (sinf128, powf128, ...) rather than the *l names. Provide those entry + * points as thin forwarders to the existing long double implementations. + * + * This file is compiled with -fno-builtin so the calls below are not themselves + * rewritten back to the f128 names, which would recurse infinitely. + */ +#include + +long double acosf128(long double x) { return acosl(x); } +long double asinf128(long double x) { return asinl(x); } +long double atanf128(long double x) { return atanl(x); } +long double atan2f128(long double y, long double x) { return atan2l(y, x); } +long double ceilf128(long double x) { return ceill(x); } +long double cosf128(long double x) { return cosl(x); } +long double coshf128(long double x) { return coshl(x); } +long double expf128(long double x) { return expl(x); } +long double exp2f128(long double x) { return exp2l(x); } +long double floorf128(long double x) { return floorl(x); } +long double fmaf128(long double x, long double y, long double z) { return fmal(x, y, z); } +long double fmaxf128(long double x, long double y) { return fmaxl(x, y); } +long double fminf128(long double x, long double y) { return fminl(x, y); } +long double fmodf128(long double x, long double y) { return fmodl(x, y); } +long double ldexpf128(long double x, int n) { return ldexpl(x, n); } +long long llroundf128(long double x) { return llroundl(x); } +long double logf128(long double x) { return logl(x); } +long double log10f128(long double x) { return log10l(x); } +long double log2f128(long double x) { return log2l(x); } +long lroundf128(long double x) { return lroundl(x); } +long double modff128(long double x, long double *iptr) { return modfl(x, iptr); } +long double nearbyintf128(long double x) { return nearbyintl(x); } +long double powf128(long double x, long double y) { return powl(x, y); } +long double rintf128(long double x) { return rintl(x); } +void sincosf128(long double x, long double *s, long double *c) { sincosl(x, s, c); } +long double sinf128(long double x) { return sinl(x); } +long double sinhf128(long double x) { return sinhl(x); } +long double sqrtf128(long double x) { return sqrtl(x); } +long double tanf128(long double x) { return tanl(x); } +long double tanhf128(long double x) { return tanhl(x); } +long double truncf128(long double x) { return truncl(x); } diff --git a/lib/msun/src/s_nearbyint.c b/lib/msun/src/s_nearbyint.c index 3dcaf98b369a..6558ab0358b4 100644 --- a/lib/msun/src/s_nearbyint.c +++ b/lib/msun/src/s_nearbyint.c @@ -29,6 +29,8 @@ #include #include +#pragma STDC FENV_ACCESS ON + /* * We save and restore the floating-point environment to avoid raising * an inexact exception. We can get away with using fesetenv() @@ -36,9 +38,12 @@ * because the only exception defined for rint() is overflow, and * rounding can't overflow as long as emax >= p. * - * The volatile keyword is needed below because clang incorrectly assumes - * that rint won't raise any floating-point exceptions. Declaring ret volatile - * is sufficient to trick the compiler into doing the right thing. + * FENV_ACCESS ON is required so the compiler does not move the rounding + * (which it may inline as a hardware round-to-integer instruction) across + * the fegetenv()/fesetenv() calls. Without it, clang hoists the rounding + * before fegetenv() on the binary128 path, so the saved environment already + * carries the inexact flag and fesetenv() restores it, leaking the exception. + * The volatile keyword on ret is kept as a belt-and-suspenders guard. */ #define DECL(type, fn, rint) \ type \ diff --git a/lib/msun/tests/Makefile b/lib/msun/tests/Makefile index d723e0aaf656..5d8537c74a0a 100644 --- a/lib/msun/tests/Makefile +++ b/lib/msun/tests/Makefile @@ -13,6 +13,7 @@ CFLAGS+= -I${TESTSRC:H}/libc/gen .if ${MACHINE_CPUARCH} == "aarch64" || \ ${MACHINE_CPUARCH} == "amd64" || \ ${MACHINE_CPUARCH} == "i386" || \ + ${MACHINE_ARCH} == "powerpc64le" || \ ${MACHINE_CPUARCH} == "riscv" CFLAGS+= -D__HAVE_LONG_DOUBLE .endif diff --git a/sys/powerpc/include/float.h b/sys/powerpc/include/float.h index 58ecbcfed74e..737d283ecf38 100644 --- a/sys/powerpc/include/float.h +++ b/sys/powerpc/include/float.h @@ -80,6 +80,22 @@ __END_DECLS #define DBL_HAS_SUBNORM 1 #endif /* __ISO_C_VISIBLE >= 2011 */ +#if __LDBL_MANT_DIG__ == 113 +#define LDBL_MANT_DIG 113 +#define LDBL_EPSILON 1.925929944387235853055977942584927319E-34L +#define LDBL_DIG 33 +#define LDBL_MIN_EXP (-16381) +#define LDBL_MIN 3.362103143112093506262677817321752603E-4932L +#define LDBL_MIN_10_EXP (-4931) +#define LDBL_MAX_EXP (+16384) +#define LDBL_MAX 1.189731495357231765085759326628007016E+4932L +#define LDBL_MAX_10_EXP (+4932) +#if __ISO_C_VISIBLE >= 2011 +#define LDBL_TRUE_MIN 6.475175119438025110924438958227646552E-4966L +#define LDBL_DECIMAL_DIG 36 +#define LDBL_HAS_SUBNORM 1 +#endif /* __ISO_C_VISIBLE >= 2011 */ +#else #define LDBL_MANT_DIG DBL_MANT_DIG #define LDBL_EPSILON ((long double)DBL_EPSILON) #define LDBL_DIG DBL_DIG @@ -94,5 +110,6 @@ __END_DECLS #define LDBL_DECIMAL_DIG DBL_DECIMAL_DIG #define LDBL_HAS_SUBNORM DBL_HAS_SUBNORM #endif /* __ISO_C_VISIBLE >= 2011 */ +#endif /* __LDBL_MANT_DIG__ == 113 */ #endif /* _MACHINE_FLOAT_H_ */ diff --git a/sys/sys/param.h b/sys/sys/param.h index dbe80ca05c68..7c3d02f842f9 100644 --- a/sys/sys/param.h +++ b/sys/sys/param.h @@ -74,7 +74,7 @@ * cannot include sys/param.h and should only be updated here. */ #undef __FreeBSD_version -#define __FreeBSD_version 1600017 +#define __FreeBSD_version 1600018 /* * __FreeBSD_kernel__ indicates that this system uses the kernel of FreeBSD,