/* rt_header is defined by the general linker script (libtock_layout.ld). It has
 * the following layout:
 *
 *     Field                       | Offset
 *     ------------------------------------
 *     Address of the start symbol |      0
 *     Initial process break       |      4
 *     Top of the stack            |      8
 *     Size of .data               |     12
 *     Start of .data in flash     |     16
 *     Start of .data in ram       |     20
 *     Size of .bss                |     24
 *     Start of .bss in ram        |     28
 */

/* start is the entry point -- the first code executed by the kernel. The kernel
 * passes arguments through 4 registers:
 *
 *     a0  Pointer to beginning of the process binary's code. The linker script
 *         locates rt_header at this address.
 *
 *     a1  Address of the beginning of the process's usable memory region.
 *     a2  Size of the process' allocated memory region (including grant region)
 *     a3  Process break provided by the kernel.
 *
 * We currently only use the value in a0. It is copied into a5 early on because
 * a0-a4 are needed to invoke system calls.
 */
.section .start, "ax"
.globl start
start:
	/* First, verify the process binary was loaded at the correct address. The
	 * check is performed by comparing the program counter at the start to the
	 * address of `start`, which is stored in rt_header. */
	auipc s0, 0            /* s0 = pc */
	mv a5, a0              /* Save rt_header so syscalls don't overwrite it */
	lw s1, 0(a5)           /* s1 = rt_header.start */
	beq s0, s1, .Lset_brk  /* Skip error handling code if pc is correct */
	/* If the beq on the previous line did not jump, then the binary is not at
	 * the correct location. Report the error via LowLevelDebug then exit. */
	li a0, 8  /* LowLevelDebug driver number */
	li a1, 1  /* Command: Print alert code */
	li a2, 2  /* Alert code 2 (incorrect location) */
	li a4, 2  /* `command` class */
	ecall
	li a0, 0  /* exit-terminate */
	/* TODO: Set a completion code, once completion codes are decided */
	li a4, 6  /* `exit` class */
	ecall

.Lset_brk:
	/* memop(): set brk to rt_header's initial break value */
	li a0, 0      /* operation: set break */
	lw a1, 4(a5)  /* rt_header's initial process break */
	li a4, 5      /* `memop` class */
	ecall

	/* Set the stack pointer */
	lw sp, 8(a5)  /* sp = rt_header._stack_top */

	/* Copy .data into place. */
	lw a0, 12(a5)              /* remaining = rt_header.data_size */
	beqz a0, .Lzero_bss        /* Jump to zero_bss if remaining is zero */
	lw a1, 16(a5)              /* src = rt_header.data_flash_start */
	lw a2, 20(a5)              /* dest = rt_header.data_ram_start */
.Ldata_loop_body:
	lw a3, 0(a1)               /* a3 = *src */
	sw a3, 0(a2)               /* *dest = a3 */
	addi a0, a0, -4            /* remaining -= 4 */
	addi a1, a1, 4             /* src += 4 */
	addi a2, a2, 4             /* dest += 4 */
	bnez a0, .Ldata_loop_body  /* Iterate again if remaining != 0 */

.Lzero_bss:
	lw a0, 24(a5)               /* remaining = rt_header.bss_size */
	beqz a0, .Lcall_rust_start  /* Jump to call_Main if remaining is zero */
	lw a1, 28(a5)               /* dest = rt_header.bss_start */
.Lbss_loop_body:
	sb zero, 0(a1)              /* *dest = zero */
	addi a0, a0, -1             /* remaining -= 1 */
	addi a1, a1, 1              /* dest += 1 */
	bnez a0, .Lbss_loop_body    /* Iterate again if remaining != 0 */

.Lcall_rust_start:
	/* Note: rust_start must be a diverging function (i.e. return `!`) */
	jal rust_start