Make symbols defined in linker script HIDDEN

This makes symbols defined in com32.ld and syslinux.ld HIDDEN, to
avoid collisions.  Additional linker scripts should have this done, too.

Signed-off-by: H. Peter Anvin <hpa@zytor.com>

2 files changed, 164 insertions, 164 deletions

diff --git a/com32/lib/com32.ld b/com32/lib/com32.ld
index 008e4ceb..4000ed72 100644
--- a/com32/lib/com32.ld
+++ b/com32/lib/com32.ld
@@ -12,8 +12,8 @@ SECTIONS
 {
   /* Read-only sections, merged into text segment: */
   . = 0;
-  PROVIDE (__executable_start = .);
-  PROVIDE (_stext = .);
+  HIDDEN (__executable_start = .);
+  HIDDEN (_stext = .);
 
   .init           :
   {
@@ -29,12 +29,12 @@ SECTIONS
   {
     KEEP (*(.fini))
   } =0x90909090
-  PROVIDE (_etext = .);
+  HIDDEN (_etext = .);
 
-  __rodata_start = .;
+  HIDDEN( __rodata_start = .);
   .rodata         : { *(.rodata .rodata.* .gnu.linkonce.r.*) }
   .rodata1        : { *(.rodata1) }
-  __rodata_end = .;
+  HIDDEN(__rodata_end = .);
 
   /*
    * The difference betwee .ctors/.dtors and .init_array/.fini_array
@@ -43,24 +43,24 @@ SECTIONS
    */
   . = ALIGN(4);
   .ctors          : {
-    PROVIDE (__ctors_start = .);
+    HIDDEN(__ctors_start = .);
     KEEP (*(SORT(.preinit_array*)))
     KEEP (*(SORT(.init_array*)))
     KEEP (*(SORT(.ctors*)))
-    PROVIDE (__ctors_end = .);
+    HIDDEN(__ctors_end = .);
   }
   .dtors          : {
-    PROVIDE (__dtors_start = .);
+    HIDDEN(__dtors_start = .);
     KEEP (*(SORT(.fini_array*)))
     KEEP (*(SORT(.dtors*)))
-    PROVIDE (__dtors_end = .);
+    HIDDEN(__dtors_end = .);
   }
 
   .got            : {
-    PROVIDE (__got_start = .);
+    HIDDEN(__got_start = .);
     KEEP (*(.got.plt))
     KEEP (*(.got))
-    PROVIDE (__got_end = .);
+    HIDDEN(__got_end = .);
   }
 
   /* Adjust the address for the data segment.  Avoid mixing code and
@@ -69,15 +69,15 @@ SECTIONS
 
   .data           :
   {
-    _sdata = .;
+    HIDDEN(_sdata = .);
     KEEP(*(.data .data.* .gnu.linkonce.d.*))
     SORT(CONSTRUCTORS)
     *(.data1)
     . = ALIGN(4);
-    _edata = .;
+    HIDDEN(_edata = .);
   }
 
-  __bss_start = .;
+  HIDDEN(__bss_start = .);
   .bss            :
   {
    *(.dynbss)
@@ -89,7 +89,7 @@ SECTIONS
    . = ALIGN(4);
   }
   . = ALIGN(4);
-  _end = .;
+  HIDDEN(_end = .);
 
   /* Stabs debugging sections.  */
   .stab          0 : { *(.stab) }
diff --git a/core/syslinux.ld b/core/syslinux.ld
index 700748c3..fa8c8c9b 100644
--- a/core/syslinux.ld
+++ b/core/syslinux.ld
@@ -26,7 +26,7 @@ SECTIONS
 {
 	/* Prefix structure for the compression program */
 	. = 0;
-	__module_start = .;
+	HIDDEN(__module_start = .);
 	.prefix : {
 		*(.prefix)
 	}
@@ -35,81 +35,81 @@ SECTIONS
 	. = 0x1000;
 
 	.earlybss (NOLOAD) : {
-		__earlybss_start = .;
+		HIDDEN(__earlybss_start = .);
 		*(.earlybss)
-		__earlybss_end = .;
+		HIDDEN(__earlybss_end = .);
 	}
-	__earlybss_len = ABSOLUTE(__earlybss_end) - ABSOLUTE(__earlybss_start);
-	__earlybss_dwords = (__earlybss_len + 3) >> 2;
+	HIDDEN(__earlybss_len = ABSOLUTE(__earlybss_end) - ABSOLUTE(__earlybss_start));
+	HIDDEN(__earlybss_dwords = (__earlybss_len + 3) >> 2);
 
 	. = ALIGN(4);
 	.bss16 (NOLOAD) : {
-		__bss16_start = .;
+		HIDDEN(__bss16_start = .);
 		*(.bss16)
-		__bss16_end = .;
+		HIDDEN(__bss16_end = .);
 	}
-	__bss16_len = ABSOLUTE(__bss16_end) - ABSOLUTE(__bss16_start);
-	__bss16_dwords = (__bss16_len + 3) >> 2;
+	HIDDEN(__bss16_len = ABSOLUTE(__bss16_end) - ABSOLUTE(__bss16_start));
+	HIDDEN(__bss16_dwords = (__bss16_len + 3) >> 2);
 
 	. = ALIGN(4);
  	.config : AT (__config_lma) {
-		__config_start = .;
+		HIDDEN(__config_start = .);
 		*(.config)
-		__config_end = .;
+		HIDDEN(__config_end = .);
 	}
-	__config_len = ABSOLUTE(__config_end) - ABSOLUTE(__config_start);
-	__config_dwords = (__config_len + 3) >> 2;
+	HIDDEN(__config_len = ABSOLUTE(__config_end) - ABSOLUTE(__config_start));
+	HIDDEN(__config_dwords = (__config_len + 3) >> 2);
 
 	/* Generated and/or copied code */
 
 	. = ALIGN(128);		/* Minimum separation from mutable data */
  	.replacestub : AT (__replacestub_lma) {
-		__replacestub_start = .;
+		HIDDEN(__replacestub_start = .);
 		*(.replacestub)
-		__replacestub_end = .;
+		HIDDEN(__replacestub_end = .);
 	}
-	__replacestub_len = ABSOLUTE(__replacestub_end) - ABSOLUTE(__replacestub_start);
-	__replacestub_dwords = (__replacestub_len + 3) >> 2;
+	HIDDEN(__replacestub_len = ABSOLUTE(__replacestub_end) - ABSOLUTE(__replacestub_start));
+	HIDDEN(__replacestub_dwords = (__replacestub_len + 3) >> 2);
 
 	. = ALIGN(16);
-	__gentextnr_lma = .;
+	HIDDEN(__gentextnr_lma = .);
 	.gentextnr : AT(__gentextnr_lma) {
-		__gentextnr_start = .;
+		HIDDEN(__gentextnr_start = .);
 		*(.gentextnr)
-		__gentextnr_end = .;
+		HIDDEN(__gentextnr_end = .);
 	}
-	__gentextnr_len = ABSOLUTE(__gentextnr_end) - ABSOLUTE(__gentextnr_start);
-	__gentextnr_dwords = (__gentextnr_len + 3) >> 2;
+	HIDDEN(__gentextnr_len = ABSOLUTE(__gentextnr_end) - ABSOLUTE(__gentextnr_start));
+	HIDDEN(__gentextnr_dwords = (__gentextnr_len + 3) >> 2);
 
 	. = STACK_BASE;
 	.stack16 : AT(STACK_BASE) {
-		__stack16_start = .;
+		HIDDEN(__stack16_start = .);
 		. += STACK_LEN;
-		__stack16_end = .;
+		HIDDEN(__stack16_end = .);
 	}
-	__stack16_len = ABSOLUTE(__stack16_end) - ABSOLUTE(__stack16_start);
-	__stack16_dwords = (__stack16_len + 3) >> 2;
+	HIDDEN(__stack16_len = ABSOLUTE(__stack16_end) - ABSOLUTE(__stack16_start));
+	HIDDEN(__stack16_dwords = (__stack16_len + 3) >> 2);
 
 	/* Initialized sections */
 
 	. = 0x7c00;
 	.init : {
 		FILL(0x90909090)
-		__init_start = .;
+		HIDDEN(__init_start = .);
 		*(.init)
-		__init_end = .;
+		HIDDEN(__init_end = .);
 	}
-	__init_len = ABSOLUTE(__init_end) - ABSOLUTE(__init_start);
-	__init_dwords = (__init_len + 3) >> 2;
+	HIDDEN(__init_len = ABSOLUTE(__init_end) - ABSOLUTE(__init_start));
+	HIDDEN(__init_dwords = (__init_len + 3) >> 2);
 
 	.text16 : {
 		FILL(0x90909090)
-		__text16_start = .;
+		HIDDEN(__text16_start = .);
 		*(.text16)
-		__text16_end = .;
+		HIDDEN(__text16_end = .);
 	}
-	__text16_len = ABSOLUTE(__text16_end) - ABSOLUTE(__text16_start);
-	__text16_dwords = (__text16_len + 3) >> 2;
+	HIDDEN(__text16_len = ABSOLUTE(__text16_end) - ABSOLUTE(__text16_start));
+	HIDDEN(__text16_dwords = (__text16_len + 3) >> 2);
 
 	/*
 	 * .textnr is used for 32-bit code that is used on the code
@@ -118,83 +118,83 @@ SECTIONS
 	. = ALIGN(16);
 	.textnr : {
 		FILL(0x90909090)
-		__textnr_start = .;
+		HIDDEN(__textnr_start = .);
 		*(.textnr)
-		__textnr_end = .;
+		HIDDEN(__textnr_end = .);
 	}
-	__textnr_len = ABSOLUTE(__textnr_end) - ABSOLUTE(__textnr_start);
-	__textnr_dwords = (__textnr_len + 3) >> 2;
+	HIDDEN(__textnr_len = ABSOLUTE(__textnr_end) - ABSOLUTE(__textnr_start));
+	HIDDEN(__textnr_dwords = (__textnr_len + 3) >> 2);
 
 	. = ALIGN(16);
-	__bcopyxx_start = .;
+	HIDDEN(__bcopyxx_start = .);
 
 	.bcopyxx.text : {
 		FILL(0x90909090)
-		__bcopyxx_text_start = .;
+		HIDDEN(__bcopyxx_text_start = .);
 		*(.bcopyxx.text)
-		__bcopyxx_text_end = .;
+		HIDDEN(__bcopyxx_text_end = .);
 	}
-	__bcopyxx_text_len = ABSOLUTE(__bcopyxx_text_end) - ABSOLUTE(__bcopyxx_text_start);
-	__bcopyxx_text_dwords = (__bcopyxx_text_len + 3) >> 2;
+	HIDDEN(__bcopyxx_text_len = ABSOLUTE(__bcopyxx_text_end) - ABSOLUTE(__bcopyxx_text_start));
+	HIDDEN(__bcopyxx_text_dwords = (__bcopyxx_text_len + 3) >> 2);
 
 	.bcopyxx.data : {
-		__bcopyxx_data_start = .;
+		HIDDEN(__bcopyxx_data_start = .);
 		*(.bcopyxx.text)
-		__bcopyxx_data_end = .;
+		HIDDEN(__bcopyxx_data_end = .);
 	}
-	__bcopyxx_data_len = ABSOLUTE(__bcopyxx_data_end) - ABSOLUTE(__bcopyxx_data_start);
-	__bcopyxx_data_dwords = (__bcopyxx_data_len + 3) >> 2;
+	HIDDEN(__bcopyxx_data_len = ABSOLUTE(__bcopyxx_data_end) - ABSOLUTE(__bcopyxx_data_start));
+	HIDDEN(__bcopyxx_data_dwords = (__bcopyxx_data_len + 3) >> 2);
 
-	__bcopyxx_end = .;
-	__bcopyxx_len = ABSOLUTE(__bcopyxx_end) - ABSOLUTE(__bcopyxx_start);
-	__bcopyxx_dwords = (__bcopyxx_len + 3) >> 2;
+	HIDDEN(__bcopyxx_end = .);
+	HIDDEN(__bcopyxx_len = ABSOLUTE(__bcopyxx_end) - ABSOLUTE(__bcopyxx_start));
+	HIDDEN(__bcopyxx_dwords = (__bcopyxx_len + 3) >> 2);
 
 	. = ALIGN(4);
 	.data16 : {
-	      __data16_start = .;
-	      *(.data16)
-	      __data16_end = .;
+		HIDDEN(__data16_start = .);
+		*(.data16)
+		HIDDEN(__data16_end = .);
 	}
-	__data16_len = ABSOLUTE(__data16_end) - ABSOLUTE(__data16_start);
-	__data16_dwords = (__data16_len + 3) >> 2;
+	HIDDEN(__data16_len = ABSOLUTE(__data16_end) - ABSOLUTE(__data16_start));
+	HIDDEN(__data16_dwords = (__data16_len + 3) >> 2);
 
 	. = ALIGN(4);
-	__config_lma = .;
+	HIDDEN(__config_lma = .);
 	. += SIZEOF(.config);
 
 	. = ALIGN(4);
-	__replacestub_lma = .;
+	HIDDEN(__replacestub_lma = .);
 	. += SIZEOF(.replacestub);
 
 	/* The 32-bit code loads above the non-progbits sections */
 
 	. = ALIGN(16);
-	__pm_code_lma = .;
+	HIDDEN(__pm_code_lma = .);
 
-	__high_clear_start = .;
+	HIDDEN(__high_clear_start = .);
 
 	. = ALIGN(512);
 	.adv (NOLOAD) : {
-		__adv_start = .;
+		HIDDEN(__adv_start = .);
 		*(.adv)
-		__adv_end = .;
+		HIDDEN(__adv_end = .);
 	}
-	__adv_len = ABSOLUTE(__adv_end) - ABSOLUTE(__adv_start);
-	__adv_dwords = (__adv_len + 3) >> 2;
+	HIDDEN(__adv_len = ABSOLUTE(__adv_end) - ABSOLUTE(__adv_start));
+	HIDDEN(__adv_dwords = (__adv_len + 3) >> 2);
 
 	/* Late uninitialized sections */
 
 	. = ALIGN(4);
 	.uibss (NOLOAD) : {
-		__uibss_start = .;
+		HIDDEN(__uibss_start = .);
 		*(.uibss)
-		__uibss_end = .;
+		HIDDEN(__uibss_end = .);
 	}
-	__uibss_len = ABSOLUTE(__uibss_end) - ABSOLUTE(__uibss_start);
-	__uibss_dwords = (__uibss_len + 3) >> 2;
+	HIDDEN(__uibss_len = ABSOLUTE(__uibss_end) - ABSOLUTE(__uibss_start));
+	HIDDEN(__uibss_dwords = (__uibss_len + 3) >> 2);
 
-	_end16 = .;
-	__assert_end16 = ASSERT(_end16 <= 0x10000, "64K overflow");
+	HIDDEN(_end16 = .);
+	HIDDEN(__assert_end16 = ASSERT(_end16 <= 0x10000, "64K overflow"));
 
 	/*
 	 * Special 16-bit segments
@@ -204,33 +204,33 @@ SECTIONS
 	.real_mode (NOLOAD) : {
 		*(.real_mode)
 	}
-	real_mode_seg = core_real_mode >> 4;
+	HIDDEN(real_mode_seg = core_real_mode >> 4);
 
 	. = ALIGN(65536);
 	.xfer_buf (NOLOAD) : {
 		*(.xfer_buf)
 	}
-	xfer_buf_seg = core_xfer_buf >> 4;
+	HIDDEN(xfer_buf_seg = core_xfer_buf >> 4);
 
 	/*
 	 * Used to allocate lowmem buffers from 32-bit code
 	 */
 	.lowmem (NOLOAD) : {
-		__lowmem_start = .;
+		HIDDEN(__lowmem_start = .);
 		*(.lowmem)
-		__lowmem_end = .;
+		HIDDEN(__lowmem_end = .);
 	}
-	__lowmem_len = ABSOLUTE(__lowmem_end) - ABSOLUTE(__lowmem_start);
-	__lowmem_dwords = (__lowmem_len + 3) >> 2;
+	HIDDEN(__lowmem_len = ABSOLUTE(__lowmem_end) - ABSOLUTE(__lowmem_start));
+	HIDDEN(__lowmem_dwords = (__lowmem_len + 3) >> 2);
 
-	__high_clear_end = .;
+	HIDDEN(__high_clear_end = .);
 
-	__high_clear_len = ABSOLUTE(__high_clear_end) - ABSOLUTE(__high_clear_start);
-	__high_clear_dwords = (__high_clear_len + 3) >> 2;
+	HIDDEN(__high_clear_len = ABSOLUTE(__high_clear_end) - ABSOLUTE(__high_clear_start));
+	HIDDEN(__high_clear_dwords = (__high_clear_len + 3) >> 2);
 
 	/* Start of the lowmem heap */
 	. = ALIGN(16);
-	__lowmem_heap = .;
+	HIDDEN(__lowmem_heap = .);
 
 	/*
 	 * 32-bit code.  This is a hack for the moment due to the
@@ -239,173 +239,173 @@ SECTIONS
 
 	. = 0x100000;
 
-	__pm_code_start = .;
+	HIDDEN(__pm_code_start = .);
 
-	__text_vma = .;
-	__text_lma = __pm_code_lma;
+	HIDDEN(__text_vma = .);
+	HIDDEN(__text_lma = __pm_code_lma);
 	.text : AT(__text_lma) {
 		FILL(0x90909090)
-		__text_start = .;
+		HIDDEN(__text_start = .);
 		*(.text)
 		*(.text.*)
-		__text_end = .;
+		HIDDEN(__text_end = .);
 	}
 
 	. = ALIGN(16);
 
-	__rodata_vma = .;
-	__rodata_lma = __rodata_vma + __text_lma - __text_vma;
+	HIDDEN(__rodata_vma = .);
+	HIDDEN(__rodata_lma = __rodata_vma + __text_lma - __text_vma);
 	.rodata : AT(__rodata_lma) {
-		__rodata_start = .;
+		HIDDEN(__rodata_start = .);
 		*(.rodata)
 		*(.rodata.*)
-		__rodata_end = .;
+		HIDDEN(__rodata_end = .);
 	}
 
 	. = ALIGN(4);
 
-	__ctors_vma = .;
-	__ctors_lma = __ctors_vma + __text_lma - __text_vma;
+	HIDDEN(__ctors_vma = .);
+	HIDDEN(__ctors_lma = __ctors_vma + __text_lma - __text_vma);
 	.ctors : AT(__ctors_lma) {
-		__ctors_start = .;
+		HIDDEN(__ctors_start = .);
 		KEEP (*(SORT(.preinit_array*)))
 		KEEP (*(SORT(.init_array*)))
 		KEEP (*(SORT(.ctors*)))
-		__ctors_end = .;
+		HIDDEN(__ctors_end = .);
 	}
 
-	__dtors_vma = .;
-	__dtors_lma = __dtors_vma + __text_lma - __text_vma;
+	HIDDEN(__dtors_vma = .);
+	HIDDEN(__dtors_lma = __dtors_vma + __text_lma - __text_vma);
 	.dtors : AT(__dtors_lma) {
-		__dtors_start = .;
+		HIDDEN(__dtors_start = .);
 		KEEP (*(SORT(.fini_array*)))
 		KEEP (*(SORT(.dtors*)))
-		__dtors_end = .;
+		HIDDEN(__dtors_end = .);
 	}
 
 	. = ALIGN(4);
 
-	__dynsym_vma = .;
-	__dynsym_lma = __dynsym_vma + __text_lma - __text_vma;
+	HIDDEN(__dynsym_vma = .);
+	HIDDEN(__dynsym_lma = __dynsym_vma + __text_lma - __text_vma);
 	.dynsym : AT(__dynsym_lma) {
-		__dynsym_start = .;
+		HIDDEN(__dynsym_start = .);
 		*(.dynsym)
-		__dynsym_end = .;
+		HIDDEN(__dynsym_end = .);
 	}
-	__dynsym_len = __dynsym_end - __dynsym_start;
+	HIDDEN(__dynsym_len = __dynsym_end - __dynsym_start);
 
 	. = ALIGN(4);
 
-	__dynstr_vma = .;
-	__dynstr_lma = __dynstr_vma + __text_lma - __text_vma;
+	HIDDEN(__dynstr_vma = .);
+	HIDDEN(__dynstr_lma = __dynstr_vma + __text_lma - __text_vma);
 	.dynstr : AT(__dynstr_lma) {
-		__dynstr_start = .;
+		HIDDEN(__dynstr_start = .);
 		*(.dynstr)
-		__dynstr_end = .;
+		HIDDEN(__dynstr_end = .);
 	}
-	__dynstr_len = __dynstr_end - __dynstr_start;
+	HIDDEN(__dynstr_len = __dynstr_end - __dynstr_start);
 
 	. = ALIGN(4);
 
-	__gnu_hash_vma = .;
-	__gnu_hash_lma = __gnu_hash_vma + __text_lma - __text_vma;
+	HIDDEN(__gnu_hash_vma = .);
+	HIDDEN(__gnu_hash_lma = __gnu_hash_vma + __text_lma - __text_vma);
 	.gnu.hash : AT(__gnu_hash_lma) {
-		__gnu_hash_start = .;
+		HIDDEN(__gnu_hash_start = .);
 		*(.gnu.hash)
-		__gnu_hash_end = .;
+		HIDDEN(__gnu_hash_end = .);
 	}
 
 
 	. = ALIGN(4);
 
-	__dynlink_vma = .;
-	__dynlink_lma = __dynlink_vma + __text_lma - __text_vma;
+	HIDDEN(__dynlink_vma = .);
+	HIDDEN(__dynlink_lma = __dynlink_vma + __text_lma - __text_vma);
 	.dynlink : AT(__dynlink_lma) {
-		__dynlink_start = .;
+		HIDDEN(__dynlink_start = .);
 		*(.dynlink)
-		__dynlink_end = .;
+		HIDDEN(__dynlink_end = .);
 	}
 
 	. = ALIGN(4);
 
-	__got_vma = .;
-	__got_lma = __got_vma + __text_lma - __text_vma;
+	HIDDEN(__got_vma = .);
+	HIDDEN(__got_lma = __got_vma + __text_lma - __text_vma);
 	.got : AT(__got_lma) {
-		__got_start = .;
+		HIDDEN(__got_start = .);
 		KEEP (*(.got.plt))
 		KEEP (*(.got))
-		__got_end = .;
+		HIDDEN(__got_end = .);
 	}
 
 	. = ALIGN(4);
 
-	__dynamic_vma = .;
-	__dynamic_lma = __dynamic_vma + __text_lma - __text_vma;
+	HIDDEN(__dynamic_vma = .);
+	HIDDEN(__dynamic_lma = __dynamic_vma + __text_lma - __text_vma);
 	.dynamic : AT(__dynamic_lma) {
-		__dynamic_start = .;
+		HIDDEN(__dynamic_start = .);
 		*(.dynamic)
-		__dynamic_end = .;
+		HIDDEN(__dynamic_end = .);
 	}
 
 	. = ALIGN(16);
 
-	__data_vma = .;
-	__data_lma = __data_vma + __text_lma - __text_vma;
+	HIDDEN(__data_vma = .);
+	HIDDEN(__data_lma = __data_vma + __text_lma - __text_vma);
 	.data : AT(__data_lma) {
-		__data_start = .;
+		HIDDEN(__data_start = .);
 		*(.data)
 		*(.data.*)
-		__data_end = .;
+		HIDDEN(__data_end = .);
 	}
 
-	__pm_code_end = .;
-	__pm_code_len = ABSOLUTE(__pm_code_end) - ABSOLUTE(__pm_code_start);
-	__pm_code_dwords = (__pm_code_len + 3) >> 2;
+	HIDDEN(__pm_code_end = .);
+	HIDDEN(__pm_code_len = ABSOLUTE(__pm_code_end) - ABSOLUTE(__pm_code_start));
+	HIDDEN(__pm_code_dwords = (__pm_code_len + 3) >> 2);
 
 	. = ALIGN(128);
 	
-	__bss_vma = .;
-	__bss_lma = .;		/* Dummy */
+	HIDDEN(__bss_vma = .);
+	HIDDEN(__bss_lma = .);		/* Dummy */
 	.bss (NOLOAD) : AT (__bss_lma) {
-		__bss_start = .;
+		HIDDEN(__bss_start = .);
 		*(.bss)
 		*(.bss.*)
 		*(COMMON)
-		__bss_end = .;
+		HIDDEN(__bss_end = .);
 	}
-	__bss_len = ABSOLUTE(__bss_end) - ABSOLUTE(__bss_start);
-	__bss_dwords = (__bss_len + 3) >> 2;
+	HIDDEN(__bss_len = ABSOLUTE(__bss_end) - ABSOLUTE(__bss_start));
+	HIDDEN(__bss_dwords = (__bss_len + 3) >> 2);
 
 	/* Data saved away before bss initialization */
 	. = ALIGN(128);
 
-	__savedata_vma = .;
-	__savedata_lma = .;		/* Dummy */
+	HIDDEN(__savedata_vma = .);
+	HIDDEN(__savedata_lma = .);		/* Dummy */
 	.savedata (NOLOAD) : AT (__savedata_lma) {
-		__savedata_start = .;
+		HIDDEN(__savedata_start = .);
 		*(.savedata)
 		*(.savedata.*)
-		__savedata_end = .;
+		HIDDEN(__savedata_end = .);
 	}
-	__savedata_len = ABSOLUTE(__savedata_end) - ABSOLUTE(__savedata_start);
-	__savedata_dwords = (__savedata_len + 3) >> 2;
+	HIDDEN(__savedata_len = ABSOLUTE(__savedata_end) - ABSOLUTE(__savedata_start));
+	HIDDEN(__savedata_dwords = (__savedata_len + 3) >> 2);
 
 	/* XXX: This stack should be unified with the COM32 stack */
-	__stack_vma = .;
+	HIDDEN(__stack_vma = .);
 	__stack_lma = .;	/* Dummy */
 	.stack (NOLOAD) : AT(__stack_lma) {
-		__stack_start = .;
+		HIDDEN(__stack_start = .);
 		*(.stack)
-		__stack_end = .;
+		HIDDEN(__stack_end = .);
 	}
-	__stack_len = ABSOLUTE(__stack_end) - ABSOLUTE(__stack_start);
-	__stack_dwords = (__stack_len + 3) >> 2;
+	HIDDEN(__stack_len = ABSOLUTE(__stack_end) - ABSOLUTE(__stack_start));
+	HIDDEN(__stack_dwords = (__stack_len + 3) >> 2);
 
-	_end = .;
+	HIDDEN(_end = .);
 
-	/* COM32R and kernels are loaded after our own PM code */
+	/* Heap follows after our own PM code */
 	. = ALIGN(65536);
-	free_high_memory = .;
+	HIDDEN(free_high_memory = .);
 
 	/* Stuff we don't need... */
 	/DISCARD/ : {