ENTRY(_start)

/*****************************************************************************
 * Virtual and linear start addresses of the TeachOS kernel
 *****************************************************************************/
PROVIDE_HIDDEN(TEACHOS_PMA = 1M);
PROVIDE_HIDDEN(TEACHOS_VMA = -2048M);

PHDRS {
  boot_rodata PT_LOAD FLAGS(4);
  boot_text   PT_LOAD FLAGS(5);
  boot_data   PT_LOAD FLAGS(6);

  kernel_rodata PT_LOAD FLAGS(4);
  kernel_text   PT_LOAD FLAGS(5);
  kernel_data   PT_LOAD FLAGS(6);

  user_rodata PT_LOAD FLAGS(4);
  user_text   PT_LOAD FLAGS(5);
  user_data   PT_LOAD FLAGS(6);
}

SECTIONS
{
  /***************************************************************************
   * Load the bootstrap code into low memory. We need to be accessible in
   * 32-Bit mode, so we want to live down low, but we need to leave the 1MiB
   * hole open since some BIOS functionality resides below it.
   ***************************************************************************/
  . = TEACHOS_PMA;

  /***************************************************************************
   * We want to be able to be able to access all memory (physical and virtual)
   * during bootstrapping and operation. To achieve this, we define some
   * symbols at the beginning.
   ***************************************************************************/
  PROVIDE_HIDDEN(_start_physical = .);
  PROVIDE_HIDDEN(_start_virtual = . + TEACHOS_VMA);

  .boot_rodata ALIGN(4K) :
  {
    KEEP(*(.boot_mbh .boot_rodata*))
  } :boot_rodata

  .boot_data ALIGN(4K) :
  {
    KEEP(*(.boot_data*))

    PROVIDE_HIDDEN(__init_array_start = .);
    KEEP(*(SORT_BY_INIT_PRIORITY(.init_array.*) SORT_BY_INIT_PRIORITY(.ctors.*)))
    KEEP(*(.init_array))
    PROVIDE_HIDDEN(__init_array_end = .);
  } :boot_data

  .boot_bss ALIGN(4K) :
  {
    KEEP(*(.boot_stack .boot_bss*))
  } :boot_data

  .boot_text ALIGN(4K) :
  {
    KEEP(*(.boot_text*))
  } :boot_text

  /***************************************************************************
   * Now it is time to load the 64-bit kernel code. We make sure to align the
   * loaded data onto a page boundary.
   ***************************************************************************/
  . = ALIGN(4K);
  . += TEACHOS_VMA;

  .kernel_rodata ALIGN(4K) : AT (ADDR (.kernel_rodata) - TEACHOS_VMA)
  {
    *(.rodata*)
  } :kernel_rodata

  .kernel_data ALIGN(4K) : AT (ADDR (.kernel_data) - TEACHOS_VMA)
  {
    *(.data*)
  } :kernel_data

  . += 4K;

  .kernel_bss ALIGN(4K) : AT (ADDR (.kernel_bss) - TEACHOS_VMA)
  {
    *(.stack .bss*)
  } :kernel_data

  .kernel_text ALIGN(4K) : AT(ADDR (.kernel_text) - TEACHOS_VMA)
  {
    *(.text*)
  } :kernel_text

  /***************************************************************************
   * Finally, we load the user-accessible code and data.
   ***************************************************************************/

  .user_rodata ALIGN(4K) : AT (ADDR (.user_rodata) - TEACHOS_VMA)
  {
    KEEP(*(.user_rodata*))
  } :user_rodata

  .user_data ALIGN(4K) : AT (ADDR (.user_data) - TEACHOS_VMA)
  {
    KEEP(*(.user_data*))
  } :user_data

  . += 4K;

  .user_bss ALIGN(4K) : AT(ADDR (.user_bss) - TEACHOS_VMA)
  {
    KEEP(*(.user_bss*))
  } :user_data

  .user_text ALIGN(4K) : AT(ADDR (.user_text) - TEACHOS_VMA)
  {
    KEEP(*(.user_text*))
  } :user_text

  /***************************************************************************
   * In accordance with the symbol definitions at the start, we generate some
   * symbols to mark the end of our loaded image.
   ***************************************************************************/
  PROVIDE_HIDDEN(_end_virtual = .);
  PROVIDE_HIDDEN(_end_physical = _end_virtual - TEACHOS_VMA);

  /DISCARD/ : { *(.comment) }
}