Subversion Repositories forwardcom

/****************************  loader.as  ********************************
* Author:        Agner Fog
* date created:  2020-12-04
* Last modified: 2021-07-30
* Version:       1.11
* Project:       Loader for ForwardCom soft core
* Language:      ForwardCom assembly
* Description:
* This loader is designed to run in a ForwardCom processor to load an 
* executable file into code and data RAM before running the loaded program.
*
* Copyright 2020-2021 GNU General Public License v.3 http://www.gnu.org/licenses
******************************************************************************

Prerequisites:
The executable file to be loaded is structured as defined in the ForwardCom 
ELF specification defined in the file elf_forwardcom.h.
The sections are sorted into blocks in the following order 
(see CLinker::sortSections() in file linker.cpp):
* const (ip)
* code (ip)
* data (datap)
* bss (datap)
* data (threadp)
* bss (threadp)
The binary data sections are stored in the executable file in the same order
as the program headers.
The executable file is position-independent. No relocation of addresses in
the code is needed.
The program has only one thread.
The available RAM is sufficient.
The input is loaded as bytes through a serial input port (BAUD rate set in defines.vh)

The data will be stored in the processor memory in the following order:

1. data (at beginning of data memory. Addressed by datap)
2. bss (uninitialized data, immediately after data. Addressed by datap)
3. free space to use for heap and stack. (The stack pointer will point to the end of this space)
4. threadp data (immediately before const. Addressed by threadp)
5. const data (at end of data memory. Addressed by IP)
6. code (at beginning of code memory. Addressed by IP)
7. loader code (at end of code memory)


Instructions for how to modify and rebuild the loader:
-----------------------------------------------------------

1. The first instruction must be a direct jump to the loader code that
loads an executable program (*.ex file). The load button will go to this 
address.

The second instruction at address 1 (word-based) must be an entry for the 
restart code that will restart a previously loaded program. The reset button 
will go to this address. The restart code must set datap, threadp, sp, and 
the entry point to the values previously calculated by the loader. 
The present version stores these values in instructions in the code section 
in order to free the entire data memory for the running program. 
Note that we have execute and write access (int32 only) to the code memory, 
but not read access.

2. Assemble:
forw -ass -debug -binlist loader.as -list=loader.txt 

3. Link:
forw -link -hex2 loader.mem loader.ob 

4. Replace the file loader.mem in the softcore project with the new version.

5. Check size:
The size of the code section of the loader can be found from the address of 
the last instruction in the file loader.txt produced by step 2.
If this size (in 32-bit words) exceeds the value MAX_LOADER_SIZE
defined in the file defines.vh, then the value of MAX_LOADER_SIZE must
be increased to at least the actual size. The value must be even.

The loader code will be placed at an address calculated as the end of the 
code memory minus MAX_LOADER_SIZE. 

6. Rebuild the soft core project.

*****************************************************************************/

// Definition of serial input ports
%serial_input_port   = 8                              // serial input port, read one byte at a time
%serial_input_status = 9                              // serial input status. bit 0-15 = number of bytes in input buffer


// Definition of offsets in the file header (struct ElfFwcEhdr in elf_forwardcom.h):
%e_ident        = 0x00  //  uint8_t   e_ident[16];    // Magic number and other info
%e_type         = 0x10  //  uint16_t  e_type;         // Object file type
%e_machine      = 0x12  //  uint16_t  e_machine;      // Architecture
%e_version      = 0x14  //  uint32_t  e_version;      // Object file version
%e_entry        = 0x18  //  uint64_t  e_entry;        // Entry point virtual address
%e_phoff        = 0x20  //  uint64_t  e_phoff;        // Program header table file offset
%e_shoff        = 0x28  //  uint64_t  e_shoff;        // Section header table file offset
%e_flags        = 0x30  //  uint32_t  e_flags;        // Processor-specific flags. We may define any values for these flags
%e_ehsize       = 0x34  //  uint16_t  e_ehsize;       // ELF header size in bytes
%e_phentsize    = 0x36  //  uint16_t  e_phentsize;    // Program header table entry size
%e_phnum        = 0x38  //  uint16_t  e_phnum;        // Program header table entry count
%e_shentsize    = 0x3A  //  uint16_t  e_shentsize;    // Section header table entry size
%e_shnum        = 0x3C  //  uint32_t  e_shnum;        // Section header table entry count (was uint16_t)
%e_shstrndx     = 0x40  //  uint32_t  e_shstrndx;     // Section header string table index (was uint16_t)
%e_stackvect    = 0x44  //  uint32_t  e_stackvect;    // number of vectors to store on stack. multiply by max vector length and add to stacksize
%e_stacksize    = 0x48  //  uint64_t  e_stacksize;    // size of stack for main thread
%e_ip_base      = 0x50  //  uint64_t  e_ip_base;      // __ip_base relative to first ip based segment
%e_datap_base   = 0x58  //  uint64_t  e_datap_base;   // __datap_base relative to first datap based segment
%e_threadp_base = 0x60  //  uint64_t  e_threadp_base; // __threadp_base relative to first threadp based segment
%file_header_size = 0x68                              // size of file header

%ELFMAG         = 0x464C457F // 0x7F 'E' 'L' 'F': identifying number at e_ident


// Definition of offsets in program headers (struct ElfFwcPhdr in elf_forwardcom.h):
%p_type         = 0x00  //  uint32_t  p_type;         // Segment type
%p_flags        = 0x04  //  uint32_t  p_flags;        // Segment flags
%p_offset       = 0x08  //  uint64_t  p_offset;       // Segment file offset
%p_vaddr        = 0x10  //  uint64_t  p_vaddr;        // Segment virtual address
%p_paddr        = 0x18  //  uint64_t  p_paddr;        // Segment physical address (not used. indicates first section instead)
%p_filesz       = 0x20  //  uint64_t  p_filesz;       // Segment size in file
%p_memsz        = 0x28  //  uint64_t  p_memsz;        // Segment size in memory
%p_align        = 0x30  //  uint8_t   p_align;        // Segment alignment
%p_unused       = 0x31  //  uint8_t   unused[7];

// Definition of section flags
%SHF_EXEC       = 0x0001     // Executable
%SHF_WRITE      = 0x0002     // Writable
%SHF_READ       = 0x0004     // Readable
%SHF_IP         = 0x1000     // Addressed relative to IP (executable and read-only sections)
%SHF_DATAP      = 0x2000     // Addressed relative to DATAP (writeable data sections)
%SHF_THREADP    = 0x4000     // Addressed relative to THREADP (thread-local data sections)

// Start of RAM address
%ram_start_address = 0

// stack alignment
%stack_align = 1 << 4        // alignment of stack


/* Register use in this loader
r0:  number of bytes to read from input
r1:  current address in ram
r6:  ram address of current program header
r10: ram_start_address  
r11: number of bytes read from input = current position in input file
r12: size of each program header
r13: size of all threadp sections
r14: current program header index
r20: ram address of first program header
r21: number of program headers
r22: temporary start address for program data (later moved to 0)
r23: start address of const data
r24: start address of code section
r25: start address of threadp sections
r26: end of initialized data section, start of BSS
r27: size of code memory
r28: end of data and bss sections
r29: start address of loader
r30: error code
*/


/*********************************************
        Program code for loader
*********************************************/

code section execute align = 8

__entry_point function public
_loader  function public

// Loader entry:
jump LOADER

// Restart entry. This will restart a previously loaded program:
RESTART:

// Dummy constants make sure the following instructions are 2-word size. 
// These constants will be changed by the loader
set_sp: 
int32 sp = 0xDEADBEEF                            // will be replaced by calculated stack address
set_datap:
int32 r1 = 0xC001F001                            // will be replaced by calculated 32-bit datap value
int64 datap = write_spec(r1)                     // save datap register
set_threadp:
int32 r2 = 0xFEE1600D                            // will be replaced by calculated 32-bit threadp value
int64 threadp = write_spec(r2)                   // save threadp register

// clear input buffer
do { // repeat until no more serial input coming
    int r2 = 1
    int output(r2, r2, serial_input_status)      // clear input buffer
    for (int r1 = 0; r1 < 1000000; r1++) {}      // delay loop
    int16 r2 = input(r2, serial_input_status)    // check if there is more input
}
while (int16 r2 != 0)

// clear registers
int r0 = 0
int r1 = 0
int r2 = 0
int r3 = 0
int r4 = 0
int r5 = 0
int r6 = 0
int r7 = 0
int r8 = 0
int r9 = 0
int r10 = 0
int r11 = 0
int r12 = 0
int r13 = 0
int r14 = 0
int r15 = 0
int r16 = 0
int r17 = 0
int r18 = 0
int r19 = 0
int r20 = 0
int r21 = 0
int r22 = 0
int r23 = 0
int r24 = 0
int r25 = 0
int r26 = 0
int r27 = 0
int r28 = 0
int r29 = 0
int r30 = read_perf(perf0, -1)                   // clear all performance counters
int r30 = 0

// breakpoint

// To do: clear r0 - r30 using POP instruction if supported

set_entry_point:
jump LOADER                                      // this will be replaced by 24-bit relative call to program entry

breakpoint                                       // debug breakpoint in case main program returns
for (int;;){}                                    // stop in infinite loop


/*********************************************
           Loader starts here
*********************************************/

LOADER:

read_restart:

do {                                             // wait until there are at least 4 bytes in input buffer
    int16 r3 = input(r0, serial_input_status)    // bit 15:0 of status = number of bytes in input buffer (r0 is dummy)
} while (int16+ r3 < 4)                          // repeat if not enough data

// Read serial input and search for file header beginning with 0x7F, 'E', 'L', 'F'
int8 r3 = input(r0, serial_input_port)           // read first byte (r0 is dummy) 
if (int8+ r3 != 0x7F) {jump read_restart}
int8 r3 = input(r0, serial_input_port)           // read second byte
if (int8+ r3 != 'E')  {jump read_restart}
int8 r3 = input(r0, serial_input_port)           // read third byte
if (int8+ r3 != 'L')  {jump read_restart}
int8 r3 = input(r0, serial_input_port)           // read fourth byte
if (int8+ r3 != 'F')  {jump read_restart}

// Store file header in memory at address 0
//int64 r1 = ram_start_address                   // Store file header in memory at address 0 
//int32 [r1] = ELFMAG                            // store first word (superfluous. will not be used)
int r1 = 4                                       // we have read 4 bytes

// read_block function input: 
// r0: number of bytes to read
// r1: pointer to memory block to write to
// return:
// r0: last byte read
// r1: end of memory block

int r0 = file_header_size - 4                    // read program header (we have already read 4 bytes)
int r11 = r0 + r1                                // count number of bytes read
call read_block
int64 r10 = ram_start_address                    // Store file header in memory at address 0 

// read program headers
int32 r0 = [r10 + e_phoff]                       // file offset to first program header
int32 r0 -= r11                                  // number of bytes read so far
int r11 += r0                                    // count number of bytes read
call read_dummy                                  // read any space between file header and first program header

// round up to align by 8
int r1 += 7
int r1 &= -8

int r20 = r1                                     // save address of first program header
int16 r21 = [r10 + e_phnum]                      // number of program headers
int16 r12 = [r10 + e_phentsize]                  // size of each program header
// int r0 = r21 * r12                            // size of all program headers
int r0 = 0
for (int+ r14 = 0; r14 < r21; r14++) {           // multiplication loop in case CPU does not support multiplication
    int16 r0 += r12
}
int r11 += r0                                    // count number of bytes read
call read_block                                  // read all program headers

int r22 = r1 + 7                                 // temporary program data start address
int r22 &= -8                                    // align by 8

// find first code section
int32 r6 = r20                                   // ram address of first program header
for (int+ r14 = 0; r14 < r21; r14++) {           // loop through code sections
    int r3 = [r6 + p_flags]                      // section flags
    if (int8+ r3 & SHF_EXEC) {break}             // search for SHF_EXEC flag
    int r6 += r12                                // next program header
}

int r24 = read_capabilities(capab5, 0)           // get data cache size = start of code section
int r27 = read_capabilities(capab4, 0)           // get code cache size = max size of code section
int64 r4 = [r6 + p_vaddr]                        // virtual address of first code section relative to first IP section
int64 r23 = r24 - r4                             // start address of const data (ip-addressed)

// load binary data

// 1. const sections
int r1 = r23                                     // start address of const data
int32 r6 = r20                                   // ram address of first program header
for (int+ r14 = 0; r14 < r21; r14++) {           // loop through program headers
    int r3 = [r6 + p_flags]                      // section flags
    int16+ test_bits_and(r3, SHF_IP | SHF_READ), jump_false LOOP3BREAK // skip if not readable IP
    if (int16+ r3 & SHF_EXEC) {break}            // stop if SHF_EXEC flag
    int32 r0 = [r6 + p_offset]                   // file offset of this section
    int32 r0 -= r11                              // space between last program header and first binary data block
    int r11 += r0                                // count number of bytes read
    call read_dummy                              // read any space
    int32 r0 = [r6 + p_filesz]                   // file size of this section
    int32 r0 += 3                                // round up to nearest multiple of 4
    int32 r0 &= -4
    int r11 += r0                                // count number of bytes read
    call read_block                              // read const data section
    int r6 += r12                                // next program header
}
LOOP3BREAK:

// 2. code sections
for (int ; r14 < r21; r14++) {                   // continue loop through program headers
    int r3 = [r6 + p_flags]                      // section flags
    if (int16+ !(r3 & SHF_EXEC)) {break}         // stop if not SHF_EXEC flag
    int32 r0 = [r6 + p_offset]                   // file offset of this section
    int32 r0 -= r11                              // any space between last binary data and this
    int r11 += r0                                // count number of bytes read
    call read_dummy                              // read any space
    uint64 r1 = r23 + [r6 + p_vaddr]             // address to place code
    int32 r0 = [r6 + p_filesz]                   // file size of this section
    int32 r0 += 3                                // round up to nearest multiple of 4
    int32 r0 &= -4
    int r11 += r0                                // count number of bytes read
    call read_block                              // read code section
    int r6 += r12                                // next program header
}

int r30 = 1                                      // error code
int r29 = address([_loader])
if (uint32 r1 > r29) {jump ERROR}                // out of code memory

// 3. datap sections
// align first data section
int r3 = [r6 + p_flags]                          // section flags
if (int+ r3 & SHF_DATAP) {                       // check if there is a data or bss section
    int8  r4 = [r6 + p_align]
    int   r5 = 1
    int64 r5 <<= r4                              // alignment
    int64 r5 -= 1
    int64 r22 += r5
    int64 r5 = ~r5
    int64 r22 &= r5                              // aligned start address of program data
}

// data section headers
for (int ; r14 < r21; r14++) {                   // continue loop through program headers
    int r3 = [r6 + p_flags]                      // section flags
    if (int16+ !(r3 & SHF_DATAP)) {break}        // stop if not SHF_DATAP flag
    int32 r0 = [r6 + p_offset]                   // file offset of this section
    int32 r0 -= r11                              // any space between last binary data and this
    int r11 += r0                                // count number of bytes read
    call read_dummy                              // read any space
    int r1 = r22 + [r6 + p_vaddr]                // address to place code
    int r27 = r1 + [r6 + p_memsz]                // end of initialized and unitialized data section
    int32 r0 = [r6 + p_filesz]                   // file size of this section
    int32 r0 += 3                                // round up to nearest multiple of 4
    int32 r0 &= -4
    int r11 += r0                                // count number of bytes read. will be zero for BSS section
    call read_block                              // read code section
    int r6 += r12                                // next program header
    int r26 = r1                                 // end of initialized data section
}

// 4. threadp sections
int r13 = 0                                      // size of all threadp sections
int64 r25 = r23                                  // default if no threadp section. used for stack pointer
// find last threadp section
int r7 = r6
for (int r2 = r14; r2 < r21; r2++) {             // continue loop through program headers
    int r3 = [r7 + p_flags]                      // section flags
    if (int16+ !(r3 & SHF_THREADP)) {break}      // stop if not SHF_THREADP flag
    int r7 += r12                                // next program header
}
int r7 -= r12                                    // last threadp header, if any
if (int r7 >= r6) {                              // check if there is any threadp header
    int r13 = [r7 + p_vaddr]                     // virtual address of last threadp section relative to first threadp section
    int r13 += [r7 + p_memsz]                    // add size of last threadp section to get total size of threadp sections
    // start of threadp section
    int64 r25 = r23 - r13
    // align start of threadp sections
    int8  r4 = [r7 + p_align]                    // alignment of first threadp section
    int   r5 = 1
    int64 r5 <<= r4                              // alignment
    int64 r5 = -r5
    int64 r25 = r25 & r5                         // aligned start address of first threadp section
}

int r30 = 2                                      // error code
if (uint32 r25 <= r27) {jump ERROR}              // out of RAM memory
// r22 contains the amount or RAM used for headers during loading. 
// This is included in the memory count above, but will be freed before the loaded program is run.
// This freed memory will be available for data stack or heap

// threadp section headers
for (int ; r14 < r21; r14++) {                   // continue loop through program headers
    int r3 = [r6 + p_flags]                      // section flags
    if (int16+ !(r3 & SHF_THREADP)) {break}      // stop if not SHF_THREADP flag
    uint64 r1 = r25 + [r6 + p_vaddr]             // address to place code
    int32 r0 = [r6 + p_offset]                   // file offset of this section
    int32 r0 -= r11                              // any space between last binary data and this
    int r11 += r0                                // count number of bytes read
    call read_dummy                              // read any space
    int32 r0 = [r6 + p_filesz]                   // file size of this section (0 if BSS)
    int32 r0 += 3                                // round up to nearest multiple of 4
    int32 r0 &= -4
    int r11 += r0                                // count number of bytes read. will be zero for BSS section
    call read_block                              // read code section
    int r6 += r12                                // next program header
}

int64 r10 = ram_start_address                    // Store file header temporarily in memory at address 0 

// calculate entry point for loaded program
// r23 = const start = start of IP-addressed block
int64 r1 = r23 + [r10 + e_entry]                 // entry point
int64 r2 = address([set_entry_point+4])          // reference point
int32 r3 = r1 - r2                               // relative address
int32 r4 = r3 << 6                               // remove upper 8 bits and scale by 4 
uint32 r5 = r4 >> 8                              // 
int32 r6 = r5 | 0x79000000                       // code for direct call instruction
int32 [set_entry_point] = r6                     // modify set_entry_point instruction to call calculated entry point

// get datap
int64 r7 = [r10 + e_datap_base] /* + r22 */      // temporary datap address is r7+r22, but moved down to r7
int32 [set_datap+4] = r7                         // modify instruction that sets datap

// get threadp
int64 r8 = r25 + [r10 + e_threadp_base]          // threadp register
int32 [set_threadp+4] = r8                       // modify instruction that sets threadp

// get sp
int64 sp = r25 & -stack_align                    // align stack at end of datap ram = begin of threadp
int32 [set_sp+4] = sp                            // modify instruction that sets stack pointer

// Move data down from r22 to 0
int r2 = ram_start_address
for (int+ r3 = r22; r3 < r26; r3 += 4) {
    int32 r4 = [r3]
    int32 [r2] = r4
    int32 r2 += 4
}

// Fill the rest with zeroes, including BSS and empty space or stack
int r0 = 0
for (int ; r2 < r25; r2 += 4) {
    int32 [r2] = r0
}

// Initialize datap, threadp, sp. Jump to the entry point of the loaded program
jump RESTART

_loader end


// Error if out of memory or if input file sections are not in desired order
ERROR:
breakpoint
int r0 = r30                                     // show error code in debugger
jump ERROR


// Function to read a block of data into memory.
// input: 
// r0: number of bytes to read. must be divisible by 4
// r1: pointer to memory block to write to. must be aligned by 4
// return:
// r0: last word read
// r1: end of memory block
read_block function 
    int r30 = 0x10                               // error code
    if (int32 r0 < 0) {jump ERROR}               // check if negative
    int64 r2 = r1 + r0                           // end of memory block
    for (uint64 ; r1 < r2; r1 += 4) {            // loop n/4 times
        do {                                     // wait until there are at least 4 bytes in input buffer
            int32 r3 = input(r0, serial_input_status) // bit 15:0 of status = number of bytes in input buffer
        } while (int16 r3 < 4)                   // repeat if data not enough data
        int8 r3 = input(r0, serial_input_port)   // read first byte
        int8 r4 = input(r0, serial_input_port)   // read second byte
        int32 r4 <<= 8;
        int32 r3 |= r4
        int8 r4 = input(r0, serial_input_port)   // read third byte
        int32 r4 <<= 16;
        int32 r3 |= r4
        int8 r4 = input(r0, serial_input_port)   // read fourth byte
        int32 r4 <<= 24;
        int32 r3 |= r4
        int32 [r1] = r3                          // store byte to memory
    }
    return
read_block end

// Function to read a block of data and discard it
// input: 
// r0: number of bytes to read
// return:
// r0: last byte read
read_dummy function 
    int r30 = 0x11                               // error code
    if (int32 r0 < 0) {jump ERROR}               // check if negative
    for (uint64 ; r0 > 0; r0--) {                // loop n times
        do {
            int16 r3 = input(r0, serial_input_port) // read one byte. r0 is dummy
        } while (int16+ !(r3 & 0x100))           // repeat if data not ready
    }
    //int8 r0 = r3                               // return last byte read
    return
read_dummy end

nop

code end