URL
https://opencores.org/ocsvn/forwardcom/forwardcom/trunk
Subversion Repositories forwardcom
Compare Revisions
- This comparison shows the changes necessary to convert path
/
- from Rev 69 to Rev 70
- ↔ Reverse comparison
Rev 69 → Rev 70
/forwardcom/trunk/loader.as
0,0 → 1,540
/**************************** 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 |