Move linker PROVIDE statements inside sections
authorBarret Rhoden <brho@cs.berkeley.edu>
Mon, 11 Jun 2018 20:01:14 +0000 (16:01 -0400)
committerBarret Rhoden <brho@cs.berkeley.edu>
Mon, 11 Jun 2018 20:01:14 +0000 (16:01 -0400)
Newer versions of binutils seem to require having the PROVIDE keyword
inside a specific section, instead of just floating between sections.

Specifically, on x86, binutils-2.30 was assigning all symbols outside a
section the value of the kernel load address (0xffffffffc2000000 or
whatever).  This included the linkerfuncs, the devtab, end, and etext.  The
bss symbols were OK.

Signed-off-by: Barret Rhoden <brho@cs.berkeley.edu>
kern/arch/riscv/kernel.ld
kern/arch/x86/kernel64.ld
kern/linker_tables.ld

index 56acaa6..521b058 100644 (file)
@@ -10,10 +10,9 @@ SECTIONS
 
        .text 0xFFFFFFFF80002000 : AT(0x2000) {
                *(.text .stub .text.* .gnu.linkonce.t.*)
+               PROVIDE(etext = .);     /* Define the 'etext' symbol to this value */
        }
 
-       PROVIDE(etext = .);     /* Define the 'etext' symbol to this value */
-
        INCLUDE kern/linker_tables.ld
        INCLUDE kern/build_id.ld
 
@@ -58,7 +57,9 @@ SECTIONS
                PROVIDE(__stop_bss = .);
        }
 
-       PROVIDE(end = .);
+       .end : {
+               PROVIDE(end = .);
+       }
 
        /DISCARD/ : {
                *(.eh_frame .note.GNU-stack)
index c1eafc3..402152e 100644 (file)
@@ -28,10 +28,9 @@ SECTIONS
 
        .text : AT(ADDR(.text) - KERN_LOAD_ADDR) {
                *(.text .stub .text.* .gnu.linkonce.t.*)
+               PROVIDE(etext = .);     /* Define the 'etext' symbol to this value */
        }
 
-       PROVIDE(etext = .);     /* Define the 'etext' symbol to this value */
-
        INCLUDE kern/linker_tables.ld
        INCLUDE kern/build_id.ld
 
@@ -41,10 +40,14 @@ SECTIONS
 
        /* TODO: add some debug info.  i hear stabs are 32 bit only, so we'll need
         * to bring in some dwarves.  for now, hack in the symbols to compile. */
-       PROVIDE(__STAB_BEGIN__ = .);
-       PROVIDE(__STAB_END__ = .);
-       PROVIDE(__STABSTR_BEGIN__ = .);
-       PROVIDE(__STABSTR_END__ = .);
+       .stab : {
+               PROVIDE(__STAB_BEGIN__ = .);
+               PROVIDE(__STAB_END__ = .);
+       }
+       .stabstr : {
+               PROVIDE(__STABSTR_BEGIN__ = .);
+               PROVIDE(__STABSTR_END__ = .);
+       }
 
        /* Adjust the address for the data segment to the next page */
        . = ALIGN(0x1000);
@@ -61,7 +64,11 @@ SECTIONS
                PROVIDE(__stop_bss = .);
        }
 
-       PROVIDE(end = .);
+       /* 'end' isn't a real section, but everything needs a name.  It'll show up
+        * as 'N' (debug) in the nm / ksyms.map output. */
+       .end : {
+               PROVIDE(end = .);
+       }
 
        /DISCARD/ : {
                *(.eh_frame .note.GNU-stack)
index aed648b..f0bef9b 100644 (file)
@@ -6,41 +6,41 @@
        . = ALIGN(64);
        /* We shouldn't have to use PROVIDE, but if we don't, we get the wrong
         * value for '.'.  And items with empty tables get the KLA (basically 0) */
-       PROVIDE(__devtabstart = .);
-       PROVIDE(devtab = .);
        .devtab : {
+               PROVIDE(__devtabstart = .);
+               PROVIDE(devtab = .);
                *(.devtab)
+               PROVIDE(__devtabend = .);
        }
-       PROVIDE(__devtabend = .);
 
        /* Not sure if these need to be aligned to 64 bytes or not.  We had to
         * change the alignment above for the devtab, so we just changed it here
         * too, but it's unclear if this is 100% necessary.  In any event, it
         * doesn't hurt anything, it just wastes some bytes in our binary. */
        . = ALIGN(64);
-       PROVIDE(__linkerfunc1start = .);
        .linkerfunc1 : {
+               PROVIDE(__linkerfunc1start = .);
                *(.linkerfunc1)
+               PROVIDE(__linkerfunc1end = .);
        }
-       PROVIDE(__linkerfunc1end = .);
 
        . = ALIGN(64);
-       PROVIDE(__linkerfunc2start = .);
        .linkerfunc2 : {
+               PROVIDE(__linkerfunc2start = .);
                *(.linkerfunc2)
+               PROVIDE(__linkerfunc2end = .);
        }
-       PROVIDE(__linkerfunc2end = .);
 
        . = ALIGN(64);
-       PROVIDE(__linkerfunc3start = .);
        .linkerfunc3 : {
+               PROVIDE(__linkerfunc3start = .);
                *(.linkerfunc3)
+               PROVIDE(__linkerfunc3end = .);
        }
-       PROVIDE(__linkerfunc3end = .);
 
        . = ALIGN(64);
-       PROVIDE(__linkerfunc4start = .);
        .linkerfunc4 : {
+               PROVIDE(__linkerfunc4start = .);
                *(.linkerfunc4)
+               PROVIDE(__linkerfunc4end = .);
        }
-       PROVIDE(__linkerfunc4end = .);