Use Linux's compiler headers (XCC)
authorBarret Rhoden <brho@cs.berkeley.edu>
Wed, 11 Apr 2018 19:29:16 +0000 (15:29 -0400)
committerBarret Rhoden <brho@cs.berkeley.edu>
Mon, 30 Apr 2018 18:38:27 +0000 (14:38 -0400)
This required a few things.  The easy ones were removing our old #defines
for things that Linux's compiler headers handle, e.g. unlikely.  The
tougher things included allowing the use of 'extern inline' and using
__percpu for our own use.  See k/i/compiler.h for details.

Signed-off-by: Barret Rhoden <brho@cs.berkeley.edu>
Makefile
kern/arch/x86/trap.c
kern/include/compiler.h
kern/include/linux/compat_todo.h
kern/include/linux/compiler.h
kern/include/ros/common.h
kern/src/ktest/pb_ktests.c

index 2182e72..c4e71b0 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -363,7 +363,7 @@ CFLAGS_KERNEL += -std=gnu99 -fgnu89-inline
 CFLAGS_KERNEL += -fno-strict-aliasing -fno-omit-frame-pointer
 CFLAGS_KERNEL += -fno-stack-protector
 CFLAGS_KERNEL += -Wall -Wno-format -Wno-unused -Werror -Wreturn-type
-CFLAGS_KERNEL += -DROS_KERNEL
+CFLAGS_KERNEL += -DROS_KERNEL -D__KERNEL__
 CFLAGS_KERNEL += -include include/generated/autoconf.h -include include/common.h
 CFLAGS_KERNEL += -fplan9-extensions
 ifeq ($(CONFIG_64BIT),y)
index ea073bd..b5af403 100644 (file)
@@ -390,7 +390,7 @@ static bool nmi_check_and_hack_tf(struct hw_trapframe *hw_tf)
 
 /* Bottom half of the NMI handler.  This can be interrupted under some
  * circumstances by NMIs.  It exits by popping the hw_tf in assembly. */
-void __attribute__((noinline, noreturn))
+void noinline __attribute__((noreturn))
 __nmi_bottom_half(struct hw_trapframe *hw_tf)
 {
        struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
index 0030b6f..5159f24 100644 (file)
@@ -1,27 +1,21 @@
 #pragma once
 
-#ifdef __GNUC__
-
-#define likely(x) __builtin_expect(!!(x), 1)
-#define unlikely(x) __builtin_expect(!!(x), 0)
-#define __weak __attribute__((weak))
-
-#else /* #ifdef __GNUC__ */
-
-#define likely(x) (x)
-#define unlikely(x) (x)
-#define __weak
-
-#endif /* #ifdef __GNUC__ */
-
-#define __always_inline inline __attribute__((always_inline))
-
-#ifdef __GNUC__
-
-#define uninitialized_var(x) x = x
+/* Linux calls it __ASSEMBLY__ */
+#ifdef __ASSEMBLER__
+#define __ASSEMBLY__ 1
+#endif
 
-#elif defined(__clang__)
+/* This is a bit hokey.  It turns off the #define inline to include
+ * always_inline, which breaks our uses of "extern inline". */
+#define CONFIG_ARCH_SUPPORTS_OPTIMIZED_INLINING 1
+#define CONFIG_OPTIMIZE_INLINING 1
 
-#define uninitialized_var(x) x = *(&(x))
+/* Make sure Linux's compiler.h is only included here. */
+#define __AKAROS_COMPILER_H 1
+#include <linux/compiler.h>
+#undef __AKAROS_COMPILER_H
 
-#endif
+/* Linux uses this as a tag for the __CHECKER__ and either defined it to
+ * nothing or to some attribute.  We use it for the name of the pcpu variables
+ * .section, so need it to not be #defined yet. */
+#undef __percpu
index a0e8851..0d80a0f 100644 (file)
@@ -116,8 +116,6 @@ extern int ____ilog2_NaN;
        LOG2_UP(n)                              \
  )
 
-#define __printf(...)
-
 #define sprintf(s, fmt, ...) ({ \
        int ret = -1; \
        if (__builtin_types_compatible_p(typeof(s), char[])) \
@@ -385,14 +383,6 @@ struct device_attribute {
 #define DEFINE_MUTEX(mutexname) \
        qlock_t mutexname = QLOCK_INITIALIZER(mutexname);
 
-#define IS_ENABLED(...) (0)
-
-/* linux/compiler-gcc.h */
-#define __packed                        __attribute__((packed))
-#define __attribute_const__             __attribute__((__const__))
-#define __aligned(n)                    __attribute__((aligned(n)))
-#define __always_unused                 __attribute__((unused))
-
 /*
  * Check at compile time that something is of a particular type.
  * Always evaluates to 1 so you may use it easily in comparisons.
index 043b60d..6fa599f 100644 (file)
@@ -1,3 +1,7 @@
+#ifndef __AKAROS_COMPILER_H
+#error "Please don't include <linux/compiler.h> directly, include <compiler.h> instead."
+#endif
+
 #ifndef __LINUX_COMPILER_H
 #define __LINUX_COMPILER_H
 
@@ -228,7 +232,15 @@ void ftrace_likely_update(struct ftrace_likely_data *f, int val,
 # define __UNIQUE_ID(prefix) __PASTE(__PASTE(__UNIQUE_ID_, prefix), __LINE__)
 #endif
 
+#if 0 // AKAROS_PORT
 #include <uapi/linux/types.h>
+#else
+#include <sys/types.h>
+typedef uint8_t __u8;
+typedef uint16_t __u16;
+typedef uint32_t __u32;
+typedef uint64_t __u64;
+#endif
 
 #define __READ_ONCE_SIZE                                               \
 ({                                                                     \
index bb23ca2..7bf4958 100644 (file)
@@ -120,12 +120,6 @@ static inline bool mult_will_overflow_u64(uint64_t a, uint64_t b)
        (type*)((char*)ptr - offsetof(type, member));                             \
 })
 
-/* Force the reading/writing exactly once of x.  You may still need mbs().  See
- * http://lwn.net/Articles/508991/ for more info. */
-#define ACCESS_ONCE(x) (*(volatile typeof(x) *)&(x))
-#define READ_ONCE(x) ACCESS_ONCE(x)
-#define WRITE_ONCE(x, val) ((*(volatile typeof(x) *)&(x)) = val)
-
 /* Makes sure func is run exactly once.  Can handle concurrent callers, and
  * other callers spin til the func is complete. */
 #define run_once(func)                                                         \
@@ -157,4 +151,14 @@ do {                                                                           \
        }                                                                          \
 } while (0)
 
+#ifdef ROS_KERNEL
+#include <compiler.h>
+#else
+/* Force the reading/writing exactly once of x.  You may still need mbs().  See
+ * http://lwn.net/Articles/508991/ for more info. */
+#define ACCESS_ONCE(x) (*(volatile typeof(x) *)&(x))
+#define READ_ONCE(x) ACCESS_ONCE(x)
+#define WRITE_ONCE(x, val) ((*(volatile typeof(x) *)&(x)) = val)
+#endif
+
 #endif /* __ASSEMBLER__ */
index 4f84ed5..34dccb8 100644 (file)
@@ -1275,7 +1275,7 @@ bool test_memset(void)
        return true;
 }
 
-void __attribute__((noinline)) __longjmp_wrapper(struct jmpbuf* jb)
+void noinline __longjmp_wrapper(struct jmpbuf *jb)
 {
        asm ("");
        printk("Starting: %s\n", __FUNCTION__);