Initial Spring 2016 commit.

kern/include/cdefs.h

@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) 2003, 2006, 2008, 2009
+ *	The President and Fellows of Harvard College.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE UNIVERSITY OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef _CDEFS_H_
+#define _CDEFS_H_
+
+/*
+ * Some miscellaneous C language definitions and related matters.
+ */
+
+
+/*
+ * Build-time assertion. Doesn't generate any code. The error message
+ * on failure is less than ideal, but you can't have everything.
+ */
+#define COMPILE_ASSERT(x) ((void)sizeof(struct { unsigned : ((x)?1:-1); }))
+
+
+/*
+ * Handy macro for the number of elements in a static array.
+ */
+#define ARRAYCOUNT(arr) (sizeof(arr) / sizeof((arr)[0]))
+
+
+/*
+ * Tell GCC how to check printf formats. Also tell it about functions
+ * that don't return, as this is helpful for avoiding bogus warnings
+ * about uninitialized variables.
+ */
+#ifdef __GNUC__
+#define __PF(a,b) __attribute__((__format__(__printf__, a, b)))
+#define __DEAD    __attribute__((__noreturn__))
+#define __UNUSED  __attribute__((__unused__))
+#else
+#define __PF(a,b)
+#define __DEAD
+#define __UNUSED
+#endif
+
+
+/*
+ * Material for supporting inline functions.
+ *
+ * A function marked inline can be handled by the compiler in three
+ * ways: in addition to possibly inlining into the code for other
+ * functions, the compiler can (1) generate a file-static out-of-line
+ * copy of the function, (2) generate a global out-of-line copy of the
+ * function, or (3) generate no out-of-line copy of the function.
+ *
+ * None of these alone is thoroughly satisfactory. Since an inline
+ * function may or may not be inlined at the compiler's discretion, if
+ * no out-of-line copy exists the build may fail at link time with
+ * undefined symbols. Meanwhile, if the compiler is told to generate a
+ * global out-of-line copy, it will generate one such copy for every
+ * source file where the inline definition is visible; since inline
+ * functions tend to appear in header files, this leads to multiply
+ * defined symbols and build failure. The file-static option isn't
+ * really an improvement, either: one tends to get compiler warnings
+ * about inline functions that haven't been used, which for any
+ * particular source file tends to be at least some of the ones that
+ * have been defined. Furthermore, this method leads to one
+ * out-of-line copy of the inline function per source file that uses
+ * it, which not only wastes space but makes debugging painful.
+ *
+ * Therefore, we use the following scheme.
+ *
+ * In the header file containing the inline functions for the module
+ * "foo", we put
+ *
+ *      #ifndef FOO_INLINE
+ *      #define FOO_INLINE INLINE
+ *      #endif
+ *
+ * where INLINE selects the compiler behavior that does *not* generate
+ * an out-of-line version. Then we define the inline functions
+ * themselves as FOO_INLINE. This allows the compiler to inline the
+ * functions anywhere it sees fit with a minimum of hassles. Then,
+ * when compiling foo.c, before including headers we put
+ *
+ *      #define FOO_INLINE  // empty
+ *
+ * which causes the inline functions to appear as ordinary function
+ * definitions, not inline at all, when foo.c is compiled. This
+ * ensures that an out-of-line definition appears, and furthermore
+ * ensures that the out-of-line definition is the same as the inline
+ * definition.
+ *
+ * The situation is complicated further because gcc is historically
+ * not compliant with the C standard. In C99, "inline" means "do not
+ * generate an out-of-line copy" and "extern inline" means "generate a
+ * global out-of-line copy". In gcc, going back far longer than C99,
+ * the meanings were reversed. This eventually changed, but varies
+ * with compiler version and options. The macro __GNUC_STDC_INLINE__
+ * is defined if the behavior is C99-compliant.
+ *
+ * (Note that inline functions that appear only within a single source
+ * file can safely be declared "static inline"; to avoid whining from
+ * compiler in some contexts you may also want to add __UNUSED to
+ * that.)
+ */
+#if defined(__GNUC__) && !defined(__GNUC_STDC_INLINE__)
+/* gcc's non-C99 inline semantics */
+#define INLINE extern inline
+
+#elif defined(__STDC__) && __STDC_VERSION__ >= 199901L
+/* C99 */
+#define INLINE inline
+
+#else
+/* something else; static inline is safest */
+#define INLINE static __UNUSED inline
+#endif
+
+
+#endif /* _CDEFS_H_ */