Page MenuHomeFreeBSD
Files F159184518

D57388.id179083.diff
No OneTemporary
Actions

D57388.id179083.diff
View Options

diff --git a/UPDATING b/UPDATING
--- a/UPDATING
+++ b/UPDATING
@@ -27,6 +27,18 @@
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
--- a/contrib/llvm-project/clang/lib/Basic/Targets/PPC.h
+++ b/contrib/llvm-project/clang/lib/Basic/Targets/PPC.h
@@ -468,7 +468,11 @@
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
--- a/contrib/llvm-project/clang/lib/CodeGen/CGBuiltin.cpp
+++ b/contrib/llvm-project/clang/lib/CodeGen/CGBuiltin.cpp
@@ -228,7 +228,10 @@
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
--- a/contrib/llvm-project/clang/lib/Driver/ToolChain.cpp
+++ b/contrib/llvm-project/clang/lib/Driver/ToolChain.cpp
@@ -193,6 +193,10 @@
}
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/clang/freebsd_cc_version.h b/lib/clang/freebsd_cc_version.h
--- a/lib/clang/freebsd_cc_version.h
+++ b/lib/clang/freebsd_cc_version.h
@@ -1 +1 @@
-#define FREEBSD_CC_VERSION 1600001
+#define FREEBSD_CC_VERSION 1600002
diff --git a/lib/libc/powerpc64/Makefile.inc b/lib/libc/powerpc64/Makefile.inc
--- 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
--- 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 @@
(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
--- 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
--- a/lib/libc/tests/gen/Makefile
+++ b/lib/libc/tests/gen/Makefile
@@ -53,6 +53,7 @@
.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
--- a/lib/libc/tests/stdlib/Makefile
+++ b/lib/libc/tests/stdlib/Makefile
@@ -30,6 +30,7 @@
.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
--- a/lib/libcompiler_rt/Makefile.inc
+++ b/lib/libcompiler_rt/Makefile.inc
@@ -4,6 +4,12 @@
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+= 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
--- /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
--- a/lib/libcxxrt/Makefile
+++ b/lib/libcxxrt/Makefile
@@ -33,11 +33,19 @@
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 <bsd.lib.mk>
diff --git a/lib/msun/powerpc/Makefile.inc b/lib/msun/powerpc/Makefile.inc
--- 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
--- /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
--- /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 <math.h>
+
+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
--- a/lib/msun/src/s_nearbyint.c
+++ b/lib/msun/src/s_nearbyint.c
@@ -29,6 +29,8 @@
#include <fenv.h>
#include <math.h>
+#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
--- a/lib/msun/tests/Makefile
+++ b/lib/msun/tests/Makefile
@@ -13,6 +13,7 @@
.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
--- a/sys/powerpc/include/float.h
+++ b/sys/powerpc/include/float.h
@@ -80,6 +80,22 @@
#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 @@
#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
--- 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,

File Metadata

Mime Type
text/plain
Expires
Fri, Jun 12, 1:31 AM (2 h, 53 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
33896518
Default Alt Text
D57388.id179083.diff (18 KB)

Event Timeline