Merge branch 'kbuild' of git://git.kernel.org/pub/scm/linux/kernel/git/mmarek/kbuild

Pull kbuild updates from Michal Marek:

 - EXPORT_SYMBOL for asm source by Al Viro.

   This does bring a regression, because genksyms no longer generates
   checksums for these symbols (CONFIG_MODVERSIONS). Nick Piggin is
   working on a patch to fix this.

   Plus, we are talking about functions like strcpy(), which rarely
   change prototypes.

 - Fixes for PPC fallout of the above by Stephen Rothwell and Nick
   Piggin

 - fixdep speedup by Alexey Dobriyan.

 - preparatory work by Nick Piggin to allow architectures to build with
   -ffunction-sections, -fdata-sections and --gc-sections

 - CONFIG_THIN_ARCHIVES support by Stephen Rothwell

 - fix for filenames with colons in the initramfs source by me.

* 'kbuild' of git://git.kernel.org/pub/scm/linux/kernel/git/mmarek/kbuild: (22 commits)
  initramfs: Escape colons in depfile
  ppc: there is no clear_pages to export
  powerpc/64: whitelist unresolved modversions CRCs
  kbuild: -ffunction-sections fix for archs with conflicting sections
  kbuild: add arch specific post-link Makefile
  kbuild: allow archs to select link dead code/data elimination
  kbuild: allow architectures to use thin archives instead of ld -r
  kbuild: Regenerate genksyms lexer
  kbuild: genksyms fix for typeof handling
  fixdep: faster CONFIG_ search
  ia64: move exports to definitions
  sparc32: debride memcpy.S a bit
  [sparc] unify 32bit and 64bit string.h
  sparc: move exports to definitions
  ppc: move exports to definitions
  arm: move exports to definitions
  s390: move exports to definitions
  m68k: move exports to definitions
  alpha: move exports to actual definitions
  x86: move exports to actual definitions
  ...

5 files changed, 179 insertions, 63 deletions

diff --git a/include/asm-generic/export.h b/include/asm-generic/export.h
new file mode 100644
index 000000000000..43199a049da5
--- /dev/null
+++ b/include/asm-generic/export.h
@@ -0,0 +1,94 @@
+#ifndef __ASM_GENERIC_EXPORT_H
+#define __ASM_GENERIC_EXPORT_H
+
+#ifndef KSYM_FUNC
+#define KSYM_FUNC(x) x
+#endif
+#ifdef CONFIG_64BIT
+#define __put .quad
+#ifndef KSYM_ALIGN
+#define KSYM_ALIGN 8
+#endif
+#ifndef KCRC_ALIGN
+#define KCRC_ALIGN 8
+#endif
+#else
+#define __put .long
+#ifndef KSYM_ALIGN
+#define KSYM_ALIGN 4
+#endif
+#ifndef KCRC_ALIGN
+#define KCRC_ALIGN 4
+#endif
+#endif
+
+#ifdef CONFIG_HAVE_UNDERSCORE_SYMBOL_PREFIX
+#define KSYM(name) _##name
+#else
+#define KSYM(name) name
+#endif
+
+/*
+ * note on .section use: @progbits vs %progbits nastiness doesn't matter,
+ * since we immediately emit into those sections anyway.
+ */
+.macro ___EXPORT_SYMBOL name,val,sec
+#ifdef CONFIG_MODULES
+        .globl KSYM(__ksymtab_\name)
+        .section ___ksymtab\sec+\name,"a"
+        .balign KSYM_ALIGN
+KSYM(__ksymtab_\name):
+        __put \val, KSYM(__kstrtab_\name)
+        .previous
+        .section __ksymtab_strings,"a"
+KSYM(__kstrtab_\name):
+#ifdef CONFIG_HAVE_UNDERSCORE_SYMBOL_PREFIX
+        .asciz "_\name"
+#else
+        .asciz "\name"
+#endif
+        .previous
+#ifdef CONFIG_MODVERSIONS
+        .section ___kcrctab\sec+\name,"a"
+        .balign KCRC_ALIGN
+KSYM(__kcrctab_\name):
+        __put KSYM(__crc_\name)
+        .weak KSYM(__crc_\name)
+        .previous
+#endif
+#endif
+.endm
+#undef __put
+
+#if defined(__KSYM_DEPS__)
+
+#define __EXPORT_SYMBOL(sym, val, sec)  === __KSYM_##sym ===
+
+#elif defined(CONFIG_TRIM_UNUSED_KSYMS)
+
+#include <linux/kconfig.h>
+#include <generated/autoksyms.h>
+
+#define __EXPORT_SYMBOL(sym, val, sec)                          \
+        __cond_export_sym(sym, val, sec, config_enabled(__KSYM_##sym))
+#define __cond_export_sym(sym, val, sec, conf)                  \
+        ___cond_export_sym(sym, val, sec, conf)
+#define ___cond_export_sym(sym, val, sec, enabled)              \
+        __cond_export_sym_##enabled(sym, val, sec)
+#define __cond_export_sym_1(sym, val, sec) ___EXPORT_SYMBOL sym, val, sec
+#define __cond_export_sym_0(sym, val, sec) /* nothing */
+
+#else
+#define __EXPORT_SYMBOL(sym, val, sec) ___EXPORT_SYMBOL sym, val, sec
+#endif
+
+#define EXPORT_SYMBOL(name)                                     \
+        __EXPORT_SYMBOL(name, KSYM_FUNC(KSYM(name)),)
+#define EXPORT_SYMBOL_GPL(name)                                 \
+        __EXPORT_SYMBOL(name, KSYM_FUNC(KSYM(name)), _gpl)
+#define EXPORT_DATA_SYMBOL(name)                                \
+        __EXPORT_SYMBOL(name, KSYM(name),)
+#define EXPORT_DATA_SYMBOL_GPL(name)                            \
+        __EXPORT_SYMBOL(name, KSYM(name),_gpl)
+
+#endif
diff --git a/include/asm-generic/vmlinux.lds.h b/include/asm-generic/vmlinux.lds.h
index 3e42bcdd014b..30747960bc54 100644
--- a/include/asm-generic/vmlinux.lds.h
+++ b/include/asm-generic/vmlinux.lds.h
@@ -196,9 +196,14 @@
         *(.dtb.init.rodata)                                             \
         VMLINUX_SYMBOL(__dtb_end) = .;
 
-/* .data section */
+/*
+ * .data section
+ * LD_DEAD_CODE_DATA_ELIMINATION option enables -fdata-sections generates
+ * .data.identifier which needs to be pulled in with .data, but don't want to
+ * pull in .data..stuff which has its own requirements. Same for bss.
+ */
 #define DATA_DATA                                                       \
-        *(.data)                                                        \
+        *(.data .data.[0-9a-zA-Z_]*)                                    \
         *(.ref.data)                                                    \
         *(.data..shared_aligned) /* percpu related */                   \
         MEM_KEEP(init.data)                                             \
@@ -320,76 +325,76 @@
         /* Kernel symbol table: Normal symbols */                       \
         __ksymtab         : AT(ADDR(__ksymtab) - LOAD_OFFSET) {         \
                 VMLINUX_SYMBOL(__start___ksymtab) = .;                  \
-                *(SORT(___ksymtab+*))                                   \
+                KEEP(*(SORT(___ksymtab+*)))                             \
                 VMLINUX_SYMBOL(__stop___ksymtab) = .;                   \
         }                                                               \
                                                                         \
         /* Kernel symbol table: GPL-only symbols */                     \
         __ksymtab_gpl     : AT(ADDR(__ksymtab_gpl) - LOAD_OFFSET) {     \
                 VMLINUX_SYMBOL(__start___ksymtab_gpl) = .;              \
-                *(SORT(___ksymtab_gpl+*))                               \
+                KEEP(*(SORT(___ksymtab_gpl+*)))                         \
                 VMLINUX_SYMBOL(__stop___ksymtab_gpl) = .;               \
         }                                                               \
                                                                         \
         /* Kernel symbol table: Normal unused symbols */                \
         __ksymtab_unused  : AT(ADDR(__ksymtab_unused) - LOAD_OFFSET) {  \
                 VMLINUX_SYMBOL(__start___ksymtab_unused) = .;           \
-                *(SORT(___ksymtab_unused+*))                            \
+                KEEP(*(SORT(___ksymtab_unused+*)))                      \
                 VMLINUX_SYMBOL(__stop___ksymtab_unused) = .;            \
         }                                                               \
                                                                         \
         /* Kernel symbol table: GPL-only unused symbols */              \
         __ksymtab_unused_gpl : AT(ADDR(__ksymtab_unused_gpl) - LOAD_OFFSET) { \
                 VMLINUX_SYMBOL(__start___ksymtab_unused_gpl) = .;       \
-                *(SORT(___ksymtab_unused_gpl+*))                        \
+                KEEP(*(SORT(___ksymtab_unused_gpl+*)))                  \
                 VMLINUX_SYMBOL(__stop___ksymtab_unused_gpl) = .;        \
         }                                                               \
                                                                         \
         /* Kernel symbol table: GPL-future-only symbols */              \
         __ksymtab_gpl_future : AT(ADDR(__ksymtab_gpl_future) - LOAD_OFFSET) { \
                 VMLINUX_SYMBOL(__start___ksymtab_gpl_future) = .;       \
-                *(SORT(___ksymtab_gpl_future+*))                        \
+                KEEP(*(SORT(___ksymtab_gpl_future+*)))                  \
                 VMLINUX_SYMBOL(__stop___ksymtab_gpl_future) = .;        \
         }                                                               \
                                                                         \
         /* Kernel symbol table: Normal symbols */                       \
         __kcrctab         : AT(ADDR(__kcrctab) - LOAD_OFFSET) {         \
                 VMLINUX_SYMBOL(__start___kcrctab) = .;                  \
-                *(SORT(___kcrctab+*))                                   \
+                KEEP(*(SORT(___kcrctab+*)))                             \
                 VMLINUX_SYMBOL(__stop___kcrctab) = .;                   \
         }                                                               \
                                                                         \
         /* Kernel symbol table: GPL-only symbols */                     \
         __kcrctab_gpl     : AT(ADDR(__kcrctab_gpl) - LOAD_OFFSET) {     \
                 VMLINUX_SYMBOL(__start___kcrctab_gpl) = .;              \
-                *(SORT(___kcrctab_gpl+*))                               \
+                KEEP(*(SORT(___kcrctab_gpl+*)))                         \
                 VMLINUX_SYMBOL(__stop___kcrctab_gpl) = .;               \
         }                                                               \
                                                                         \
         /* Kernel symbol table: Normal unused symbols */                \
         __kcrctab_unused  : AT(ADDR(__kcrctab_unused) - LOAD_OFFSET) {  \
                 VMLINUX_SYMBOL(__start___kcrctab_unused) = .;           \
-                *(SORT(___kcrctab_unused+*))                            \
+                KEEP(*(SORT(___kcrctab_unused+*)))                      \
                 VMLINUX_SYMBOL(__stop___kcrctab_unused) = .;            \
         }                                                               \
                                                                         \
         /* Kernel symbol table: GPL-only unused symbols */              \
         __kcrctab_unused_gpl : AT(ADDR(__kcrctab_unused_gpl) - LOAD_OFFSET) { \
                 VMLINUX_SYMBOL(__start___kcrctab_unused_gpl) = .;       \
-                *(SORT(___kcrctab_unused_gpl+*))                        \
+                KEEP(*(SORT(___kcrctab_unused_gpl+*)))                  \
                 VMLINUX_SYMBOL(__stop___kcrctab_unused_gpl) = .;        \
         }                                                               \
                                                                         \
         /* Kernel symbol table: GPL-future-only symbols */              \
         __kcrctab_gpl_future : AT(ADDR(__kcrctab_gpl_future) - LOAD_OFFSET) { \
                 VMLINUX_SYMBOL(__start___kcrctab_gpl_future) = .;       \
-                *(SORT(___kcrctab_gpl_future+*))                        \
+                KEEP(*(SORT(___kcrctab_gpl_future+*)))                  \
                 VMLINUX_SYMBOL(__stop___kcrctab_gpl_future) = .;        \
         }                                                               \
                                                                         \
         /* Kernel symbol table: strings */                              \
         __ksymtab_strings : AT(ADDR(__ksymtab_strings) - LOAD_OFFSET) { \
-                *(__ksymtab_strings)                                    \
+                KEEP(*(__ksymtab_strings))                              \
         }                                                               \
                                                                         \
         /* __*init sections */                                          \
@@ -424,12 +429,17 @@
 #define SECURITY_INIT                                                   \
         .security_initcall.init : AT(ADDR(.security_initcall.init) - LOAD_OFFSET) { \
                 VMLINUX_SYMBOL(__security_initcall_start) = .;          \
-                *(.security_initcall.init)                              \
+                KEEP(*(.security_initcall.init))                        \
                 VMLINUX_SYMBOL(__security_initcall_end) = .;            \
         }
 
 /* .text section. Map to function alignment to avoid address changes
- * during second ld run in second ld pass when generating System.map */
+ * during second ld run in second ld pass when generating System.map
+ * LD_DEAD_CODE_DATA_ELIMINATION option enables -ffunction-sections generates
+ * .text.identifier which needs to be pulled in with .text , but some
+ * architectures define .text.foo which is not intended to be pulled in here.
+ * Those enabling LD_DEAD_CODE_DATA_ELIMINATION must ensure they don't have
+ * conflicting section names, and must pull in .text.[0-9a-zA-Z_]* */
 #define TEXT_TEXT                                                       \
                 ALIGN_FUNCTION();                                       \
                 *(.text.hot .text .text.fixup .text.unlikely)           \
@@ -533,6 +543,7 @@
 
 /* init and exit section handling */
 #define INIT_DATA                                                       \
+        KEEP(*(SORT(___kentry+*)))                                      \
         *(.init.data)                                                   \
         MEM_DISCARD(init.data)                                          \
         KERNEL_CTORS()                                                  \
@@ -599,7 +610,7 @@
                 BSS_FIRST_SECTIONS                                      \
                 *(.bss..page_aligned)                                   \
                 *(.dynbss)                                              \
-                *(.bss)                                                 \
+                *(.bss .bss.[0-9a-zA-Z_]*)                              \
                 *(COMMON)                                               \
         }
 
@@ -682,12 +693,12 @@
 
 #define INIT_CALLS_LEVEL(level)                                         \
                 VMLINUX_SYMBOL(__initcall##level##_start) = .;          \
-                *(.initcall##level##.init)                              \
-                *(.initcall##level##s.init)                             \
+                KEEP(*(.initcall##level##.init))                        \
+                KEEP(*(.initcall##level##s.init))                       \
 
 #define INIT_CALLS                                                      \
                 VMLINUX_SYMBOL(__initcall_start) = .;                   \
-                *(.initcallearly.init)                                  \
+                KEEP(*(.initcallearly.init))                            \
                 INIT_CALLS_LEVEL(0)                                     \
                 INIT_CALLS_LEVEL(1)                                     \
                 INIT_CALLS_LEVEL(2)                                     \
@@ -701,21 +712,21 @@
 
 #define CON_INITCALL                                                    \
                 VMLINUX_SYMBOL(__con_initcall_start) = .;               \
-                *(.con_initcall.init)                                   \
+                KEEP(*(.con_initcall.init))                             \
                 VMLINUX_SYMBOL(__con_initcall_end) = .;
 
 #define SECURITY_INITCALL                                               \
                 VMLINUX_SYMBOL(__security_initcall_start) = .;          \
-                *(.security_initcall.init)                              \
+                KEEP(*(.security_initcall.init))                        \
                 VMLINUX_SYMBOL(__security_initcall_end) = .;
 
 #ifdef CONFIG_BLK_DEV_INITRD
 #define INIT_RAM_FS                                                     \
         . = ALIGN(4);                                                   \
         VMLINUX_SYMBOL(__initramfs_start) = .;                          \
-        *(.init.ramfs)                                                  \
+        KEEP(*(.init.ramfs))                                            \
         . = ALIGN(8);                                                   \
-        *(.init.ramfs.info)
+        KEEP(*(.init.ramfs.info))
 #else
 #define INIT_RAM_FS
 #endif
diff --git a/include/linux/compiler.h b/include/linux/compiler.h
index 668569844d37..f1bfa15b6f9b 100644
--- a/include/linux/compiler.h
+++ b/include/linux/compiler.h
@@ -182,6 +182,29 @@ void ftrace_likely_update(struct ftrace_branch_data *f, int val, int expect);
 # define unreachable() do { } while (1)
 #endif
 
+/*
+ * KENTRY - kernel entry point
+ * This can be used to annotate symbols (functions or data) that are used
+ * without their linker symbol being referenced explicitly. For example,
+ * interrupt vector handlers, or functions in the kernel image that are found
+ * programatically.
+ *
+ * Not required for symbols exported with EXPORT_SYMBOL, or initcalls. Those
+ * are handled in their own way (with KEEP() in linker scripts).
+ *
+ * KENTRY can be avoided if the symbols in question are marked as KEEP() in the
+ * linker script. For example an architecture could KEEP() its entire
+ * boot/exception vector code rather than annotate each function and data.
+ */
+#ifndef KENTRY
+# define KENTRY(sym)                                            \
+        extern typeof(sym) sym;                                 \
+        static const unsigned long __kentry_##sym               \
+        __used                                                  \
+        __attribute__((section("___kentry" "+" #sym ), used))   \
+        = (unsigned long)&sym;
+#endif
+
 #ifndef RELOC_HIDE
 # define RELOC_HIDE(ptr, off)                                   \
   ({ unsigned long __ptr;                                       \
diff --git a/include/linux/export.h b/include/linux/export.h
index d7df4922da1d..2a0f61fbc731 100644
--- a/include/linux/export.h
+++ b/include/linux/export.h
@@ -1,5 +1,6 @@
 #ifndef _LINUX_EXPORT_H
 #define _LINUX_EXPORT_H
+
 /*
  * Export symbols from the kernel to modules.  Forked from module.h
  * to reduce the amount of pointless cruft we feed to gcc when only
@@ -42,27 +43,26 @@ extern struct module __this_module;
 #ifdef CONFIG_MODVERSIONS
 /* Mark the CRC weak since genksyms apparently decides not to
  * generate a checksums for some symbols */
-#define __CRC_SYMBOL(sym, sec)                                  \
-        extern __visible void *__crc_##sym __attribute__((weak));               \
-        static const unsigned long __kcrctab_##sym              \
-        __used                                                  \
-        __attribute__((section("___kcrctab" sec "+" #sym), unused))     \
+#define __CRC_SYMBOL(sym, sec)                                          \
+        extern __visible void *__crc_##sym __attribute__((weak));       \
+        static const unsigned long __kcrctab_##sym                      \
+        __used                                                          \
+        __attribute__((section("___kcrctab" sec "+" #sym), used))       \
         = (unsigned long) &__crc_##sym;
 #else
 #define __CRC_SYMBOL(sym, sec)
 #endif
 
 /* For every exported symbol, place a struct in the __ksymtab section */
-#define ___EXPORT_SYMBOL(sym, sec)                              \
-        extern typeof(sym) sym;                                 \
-        __CRC_SYMBOL(sym, sec)                                  \
-        static const char __kstrtab_##sym[]                     \
-        __attribute__((section("__ksymtab_strings"), aligned(1))) \
-        = VMLINUX_SYMBOL_STR(sym);                              \
-        extern const struct kernel_symbol __ksymtab_##sym;      \
-        __visible const struct kernel_symbol __ksymtab_##sym    \
-        __used                                                  \
-        __attribute__((section("___ksymtab" sec "+" #sym), unused))     \
+#define ___EXPORT_SYMBOL(sym, sec)                                      \
+        extern typeof(sym) sym;                                         \
+        __CRC_SYMBOL(sym, sec)                                          \
+        static const char __kstrtab_##sym[]                             \
+        __attribute__((section("__ksymtab_strings"), aligned(1)))       \
+        = VMLINUX_SYMBOL_STR(sym);                                      \
+        static const struct kernel_symbol __ksymtab_##sym               \
+        __used                                                          \
+        __attribute__((section("___ksymtab" sec "+" #sym), used))       \
         = { (unsigned long)&sym, __kstrtab_##sym }
 
 #if defined(__KSYM_DEPS__)
diff --git a/include/linux/init.h b/include/linux/init.h
index 5a3321a7909b..024a0b5b3ed0 100644
--- a/include/linux/init.h
+++ b/include/linux/init.h
@@ -139,24 +139,8 @@ extern bool initcall_debug;
 
 #ifndef __ASSEMBLY__
 
-#ifdef CONFIG_LTO
-/* Work around a LTO gcc problem: when there is no reference to a variable
- * in a module it will be moved to the end of the program. This causes
- * reordering of initcalls which the kernel does not like.
- * Add a dummy reference function to avoid this. The function is
- * deleted by the linker.
- */
-#define LTO_REFERENCE_INITCALL(x) \
-        ; /* yes this is needed */                      \
-        static __used __exit void *reference_##x(void)  \
-        {                                               \
-                return &x;                              \
-        }
-#else
-#define LTO_REFERENCE_INITCALL(x)
-#endif
-
-/* initcalls are now grouped by functionality into separate 
+/*
+ * initcalls are now grouped by functionality into separate
  * subsections. Ordering inside the subsections is determined
  * by link order. 
  * For backwards compatibility, initcall() puts the call in 
@@ -164,12 +148,16 @@ extern bool initcall_debug;
  *
  * The `id' arg to __define_initcall() is needed so that multiple initcalls
  * can point at the same handler without causing duplicate-symbol build errors.
+ *
+ * Initcalls are run by placing pointers in initcall sections that the
+ * kernel iterates at runtime. The linker can do dead code / data elimination
+ * and remove that completely, so the initcall sections have to be marked
+ * as KEEP() in the linker script.
  */
 
 #define __define_initcall(fn, id) \
         static initcall_t __initcall_##fn##id __used \
-        __attribute__((__section__(".initcall" #id ".init"))) = fn; \
-        LTO_REFERENCE_INITCALL(__initcall_##fn##id)
+        __attribute__((__section__(".initcall" #id ".init"))) = fn;
 
 /*
  * Early initcalls run before initializing SMP.
@@ -205,15 +193,15 @@ extern bool initcall_debug;
 
 #define __initcall(fn) device_initcall(fn)
 
-#define __exitcall(fn) \
+#define __exitcall(fn)                                          \
         static exitcall_t __exitcall_##fn __exit_call = fn
 
-#define console_initcall(fn) \
-        static initcall_t __initcall_##fn \
+#define console_initcall(fn)                                    \
+        static initcall_t __initcall_##fn                       \
         __used __section(.con_initcall.init) = fn
 
-#define security_initcall(fn) \
-        static initcall_t __initcall_##fn \
+#define security_initcall(fn)                                   \
+        static initcall_t __initcall_##fn                       \
         __used __section(.security_initcall.init) = fn
 
 struct obs_kernel_param {