Adjust alignment for the devtab and linker funcs
authorKevin Klues <klueska@cs.berkeley.edu>
Wed, 17 Dec 2014 21:59:38 +0000 (13:59 -0800)
committerBarret Rhoden <brho@cs.berkeley.edu>
Wed, 31 Dec 2014 18:03:09 +0000 (13:03 -0500)
The new gcc apparently wants us to have 64 bit alignment for the devtab.
We oblige accordingly.  Also changed the alignment for the linker
function sections preemptively.  Not as clear whether we needed to do
this or not, but the change was necessary for the devtab.

kern/include/ns.h
kern/linker_tables.ld

index 614969d..07c1413 100644 (file)
@@ -427,8 +427,8 @@ struct dev {
        void (*power) (int);            /* power mgt: power(1) → on, power (0) → off */
 //  int (*config)( int unused_int, char *unused_char_p_t, DevConf*);
        char *(*chaninfo) (struct chan *, char *, size_t);
-       /* we need to be aligned, i think to 32 bytes, for the linker tables. */
-} __attribute__ ((aligned(32)));
+       /* we need to be aligned, we think to 64 bytes, for the linker tables. */
+} __attribute__ ((aligned(64)));
 
 struct dirtab {
        char name[KNAMELEN];
index 8701179..aed648b 100644 (file)
@@ -1,9 +1,9 @@
 /* this is INCLUDEd into the arch-specific ld scripts */
 
-       /* Linker-made tables.  Our tables (e.g. devtab) are 2^5 aligned,
+       /* Linker-made tables.  Our tables (e.g. devtab) are 2^6 aligned,
         * independently of us aligning '.'.  We align '.' to get the right start,
         * e.g.  __devtabstart. */
-       . = ALIGN(32);
+       . = 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(__devtabend = .);
 
-       . = ALIGN(32);
+       /* 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 : {
                *(.linkerfunc1)
        }
        PROVIDE(__linkerfunc1end = .);
 
-       . = ALIGN(32);
+       . = ALIGN(64);
        PROVIDE(__linkerfunc2start = .);
        .linkerfunc2 : {
                *(.linkerfunc2)
        }
        PROVIDE(__linkerfunc2end = .);
 
-       . = ALIGN(32);
+       . = ALIGN(64);
        PROVIDE(__linkerfunc3start = .);
        .linkerfunc3 : {
                *(.linkerfunc3)
        }
        PROVIDE(__linkerfunc3end = .);
 
-       . = ALIGN(32);
+       . = ALIGN(64);
        PROVIDE(__linkerfunc4start = .);
        .linkerfunc4 : {
                *(.linkerfunc4)