// Code that might be executed out of either RAM or ROM
#define SECTION_text(_region_, _vma_, _lma_)                   \
  .text _vma_ : _lma_                                          \
  { __stext = .;                                               \
    *(.text*) *(.gnu.warning) *(.gnu.linkonce.t.*) }           \
  > _region_                                                   \
  __etext = .;  PROVIDE (etext = .);

// The .text.ram section is for performance-sensitive code that is
// always executed from RAM.  (If the code is loaded into ROM, it will
// be copied into RAM prior to execution.)
//
// Note: The SECTION_text_ram() macro must be listed in the linker
// include script (*.ldi file) prior to SECTION_text().
//
// All eCos code is put in the .text section unless explicitly placed
// into a section named section .text.ram*.

#define SECTION_text_ram(_region_, _vma_, _lma_)           \
  .text.ram _vma_ : _lma_                                  \
  { __stext_ram = .;                                       \
    __ram_text_start = ABSOLUTE(.);                        \
    *(.text.ram*)                                          \
  } > _region_                                             \
  __load_addr_text_ram = LOADADDR(.text.ram);              \
  __ram_text_end = .; PROVIDE(__ram_text_end = .);         \
  __etext_ram = .;  PROVIDE (etext_ram = .);

#define SECTION_rodata1(_region_, _vma_, _lma_)        \
    .rodata1 _vma_ : _lma_                             \
    { FORCE_OUTPUT; *(.rodata1) *(.rodata1*) }         \
    > _region_

#define SECTION_rodata(_region_, _vma_, _lma_)                     \
    .rodata _vma_ : _lma_                                          \
    { FORCE_OUTPUT;  *(.rodata) *(.rodata*) *(.gnu.linkonce.r*) }  \
    > _region_

#define SECTION_fixup(_region_, _vma_, _lma_)                      \
    .fixup _vma_ : _lma_                                                          \
    { __FIXUP_START__ = ABSOLUTE(.); *(.fixup) __FIXUP_END__ = ABSOLUTE(.);}\
    > _region_

#define SECTION_gcc_except_table(_region_, _vma_, _lma_)       \
    .gcc_except_table _vma_ : _lma_                                           \
    { __EXCEPT_START__ = ABSOLUTE(.); *(.gcc_except_table)              \
      __EXCEPT_END__ = ABSOLUTE(.);}                                    \
    > _region_

#define SECTION_ctors(_region_, _vma_, _lma_)     \
  .ctors _vma_ : _lma_                            \
    {                                             \
      FORCE_OUTPUT;                               \
      KEEP (*crtbegin.o(.ctors))                  \
      KEEP (*_ctors.o(.ctors))                    \
      __CTOR_LIST__ = .;                          \
      PROVIDE (__CTOR_LIST__ = .);                \
      KEEP (*(.ctors));                           \
      KEEP (*(SORT(.ctors.*)))                    \
      __CTOR_END__ = .;                           \
      PROVIDE (__CTOR_END__ = .);                 \
    } > _region_

#define SECTION_dtors(_region_, _vma_, _lma_)     \
  .dtors _vma_ : _lma_                            \
    {                                             \
      FORCE_OUTPUT;                               \
      KEEP (*crtbegin.o(.dtors))                  \
      __DTOR_LIST__ = .;                          \
      PROVIDE (__DTOR_LIST__ = .);                \
      KEEP (*(SORT(.dtors.*)))                    \
      __DTOR_END__ = .;                           \
      KEEP (*(.dtors));                           \
      PROVIDE (__DTOR_END__ = .);                 \
    } > _region_

#define SECTION_got(_region_, _vma_, _lma_)     \
  .got _vma_ : _lma_                            \
    {                                           \
      FORCE_OUTPUT; *(.got.plt) *(.got*)        \
    } > _region_

#define SECTION_dynamic(_region_, _vma_, _lma_) \
  .dynamic _vma_ : _lma_                        \
    {                                           \
      FORCE_OUTPUT; *(.dynamic)                 \
    } > _region_

#define SECTION_devtab(_region_, _vma_, _lma_)    \
  .devtab _vma_ : _lma_                           \
    {                                             \
      FORCE_OUTPUT;                               \
      KEEP(*( SORT (.ecos.table.*))) ;            \
    } > _region_

#define SECTION_data(_region_, _vma_, _lma_)                                  \
    .data _vma_ : _lma_                                                       \
    { __ram_data_start = ABSOLUTE(.);                                         \
      *(.data*)  *(.data.*) *(.gnu.linkonce.d*)                               \
      *( .2ram.*)                                                             \
      . = ALIGN (8);                                                          \
      SORT(CONSTRUCTORS)                                                      \
    } > _region_                                                              \
    __rom_data_start = LOADADDR(.data);                                       

  /* We want the small data sections together, so single-instruction offsets
     can access them all, and initialized data all before uninitialized, so
     we can shorten the on-disk segment size.  */

#define SECTION_sdata(_region_, _vma_, _lma_)                 \
  .sdata _vma_ : _lma_                                        \
    {                                                         \
    __SDATA_START__ = ABSOLUTE(.);                            \
      FORCE_OUTPUT; *(.sdata) *(.sdata.*) *(.gnu.linkonce.s*) \
    } > _region_

#define SECTION_lit8(_region_, _vma_, _lma_)    \
  .lit8 _vma_ : _lma_                           \
    {                                           \
      FORCE_OUTPUT; *(.lit8)                    \
    } > _region_

#define SECTION_lit4(_region_, _vma_, _lma_)    \
  .lit4 : FOLLOWING(.lit8)                      \
    {                                           \
      FORCE_OUTPUT; *(.lit4)                    \
    } > _region_                                \
  __ram_data_end = .; _edata = . ;              \
  PROVIDE (edata = .);

#define SECTION_sbss(_region_, _vma_, _lma_)                     \
    .sbss _vma_ : _lma_                                                         \
    { __sbss_start = ABSOLUTE (.);                                        \
    __SBSS_START__ = ABSOLUTE(.); *(.sbss.*) __SBSS_END__ = ABSOLUTE(.);   \
    __SBSSx_START__ = ABSOLUTE(.); *(.sbss*) __SBSSx_END__ = ABSOLUTE(.);\
    *(.scommon*)                                                          \
    __sbss_end = ABSOLUTE (.); }                                          \
    > _region_

#define SECTION_bss(_region_, _vma_, _lma_)                      \
    .bss _vma_ : _lma_                                                          \
    { __bss_start = ABSOLUTE (.);                           \
      FORCE_OUTPUT; *(.dynbss*) *(.bss) *(.bss.*) *(COMMON) \
      __bss_end = ABSOLUTE (.); }                           \
    > _region_

#define SECTIONS_END . = ALIGN(4); _end = .; PROVIDE (end = .);

#include <pkgconf/system.h>
#include CYGHWR_MEMORY_LAYOUT_LDI

// Define VSR and virtual tables to reside at fixed addresses.
#include CYGBLD_HAL_TARGET_H
_hal_vsr_table = CYGHWR_HAL_VSR_TABLE;
_hal_virtual_vector_table = CYGHWR_HAL_VIRTUAL_VECTOR_TABLE;

// EOF openrisc.ld