ld/scripttempl/avr.sc

   1 # Copyright (C) 2014-2025 Free Software Foundation, Inc.
   2 #
   3 # Copying and distribution of this file, with or without modification,
   4 # are permitted in any medium without royalty provided the copyright
   5 # notice and this notice are preserved.
   6
   7 # RODATA_PM_OFFSET
   8 #         If empty and not HAVE_FLMAP, .rodata sections will be part of .data.
   9 #         This is for devices where it is not possible to use LD* instructions
  10 #         to read from flash.
  11 #
  12 #         If non-empty, .rodata is not part of .data and the .rodata
  13 #         objects are assigned addresses at an offest of RODATA_PM_OFFSET.
  14 #         This is for devices that feature reading from flash by means of
  15 #         LD* instructions, provided the addresses are offset by
  16 #         __RODATA_PM_OFFSET__ (which defaults to RODATA_PM_OFFSET).
  17
  18 # HAVE_FLMAP
  19 #         The .rodata section is located in program memory. Devices from
  20 #         the AVR64* and AVR128* families (from avrxmega2 and avrxmega4)
  21 #         see a 32k segment of their program memory in their RAM address
  22 #         space.  Which 32k segment is visible is determined by the
  23 #         bit-field NVMCTRL_CTRLB.FLMAP.
  24 #         Output section .rodata is placed in MEMORY region rodata.
  25 #         The LMA of the .rodata section can be set by means of:
  26 #         * __RODATA_FLASH_START__ specifies the byte address of the
  27 #           rodata LMA.
  28 #         * __flmap specifies which 32k block is visible in RAM provided
  29 #           __RODATA_FLASH_START__ is undefined
  30 #         * When __flmap and __RODATA_FLASH_START__ are undefined, then an
  31 #           emulation-specific default is used (the last 32k block).
  32
  33 # MAYBE_FLMAP
  34 #         For devices from avrxmega2 and avrxmega4: The user can chose whether
  35 #         or not .rodata is located in flash (if HAVE_FLMAP) or located in
  36 #         in RAM (if not HAVE_FLMAP by means of -mrodata-in-ram).  This is
  37 #         achieved by new emulations avrxmega2_flmap and avrxmega4_flmap that
  38 #         are selected by compiler option -mno-rodata-in-ram.
  39 #
  40 #         In order to facilitate initialization of NVMCTRL_CTRLB.FLMAP and
  41 #         NVMCTRL_CTRLB.FLMAPLOCK in the startup code irrespective of
  42 #         HAVE_FLMAP, the following symbols are used / defined in order to
  43 #         communicate with the startup code.
  44 #         Notice that the hardware default for FLMAP is the last 32k block,
  45 #         so that explicit initialization of FLMAP is only required when the
  46 #         user wants to deviate from the defaults.
  47 #
  48 #         __flmap = HAVE_FLMAP
  49 #                   ? given by __flmap resp. __RODATA_FLASH_START__ >> 15
  50 #                   : 0;
  51 #
  52 #         __flmap_value = __flmap << __flmap_bpos;
  53 #
  54 #         __flmap_value_with_lock = __flmap__value | __flmap_lock_mask;
  55 #
  56 #         __flmap_init_label = HAVE_FLMAP
  57 #                              ? __flmap_init_start
  58 #                              : __flmap_noinit_start;
  59 #             Supposed to be used as a jump target for RJMP so that the code
  60 #             can initialize FLMAP / skip initialization of FLMAP depending
  61 #             on the chosen emulation, and without the need to support two code
  62 #             versions of crt<mcu>.o for the two possible emulations.
  63 #
  64 #         __flmap_lock is a bool provided by the user when FLMAP should be
  65 #             protected from any further changes.
  66 #
  67 #         __flmap_lock_mask is an 8-bit mask like NVMCTRL_FLMAPLOCK_bm
  68 #             provided by the user which is set in __flmap_value_with_lock
  69 #             when __flmap_lock is on.
  70 #
  71 #         __do_init_flmap = HAVE_FLMAP ? 1 : 0;
  72 #             Whether or not FLMAP is supposed to be initialized according
  73 #             to, and for the purpose of, .rodata in flash.
  74 #
  75 #         Apart from that, the compiler (device-specs actually) defines the
  76 #         following macros:
  77 #
  78 #         __AVR_HAVE_FLMAP__
  79 #             Defined if a device has the NVMCTRL_CTRLB.FLMAP bitfield
  80 #             *AND* if it's unknown at compile-time / assembler-time whether
  81 #             emulation avrxmega* is used or avrxmega*_flmap.
  82
  83 cat <<EOF
  84 /* Copyright (C) 2014-2025 Free Software Foundation, Inc.
  85
  86    Copying and distribution of this script, with or without modification,
  87    are permitted in any medium without royalty provided the copyright
  88    notice and this notice are preserved.  */
  89
  90 OUTPUT_FORMAT("${OUTPUT_FORMAT}","${OUTPUT_FORMAT}","${OUTPUT_FORMAT}")
  91 OUTPUT_ARCH(${ARCH})
  92 EOF
  93
  94 test -n "${RELOCATING}" && cat <<EOF
  95 __TEXT_REGION_ORIGIN__ = DEFINED(__TEXT_REGION_ORIGIN__) ? __TEXT_REGION_ORIGIN__ : 0;
  96 __TEXT_REGION_LENGTH__ = DEFINED(__TEXT_REGION_LENGTH__) ? __TEXT_REGION_LENGTH__ : $TEXT_LENGTH;
  97 __DATA_REGION_ORIGIN__ = DEFINED(__DATA_REGION_ORIGIN__) ? __DATA_REGION_ORIGIN__ : $DATA_ORIGIN;
  98 __DATA_REGION_LENGTH__ = DEFINED(__DATA_REGION_LENGTH__) ? __DATA_REGION_LENGTH__ : $DATA_LENGTH;
  99
 100 ${EEPROM_LENGTH+__EEPROM_REGION_LENGTH__ = DEFINED(__EEPROM_REGION_LENGTH__) ? __EEPROM_REGION_LENGTH__ : $EEPROM_LENGTH;}
 101 __FUSE_REGION_LENGTH__ = DEFINED(__FUSE_REGION_LENGTH__) ? __FUSE_REGION_LENGTH__ : $FUSE_LENGTH;
 102 __LOCK_REGION_LENGTH__ = DEFINED(__LOCK_REGION_LENGTH__) ? __LOCK_REGION_LENGTH__ : $LOCK_LENGTH;
 103 __SIGNATURE_REGION_LENGTH__ = DEFINED(__SIGNATURE_REGION_LENGTH__) ? __SIGNATURE_REGION_LENGTH__ : $SIGNATURE_LENGTH;
 104 ${USER_SIGNATURE_LENGTH+__USER_SIGNATURE_REGION_LENGTH__ = DEFINED(__USER_SIGNATURE_REGION_LENGTH__) ? __USER_SIGNATURE_REGION_LENGTH__ : $USER_SIGNATURE_LENGTH;}
 105 ${RODATA_PM_OFFSET+__RODATA_PM_OFFSET__ = DEFINED(__RODATA_PM_OFFSET__) ? __RODATA_PM_OFFSET__ : $RODATA_PM_OFFSET;}
 106 ${HAVE_FLMAP+__RODATA_VMA__ = ${RODATA_VMA};}
 107 ${HAVE_FLMAP+__RODATA_LDS_OFFSET__ = DEFINED(__RODATA_LDS_OFFSET__) ? __RODATA_LDS_OFFSET__ : ${RODATA_LDS_OFFSET};}
 108 ${HAVE_FLMAP+__RODATA_REGION_LENGTH__ = DEFINED(__RODATA_REGION_LENGTH__) ? __RODATA_REGION_LENGTH__ : ${RODATA_LENGTH};}
 109 ${HAVE_FLMAP+__RODATA_ORIGIN__ = __RODATA_VMA__ + __RODATA_LDS_OFFSET__;}
 110 MEMORY
 111 {
 112   text   (rx)   : ORIGIN = __TEXT_REGION_ORIGIN__, LENGTH = __TEXT_REGION_LENGTH__
 113   data   (rw!x) : ORIGIN = __DATA_REGION_ORIGIN__, LENGTH = __DATA_REGION_LENGTH__
 114 ${EEPROM_LENGTH+  eeprom (rw!x) : ORIGIN = 0x810000, LENGTH = __EEPROM_REGION_LENGTH__}
 115   $FUSE_NAME      (rw!x) : ORIGIN = 0x820000, LENGTH = __FUSE_REGION_LENGTH__
 116   lock      (rw!x) : ORIGIN = 0x830000, LENGTH = __LOCK_REGION_LENGTH__
 117   signature (rw!x) : ORIGIN = 0x840000, LENGTH = __SIGNATURE_REGION_LENGTH__
 118 ${USER_SIGNATURE_LENGTH+  user_signatures (rw!x) : ORIGIN = 0x850000, LENGTH = __USER_SIGNATURE_REGION_LENGTH__}
 119 ${HAVE_FLMAP+  rodata (r!x) : ORIGIN = __RODATA_ORIGIN__, LENGTH = __RODATA_REGION_LENGTH__}
 120 }
 121 EOF
 122
 123 cat <<EOF
 124 SECTIONS
 125 {
 126   /* Read-only sections, merged into text segment: */
 127   ${TEXT_DYNAMIC+${DYNAMIC}}
 128   .hash        ${RELOCATING-0} : { *(.hash)             }
 129   .dynsym      ${RELOCATING-0} : { *(.dynsym)           }
 130   .dynstr      ${RELOCATING-0} : { *(.dynstr)           }
 131   .gnu.version ${RELOCATING-0} : { *(.gnu.version)      }
 132   .gnu.version_d ${RELOCATING-0} : { *(.gnu.version_d)  }
 133   .gnu.version_r ${RELOCATING-0} : { *(.gnu.version_r)  }
 134
 135   .rel.init    ${RELOCATING-0} : { *(.rel.init)         }
 136   .rela.init   ${RELOCATING-0} : { *(.rela.init)        }
 137   .rel.text    ${RELOCATING-0} :
 138     {
 139       *(.rel.text)
 140       ${RELOCATING+*(.rel.text.*)}
 141       ${RELOCATING+*(.rel.gnu.linkonce.t*)}
 142     }
 143   .rela.text   ${RELOCATING-0} :
 144     {
 145       *(.rela.text)
 146       ${RELOCATING+*(.rela.text.*)}
 147       ${RELOCATING+*(.rela.gnu.linkonce.t*)}
 148     }
 149   .rel.fini    ${RELOCATING-0} : { *(.rel.fini)         }
 150   .rela.fini   ${RELOCATING-0} : { *(.rela.fini)        }
 151   .rel.rodata  ${RELOCATING-0} :
 152     {
 153       *(.rel.rodata)
 154       ${RELOCATING+*(.rel.rodata.*)}
 155       ${RELOCATING+*(.rel.gnu.linkonce.r*)}
 156     }
 157   .rela.rodata ${RELOCATING-0} :
 158     {
 159       *(.rela.rodata)
 160       ${RELOCATING+*(.rela.rodata.*)}
 161       ${RELOCATING+*(.rela.gnu.linkonce.r*)}
 162     }
 163   .rel.data    ${RELOCATING-0} :
 164     {
 165       *(.rel.data)
 166       ${RELOCATING+*(.rel.data.*)}
 167       ${RELOCATING+*(.rel.gnu.linkonce.d*)}
 168     }
 169   .rela.data   ${RELOCATING-0} :
 170     {
 171       *(.rela.data)
 172       ${RELOCATING+*(.rela.data.*)}
 173       ${RELOCATING+*(.rela.gnu.linkonce.d*)}
 174     }
 175   .rel.ctors   ${RELOCATING-0} : { *(.rel.ctors)        }
 176   .rela.ctors  ${RELOCATING-0} : { *(.rela.ctors)       }
 177   .rel.dtors   ${RELOCATING-0} : { *(.rel.dtors)        }
 178   .rela.dtors  ${RELOCATING-0} : { *(.rela.dtors)       }
 179   .rel.got     ${RELOCATING-0} : { *(.rel.got)          }
 180   .rela.got    ${RELOCATING-0} : { *(.rela.got)         }
 181   .rel.bss     ${RELOCATING-0} : { *(.rel.bss)          }
 182   .rela.bss    ${RELOCATING-0} : { *(.rela.bss)         }
 183   .rel.plt     ${RELOCATING-0} : { *(.rel.plt)          }
 184   .rela.plt    ${RELOCATING-0} : { *(.rela.plt)         }
 185
 186   /* Internal text space or external memory.  */
 187   .text ${RELOCATING-0} :
 188   {
 189     ${RELOCATING+*(.vectors)
 190     KEEP(*(.vectors))
 191
 192     /* For data that needs to reside in the lower 64k of progmem.  */
 193     *(.progmem.gcc*)
 194
 195     /* PR 13812: Placing the trampolines here gives a better chance
 196        that they will be in range of the code that uses them.  */
 197     . = ALIGN(2);
 198     __trampolines_start = . ;
 199     /* The jump trampolines for the 16-bit limited relocs will reside here.  */
 200     *(.trampolines)
 201     *(.trampolines*)
 202     __trampolines_end = . ;
 203
 204     /* avr-libc expects these data to reside in lower 64K. */
 205     *libprintf_flt.a:*(.progmem.data)
 206     *libc.a:*(.progmem.data)
 207
 208     *(.progmem.*)
 209
 210     . = ALIGN(2);
 211
 212     /* For code that needs to reside in the lower 128k progmem.  */
 213     *(.lowtext)
 214     *(.lowtext*)}
 215
 216     ${CONSTRUCTING+ __ctors_start = . ; }
 217     ${CONSTRUCTING+ *(.ctors) }
 218     ${CONSTRUCTING+ __ctors_end = . ; }
 219     ${CONSTRUCTING+ __dtors_start = . ; }
 220     ${CONSTRUCTING+ *(.dtors) }
 221     ${CONSTRUCTING+ __dtors_end = . ; }
 222     ${RELOCATING+KEEP(SORT(*)(.ctors))
 223     KEEP(SORT(*)(.dtors))
 224
 225     /* From this point on, we do not bother about whether the insns are
 226        below or above the 16 bits boundary.  */
 227     *(.init0)  /* Start here after reset.  */
 228     KEEP (*(.init0))
 229     *(.init1)
 230     KEEP (*(.init1))
 231     *(.init2)  /* Clear __zero_reg__, set up stack pointer.  */
 232     KEEP (*(.init2))
 233     *(.init3)
 234     KEEP (*(.init3))
 235     *(.init4)  /* Initialize data and BSS.  */
 236     KEEP (*(.init4))
 237     *(.init5)
 238     KEEP (*(.init5))
 239     *(.init6)  /* C++ constructors.  */
 240     KEEP (*(.init6))
 241     *(.init7)
 242     KEEP (*(.init7))
 243     *(.init8)
 244     KEEP (*(.init8))
 245     *(.init9)  /* Call main().  */
 246     KEEP (*(.init9))}
 247     *(.text)
 248     ${RELOCATING+. = ALIGN(2);
 249     *(.text.*)
 250     . = ALIGN(2);
 251     *(.fini9)  /* _exit() starts here.  */
 252     KEEP (*(.fini9))
 253     *(.fini8)
 254     KEEP (*(.fini8))
 255     *(.fini7)
 256     KEEP (*(.fini7))
 257     *(.fini6)  /* C++ destructors.  */
 258     KEEP (*(.fini6))
 259     *(.fini5)
 260     KEEP (*(.fini5))
 261     *(.fini4)
 262     KEEP (*(.fini4))
 263     *(.fini3)
 264     KEEP (*(.fini3))
 265     *(.fini2)
 266     KEEP (*(.fini2))
 267     *(.fini1)
 268     KEEP (*(.fini1))
 269     *(.fini0)  /* Infinite loop after program termination.  */
 270     KEEP (*(.fini0))
 271
 272     /* For code that needs not to reside in the lower progmem.  */
 273     *(.hightext)
 274     *(.hightext*)
 275
 276     *(.progmemx.*)
 277
 278     . = ALIGN(2);
 279
 280     /* For tablejump instruction arrays.  We do not relax
 281        JMP / CALL instructions within these sections.  */
 282     *(.jumptables)
 283     *(.jumptables*)
 284
 285     _etext = . ;}
 286   } ${RELOCATING+ > text}
 287 EOF
 288
 289 # Devices like ATtiny816 allow to read from flash memory by means of LD*
 290 # instructions provided we add an offset of __RODATA_PM_OFFSET__ to the
 291 # flash addresses.
 292
 293 if test -n "$RODATA_PM_OFFSET"; then
 294     cat <<EOF
 295   .rodata ${RELOCATING+ ADDR(.text) + SIZEOF (.text) + __RODATA_PM_OFFSET__ } ${RELOCATING-0} :
 296   {
 297     *(.rodata)
 298     ${RELOCATING+ *(.rodata*)
 299     *(.gnu.linkonce.r*)}
 300   } ${RELOCATING+AT> text}
 301 EOF
 302 fi
 303
 304 cat <<EOF
 305   .data        ${RELOCATING-0} :
 306   {
 307     ${RELOCATING+ PROVIDE (__data_start = .) ; }
 308     *(.data)
 309     ${RELOCATING+ *(.data*)
 310     *(.gnu.linkonce.d*)}
 311 EOF
 312
 313 # Classical devices that don't show flash memory in the SRAM address space
 314 # need .rodata to be part of .data because the compiler will use LD*
 315 # instructions and LD* cannot access flash.
 316
 317 if test -z "$RODATA_PM_OFFSET" && test -z "${HAVE_FLMAP}" && test -n "${RELOCATING}"; then
 318     cat <<EOF
 319     *(.rodata)  /* We need to include .rodata here if gcc is used */
 320     *(.rodata*) /* with -fdata-sections.  */
 321     *(.gnu.linkonce.r*)
 322 EOF
 323 fi
 324
 325 cat <<EOF
 326     ${RELOCATING+. = ALIGN(2);}
 327     ${RELOCATING+ _edata = . ; }
 328     ${RELOCATING+ PROVIDE (__data_end = .) ; }
 329   } ${RELOCATING+ > data ${RELOCATING+AT> text}}
 330
 331   .bss ${RELOCATING+ ADDR(.data) + SIZEOF (.data)} ${RELOCATING-0} :${RELOCATING+ AT (ADDR (.bss))}
 332   {
 333     ${RELOCATING+ PROVIDE (__bss_start = .) ; }
 334     *(.bss)
 335     ${RELOCATING+ *(.bss*)}
 336     ${RELOCATING+ *(COMMON)}
 337     ${RELOCATING+ PROVIDE (__bss_end = .) ; }
 338   } ${RELOCATING+ > data}
 339
 340   ${RELOCATING+ __data_load_start = LOADADDR(.data); }
 341   ${RELOCATING+ __data_load_end = __data_load_start + SIZEOF(.data); }
 342
 343   /* Global data not cleared after reset.  */
 344   .noinit ${RELOCATING+ ADDR(.bss) + SIZEOF (.bss)} ${RELOCATING-0}: ${RELOCATING+ AT (ADDR (.noinit))}
 345   {
 346     ${RELOCATING+ PROVIDE (__noinit_start = .) ; }
 347     *(.noinit${RELOCATING+ .noinit.* .gnu.linkonce.n.*})
 348     ${RELOCATING+ PROVIDE (__noinit_end = .) ; }
 349     ${RELOCATING+ _end = . ;  }
 350     ${RELOCATING+ PROVIDE (__heap_start = .) ; }
 351   } ${RELOCATING+ > data}
 352 EOF
 353
 354 # Devices like AVR128DA32 and AVR64DA32 see a 32 KiB block of their program
 355 # memory at 0x8000 (RODATA_LDS_OFFSET).  Which portion will be determined by
 356 # bitfield NVMCTRL_CTRLB.FLMAP.
 357
 358 if test -z "${HAVE_FLMAP}" && test -n "${RELOCATING}"; then
 359     cat <<EOF
 360
 361 __flmap_init_label = DEFINED(__flmap_noinit_start) ? __flmap_noinit_start : 0 ;
 362 __flmap = DEFINED(__flmap) ? __flmap : 0 ;
 363
 364 EOF
 365 fi
 366
 367 if test -n "${HAVE_FLMAP}"; then
 368     cat <<EOF
 369
 370 ${RELOCATING+
 371 __flmap_init_label = DEFINED(__flmap_init_start) ? __flmap_init_start : 0 ;
 372 /* User can specify position of .rodata in flash (LMA) by supplying
 373    __RODATA_FLASH_START__ or __flmap, where the former takes precedence. */
 374 __RODATA_FLASH_START__ = DEFINED(__RODATA_FLASH_START__)
 375    ? __RODATA_FLASH_START__
 376    : DEFINED(__flmap) ? __flmap * 32K : ${RODATA_FLASH_START};
 377 ASSERT (__RODATA_FLASH_START__ % 32K == 0, \"__RODATA_FLASH_START__ must be a multiple of 32 KiB\")
 378 __flmap = ${FLMAP_MASK} & (__RODATA_FLASH_START__ >> 15);
 379 __RODATA_FLASH_START__ = __flmap << 15;
 380 __rodata_load_start = MAX (__data_load_end, __RODATA_FLASH_START__);
 381 __rodata_start = __RODATA_ORIGIN__ + __rodata_load_start - __RODATA_FLASH_START__;}
 382
 383   .rodata ${RELOCATING+ __rodata_start} ${RELOCATING-0} : ${RELOCATING+ AT (__rodata_load_start)}
 384   {
 385     *(.rodata)
 386     ${RELOCATING+ *(.rodata*)}
 387     ${RELOCATING+ *(.gnu.linkonce.r*)}
 388     ${RELOCATING+ __rodata_end = ABSOLUTE(.) ;}
 389   } ${RELOCATING+ > rodata}
 390
 391 ${RELOCATING+ __rodata_load_end = __rodata_load_start + __rodata_end - __rodata_start;}
 392
 393 EOF
 394 fi
 395
 396 if test -n "${MAYBE_FLMAP}" && test -n "${RELOCATING}"; then
 397     cat <<EOF
 398
 399 __do_init_flmap = ${HAVE_FLMAP-0};
 400 __flmap_value = __flmap << (DEFINED(__flmap_bpos) ? __flmap_bpos : 4);
 401 __flmap_value_with_lock =
 402    __flmap_value | (DEFINED(__flmap_lock) && DEFINED(__flmap_lock_mask)
 403                     ? (__flmap_lock && __do_init_flmap ? __flmap_lock_mask : 0)
 404                     : 0);
 405
 406 EOF
 407 fi
 408
 409 if test -n "${EEPROM_LENGTH}"; then
 410 cat <<EOF
 411
 412   .eeprom ${RELOCATING-0}:
 413   {
 414     /* See .data above...  */
 415     KEEP(*(.eeprom*))
 416     ${RELOCATING+ __eeprom_end = . ; }
 417   } ${RELOCATING+ > eeprom}
 418 EOF
 419 fi
 420
 421 if test "$FUSE_NAME" = "fuse" ; then
 422 cat <<EOF
 423
 424   .fuse ${RELOCATING-0}:
 425   {
 426     KEEP(*(.fuse))
 427     ${RELOCATING+KEEP(*(.lfuse))
 428     KEEP(*(.hfuse))
 429     KEEP(*(.efuse))}
 430   } ${RELOCATING+ > fuse}
 431 EOF
 432 fi
 433
 434 cat <<EOF
 435
 436   .lock ${RELOCATING-0}:
 437   {
 438     KEEP(*(.lock*))
 439   } ${RELOCATING+ > lock}
 440
 441   .signature ${RELOCATING-0}:
 442   {
 443     KEEP(*(.signature*))
 444   } ${RELOCATING+ > signature}
 445 EOF
 446
 447 if test "$FUSE_NAME" = "config" ; then
 448 cat <<EOF
 449
 450   .config ${RELOCATING-0}:
 451   {
 452     KEEP(*(.config*))
 453   } ${RELOCATING+ > config}
 454 EOF
 455 fi
 456
 457 source_sh $srcdir/scripttempl/misc-sections.sc
 458
 459 cat <<EOF
 460   .note.gnu.build-id ${RELOCATING-0} : { *(.note.gnu.build-id) }
 461 EOF
 462
 463 source_sh $srcdir/scripttempl/DWARF.sc
 464
 465 cat <<EOF
 466 }
 467 EOF