gdb/testsuite/gdb.base/m32r.ld

   1 OUTPUT_FORMAT("elf32-m32r", "elf32-m32r",
   2               "elf32-m32r")
   3 OUTPUT_ARCH(m32r)
   4 ENTRY(_start)
   5
   6 MEMORY
   7 {
   8   RAM : ORIGIN = 0x208000, LENGTH = 0x100000
   9   OVLY_1 : ORIGIN = 0x300000, LENGTH = 0x40000
  10   OVLY_2 : ORIGIN = 0x340000, LENGTH = 0x40000
  11   OVLY_3 : ORIGIN = 0x380000, LENGTH = 0x40000
  12   OVLY_4 : ORIGIN = 0x3c0000, LENGTH = 0x40000
  13   OVLY_STORAGE : ORIGIN = 0x400000, LENGTH = 0x100000
  14 }
  15
  16 /* Do we need any of these for elf?
  17    __DYNAMIC = 0;    */
  18 SECTIONS
  19 {
  20    OVERLAY :
  21       {
  22         .ovly0 { */overlays2.o(.text) }
  23         .ovly1 { */overlays3.o(.text) }
  24       } >OVLY_1 AT>OVLY_STORAGE
  25    OVERLAY :
  26       {
  27         .ovly2 { */overlays4.o(.text) }
  28         .ovly3 { */overlays5.o(.text) }
  29       } >OVLY_3 AT>OVLY_STORAGE
  30    OVERLAY :
  31       {
  32         .data00 { */overlays2.o(.data) }
  33         .data01 { */overlays3.o(.data) }
  34       } >OVLY_2 AT>OVLY_STORAGE
  35    OVERLAY :
  36       {
  37         .data02 { */overlays4.o(.data) }
  38         .data03 { */overlays5.o(.data) }
  39       } >OVLY_4 AT>OVLY_STORAGE
  40
  41   /* Read-only sections, merged into text segment: */
  42   .interp        : { *(.interp)         }
  43   .hash          : { *(.hash)           }
  44   .dynsym        : { *(.dynsym)         }
  45   .dynstr        : { *(.dynstr)         }
  46   .rel.text      : { *(.rel.text)       }
  47   .rela.text     : { *(.rela.text)      }
  48   .rel.data      : { *(.rel.data)       }
  49   .rela.data     : { *(.rela.data)      }
  50   .rel.rodata    : { *(.rel.rodata)     }
  51   .rela.rodata   : { *(.rela.rodata)    }
  52   .rel.got       : { *(.rel.got)        }
  53   .rela.got      : { *(.rela.got)       }
  54   .rel.ctors     : { *(.rel.ctors)      }
  55   .rela.ctors    : { *(.rela.ctors)     }
  56   .rel.dtors     : { *(.rel.dtors)      }
  57   .rela.dtors    : { *(.rela.dtors)     }
  58   .rel.init      : { *(.rel.init)       }
  59   .rela.init     : { *(.rela.init)      }
  60   .rel.fini      : { *(.rel.fini)       }
  61   .rela.fini     : { *(.rela.fini)      }
  62   .rel.bss       : { *(.rel.bss)        }
  63   .rela.bss      : { *(.rela.bss)       }
  64   .rel.plt       : { *(.rel.plt)        }
  65   .rela.plt      : { *(.rela.plt)       }
  66   .init          : { *(.init)           } >RAM AT>RAM =0
  67   .plt           : { *(.plt)            } >RAM AT>RAM
  68
  69   .text          :
  70   {
  71     *(.text)
  72     /* .gnu.warning sections are handled specially by elf32.em.  */
  73     *(.gnu.warning)
  74     *(.gnu.linkonce.t*)
  75   } >RAM AT>RAM =0
  76   _etext = .;
  77   PROVIDE (etext = .);
  78   .fini          : { *(.fini)           } >RAM AT>RAM =0
  79   .rodata        : { *(.rodata) *(.gnu.linkonce.r*) } >RAM AT>RAM
  80   .rodata1       : { *(.rodata1)        } >RAM AT>RAM
  81   /* Adjust the address for the data segment.  We want to adjust up to
  82      the same address within the page on the next page up.  */
  83   . = ALIGN(32) + (ALIGN(8) & (32 - 1));
  84   .data          :
  85   {
  86     *(.data)
  87     *(.gnu.linkonce.d*)
  88     _ovly_table = .;
  89       _ovly0_entry = .;
  90         LONG(ABSOLUTE(ADDR(.ovly0)));
  91         LONG(SIZEOF(.ovly0));
  92         LONG(LOADADDR(.ovly0));
  93         LONG(0);
  94       _ovly1_entry = .;
  95         LONG(ABSOLUTE(ADDR(.ovly1)));
  96         LONG(SIZEOF(.ovly1));
  97         LONG(LOADADDR(.ovly1));
  98         LONG(0);
  99       _ovly2_entry = .;
 100         LONG(ABSOLUTE(ADDR(.ovly2)));
 101         LONG(SIZEOF(.ovly2));
 102         LONG(LOADADDR(.ovly2));
 103         LONG(0);
 104       _ovly3_entry = .;
 105         LONG(ABSOLUTE(ADDR(.ovly3)));
 106         LONG(SIZEOF(.ovly3));
 107         LONG(LOADADDR(.ovly3));
 108         LONG(0);
 109       _data00_entry = .;
 110         LONG(ABSOLUTE(ADDR(.data00)));
 111         LONG(SIZEOF(.data00));
 112         LONG(LOADADDR(.data00));
 113         LONG(0);
 114       _data01_entry = .;
 115         LONG(ABSOLUTE(ADDR(.data01)));
 116         LONG(SIZEOF(.data01));
 117         LONG(LOADADDR(.data01));
 118         LONG(0);
 119       _data02_entry = .;
 120         LONG(ABSOLUTE(ADDR(.data02)));
 121         LONG(SIZEOF(.data02));
 122         LONG(LOADADDR(.data02));
 123         LONG(0);
 124       _data03_entry = .;
 125         LONG(ABSOLUTE(ADDR(.data03)));
 126         LONG(SIZEOF(.data03));
 127         LONG(LOADADDR(.data03));
 128         LONG(0);
 129     _novlys = .;
 130         LONG((_novlys - _ovly_table) / 16);
 131
 132     CONSTRUCTORS
 133   } >RAM AT>RAM
 134   .data1         : { *(.data1)          } >RAM AT>RAM
 135   .ctors         : { *(.ctors)          } >RAM AT>RAM
 136   .dtors         : { *(.dtors)          } >RAM AT>RAM
 137   .got           : { *(.got.plt) *(.got)} >RAM AT>RAM
 138   .dynamic       : { *(.dynamic)        } >RAM AT>RAM
 139   /* We want the small data sections together, so single-instruction offsets
 140      can access them all, and initialized data all before uninitialized, so
 141      we can shorten the on-disk segment size.  */
 142   .sdata         : { *(.sdata)          } >RAM AT>RAM
 143   _edata  =  .;
 144   PROVIDE (edata = .);
 145   __bss_start = .;
 146   .sbss          : { *(.sbss) *(.scommon) } >RAM AT>RAM
 147   .bss           : { *(.dynbss) *(.bss) *(COMMON) } >RAM AT>RAM
 148   _end = . ;
 149   PROVIDE (end = .);
 150   /* Stabs debugging sections.  */
 151   .stab 0        : { *(.stab)           }
 152   .stabstr 0     : { *(.stabstr)        }
 153   .stab.excl 0   : { *(.stab.excl)      }
 154   .stab.exclstr 0 : { *(.stab.exclstr)  }
 155   .stab.index 0  : { *(.stab.index)     }
 156   .stab.indexstr 0 : { *(.stab.indexstr) }
 157   .comment 0     : { *(.comment)        }
 158   /* DWARF debug sections.
 159      Symbols in the .debug DWARF section are relative to the beginning of the
 160      section so we begin .debug at 0.  It's not clear yet what needs to happen
 161      for the others.   */
 162   .debug          0 : { *(.debug)         }
 163   .debug_srcinfo  0 : { *(.debug_srcinfo) }
 164   .debug_aranges  0 : { *(.debug_aranges) }
 165   .debug_pubnames 0 : { *(.debug_pubnames) }
 166   .debug_sfnames  0 : { *(.debug_sfnames) }
 167   .line           0 : { *(.line)          }
 168   .stack   0x5ffffc : { _stack = .; *(.stack) }
 169   /* These must appear regardless of  .  */
 170 }