github-mirrors/vortex
1
0
Fork 0
mirror of https://github.com/vortexgpgpu/vortex.git synced 2025-04-23 21:39:10 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

code cleanup

Browse source
This commit is contained in:
felsabbagh3 2019-03-16 19:38:47 -04:00
parent 7fe17b2055
commit e5f1ed1af4
32 changed files with 801 additions and 4603 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/Makefile
View file

@ -5,7 +5,7 @@ CXXFLAGS ?= -std=c++11 -fPIC -O3 # -g -DUSE_DEBUG=3 -DPRINT_ACTIVE_THREADS
LDLIBS ?= -pthread
PREFIX ?= /usr/local
LIB_OBJS=args.o obj.o mem.o core.o instruction.o enc.o util.o
LIB_OBJS=args.o mem.o core.o instruction.o enc.o util.o
all: harptool libharplib.so libharplib.a #libqsim-harp.so
@ -28,8 +28,6 @@ harptool.o : harptool.cpp include/types.h include/core.h include/enc.h \
include/archdef.h include/args.h include/help.h include/debug.h
instruction.o : instruction.cpp include/instruction.h include/obj.h \
include/core.h include/debug.h include/asm-tokens.h
obj.o : obj.cpp include/types.h include/obj.h include/util.h \
include/asm-tokens.h include/debug.h include/instruction.h
util.o : util.cpp include/types.h include/util.h
mem.o : mem.cpp include/types.h include/util.h include/mem.h include/debug.h \
include/core.h

212
src/firmware/firmware.c
View file

@ -1,212 +0,0 @@
/*
* PicoSoC - A simple example SoC using PicoRV32
*
* Copyright (C) 2017 Clifford Wolf <clifford@clifford.at>
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
*/
#include <stdint.h>
#include <stdbool.h>
// #if !defined(ICEBREAKER) && !defined(HX8KDEMO)
// # error "Set -DICEBREAKER or -DHX8KDEMO when compiling firmware.c"
// #endif
// a pointer to this is a null pointer, but the compiler does not
// know that because "sram" is a linker symbol from sections.lds.
#define reg_uart_data (*(volatile uint32_t*)0xFF000000)
// --------------------------------------------------------
// --------------------------------------------------------
int main()
{
// FUNC DEFINITIONS
void putchar(char);
void print(const char *);
char getchar_prompt(char *);
void getsent_prompt(char *, char *);
char arr[2];
arr[1] = 0;
char c;
print("$ Booting..\n");
while ((c = getchar_prompt("$ Press ENTER to continue.. ")) != '\n')
{
// arr[0] = c;
// print("char printed[ ");
// print(arr);
// print(" ]\n");
}
// getchar_prompt("Press ENTER to continue..\n");
print("$ \n");
print(" ______ __ __ _______ ______ ______ ______ __ __ \n");
print(" / \\ | \\ | \\ | \\| \\/ \\ / \\ | \\ | \\\n");
print("| $$$$$$\\ ______ | $$____ \\$$_______ __ __ | $$$$$$$\\\\$$$$$| $$$$$$| $$$$$$\\ | $$ | $$\n");
print("| $$___\\$$/ \\| $$ \\| | \\| \\ / \\ | $$__| $$ | $$ | $$___\\$| $$ \\$_____| $$ | $$\n");
print(" \\$$ \\| $$$$$$| $$$$$$$| $| $$$$$$$\\\\$$\\/ $$ | $$ $$ | $$ \\$$ \\| $$ | \\$$\\ / $$\n");
print(" _\\$$$$$$| $$ | $| $$ | $| $| $$ | $$ >$$ $$ | $$$$$$$\\ | $$ _\\$$$$$$| $$ __\\$$$$$$\\$$\\ $$ \n");
print("| \\__| $| $$__/ $| $$ | $| $| $$ | $$/ $$$$\\ | $$ | $$_| $$_| \\__| $| $$__/ \\ \\$$ $$ \n");
print(" \\$$ $| $$ $| $$ | $| $| $$ | $| $$ \\$$\\ | $$ | $| $$ \\\\$$ $$\\$$ $$ \\$$$ \n");
print(" \\$$$$$$| $$$$$$$ \\$$ \\$$\\$$\\$$ \\$$\\$$ \\$$ \\$$ \\$$\\$$$$$$ \\$$$$$$ \\$$$$$$ \\$ \n");
print(" | $$ \n");
print(" | $$ \n");
print(" \\$$ \n");
print("\n");
char buf[50];
while (1)
{
getsent_prompt("$ Do you want to play a guessing game? [y/n] ", buf);
c = buf[0];
if (c == 'y')
{
break;
} else if (c == 'n')
{
return 0;
} else
{
print("\n$ Wrong input, please try again\n");
}
}
char n = '5';
while (1)
{
getsent_prompt("> Guess a number between 0 and 9: ", buf);
c = buf[0];
if (c < n)
{
print("> The number is larger\n");
} else if (c > n)
{
print("> The number is smaller\n");
} else
{
print(" _ _ _ _ _ _ \n");
print(" | | | | | | (_) | | |\n");
print(" ___ ___ _ __ __ _ _ __ __ _| |_ _ _| | __ _| |_ _ ___ _ __ ___| | |\n");
print(" / __/ _ \\| '_ \\ / _` | '__/ _` | __| | | | |/ _` | __| |/ _ \\| '_ \\/ __| | |\n");
print(" | (_| (_) | | | | (_| | | | (_| | |_| |_| | | (_| | |_| | (_) | | | \\__ \\_|_|\n");
print(" \\___\\___/|_| |_|\\__, |_| \\__,_|\\__|\\__,_|_|\\__,_|\\__|_|\\___/|_| |_|___(_|_)\n");
print(" __/ | \n");
print(" |___/ \n");
print("\n");
break;
}
}
print("$ Press CNTR-C to exit ");
return 0;
}
void putchar(char c)
{
if (c == '\n')
putchar('\r');
reg_uart_data = c;
}
void print(const char *p)
{
while (*p)
putchar(*(p++));
}
char getchar_prompt(char *prompt)
{
int32_t c = -1;
uint32_t cycles_begin, cycles_now, cycles;
__asm__ volatile ("rdcycle %0" : "=r"(cycles_begin));
cycles = 0;
if (prompt)
print(prompt);
while (c == -1) {
__asm__ volatile ("rdcycle %0" : "=r"(cycles_now));
cycles = cycles_now - cycles_begin;
// if (cycles > 1200000) {
// if (prompt)
// print(prompt);
// cycles_begin = cycles_now;
// }
c = reg_uart_data;
}
print("\n");
return c;
}
void getsent_prompt(char *prompt, char * buf)
{
int32_t c = -1;
uint32_t cycles_begin, cycles_now, cycles;
__asm__ volatile ("rdcycle %0" : "=r"(cycles_begin));
cycles = 0;
if (prompt)
print(prompt);
int inx = 0;
while (c != (int) '\n') {
__asm__ volatile ("rdcycle %0" : "=r"(cycles_now));
cycles = cycles_now - cycles_begin;
// if (cycles > 1200000) {
// if (prompt)
// print(prompt);
// cycles_begin = cycles_now;
// }
c = reg_uart_data;
if (c != -1)
{
buf[inx] = c;
inx++;
}
}
// print("\n");
return;
}

1166
src/firmware/firmware.dump
View file

File diff suppressed because it is too large Load diff

BIN
src/firmware/firmware.elf
View file

Binary file not shown.

201
src/firmware/firmware.hex
View file

@ -1,201 +0,0 @@
:0200000480007A
:10000000130101FB23261104232481041304010599
:10001000A30604FEB707008113850700EF00C02583
:1000200013000000B707008113850701EF00C02906
:1000300093070500A307F4FE0347F4FE9307A0000F
:10004000E312F7FEB707008113850703EF00C02214
:10005000B707008113858703EF000022B7070081EF
:100060001385470AEF004021B70700811385071168
:10007000EF008020B70700811385C717EF00C01F6E
:10008000B70700811385871EEF00001FB7070081A7
:1000900013854725EF00401EB70700811385072C05
:1000A000EF00801DB70700811385C732EF00C01C29
:1000B000B707008113858739EF00001CB70700815F
:1000C00013854740EF00401BB70700811385474069
:1000D000EF00801AB707008113850747EF00C019AA
:1000E000B70700811385C74DEF000019930784FB04
:1000F00093850700B70700811385074EEF000026A0
:10010000834784FBA307F4FE0347F4FE930790079D
:100110006304F7020347F4FE9307E0066316F70053
:10012000930700006F00400FB70700811385075148
:10013000EF0080146FF09FFB130000009307500343
:100140002307F4FE930784FB93850700B70700811C
:1001500013854753EF008020834784FBA307F4FEF9
:100160000347F4FE8347E4FE637AF700B707008194
:1001700013858755EF0040106FF0DFFC0347F4FE56
:100180008347E4FE63FAE700B7070081138547570A
:10019000EF00800E6FF01FFBB70700811385075932
:1001A000EF00800DB70700811385075EEF00C00CDC
:1001B000B707008113850763EF00000CB7070081C4
:1001C00013850768EF00400BB70700811385076DA3
:1001D000EF00800AB707008113850772EF00C0099E
:1001E000B707008113850777EF000009B707008183
:1001F0001385077CEF004008B70700811385C74DC2
:10020000EF00800713000000B717008113850781F6
:10021000EF00800693070000138507008320C104C8
:10022000032481041301010567800000130101FE0E
:10023000232E1100232C81001304010293070500D3
:10024000A307F4FE0347F4FE9307A0006316F7002C
:100250001305D000EFF09FFDB70700FF0347F4FE42
:1002600023A0E700130000008320C10103248101C3
:100270001301010267800000130101FE232E11000B
:10028000232C8100130401022326A4FE6F00C00169
:100290008327C4FE138717002326E4FE83C70700C5
:1002A00013850700EFF09FF88327C4FE83C707007C
:1002B000E39007FE130000008320C10103248101A5
:1002C0001301010267800000130101FD23261102C2
:1002D0002324810213040103232EA4FC9307F0FFBF
:1002E0002326F4FEF32700C02324F4FE232204FE79
:1002F0008327C4FD638A07020325C4FDEFF0DFF7FF
:100300006F008002F32700C02320F4FE032704FEC1
:10031000832784FEB307F7402322F4FEB70700FFCC
:1003200083A707002326F4FE0327C4FE9307F0FFEC
:10033000E30AF7FCB70700811385C74DEFF0DFF341
:100340008327C4FE93F7F70F138507008320C102AC
:10035000032481021301010367800000130101FCE3
:10036000232E1102232C8102130401042326A4FC52
:100370002324B4FC9307F0FF2326F4FEF32700C0E8
:100380002322F4FE232004FE8327C4FC6386070097
:100390000325C4FCEFF05FEE232404FE6F0080050C
:1003A000F32700C0232EF4FC0327C4FD832744FE5B
:1003B000B307F7402320F4FEB70700FF83A7070029
:1003C0002326F4FE0327C4FE9307F0FF6304F7021D
:1003D000832784FE032784FCB307F7000327C4FEAA
:1003E0001377F70F2380E700832784FE9387170096
:1003F0002324F4FE0327C4FE9307A000E312F7FAB8
:10040000130000008320C1030324810313010104AE
:040410006780000001
:02000004810079
:10000000242020426F6F74696E672E2E0A00000054
:10001000242020507265737320454E54455220743D
:100020006F20636F6E74696E75652E2E2000000060
:100030002420200A0000000020205F5F5F5F5F5FD8
:1000400020202020202020202020205F5F20202032
:10005000202020205F5F2020202020202020202022
:100060002020202020202020202020202020202090
:100070005F5F5F5F5F5F5F20205F5F5F5F5F5F204D
:10008000205F5F5F5F5F5F2020205F5F5F5F5F5F7C
:10009000202020202020205F5F20202020205F5F64
:1000A000200A0000202F2020202020205C2020205B
:1000B0002020202020207C20205C20202020207C4C
:1000C00020205C20202020202020202020202020F4
:1000D00020202020202020202020207C20202020C4
:1000E0002020205C7C2020202020205C2F2020202D
:1000F0002020205C202F2020202020205C20202079
:1001000020207C20205C2020207C20205C0A000015
:100110007C20202424242424245C205F5F5F5F5FF4
:100120005F207C2024245F5F5F5F20205C24245FAD
:100130005F5F5F5F5F5F20205F5F202020205F5F49
:10014000202020202020207C202424242424242437
:100150005C5C24242424247C20202424242424249F
:100160007C20202424242424245C202020207C2083
:1001700024242020207C2024240A00007C20242405
:100180005F5F5F5C24242F2020202020205C7C20C7
:100190002424202020205C7C20207C202020202063
:1001A00020205C7C20205C20202F20205C20202030
:1001B0002020207C2024245F5F7C202424207C209D
:1001C0002424207C2024245F5F5F5C247C20242462
:1001D0002020205C245F5F5F5F5F7C202424202040
:1001E000207C2024240A0000205C242420202020BD
:1001F0005C7C20202424242424247C2024242424E3
:100200002424247C20247C20242424242424245CCE
:100210005C24245C2F202024242020202020207CEB
:10022000202424202020202424207C20242420205A
:100230005C2424202020205C7C20242420202020DA
:100240007C2020202020205C24245C202F202024BF
:10025000240A0000205F5C2424242424247C2024FD
:100260002420207C20247C20242420207C20247C0A
:1002700020247C20242420207C202424203E24248C
:1002800020202424202020202020207C20242424FE
:10029000242424245C207C20242420205F5C24242B
:1002A000242424247C2024242020205F5F5C242418
:1002B000242424245C24245C20202424200A0000FC
:1002C0007C20205C5F5F7C20247C2024245F5F2FC7
:1002D00020247C20242420207C20247C20247C209A
:1002E000242420207C2024242F2020242424245C47
:1002F000202020202020207C20242420207C20243A
:10030000245F7C2024245F7C20205C5F5F7C202491
:100310007C2024245F5F2F20205C202020202020B0
:10032000205C242420242420200A0000205C242493
:1003300020202020247C20242420202020247C20F5
:10034000242420207C20247C20247C202424202081
:100350007C20247C20202424205C24245C20202059
:100360002020207C20242420207C20247C2020206D
:100370002424205C5C24242020202024245C2424A9
:1003800020202020242420202020202020205C2425
:1003900024242020200A000020205C24242424245B
:1003A000247C2024242424242424205C242420208D
:1003B000205C24245C24245C24242020205C24242D
:1003C0005C24242020205C242420202020202020A5
:1003D0005C24242020205C24245C24242424242441
:1003E000205C24242424242420205C242424242469
:1003F00024202020202020202020205C24202020B9
:10040000200A00002020202020202020207C2024E2
:1004100024202020202020202020202020202020D8
:1004200020202020202020202020202020202020CC
:1004300020202020202020202020202020202020BC
:1004400020202020202020202020202020202020AC
:10045000202020202020202020202020202020209C
:10046000202020202020202020202020200A0000E2
:10047000202020202020202020205C242420202038
:10048000202020202020202020202020202020206C
:10049000202020202020202020202020202020205C
:1004A000202020202020202020202020202020204C
:1004B000202020202020202020202020202020203C
:1004C000202020202020202020202020202020202C
:1004D0002020202020202020200A00000A000000E8
:1004E000242020446F20796F752077616E7420740A
:1004F0006F20706C61792061206775657373696E18
:10050000672067616D653F205B792F6E5D2000007D
:100510000A24202057726F6E6720696E7075742CE4
:1005200020706C6561736520747279206167616900
:100530006E0A00003E202047756573732061206EAF
:10054000756D626572206265747765656E20302016
:10055000616E6420393A20003E2020546865206E88
:10056000756D626572206973206C61726765720ACD
:10057000000000003E2020546865206E756D6265A5
:100580007220697320736D616C6C65720A000000E3
:10059000202020202020202020202020202020205B
:1005A000202020202020202020202020202020204B
:1005B00020205F2020202020202020205F202020BD
:1005C000202020205F2020205F20202020202020AD
:1005D000202020202020202020205F205F200A00D3
:1005E000202020202020202020202020202020200B
:1005F00020202020202020202020202020202020FB
:10060000207C207C202020202020207C207C20207A
:100610002020207C207C20285F29202020202020D2
:100620002020202020202020207C207C207C0A00EC
:100630002020205F5F5F205F5F5F20205F205F5F83
:100640002020205F5F205F205F205F5F205F5F20B2
:100650005F7C207C5F205F2020205F7C207C205FEF
:100660005F205F7C207C5F205F20205F5F5F202019
:100670005F205F5F20205F5F5F7C207C207C0A0022
:1006800020202F205F5F2F205F205C7C20275F20B1
:100690005C202F205F60207C20275F5F2F205F6021
:1006A000207C205F5F7C207C207C207C207C2F2095
:1006B0005F60207C205F5F7C207C2F205F205C7C43
:1006C00020275F205C2F205F5F7C207C207C0A003D
:1006D000207C20285F7C20285F29207C207C207CB7
:1006E000207C20285F7C207C207C207C20285F7C54
:1006F000207C207C5F7C207C5F7C207C207C2028F0
:100700005F7C207C207C5F7C207C20285F29207CF3
:10071000207C207C205C5F5F205C5F7C5F7C0A002B
:1007200020205C5F5F5F5C5F5F5F2F7C5F7C207C75
:100730005F7C5C5F5F2C207C5F7C20205C5F5F2C9B
:100740005F7C5C5F5F7C5C5F5F2C5F7C5F7C5C5F81
:100750005F2C5F7C5C5F5F7C5F7C5C5F5F5F2F7C9E
:100760005F7C207C5F7C5F5F5F285F7C5F290A0085
:100770002020202020202020202020202020202079
:100780002020205F5F2F207C202020202020202080
:100790002020202020202020202020202020202059
:1007A0002020202020202020202020202020202049
:1007B00020202020202020202020202020200A006F
:1007C0002020202020202020202020202020202029
:1007D00020207C5F5F5F2F202020202020202020F1
:1007E0002020202020202020202020202020202009
:1007F00020202020202020202020202020202020F9
:1008000020202020202020202020202020200A001E
:10081000242020507265737320434E54522D432080
:09082000746F20657869742000F2
:040000058000000077
:00000001FF

11
src/firmware/firmware1.hex
View file

@ -1,11 +0,0 @@
:0200000480007A
:10000000130101FE232E810013040102B7070081B2
:10001000938707002326F4FE6F0040028327C4FE67
:10002000138717002326E4FE83C70700A305F4FE09
:10003000B70700FF0347B4FE23A0E7008327C4FEF1
:1000400083C70700E39C07FC9307000013850700A4
:0C0050000324C1011301010267800000BD
:02000004810079
:09000000626F6F74696E670A00FB
:040000058000000077
:00000001FF

3
src/firmware/hi.sh
View file

@ -1,3 +0,0 @@
/opt/riscv-nommu/bin/riscv32-unknown-linux-gnu-gcc -march=rv32i -mabi=ilp32 -Wl,-Bstatic,-T,linker.ld -ffreestanding -nostdlib firmware.c -o firmware.elf
/opt/riscv-nommu/bin/riscv32-unknown-linux-gnu-objdump -D firmware.elf > firmware.dump
/opt/riscv-nommu/bin/riscv32-unknown-linux-gnu-objcopy -O ihex firmware.elf firmware.hex

44
src/firmware/linker.ld
View file

@ -1,44 +0,0 @@
/* ---- Original Script: /opt/riscv32i/riscv32-unknown-elf/lib/ldscripts/elf32lriscv.x ---- */
/* Default linker script, for normal executables */
/* Copyright (C) 2014-2017 Free Software Foundation, Inc.
Copying and distribution of this script, with or without modification,
are permitted in any medium without royalty provided the copyright
notice and this notice are preserved. */
OUTPUT_FORMAT("elf32-littleriscv", "elf32-littleriscv",
"elf32-littleriscv")
OUTPUT_ARCH(riscv)
ENTRY(main)
SECTIONS
{
. = 0x80000000;
.text :
{
*(.text)
*(.text.unlikely .text.*_unlikely .text.unlikely.*)
*(.text.exit .text.exit.*)
*(.text.startup .text.startup.*)
*(.text.hot .text.hot.*)
*(.stub .text.* .gnu.linkonce.t.*)
/* .gnu.warning sections are handled specially by elf32.em. */
*(.gnu.warning)
}
.init :
{
KEEP (*(SORT_NONE(.init)))
}
.plt : { *(.plt) }
.iplt : { *(.iplt) }
.fini :
{
KEEP (*(SORT_NONE(.fini)))
}
PROVIDE (__etext = .);
PROVIDE (_etext = .);
PROVIDE (etext = .);
. = 0x81000000;
.rodata : { *(.rodata .rodata.* .gnu.linkonce.r.*) }
.rodata1 : { *(.rodata1) }
. = 0x82000000;
.comment : { *(.comment) }
}

278
src/harptool.cpp
View file

@ -50,163 +50,6 @@ HarpToolMode findMode(int argc, char** argv) {
return HARPTOOL_MODE_HELP;
}
int asm_main(int argc, char **argv) {
// string archString("8w32/32/8/8"), outFileName("a.out.HOF"),
// inFileName(argv[argc-1]);
// bool showHelp;
// /* Get command line arguments. */
// CommandLineArgFlag fh("-h", "--help", "", showHelp);
// CommandLineArgSetter<string>fo("-o", "--output", "", outFileName);
// CommandLineArgSetter<string>fa("-a", "--arch", "", archString);
// CommandLineArg::readArgs(argc-1, argv);
// if (showHelp || argc == 0) {
// cout << Help::asmHelp;
// exit(0);
// }
// ArchDef arch(archString);
// D(0, "Created ArchDef for " << string(arch));
// /* Create an appropriate encoder. */
// Encoder *enc;
// switch (arch.getEncChar()) {
// case 'b': enc = new ByteEncoder(arch); break;
// case 'w': enc = new WordEncoder(arch); break;
// defaulet:
// cout << "Unknown encoding type, \"" << arch.getEncChar() << "\"\n";
// exit(1);
// }
// /* Open files. */
// if (outFileName == "") {
// cout << "HARP Assembler: No output filename given.\n";
// exit(1);
// }
// ifstream asmFile(inFileName.c_str());
// ofstream outFile(outFileName.c_str());
// if (!asmFile) {
// cout << "Could not open \"" << inFileName << "\" for reading.\n";
// exit(1);
// }
// if (!outFile) {
// cout << "Could not open \"" << outFileName << "\" for writing.\n";
// exit(1);
// }
// /* Read an Obj from the assembly file. */
// D(0, "Passing AsmReader ArchDef: " << string(arch));
// AsmReader ar(arch);
// Obj *o = ar.read(asmFile);
// /* Encode the text chunks read from the assembly file. */
// for (Size j = 0; j < o->chunks.size(); j++) {
// Chunk *&c = o->chunks[j];
// TextChunk *tc;
// DataChunk *dc;
// if ((tc = dynamic_cast<TextChunk*>(c)) != NULL) {
// /* Encode it. */
// dc = new DataChunk(tc->name);
// enc->encodeChunk(*dc, *tc);
// /* Delete the text chunk. */
// delete tc;
// /* Do the switch. */
// c = dc;
// }
// }
// asmFile.close();
// delete enc;
// /* Write a HOF binary. */
// D(0, "Creating a HOFWriter, passing it ArchDef: " << string(arch));
// HOFWriter hw(arch);
// hw.write(outFile, *o);
// outFile.close();
// delete o;
return 0;
}
int disasm_main(int argc, char **argv) {
// bool showHelp;
// string outFileName("a.out.s"), archString("8w32/32/8/8");
// /* Get command line arguments. */
// CommandLineArgFlag fh("-h", "--help", "", showHelp);
// CommandLineArgSetter<string>fa("-a", "--arch", "", archString);
// CommandLineArgSetter<string>fo("-o", "--output", "", outFileName);
// if (argc != 0) CommandLineArg::readArgs(argc-1, argv);
// if (argc == 0 || showHelp) {
// cout << Help::disasmHelp;
// exit(0);
// }
// ifstream objFile(argv[argc-1]);
// ofstream outFile(outFileName.c_str());
// ArchDef arch(archString);
// if (!objFile) {
// cout << "Disassembler could not open \"" << argv[argc-1]
// << "\" for reading.\n";
// exit(1);
// }
// if (!outFile) {
// cout << "Disassembler could not open \"" << outFileName
// << "\" for output.\n";
// exit(1);
// }
// HOFReader hr(arch);
// Obj *o = hr.read(objFile);
// objFile.close();
// Decoder *dec;
// switch (arch.getEncChar()) {
// case 'b': dec = new ByteDecoder(arch); break;
// case 'w': dec = new WordDecoder(arch); break;
// default:
// cout << "Unrecognized encoding character for disassembler.\n";
// exit(1);
// }
// /* Decode the chunks read from the object. */
// for (Size j = 0; j < o->chunks.size(); j++) {
// Chunk *&c = o->chunks[j];
// if (c->flags & EX_USR) {
// TextChunk *tc;
// DataChunk *dc;
// if ((dc = dynamic_cast<DataChunk*>(c)) != NULL) {
// TextChunk *tc = new TextChunk(dc->name);
// dec->decodeChunk(*tc, *dc);
// delete dc;
// c = tc;
// }
// }
// }
// delete dec;
// AsmWriter aw(arch);
// aw.write(outFile, *o);
// outFile.close();
// delete o;
return 0;
}
int emu_main(int argc, char **argv) {
string archString("rv32i"), imgFileName("a.dsfsdout.bin");
bool showHelp, showStats, basicMachine, batch;
@ -267,129 +110,14 @@ int emu_main(int argc, char **argv) {
return 0;
}
int ld_main(int argc, char **argv) {
// bool showHelp, mustResolveRefs(true);
// string outFileName("a.out.bin"), archString("8w32/32/8/8"),
// formatString("bin");
// Size nObjects;
// Addr binOffset(0);
// /* Get command line arguments. */
// CommandLineArgFlag fh("-h", "--help", "", showHelp);
// CommandLineArgSetter<string>fa("-a", "--arch", "", archString);
// CommandLineArgSetter<string>ff("-f", "--format", "", formatString);
// CommandLineArgSetter<Addr> foffset("--offset", "", binOffset);
// CommandLineArgSetter<string>fo("-o", "--output", "", outFileName);
// int firstInput(0), newArgc;
// for (size_t i = 0; i < argc; i++) {
// if (*(argv[i]) != '-') { firstInput = i; newArgc = i; break; }
// else if (string(argv[i]) == "--") { firstInput = i+1; newArgc = i; break; }
// else i++; /* Skip both the switch and its argument. */
// }
// nObjects = argc - firstInput;
// if (argc != 0) CommandLineArg::readArgs(newArgc, argv);
// if (argc == 0 || showHelp) {
// cout << Help::ldHelp;
// exit(0);
// }
// if (firstInput == argc) {
// cout << "Linker: no input files given.\n";
// exit(1);
// }
// ArchDef arch(archString);
// /* Read all of the objects, assign addresses to their chunks, and place them
// in an address map.*/
// vector<Obj *> objects(nObjects);
// vector<DataChunk*> chunks;
// map<string, Addr> gChunkMap;
// Addr nextOffset(binOffset);
// for (Size i = 0; i < nObjects; i++) {
// map <string, Addr> lChunkMap;
// /* Read the object. */
// HOFReader hr(arch);
// ifstream objFile(argv[firstInput + i]);
// if (!objFile) {
// cout << "Could not open \"" << argv[firstInput + i]
// << "\" for reading.\n";
// exit(1);
// }
// objects[i] = hr.read(objFile);
// /* Assign addresses to chunks. */
// Obj &obj = *objects[i];
// for (Size j = 0; j < obj.chunks.size(); j++) {
// DataChunk *c = dynamic_cast<DataChunk*>(obj.chunks[j]);
// if (c->alignment != 0 && nextOffset % c->alignment)
// nextOffset += c->alignment - (nextOffset % c->alignment);
// c->bind(nextOffset);
// chunks.push_back(c);
// if (obj.chunks[j]->name != "") {
// if (c->isGlobal()) gChunkMap[c->name] = nextOffset;
// else lChunkMap[c->name] = nextOffset;
// }
// nextOffset += (c->size);
// }
// /* Resolve local references. */
// for (Size i = 0; i < obj.chunks.size(); i++) {
// DataChunk *dc = dynamic_cast<DataChunk*>(obj.chunks[i]);
// for (Size j = 0; j < dc->refs.size(); j++) {
// Ref &ref = *(dc->refs[j]);
// if (lChunkMap.find(dc->refs[j]->name) != lChunkMap.end()) {
// dc->refs[j]->bind(lChunkMap[dc->refs[j]->name],
// dc->address + dc->refs[j]->ibase);
// }
// }
// }
// }
// /* Resolve references. */
// for (Size i = 0; i < chunks.size(); i++) {
// DataChunk *dc = chunks[i];
// for (Size j = 0; j < dc->refs.size(); j++) {
// Ref &ref = *(dc->refs[j]);
// if (!ref.bound && (gChunkMap.find(ref.name) != gChunkMap.end())) {
// ref.bind(gChunkMap[ref.name], dc->address + ref.ibase);
// } else if (!ref.bound && mustResolveRefs) {
// cout << "Undefined symbol: \"" << ref.name << "\"\n";
// exit(1);
// }
// }
// }
// /* Write out the chunks. */
// ofstream outFile(outFileName.c_str());
// for (Size i = 0; i < chunks.size(); i++) {
// if (outFile.tellp() > chunks[i]->address - binOffset) {
// cout << "Linker internal error. Wrote past next chunk address.\n";
// exit(1);
// }
// while (outFile.tellp() < chunks[i]->address - binOffset) outFile.put('\0');
// outFile.seekp(chunks[i]->address - binOffset);
// outFile.write((char*)&chunks[i]->contents[0], chunks[i]->contents.size());
// }
// /* Clean up. */
// for (Size i = 0; i < nObjects; i++) delete objects[i];
return 0;
}
int main(int argc, char** argv) {
try {
switch (findMode(argc - 1, argv + 1)) {
case HARPTOOL_MODE_ASM: return asm_main (argc - 2, argv + 2);
case HARPTOOL_MODE_DISASM: return disasm_main(argc - 2, argv + 2);
case HARPTOOL_MODE_ASM: cout << "ASM not supported\n";
case HARPTOOL_MODE_DISASM: cout << "DISASM not supported\n";
case HARPTOOL_MODE_EMU: return emu_main (argc - 2, argv + 2);
case HARPTOOL_MODE_LD: return ld_main (argc - 2, argv + 2);
case HARPTOOL_MODE_LD: cout << "LD not supported\n";
case HARPTOOL_MODE_HELP:
default:
cout << "Usage:\n" << Help::mainHelp;

10
src/mem.cpp
View file

@ -178,16 +178,6 @@ Word MemoryUnit::fetch(Addr vAddr, bool sup) {
Word instruction = ad.read(pAddr, sup, 8*addrBytes);
// Flip endianess (instead of changing decoding logic)
// Word first = (instruction) & 0xFF;
// Word second = (instruction >> 8) & 0xFF;
// Word third = (instruction >> 16) & 0xFF;
// Word fourth = (instruction >> 24) & 0xFF;
// instruction = (instruction & 0xFFFFFF00) | fourth;
// instruction = (instruction & 0xFFFF00FF) | (third << 8);
// instruction = (instruction & 0xFF00FFFF) | (second << 16);
// instruction = (instruction & 0x00FFFFFF) | (first << 24);
return instruction;
}

748
src/obj.cpp
View file

@ -1,748 +0,0 @@
/*******************************************************************************
HARPtools by Chad D. Kersey, Summer 2011
*******************************************************************************/
// #include "include/types.h"
// #include "include/obj.h"
// #include "include/util.h"
// #include "include/asm-tokens.h"
// #include "include/debug.h"
// #include <iostream>
// #include <stdlib.h>
// #include <FlexLexer.h>
// #include <cctype>
// #include <cstdio>
// #include <cmath>
// #include <map>
// using namespace std;
// using namespace Harp;
// using namespace HarpTools;
// extern struct rval_t { std::string s; uint64_t u; } yylval;
// extern unsigned yyline;
// static void asmReaderError(unsigned line, const string &message) {
// cout << "Assembly reader error, line " << line << ": " << message << '\n';
// exit(1);
// }
// static int skip_parens(const string &s, int i) {
// int paren_level = 1;
// do {
// i++;
// if (s[i] == '(') paren_level++;
// if (s[i] == ')') paren_level--;
// } while (paren_level > 0);
// return i;
// }
// // Probably the worst recursive descent parser ever written, but it's an easy
// // way to make our assembly language prettier.
// static uint64_t rPE(bool &v, const string &s, const map<string, Word> &d,
// int start, int end)
// {
// D(2, "rPE(" << v << ", " << s << ", d, " << start << ", " << end << ");");
// if (end == start) { v = false; return 0; }
// while (isspace(s[start])) start++;
// while (isspace(s[end-1])) end--;
// for (int i = start; i < end; i++) {
// if (s[i] == '(') { i = skip_parens(s, i); continue; }
// if (s[i] == '<') return rPE(v, s, d, start, i) << rPE(v, s, d, i+2, end);
// if (s[i] == '>') return rPE(v, s, d, start, i) >> rPE(v, s, d, i+2, end);
// }
// for (int i = start; i < end; i++) {
// if (s[i] == '(') { i = skip_parens(s, i); continue; }
// if (s[i] == '+') return rPE(v, s, d, start, i) + rPE(v, s, d, i+1, end);
// if (s[i] == '-') {
// // If we've already failed, don't try this.
// if (v == false) return 0;
// // If it works as a binary -, return that. Otherwise, it's a unary -
// uint64_t x(rPE(v, s, d, start, i) - rPE(v, s, d, i+1, end));
// if (v) return x;
// else v = true;
// }
// if (s[i] == '|') return rPE(v, s, d, start, i) | rPE(v, s, d, i+1, end);
// if (s[i] == '^') return rPE(v, s, d, start, i) ^ rPE(v, s, d, i+1, end);
// }
// for (int i = start; i < end; i++) {
// if (s[i] == '(') { i = skip_parens(s, i); continue; }
// if (s[i] == '*') return rPE(v, s, d, start, i) * rPE(v, s, d, i+1, end);
// if (s[i] == '/') return rPE(v, s, d, start, i) / rPE(v, s, d, i+1, end);
// if (s[i] == '%') return rPE(v, s, d, start, i) % rPE(v, s, d, i+1, end);
// if (s[i] == '&') return rPE(v, s, d, start, i) & rPE(v, s, d, i+1, end);
// }
// // Unary operators
// if (s[start] == '-') return -rPE(v, s, d, start+1, end);
// if (s[start] == '`') return log2(rPE(v, s, d, start+1, end));
// if (isdigit(s[start])) {
// unsigned long long u;
// sscanf(s.substr(start, end-start).c_str(), "%lli", &u);
// return u;
// }
// if (s[start] == '(') return rPE(v, s, d, start+1, end-1);
// string label(s.substr(start, end-start));
// map<string, Word>::const_iterator it(d.find(label));
// if (it != d.end()) return it->second;
// // If nothing else works, set valid to false.
// v = 0;
// return 0;
// }
// static uint64_t readParenExpression(bool &valid, const string &s,
// const map<string, Word> &d)
// {
// valid = true;
// return rPE(valid, s, d, 0, s.length());
// }
// AsmReader::ArgType AsmReader::operandtype_table[][4] = {
// {AT_END}, // AC_NONE
// {AT_REG, AT_REG, AT_END}, // AC_2REG
// {AT_REG, AT_LIT, AT_END}, // AC_2IMM
// {AT_REG, AT_REG, AT_REG, AT_END}, // AC_3REG
// {AT_PREG, AT_PREG, AT_PREG, AT_END}, // AC_3PREG
// {AT_REG, AT_REG, AT_LIT, AT_END}, // AC_3IMM
// {AT_REG, AT_REG, AT_REG, AT_END}, // AC_3REGSRC
// {AT_LIT, AT_END}, // AC_1IMM
// {AT_REG, AT_END}, // AC_1REG
// {AT_REG, AT_REG, AT_LIT, AT_END}, // AC_3IMMSRC
// {AT_PREG, AT_REG, AT_END}, // AC_PREG_REG
// {AT_PREG, AT_PREG, AT_END}, // AC_2PREG
// {AT_REG, AT_REG, AT_END} // AC_2REGSRC
// };
// int lexerFloatBytes;
// Obj *AsmReader::read(std::istream &input) {
// lexerFloatBytes = wordSize;
// FlexLexer *f = new yyFlexLexer(&input);
// Obj *o = new Obj();
// std::vector<Chunk>::reverse_iterator cur;
// bool permR(true), permW(false), permX(false), entry(false), nextPred(false),
// global(false);
// map <string, Word> defs;
// /* Pre-defined defs. */
// defs["__WORD"] = wordSize;
// map <string, Instruction::Opcode> opMap;
// // Build opMap
// for (size_t i = 0; Instruction::instTable[i].opString; i++)
// opMap[std::string(Instruction::instTable[i].opString)]
// = Instruction::Opcode(i);
// enum {
// ST_INIT, ST_DEF1, ST_DEF2, ST_PERM, ST_WORD1, ST_SPACE, ST_STRING1,
// ST_STRING2, ST_BYTE1, ST_BYTE2, ST_ALIGN, ST_INST1, ST_INST2
// } state(ST_INIT);
// enum { OS_NOCHUNK, OS_TEXTCHUNK, OS_DATACHUNK } outstate(OS_NOCHUNK);
// TextChunk *tc;
// DataChunk *dc;
// Instruction *curInst;
// string string_arg, next_chunk_name;
// bool chunkCreated = true;
// Size next_chunk_align(0);
// uint64_t num_arg;
// RegNum nextPredNum;
// Instruction::ArgClass ac;
// int argPos;
// AsmTokens t;
// while ((t = (AsmTokens)f->yylex()) != 0) {
// switch (t) {
// case ASM_T_DIR_DEF:
// if (state == ST_INIT) state = ST_DEF1;
// else { asmReaderError(yyline, "Unexpected .def"); }
// break;
// case ASM_T_DIR_PERM:
// if (state == ST_INIT) {
// state = ST_PERM;
// permR = permW = permX = false;
// if (outstate != OS_NOCHUNK) {
// outstate = OS_NOCHUNK;
// entry = false;
// global = false;
// }
// } else { asmReaderError(yyline, "Unexpected .perm"); }
// break;
// case ASM_T_DIR_BYTE:
// if (state == ST_INIT) {
// state = ST_BYTE1;
// } else { asmReaderError(yyline, "Unexpected .byte"); }
// break;
// case ASM_T_DIR_WORD:
// if (state == ST_INIT) {
// state = ST_WORD1;
// } else { asmReaderError(yyline, "Unexpected .word"); }
// break;
// case ASM_T_DIR_SPACE:
// if (state == ST_INIT) state = ST_SPACE;
// else asmReaderError(yyline, "Unexpected .space");
// break;
// case ASM_T_DIR_STRING:
// if (state == ST_INIT) {
// state = ST_STRING1;
// } else { asmReaderError(yyline, "Unexpected .string"); }
// break;
// case ASM_T_DIR_ALIGN:
// if (state == ST_INIT) {
// state = ST_ALIGN;
// } else { asmReaderError(yyline, "Unexpected .align"); }
// break;
// case ASM_T_DIR_ENTRY:
// outstate = OS_NOCHUNK;
// entry = true;
// break;
// case ASM_T_DIR_GLOBAL:
// outstate = OS_NOCHUNK;
// global = true;
// break;
// case ASM_T_DIR_ARG_NUM:
// switch (state) {
// case ST_DEF2: defs[string_arg] = yylval.u; state = ST_INIT; break;
// case ST_WORD1: {
// if (outstate != OS_DATACHUNK) {
// outstate = OS_DATACHUNK;
// dc = new DataChunk(next_chunk_name, next_chunk_align?
// next_chunk_align:wordSize,
// flagsToWord(permR, permW, permX));
// next_chunk_align = 0;
// o->chunks.push_back(dc);
// if (entry) o->entry = o->chunks.size() - 1;
// if (global) dc->setGlobal();
// chunkCreated = true;
// }
// dc->size += wordSize;
// dc->contents.resize(dc->size);
// wordToBytes(&*(dc->contents.end()-wordSize), yylval.u, wordSize);
// } break;
// case ST_SPACE: {
// // TODO: the following statement is basically copied from above. Fix
// // this.
// if (outstate != OS_DATACHUNK) {
// outstate = OS_DATACHUNK;
// dc = new DataChunk(next_chunk_name, next_chunk_align?
// next_chunk_align:wordSize,
// flagsToWord(permR, permW, permX));
// next_chunk_align = 0;
// o->chunks.push_back(dc);
// if (entry) o->entry = o->chunks.size() - 1;
// if (global) dc->setGlobal();
// chunkCreated = true;
// }
// size_t oldSize = dc->size;
// dc->size += wordSize * yylval.u;
// dc->contents.resize(dc->size);
// for (size_t i = oldSize; i < dc->size; ++i) dc->contents[i] = 0;
// } break;
// case ST_BYTE1:
// if (outstate != OS_DATACHUNK) {
// // TODO: more of this pasted code
// outstate = OS_DATACHUNK;
// dc = new DataChunk(next_chunk_name,
// next_chunk_align?next_chunk_align:wordSize,
// flagsToWord(permR, permW, permX));
// next_chunk_align = 0;
// o->chunks.push_back(dc);
// if (entry) o->entry = o->chunks.size() - 1;
// if (global) dc->setGlobal();
// chunkCreated = true;
// }
// dc->size++;
// dc->contents.resize(dc->size);
// *(dc->contents.end() - 1) = yylval.u;
// state = ST_INIT;
// break;
// case ST_ALIGN:
// next_chunk_align = yylval.u;
// if (outstate != OS_NOCHUNK) {
// outstate = OS_NOCHUNK;
// entry = false;
// global = false;
// }
// state = ST_INIT;
// break;
// default: asmReaderError(yyline, "Unexpected literal argument");
// }
// break;
// case ASM_T_DIR_ARG_STRING:
// if (state == ST_STRING1) {
// if (outstate != OS_DATACHUNK) {
// // TODO: pasted code (see above)
// outstate = OS_DATACHUNK;
// dc = new DataChunk(next_chunk_name,
// next_chunk_align?next_chunk_align:wordSize,
// flagsToWord(permR, permW, permX));
// next_chunk_align = 0;
// o->chunks.push_back(dc);
// if (entry) o->entry = o->chunks.size() - 1;
// if (global) dc->setGlobal();
// chunkCreated = true;
// }
// const char *s = yylval.s.c_str();
// do {
// if (*s == '\\') {
// switch (*(++s)) {
// case 'n': dc->contents.push_back('\n'); break;
// case '"': dc->contents.push_back(*s); break;
// default: dc->contents.push_back(*s); break;
// }
// } else {
// dc->contents.push_back(*s);
// }
// dc->size++;
// } while(*(s++));
// } else {
// asmReaderError(yyline, "Unexpected string literal.");
// }
// state = ST_INIT;
// break;
// case ASM_T_DIR_ARG_SYM:
// switch (state) {
// case ST_DEF1: string_arg = yylval.s; state = ST_DEF2; break;
// default: asmReaderError(yyline, "");
// };
// break;
// case ASM_T_DIR_ARG_R:
// permR = true;
// break;
// case ASM_T_DIR_ARG_W:
// permW = true;
// break;
// case ASM_T_DIR_ARG_X:
// permX = true;
// break;
// case ASM_T_DIR_END:
// if (state == ST_INST1 || state == ST_INST2) {
// if (outstate == OS_TEXTCHUNK) {
// tc->instructions.push_back(curInst);
// } else {
// asmReaderError(yyline, "Inst not in text chunk(internal error)");
// }
// }
// state = ST_INIT;
// break;
// case ASM_T_LABEL:
// if (!chunkCreated) {
// // We have an empty label; create an empty chunk.
// dc = new DataChunk(next_chunk_name, 0,
// flagsToWord(permR, permW, permX));
// next_chunk_align = 0;
// o->chunks.push_back(dc);
// if (entry) o->entry = o->chunks.size() - 1;
// if (global) dc->setGlobal();
// }
// if (outstate != OS_NOCHUNK) {
// entry = false;
// global = false;
// outstate = OS_NOCHUNK;
// }
// next_chunk_name = yylval.s;
// chunkCreated = false;
// break;
// case ASM_T_PRED:
// nextPred = true;
// nextPredNum = yylval.u;
// break;
// case ASM_T_INST:
// if (state == ST_INIT) {
// map<string, Instruction::Opcode>::iterator
// opcIterator = opMap.find(yylval.s);
// if (opcIterator == opMap.end())
// asmReaderError(yyline, "Invalid Instruction");
// Instruction::Opcode opc = opcIterator->second;
// if (outstate != OS_TEXTCHUNK) {
// tc = new TextChunk(next_chunk_name, next_chunk_align,
// flagsToWord(permR, permW, permX));
// next_chunk_align = 0;
// o->chunks.push_back(tc);
// if (entry) o->entry = o->chunks.size() - 1;
// if (global) tc->setGlobal();
// outstate = OS_TEXTCHUNK;
// chunkCreated = true;
// }
// curInst = new Instruction();
// curInst->setOpcode(opc);
// ac = Instruction::instTable[opc].argClass;
// argPos = 0;
// if (nextPred) {
// nextPred = false;
// curInst->setPred(nextPredNum);
// }
// state = Instruction::instTable[opc].allSrcArgs?ST_INST2:ST_INST1;
// } else { asmReaderError(yyline, "Unexpected instruction"); }
// break;
// case ASM_T_PREG:
// if (operandtype_table[ac][argPos++] != AT_PREG)
// asmReaderError(yyline, "Unexpected predicate register");
// switch (state) {
// case ST_INST1: curInst->setDestPReg(yylval.u);
// state = ST_INST2;
// break;
// case ST_INST2: curInst->setSrcPReg(yylval.u);
// break;
// default: asmReaderError(yyline, "Unexpected predicate register");
// }
// break;
// case ASM_T_REG_RA:
// yylval.u = nRegs - 1;
// goto continue_reg;
// case ASM_T_REG_FP:
// yylval.u = nRegs - 3;
// goto continue_reg;
// case ASM_T_REG_SP:
// yylval.u = nRegs - 2;
// goto continue_reg;
// case ASM_T_REG:
// continue_reg:
// if (operandtype_table[ac][argPos++] != AT_REG)
// asmReaderError(yyline, "Unexpected register operand.");
// switch (state) {
// case ST_INST1: curInst->setDestReg(yylval.u);
// state = ST_INST2;
// break;
// case ST_INST2: curInst->setSrcReg(yylval.u);
// break;
// default: asmReaderError(yyline, "Unexpected register");
// }
// break;
// case ASM_T_PEXP: {
// // Decode the paren expression.
// bool valid;
// yylval.u = readParenExpression(valid, yylval.s, defs);
// if (!valid) asmReaderError(yyline, "Invalid paren expression");
// }
// case ASM_T_LIT:
// if (operandtype_table[ac][argPos++] != AT_LIT)
// asmReaderError(yyline, "Unexpected literal operand.");
// switch (state) {
// case ST_INST1: asmReaderError(yyline, "Unexpected literal");
// case ST_INST2: curInst->setSrcImm(yylval.u);
// break;
// default: asmReaderError(yyline, "Unexpected literal");
// }
// break;
// case ASM_T_SYM:
// if (operandtype_table[ac][argPos++] != AT_LIT)
// asmReaderError(yyline, "Unexpected symbol operand.");
// switch (state) {
// case ST_INST1: asmReaderError(yyline, "Unexpected symbol");
// case ST_INST2: if (defs.find(yylval.s) != defs.end()) {
// curInst->setSrcImm(defs[yylval.s]);
// } else {
// Ref *r = new
// SimpleRef(yylval.s, *curInst->setSrcImm(),
// curInst->hasRelImm());
// tc->refs.push_back(r);
// curInst->setImmRef(*r);
// }
// break;
// default: asmReaderError(yyline, "Unexpected symbol");
// }
// break;
// default: asmReaderError(yyline, "Invalid state(internal error)");
// };
// }
// if (!chunkCreated) {
// // We have an empty label; create an empty chunk.
// dc = new DataChunk(next_chunk_name, 0,
// flagsToWord(permR, permW, permX));
// next_chunk_align = 0;
// o->chunks.push_back(dc);
// if (entry) o->entry = o->chunks.size() - 1;
// if (global) dc->setGlobal();
// }
// return o;
// }
// void AsmWriter::write(std::ostream &output, const Obj &obj) {
// Word prevFlags(0);
// for (size_t j = 0; j < obj.chunks.size(); j++) {
// Chunk * const &c = obj.chunks[j];
// /* Write out the flags. */
// if (c->flags != prevFlags) {
// bool r, w, x;
// wordToFlags(r, w, x, c->flags);
// output << ".perm ";
// if (r) output << 'r';
// if (w) output << 'w';
// if (x) output << 'x';
// output << '\n';
// prevFlags = c->flags;
// }
// /* Write align if set. */
// if (c->alignment) output << ".align 0x" << hex << c->alignment << '\n';
// TextChunk * const tc = dynamic_cast<TextChunk* const>(c);
// DataChunk * const dc = dynamic_cast<DataChunk* const>(c);
// if (tc) {
// if (j == obj.entry) output << "\n.entry\n";
// if (c->isGlobal()) output << "\n.global\n";
// if (tc->name != "") output << tc->name << ':';
// for (size_t i = 0; i < tc->instructions.size(); i++) {
// output << "\t" << *(tc->instructions[i]) << '\n';
// }
// } else if (dc) {
// if (c->name != "") output << c->name << ':' << endl;
// Size i;
// for (i = 0; i < dc->contents.size();) {
// Size tmpWordSize = (dc->contents.size() - i < wordSize) ?
// dc->contents.size() - i : wordSize;
// i += tmpWordSize;
// Word w = 0;
// for (size_t j = 0; j < tmpWordSize; j++) {
// w <<= 8;
// w |= dc->contents[i - j - 1];
// }
// if (i == tmpWordSize && c->name != "")
// output << " .word " << " 0x" << hex << w << endl;
// else
// output << " .word " << " 0x" << hex << w << endl;
// }
// if (i % wordSize) i += (wordSize - (i%wordSize));
// if (dc->size > i) {
// Size fillSize = (dc->size - i)/wordSize;
// output << ".word 0x" << hex << fillSize << '\n';
// }
// } else {
// cout << "Unrecognized chunk type in AsmWriter.\n";
// exit(1);
// }
// }
// }
// enum HOFFlag { HOF_GLOBAL = 1 };
// Word getHofFlags(Chunk &c) {
// Word w = 0;
// if (c.isGlobal()) w |= HOF_GLOBAL;
// return w;
// }
// static void outputWord(std::ostream &out, Word w,
// vector<Byte> &tmp, Size wordSize)
// {
// Size n(0);
// writeWord(tmp, n, wordSize, w);
// out.write((char*)&tmp[0], wordSize);
// }
// void HOFWriter::write(std::ostream &output, const Obj &obj) {
// string archString(arch);
// Size wordSize(arch.getWordSize()), n, offsetVectorPos;
// vector<Byte> tmp;
// vector<Size> offsets(obj.chunks.size());
// /* Magic number, arch string, and padding. */
// output.write("HARP", 4);
// output.write(archString.c_str(), archString.length()+1);
// Size padBytes = (wordSize-(4+archString.length()+1)%wordSize)%wordSize;
// for (Size i = 0; i < padBytes; i++) output.put(0);
// /* Write out the entry chunk index. */
// outputWord(output, obj.entry, tmp, wordSize);
// /* Write out the number of chunks. */
// outputWord(output, obj.chunks.size(), tmp, wordSize);
// /* Skip the chunk size offset vector. */
// offsetVectorPos = output.tellp();
// output.seekp(output.tellp() + streampos(wordSize * obj.chunks.size()));
// /* Write out the chunks, keeping track of their offsets. */
// for (Size i = 0; i < obj.chunks.size(); i++) {
// offsets[i] = output.tellp();
// // Is it a data chunk?
// DataChunk *dc = dynamic_cast<DataChunk*>(obj.chunks[i]);
// if (!dc) { cout << "HOFWriter::write(): invalid chunk type.\n"; exit(1); }
// D(1, "Writing chunk \"" << dc->name << "\", size=" << dc->contents.size());
// // Chunk name
// output.write(dc->name.c_str(), dc->name.length() + 1);
// /* Padding */
// padBytes = (wordSize - (dc->name.length()+1)%wordSize)%wordSize;
// for (Size i = 0; i < padBytes; i++) output.put(0);
// /* Chunk alignment, flags, address, size (in RAM and disk) */
// outputWord(output, dc->alignment, tmp, wordSize);
// outputWord(output, dc->flags, tmp, wordSize);
// outputWord(output, getHofFlags(*dc), tmp, wordSize);
// outputWord(output, dc->bound?dc->address:0, tmp, wordSize);
// outputWord(output, dc->size, tmp, wordSize);
// outputWord(output, dc->contents.size(), tmp, wordSize);
// /* References */
// outputWord(output, dc->refs.size(), tmp, wordSize);
// for (Size j = 0; j < dc->refs.size(); j++) {
// OffsetRef *r = dynamic_cast<OffsetRef*>(dc->refs[j]);
// if (!r) { cout << "HOFWriter::write(): invalid ref type.\n"; exit(1); }
// /* Reference name */
// output.write(r->name.c_str(), r->name.length() + 1);
// /* Padding */
// padBytes = (wordSize - (r->name.length() + 1)%wordSize)%wordSize;
// for (Size i = 0; i < padBytes; i++) output.put(0);
// /* Compute flags word. */
// Word rFlags(0);
// if (r->relative) rFlags |= 1;
// /* Output flags word. */
// outputWord(output, rFlags, tmp, wordSize);
// /* Offset from which relative branches are computed. */
// outputWord(output, r->ibase, tmp, wordSize);
// /* Reference offset in block. */
// outputWord(output, r->getOffset(), tmp, wordSize);
// /* Reference size in bits. */
// outputWord(output, r->getBits(), tmp, wordSize);
// }
// /* Chunk data. */
// output.write((char*)&(dc->contents[0]), dc->contents.size());
// /* Chunk padding. */
// padBytes = (wordSize - dc->contents.size()%wordSize)%wordSize;
// for (Size i = 0; i < padBytes; i++) output.put(0);
// }
// /* Write out the chunk offset vector. */
// output.seekp(offsetVectorPos);
// for (Size i = 0; i < obj.chunks.size(); i++) {
// outputWord(output, offsets[i], tmp, wordSize);
// }
// }
// static Word inputWord(std::istream &input, Size wordSize, vector<Byte> &tmp) {
// Size n(0), pos(input.tellg());
// if (tmp.size() < wordSize) tmp.resize(wordSize);
// /* Seek to the next word-aligned place. */
// if (input.tellg()%wordSize) {
// input.seekg(input.tellg() +
// streampos((wordSize - input.tellg()%wordSize)%wordSize));
// }
// input.read((char*)&tmp[0], wordSize);
// return readWord(tmp, n, wordSize);
// }
// static string inputString(std::istream &input) {
// string s;
// char c;
// while (input && (c = input.get()) != '\0') s += c;
// return s;
// }
// Obj *HOFReader::read(std::istream &input) {
// Size wordSize(arch.getWordSize());
// Obj *o = new Obj();
// vector<Byte> tmp(4);
// input.read((char*)&tmp[0], 4);
// if (tmp[0] != 'H' || tmp[1] != 'A' || tmp[2] != 'R' || tmp[3] != 'P') {
// cout << "Bad magic number in HOFReader::read().\n";
// exit(1);
// }
// string archString(inputString(input));
// ArchDef fileArch(archString);
// if (fileArch != arch) {
// cout << "File arch " << archString << " does not match reader arch "
// << string(arch) << " in HOFReader::read().\n";
// exit(1);
// }
// o->entry = inputWord(input, wordSize, tmp);
// Size nChunks(inputWord(input, wordSize, tmp));
// vector<Size> chunkOffsets(nChunks);
// /* Read in the chunk offsets. */
// for (Size i = 0; i < nChunks; i++) {
// chunkOffsets[i] = inputWord(input, wordSize, tmp);
// }
// /* Read in the chunks. */
// o->chunks.resize(nChunks);
// for (Size i = 0; i < nChunks; i++) {
// input.seekg(chunkOffsets[i]);
// string name(inputString(input));
// Word alignment(inputWord(input, wordSize, tmp)),
// flags(inputWord(input, wordSize, tmp)),
// hofFlags(inputWord(input, wordSize, tmp)),
// address(inputWord(input, wordSize, tmp)),
// size(inputWord(input, wordSize, tmp)),
// dSize(inputWord(input, wordSize, tmp)),
// nRefs(inputWord(input, wordSize, tmp));
// DataChunk *dc = new DataChunk(name, alignment, flags);
// if (hofFlags & HOF_GLOBAL) dc->setGlobal();
// dc->address = address;
// dc->bound = address?true:false;
// dc->contents.resize(dSize);
// /* Get the refs. */
// for (Size j = 0; j < nRefs; j++) {
// string rName(inputString(input));
// Word rFlags(inputWord(input, wordSize, tmp)),
// ibase(inputWord(input, wordSize, tmp)),
// offset(inputWord(input, wordSize, tmp)),
// bits(inputWord(input, wordSize, tmp));
// OffsetRef *r =
// new OffsetRef(rName, dc->contents, offset, bits, wordSize, rFlags&1,
// ibase);
// dc->refs.push_back(r);
// }
// D(1, "Reading chunk \"" << name << "\", size " << dSize);
// /* Get the contents. */
// input.read((char*)&dc->contents[0], dSize);
// dc->size = size;
// o->chunks[i] = dc;
// }
// return o;
// }

2
src/riscv_gpgpu/Makefile
View file

@ -1,6 +1,6 @@
COMP = /opt/riscv/bin/riscv32-unknown-elf-gcc
CC_FLAGS = -march=rv32ic -mabi=ilp32 -O0 -Wl,-Bstatic,-T,linker.ld -ffreestanding -nostdlib
CC_FLAGS = -march=rv32i -mabi=ilp32 -O0 -Wl,-Bstatic,-T,linker.ld -ffreestanding -nostdlib
DMP = /opt/riscv/bin/riscv32-unknown-elf-objdump
CPY = /opt/riscv/bin/riscv32-unknown-elf-objcopy

1286
src/riscv_gpgpu/gpgpu_test.dump
View file

File diff suppressed because it is too large Load diff

BIN
src/riscv_gpgpu/gpgpu_test.elf
View file

Binary file not shown.

266
src/riscv_gpgpu/gpgpu_test.hex
View file

@ -1,117 +1,157 @@
:0200000480007A
:1000000037F1FF7FEF00600873000000B68B3A8C79
:10001000BE8C428D0A8FAA83054563597500130172
:1000200001802A836B5003000505C5BF7A81014515
:10003000B28F9E8DEBE0BF01170500001305053A56
:100040006B400500B708010023A0B80082801703A9
:1000500000001303E3FB6B0003008280511106C014
:100060002EC28345050081C5F13F0505DDBF8240F5
:10007000924531018280511106C02EC293050503BD
:10008000D1378240924531018280011106CE22CCC7
:100090000010232604FE15A80327C4FEBA878E0786
:1000A000998F8A07998F139747001D8F9317270001
:1000B0003E87B707008193874724BA973E85912AE8
:1000C0008327C4FE85072326F4FE0327C4FE9D472D
:1000D000E3D4E7FCB70700819387871F37070081C8
:1000E00013078717B70600819386861337060080AB
:1000F00013064617A145094541210945A12BB7071C
:10010000008113850704993FB70700811385C70550
:10011000B137232404FE3DA8832784FE3E852D2489
:10012000B707008113858706153FB70700810327AE
:1001300084FE0A079387871FBA979C433E8529242C
:10014000B70700811385C706113F832784FE850703
:100150002324F4FE032784FEBD47E3DFE7FAB70755
:10016000008113850707DD3D81473E85F2406244EB
:1001700005618280397106DE22DC80002326A4FC22
:100180002324B4FC99232326A4FE912B2324A4FE2C
:100190008D232322A4FE832784FC8E070327C4FC1F
:1001A000BA972320F4FE832704FE93B7B70093C7C2
:1001B0001700A30FF4FC8347F4FD3E8FB7070080C0
:1001C000938F27206B200F007B70FF01832704FE95
:1001D0008A070327C4FEBA979443832704FE8A073D
:1001E000032784FEBA979843832704FE8A070326D1
:1001F00044FEB297369798C3B7070080138E472006
:10020000028E01006B3000000100F2506254216147
:100210008280AA8201439D4323A0620023A2620040
:1002200023A4620023A6720023A862008280AA820F
:1002300003A38200050323A462001383420183AE5B
:10024000420093935E001E9303AE05002320C3017A
:1002500003AE45002322C30103AE85002324C3015E
:1002600003AEC5002326C30103AE05012328C30145
:1002700003AE4501232AC30103AE8501232CC3012C
:1002800003AEC501232EC301850E130F2003639413
:10029000EE01930E000023A2D2018280AA8203A362
:1002A00082007D1323A462001383420183AE020007
:1002B000930F2003768F050F6314FF01130F0000C7
:1002C00023A0E20193935E001E93032E030023A05C
:1002D000C501032E430023A2C501032E830023A4DE
:1002E000C501032EC30023A6C501032E030123A8C5
:1002F000C501032E430123AAC501032E830123ACAC
:10030000C501032EC30123AEC5018280AA8203A3C7
:10031000820013050000130E200363136E00050511
:100320008280AA8203A3820013050000130E00003E
:1003300063136E0005058280AA8203A3C20083A313
:10034000020133B563008280797106D622D4001889
:10035000232EA4FC0327C4FDBD4763EEE700B707C7
:1003600000810327C4FD0A079387871BBA979C4324
:100370003E85ED31B1A8930700022326F4FEA305C4
:1003800004FE8327C4FEF1170327C4FDB357F7000B
:10039000BD8B2322F4FE832744FE81C78547A30536
:1003A000F4FE8347B4FE81CFB7070081032744FEE4
:1003B0000A079387871BBA979C433E85453183275D
:1003C000C4FEF1172326F4FE8327C4FEE34BF0FAA4
:1003D000B250225445618280797106D622D46AD205
:1003E00000186A87BA878E07998F8A07998F1397A3
:1003F00047001D8F931727003E87B707008193871B
:100400004724BA973E85313FAA878DCBB707008135
:100410001385470DA131EA873E853D37B707008137
:100420001385C70D25396A87B73700819387474EF3
:10043000BA9705472380E700730000006A87BA87F0
:100440008E07998F8A07998F139747001D8F9317EF
:1004500027003E87B707008193874724BA97130781
:1004600004FDBA853E851D3D832784FD3E8103251D
:1004700044FD832504FD0326C4FD832604FE0327D3
:1004800044FE832784FE0328C4FE4936730000001F
:100490000100B2502254125D45618280397106DE3E
:1004A00022DC80008A89232604FE69A00327C4FE7B
:1004B000BA878E07998F8A07998F139747001D8FE8
:1004C000931727003E87B707008193874724BA9781
:1004D0003E85813DAA87B1EB0327C4FEBA878E070C
:1004E000998F8A07998F139747001D8F93172700BD
:1004F0003E87B707008193874724BA971307C4FC48
:10050000BA853E85613B832744FD3E81032504FD7A
:100510008325C4FC032684FD8326C4FD032704FE33
:10052000832744FE032884FE1D368327C4FE8507E7
:100530002326F4FE0327C4FE9947E3D9E7F64E814C
:100540000100F250625421618280797122D6001834
:10055000232EA4FC232604FE31A08327C4FE850796
:100560002326F4FE0327C4FE8327C4FDE347F7FEDA
:1005700001003254456182801D7186CEA2CC80106C
:10058000232EA4FA232CB4FA232AC4FA2328D4FA5B
:100590002326E4FA2324F4FA13090100232604FE97
:1005A000232404FE51A8C1794E91832784FE23247D
:1005B000F4FC832784FB2326F4FC8A872328F4FC9D
:1005C000832744FB232AF4FC832704FB232CF4FC1D
:1005D0008327C4FA232EF4FC832784FA2320F4FE15
:1005E0008327C4FE2322F4FE0327C4FEBA878E07A6
:1005F000998F8A07998F139747001D8F93172700AC
:100600003E87B707008193874724BA97130784FC76
:10061000BA853E8529398327C4FE85072326F4FE43
:100620000327C4FE994763D4E700232604FE8327EB
:1006300084FE85072324F4FE032784FE8327C4FB5E
:10064000E363F7F613010900913D0100F6406644AB
:1006500025618280797106D622D40018232EA4FC4D
:10066000B70700811385070ED53AA30704FE91A0B2
:100670008547A307F4FE232404FE35A08347F4FE38
:10068000373700819306474E032784FE369703478A
:100690000700F98FB337F000A307F4FE832784FE29
:1006A00085072324F4FE832784FE0327C4FDE3E7A4
:1006B000E7FC8347F4FE93C7170093F7F70FCDFBD2
:1006C0000100B250225445618280411122C65EC4AD
:1006D0000008DE873E853244A24B410182804111F1
:1006E00022C662C40008E2873E853244224C4101A2
:1006F0008280411122C666C40008E6873E853244E6
:06070000A24C41018280C1
:1000000037F1FF7FEF00C00C73000000938B0600F8
:10001000130C0700938C0700130D0800130F010049
:100020009303050013051000635C75001301018044
:10003000130305006B500300130515006FF0DFFE7E
:1000400013010F0013050000930F0600938D0300AA
:10005000EBE0BF01170500001305854B6B40050061
:10006000B708010023A0B800678000001703000054
:10007000130303FA6B00030067800000130141FFC4
:10008000232011002322B100834505006388050069
:10009000EFF01FFD130515006FF01FFF8320010017
:1000A000832541001301C10067800000130141FF57
:1000B000232011002322B10093050503EFF05FFA1E
:1000C00083200100832541001301C10067800000E7
:1000D000130101FE232E1100232C810013040102C1
:1000E000232604FE6F00C0040327C4FE9307070005
:1000F00093973700B387E74093972700B387E7408C
:10010000139747003307F74093172700138707001B
:10011000B707008193874724B307F70013850700CB
:10012000EF00401C8327C4FE938717002326F4FEAC
:100130000327C4FE93077000E3D8E7FAB7070081EE
:100140009387871F3707008113078717B70600813A
:1001500093868613370600801306062193058000D8
:1001600013052000EF00406013052000EF00007130
:10017000B707008113850704EFF05FF0B707008130
:100180001385C705EFF09FEF232404FE6F004005A1
:10019000832784FE13850700EF00002BB70700813B
:1001A00013858706EFF09FEDB7070081032784FED4
:1001B000131727009387871FB307F70083A707004C
:1001C00013850700EF004028B70700811385C70695
:1001D000EFF0DFEA832784FE938717002324F4FEE1
:1001E000032784FE9307F000E3D4E7FAB707008102
:1001F00013850707EFF09FE89307000013850700BA
:100200008320C101032481011301010267800000E2
:10021000130101FC232E1102232C8102130401047B
:100220002326A4FC2324B4FCEF00C06E2326A4FEE6
:10023000EF00C0702324A4FEEF00C0722322A4FEAE
:10024000832784FC939737000327C4FCB307F70088
:100250002320F4FE832704FE93B7B70093C717004B
:10026000A30FF4FC8347F4FD138F0700B70700804A
:10027000938F872C6B200F007B70FF01832704FE78
:10028000939727000327C4FEB307F70083A6070050
:10029000832704FE93972700032784FEB307F70004
:1002A00003A70700832704FE93972700032644FE35
:1002B000B307F6003387E60023A0E700B707008006
:1002C000138EC72C67000E00130000006B30000077
:1002D000130000008320C1030324810313010104E0
:1002E0006780000093020500130300009303700071
:1002F00023A0620023A2620023A4620023A672004E
:1003000023A86200678000009302050003A3820017
:100310001303130023A462001383420183AE42003F
:1003200093935E003303730003AE05002320C301E3
:1003300003AE45002322C30103AE85002324C3017D
:1003400003AEC5002326C30103AE05012328C30164
:1003500003AE4501232AC30103AE8501232CC3014B
:1003600003AEC501232EC301938E1E00130F20037D
:100370006394EE01930E000023A2D2016780000077
:100380009302050003A382001303F3FF23A462007A
:100390001383420183AE0200930F2003138F0E00DC
:1003A000130F1F006314FF01130F000023A0E201CD
:1003B00093935E0033037300032E030023A0C50153
:1003C000032E430023A2C501032E830023A4C501ED
:1003D000032EC30023A6C501032E030123A8C501D4
:1003E000032E430123AAC501032E830123ACC501BB
:1003F000032EC30123AEC5016780000093020500F0
:1004000003A3820013050000130E200363146E0083
:1004100013051500678000009302050003A3820006
:1004200013050000130E000063146E001305150081
:10043000678000009302050003A3C20083A30201AA
:1004400033B5630067800000130101FD232611020C
:100450002324810213040103232EA4FC0327C4FDDB
:100460009307F00063E4E702B70700810327C4FDA8
:10047000131727009387871BB307F70083A707008D
:1004800013850700EFF09FBF6F004007930700023E
:100490002326F4FEA30504FE8327C4FE9387C7FF2B
:1004A0000327C4FDB357F70093F7F7002322F4FEA8
:1004B000832744FE6386070093071000A305F4FE1C
:1004C0008347B4FE63820702B7070081032744FE17
:1004D000131727009387871BB307F70083A707002D
:1004E00013850700EFF09FB98327C4FE9387C7FFEA
:1004F0002326F4FE8327C4FEE340F0FA8320C102E2
:10050000032481021301010367800000130101FD30
:1005100023261102232481022322A10313040103B1
:1005200013070D009307070093973700B387E74041
:1005300093972700B387E740139747003307F740A7
:100540009317270013870700B70700819387472475
:10055000B307F70013850700EFF01FEC93070500C2
:1005600063820704B70700811385470DEFF01FB1C1
:1005700093070D0013850700EFF01FEDB70700810B
:100580001385C70DEFF09FAF13070D00B73700813C
:100590009387474EB307F700130710002380E70047
:1005A0007300000013070D009307070093973700AF
:1005B000B387E74093972700B387E7401397470037
:1005C0003307F7409317270013870700B707008109
:1005D00093874724B307F700130704FD930507002B
:1005E00013850700EFF0DFD9832784FD138107000F
:1005F000032544FD832504FD0326C4FD832604FE54
:10060000032744FE832784FE0328C4FEEFF01FA0C7
:1006100073000000130000008320C1020324810244
:10062000032D41021301010367800000130101FC47
:10063000232E1102232C81021304010493090100CB
:10064000232604FE6F00000C0327C4FE9307070057
:1006500093973700B387E74093972700B387E74026
:10066000139747003307F7409317270013870700B6
:10067000B707008193874724B307F7001385070066
:10068000EFF09FD993070500639807060327C4FE80
:100690009307070093973700B387E74093972700A6
:1006A000B387E740139747003307F74093172700B6
:1006B00013870700B707008193874724B307F70024
:1006C0001307C4FC9305070013850700EFF05FCB09
:1006D000832744FD13810700032504FD8325C4FC03
:1006E000032684FD8326C4FD032704FE832744FEDE
:1006F000032884FEEFF09F978327C4FE938717009B
:100700002326F4FE0327C4FE93076000E3DEE7F22E
:1007100013810900130000008320C1030324810317
:100720001301010467800000130101FD23268102EB
:1007300013040103232EA4FC232604FE6F000001F2
:100740008327C4FE938717002326F4FE0327C4FEE5
:100750008327C4FDE346F7FE130000000324C10213
:100760001301010367800000130101FA232E110415
:10077000232C810413040106232EA4FA232CB4FA9B
:10078000232AC4FA2328D4FA2326E4FA2324F4FAE9
:1007900013090100232604FE232404FE6F00800BAE
:1007A000B709FFFF33013101832784FE2324F4FCC2
:1007B000832784FB2326F4FC930701002328F4FC01
:1007C000832744FB232AF4FC832704FB232CF4FC1B
:1007D0008327C4FA232EF4FC832784FA2320F4FE13
:1007E0008327C4FE2322F4FE0327C4FE93070700D9
:1007F00093973700B387E74093972700B387E74085
:10080000139747003307F740931727001387070014
:10081000B707008193874724B307F700130784FCC9
:100820009305070013850700EFF01FAE8327C4FE72
:10083000938717002326F4FE0327C4FE9307600066
:1008400063D4E700232604FE832784FE93871700E2
:100850002324F4FE032784FE8327C4FBE362F7F41A
:1008600013010900EFF09FDC130000008320C10595
:10087000032481051301010667800000130101FDB7
:10088000232611022324810213040103232EA4FC36
:10089000B70700811385070EEFF04FFEA30704FE94
:1008A0006F00000593071000A307F4FE232404FE45
:1008B0006F0040038347F4FE373700819306474EAD
:1008C000032784FE3387E60003470700B3F7E700FA
:1008D000B337F000A307F4FE832784FE9387170045
:1008E0002324F4FE832784FE0327C4FDE3E4E7FC0E
:1008F0008347F4FE93C7170093F7F70FE39407FAC3
:10090000130000008320C1020324810213010103AC
:1009100067800000130101FF232681002324710159
:100920001304010193870B00138507000324C10002
:10093000832B81001301010167800000130101FF77
:1009400023268100232481011304010193070C0055
:10095000138507000324C100032C8100130101014A
:1009600067800000130101FF2326810023249101E9
:100970001304010193870C00138507000324C100B1
:0C098000832C810013010101678000003E
:02000004810079
:10000000300000003100000032000000330000002A
:10001000340000003500000036000000370000000A

142
src/scanner.lex
View file

@ -1,142 +0,0 @@
/*******************************************************************************
HARPtools by Chad D. Kersey, Summer 2011
*******************************************************************************/
%option c++
%option noyywrap
%{
#include <stdlib.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <string>
#include <iostream>
#include "include/asm-tokens.h"
#include "include/harpfloat.h"
extern int lexerFloatBytes;
static int64_t read_number(const char *s) {
while (!isdigit(*s) && *s != '-' && *s != '+') s++;
if (strchr(s, 'f') && !strchr(s, 'x') || strchr(s, '.')) {
double d;
sscanf(s, "%lf", &d);
return Harp::Word_u(Harp::Float(d, lexerFloatBytes));
} else {
long long u;
sscanf(s, "%lli", &u);
return u;
}
}
static std::string label_name(const char *cs) {
return std::string(cs, strlen(cs)-1);
}
struct rval_t { std::string s; uint64_t u; } yylval;
unsigned yyline(1);
using namespace HarpTools;
%}
%start DEFARGS PERMARGS WORDARGS STRINGARGS ALIGNARGS EMPTYARGS INSTARGS
%start EATCOLON
sym [A-Za-z_.][A-Za-z0-9_.]*
decnum [1-9][0-9]*
hexnum 0x[0-9a-f]+
octnum 0[0-7]*
floatnum ([0-9]+f|[0-9]*\.[0-9]+)
num [+-]?({decnum}|{hexnum}|{octnum}|{floatnum})
space [ \t]*
peoperator ("+"|"-"|"*"|"/"|"%"|"&"|"|"|"^"|"<<"|">>"|"`")
parenexp "("({num}|{sym}|{peoperator}|{space}|"("|")")+")"
endl \r?\n
%%
\/\*([^*]|\*[^/]|{endl})*\*\/ {
/* Ignore comments but keep line count consistent. */
for (const char *c = YYText(); *c; c++) if (*c == '\n') yyline++;
}
to
<INITIAL>\.def { BEGIN DEFARGS; return ASM_T_DIR_DEF; }
<INITIAL>\.perm { BEGIN PERMARGS; return ASM_T_DIR_PERM; }
<INITIAL>\.byte { BEGIN WORDARGS; return ASM_T_DIR_BYTE; }
<INITIAL>\.word { BEGIN WORDARGS; return ASM_T_DIR_WORD; }
<INITIAL>\.space { BEGIN WORDARGS; return ASM_T_DIR_SPACE; }
<INITIAL>\.string { BEGIN STRINGARGS; return ASM_T_DIR_STRING; }
<INITIAL>\.align { BEGIN ALIGNARGS; return ASM_T_DIR_ALIGN; }
<INITIAL>\.entry { BEGIN EMPTYARGS; return ASM_T_DIR_ENTRY; }
<INITIAL>\.global { BEGIN EMPTYARGS; return ASM_T_DIR_GLOBAL; }
<INITIAL>@p{num}{space}\? { yylval.u = read_number(YYText());
return ASM_T_PRED; }
<INITIAL>{sym}/: { BEGIN EATCOLON;
yylval.s = std::string(YYText());
return ASM_T_LABEL; }
<INITIAL>{sym} { BEGIN INSTARGS;
yylval.s = std::string(YYText());
return ASM_T_INST; }
<INITIAL>; {}
<INITIAL>{endl} {yyline++;}
<EATCOLON>: { BEGIN INITIAL; }
<INSTARGS>@p{num}{space}[,;]? { yylval.u = read_number(YYText());
return ASM_T_PREG; }
<INSTARGS>%r{num}{space}[,;]? { yylval.u = read_number(YYText());
return ASM_T_REG; }
<INSTARGS>%ra{space}[,;]? { return ASM_T_REG_RA; }
<INSTARGS>%sp{space}[,;]? { return ASM_T_REG_SP; }
<INSTARGS>%fp{space}[,;]? { return ASM_T_REG_FP; }
<INSTARGS>#{num}{space}[,;]? { yylval.u = read_number(YYText());
return ASM_T_LIT; }
<INSTARGS>{sym} { yylval.s = std::string(YYText()); return ASM_T_SYM; }
<INSTARGS>{parenexp} { yylval.s = std::string(YYText()); return ASM_T_PEXP; }
<INSTARGS>{space} {}
<INSTARGS>; { BEGIN INITIAL; return ASM_T_DIR_END; }
<INSTARGS>{endl} { BEGIN INITIAL; yyline++; return ASM_T_DIR_END; }
<DEFARGS>{sym} { yylval.s = std::string(YYText());
return ASM_T_DIR_ARG_SYM; }
<DEFARGS>{num} { yylval.u = read_number(YYText());
return ASM_T_DIR_ARG_NUM; }
<DEFARGS>{endl} { yyline++; BEGIN INITIAL; }
<PERMARGS>r { return ASM_T_DIR_ARG_R; }
<PERMARGS>w { return ASM_T_DIR_ARG_W; }
<PERMARGS>x { return ASM_T_DIR_ARG_X; }
<PERMARGS>{endl} { BEGIN INITIAL; yyline++; return ASM_T_DIR_END; }
<WORDARGS>{num} { yylval.u = read_number(YYText());
return ASM_T_DIR_ARG_NUM; }
<WORDARGS>{endl} { BEGIN INITIAL; yyline++; return ASM_T_DIR_END; }
<STRINGARGS>{sym} { yylval.s = std::string(YYText());
return ASM_T_DIR_ARG_SYM; }
<STRINGARGS>\"([^\"]|\\\")*\" { BEGIN INITIAL;
yylval.s = std::string(YYText());
yylval.s = yylval.s.substr(1,
yylval.s.length() - 2);
return ASM_T_DIR_ARG_STRING; }
<ALIGNARGS>{num} { yylval.u = read_number(YYText());
return ASM_T_DIR_ARG_NUM; }
<ALIGNARGS>{endl} { yyline++; BEGIN INITIAL; }
<EMPTYARGS>{endl} { yyline++; BEGIN INITIAL; }
{space} { /*Ignore inter-token whitespace.*/ }
. { std::cout << "Unexpected character on line " << std::dec << yyline << '\n';
exit(1); }

36
src/test/2thread.s
View file

@ -1,36 +0,0 @@
/* 2-SIMD-thread test program! */
.perm x
.entry
.global
entry: ldi %r0, #0;
ldi %r2, #1;
ldi %r1, Array2;
clone %r2;
ldi %r1, Array1;
ldi %r5, #2;
jalis %r5, %r5, sumArr;
ldi %r7, Array1;
ld %r7, %r7, #0;
jali %r5, printdec;
ldi %r7, Array2;;
ld %r7, %r7, #0;
jali %r5, printdec
trap;
/* Sum multiple arrays at once through the magic of SIMD! */
sumArr: ldi %r3, #0;
ldi %r4, #8;
loop: ld %r2, %r1, #0;
add %r3, %r3, %r2;
addi %r1, %r1, __WORD;
subi %r4, %r4, #1;
rtop @p0, %r4;
@p0 ? jmpi loop;
st %r3, %r1, (-__WORD*8)
jmprt %r5;
.perm rw
Array1: .word -1 -2 -3 -4 -5 -6 -7 -8
Array2: .word 1 2 3 4 5 6 7 8

82
src/test/2warp_matadd.s
View file

@ -1,82 +0,0 @@
/*******************************************************************************
Harptools by Chad D. Kersey, Summer 2011
********************************************************************************
Sample HARP assmebly program.
*******************************************************************************/
/* Divergent branch: test immediate postdominator branch divergence support. */
.def THREADS 8
.align 4096
.perm x
.entry
.global
entry: ldi %r20, #1
ldi %r21, Begin
wspawn %r20, %r21, %r20
ldi %r20, #0
Begin: ldi %r0, #1
ldi %r1, THREADS
tc_loop: clone %r0
addi %r0, %r0, #1
sub %r2, %r1, %r0
rtop @p0, %r2
@p0 ? jmpi tc_loop
ldi %r0, #0
jalis %r5, %r1, dthread;
ldi %r25, #55
ldi %r26, #1
bar %r25, %r26
subi %r20, %r20, #1
iszero @p0, %r20
@p0 ? trap;
ldi %r0, #0
ldi %r1, (__WORD * THREADS)
shli %r1, %r1, #1
ploop: ld %r7, %r0, RESULT
jali %r5, printdec
addi %r0, %r0, __WORD
sub %r7, %r1, %r0
rtop @p0, %r7
@p0 ? jmpi ploop
trap;
dthread: shli %r15, %r20 , #6
shli %r10, %r0 , #3
add %r10, %r10, %r15
ld %r11, %r10, Array1
ld %r12, %r10, Array2
subi %r13, %r0, #4
isneg @p0, %r13
@p0 ? split
@p0 ? jmpi SUBT
add %r14, %r11, %r12
jmpi after
SUBT: sub %r14, %r11, %r12
after: join
st %r14, %r10, RESULT
jmprt %r5;
.align 4096
Array1:
.word 1 5 10 0 3 1 1 2
.word 8 7 8 7 5 7 7 9
Array2:
.word 0 2 2 0 5 0 1 1
.word 4 2 2 0 3 2 3 2
RESULT: .space 512

42
src/test/Makefile
View file

@ -1,42 +0,0 @@
HARPLD = ../harptool -L
HARPAS = ../harptool -A
HARPEM = ../harptool -E -i
HARPDIS = ../harptool -D
4BARCH = 4b16/16/2/1
all: simple.bin sieve.bin 2thread.bin simple.4b.bin sieve.4b.bin 2thread.4b.bin bubble.bin bubble.4b.bin dotprod.bin dotprod.4b.bin matmul.bin matmul.4b.bin \
matmul-mt.s lfsr.bin diverge.bin matadd.bin 2warp_matadd.bin
run: simple.out sieve.out 2thread.out simple.4b.out sieve.4b.out 2thread.4b.out bubble.out bubble.4b.out dotprod.out dotprod.4b.out matmul.out matmul.4b.out\
matmul-mt.out lfsr.4b.out lfsr.out diverge.out matadd.out 2warp_matadd.out
disas: simple.d sieve.d 2thread.d simple.4b.d sieve.4b.d 2thread.4b.d bubble.d \
bubble.4b.d dotprod.d dotprod.4b.d matmul.d matmul.4b.d matmul-mt.d lfsr.d \
diverge.d matadd.d 2warp_matadd.d
%.4b.out : %.4b.bin
$(HARPEM) -a $(4BARCH) -c $< > $@
%.out : %.bin
$(HARPEM) -c $< > $@
%.4b.bin : boot.4b.HOF lib.4b.HOF %.4b.HOF
$(HARPLD) --arch $(4BARCH) -o $@ $^
%.bin : boot.HOF lib.HOF %.HOF
$(HARPLD) -o $@ $^
%.4b.HOF : %.s
$(HARPAS) --arch $(4BARCH) -o $@ $<
%.HOF : %.s
$(HARPAS) -o $@ $<
%.4b.d : %.4b.HOF
$(HARPDIS) -o $@ --arch $(4BARCH) $<
%.d : %.HOF
$(HARPDIS) -o $@ $<
clean:
rm -f *.HOF *.bin *.out *.d *~

52
src/test/boot.s
View file

@ -1,52 +0,0 @@
/* Bootstrap program for HARP. */
.perm x
.entry
boot: ldi %r5, kernEnt;
skep %r5;
/* ldi %r0, #1;
ldi %r1, #033;
ldi %r2, __WORD;
muli %r2, %r2, #8;
subi %r2, %r2, #1;
shl %r0, %r0, %r2;
tlbadd %r0, %r0, %r1; */
ei;
ldi %r5, entry;
jmpru %r5;
.perm x
/* The Kernel Entry Point / Interrupt service routine. */
kernEnt: subi %r0, %r0, #1;
rtop @p0, %r0;
@p0 ? jmpi kernEnt1; /* If it's not page not found, try again. */
ldi %r0, #077; /* Just map virt to phys, any address. */
tlbadd %r1, %r1, %r0;
reti;
kernEnt1: subi %r0, %r0, #7; /* If it's not console input, halt.*/
rtop @p0, %r0;
@p0 ? halt;
ldi %r8, #1;
ldi %r1, __WORD;
muli %r1, %r1, #8;
subi %r1, %r1, #1;
shl %r8, %r8, %r1;
ld %r0, %r8, #0;
subi %r1, %r0, #0x71
rtop @p0, %r1
notp @p0, @p0
@p0 ? halt; /* If it's 'q', halt. */
st %r0, %r8, #0;
ldi %r0, #0xa;
st %r0, %r8, #0;
reti;

56
src/test/bubble.s
View file

@ -1,56 +0,0 @@
/* Bubble Sort */
.def SIZE 100
.align 4096
.perm x
.global
entry: ldi %r1, Array; /* p = array; */
ldi %r6, ArrayEnd; /* lim = array+N */
oloop: /* do { */
ldi %r2, Array; /* q = array; */
ldi %r7, #1; /* sorted = 1; */
iloop:
sub %r3, %r2, %r6; /* while (q != lim) { */
iszero @p0, %r3;
@p0 ? jmpi onext;
ld %r3, %r2, #0; /* if (*q > *(q + 1)) { */
ld %r4, %r2, __WORD; /* temp = *(q + 1); */
sub %r5, %r4, %r3;
isneg @p0, %r5;
notp @p0, @p0;
@p0 ? jmpi inext;
st %r3, %r2, __WORD; /* *(q + 1) = *q; */
st %r4, %r2, #0; /* *q = temp; */
ldi %r7, #0; /* sorted = 0; */
/* } */
inext: addi %r2, %r2, __WORD; /* q++; */
jmpi iloop; /* } */
onext: addi %r1, %r1, __WORD; /* p++; */
subi %r6, %r6, __WORD; /* lim--; */
rtop @p0, %r7; /* } while (!sorted && p != array+N) */
@p0 ? jmpi printresults;
subi %r3, %r1, ArrayEnd;
rtop @p0, %r3;
@p0 ? jmpi oloop;
/* p = array; do { printdec(*p); p++; } while(p != array+N); */
printresults: ldi %r1, Array;
printloop: ld %r7, %r1, #0;
jali %r5, printdec;
addi %r1, %r1, __WORD;
subi %r2, %r1, ArrayEnd;
rtop @p0, %r2;
@p0 ? jmpi printloop;
trap;
.align 4096
.perm rw
Array:
.word 3 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3 2 3 8 4 6 2 6 4 3 3 8 3 2 7 9 5 0
.word 2 8 8 4 1 9 7 1 6 9 3 9 9 3 7 5 1 0 5 8 2 0 9 7 4 9 4 4 5 9 2 3 0
.word 7 8 1 6 4 0 6 2 8 6 2 0 8 9 9 8 6 2 8 0 3 4 8 2 5 3 4 2 1 1 7 0 6 7
ArrayEnd: .word 0

64
src/test/diverge.s
View file

@ -1,64 +0,0 @@
/*******************************************************************************
Harptools by Chad D. Kersey, Summer 2011
********************************************************************************
Sample HARP assmebly program.
*******************************************************************************/
/* Divergent branch: test immediate postdominator branch divergence support. */
.def THREADS 8
.align 4096
.perm x
.entry
.global
entry:
ldi %r0, #1
ldi %r1, THREADS
sloop: clone %r0
addi %r0, %r0, #1
sub %r2, %r1, %r0
rtop @p0, %r2
@p0 ? jmpi sloop
ldi %r0, #0
jalis %r5, %r1, dthread;
ldi %r0, #0
ldi %r1, (__WORD * THREADS)
ploop: ld %r7, %r0, array
jali %r5, printdec
addi %r0, %r0, __WORD
sub %r7, %r1, %r0
rtop @p0, %r7
@p0 ? jmpi ploop
trap;
dthread: ldi %r1, #10
ldi %r2, #0
loop: andi %r3, %r0, #1
rtop @p1, %r3
@p1 ? split
@p1 ? jmpi else
add %r2, %r2, %r0
jmpi after
else: sub %r2, %r2, %r0
after: join
subi %r1, %r1, #1
rtop @p0, %r1
@p0 ? jmpi loop
shli %r4, %r0, (`__WORD)
st %r2, %r4, array
jmprt %r5;
.align 4096
array: .space 4096

45
src/test/dotprod.s
View file

@ -1,45 +0,0 @@
/*******************************************************************************
HARPtools by Chad D. Kersey, Summer 2011
********************************************************************************
Sample HARP assmebly program.
*******************************************************************************/
/* Dot product: find scalar product of two vectors */
.def SIZE 0x1000
.align 4096
.perm x
.entry
.global
entry: ldi %r0, array_a;
ldi %r1, array_b;
ldi %r2, #10;
jali %r5, dotprod
ori %r7, %r0, #0;
jali %r5, printfloat;
trap;
/* Return in r0 dot product of vectors of real values pointed to by r0 and r1,
length in r2 */
dotprod: ldi %r3, #0;
dploop: ld %r4, %r0, #0;
ld %r6, %r1, #0;
subi %r2, %r2, #1;
addi %r0, %r0, __WORD;
addi %r1, %r1, __WORD;
rtop @p0, %r2;
fmul %r4, %r4, %r6;
fadd %r3, %r3, %r4;
@p0 ? jmpi dploop;
ori %r0, %r3, #0;
jmpr %r5;
.align 4096
.perm rw
array_a: .word 1.0 2.0 3.0 0.5 1.0 1.5 0.33 0.67 1.0 1.33
array_b: .word 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1f

26
src/test/lfsr.s
View file

@ -1,26 +0,0 @@
.perm x
.entry
.global
entry: ldi %r0, #0x1234;
ldi %r3, #100;
loop: ori %r7, %r0, #0;
jali %r5, printhex
jali %r5, lfsr_step
subi %r3, %r3, #1
rtop @p0, %r3
@p0 ? jmpi loop
halt
/* %r0: value and return value
* %r5: return address
*/
lfsr_step: shri %r1, %r0, #30
shri %r2, %r0, #2
xor %r1, %r1, %r2
andi %r1, %r1, #1
shli %r0, %r0, #1
or %r0, %r0, %r1
jmpr %r5

130
src/test/lib.s
View file

@ -1,130 +0,0 @@
/*******************************************************************************
HARPtools by Chad D. Kersey, Summer 2011
********************************************************************************
Sample HARP assmebly programs. These should work on anything from a 4x up.
*******************************************************************************/
/* Library: print decimals and strings! */
.perm x
.global
printhex: ldi %r8, (__WORD * 8);
ldi %r11, #1;
shli %r11, %r11, (__WORD*8 - 1);
printhex_l1: subi %r8, %r8, #4;
shr %r9, %r7, %r8;
andi %r9, %r9, #15;
subi %r10, %r9, #10;
isneg @p0, %r10;
notp @p1, @p0;
@p0 ? addi %r9, %r9, #0x30
@p1 ? addi %r9, %r10, #0x61
rtop @p0, %r8;
st %r9, %r11, #0;
@p0 ? jmpi printhex_l1;
ldi %r9, #0x0a;
st %r9, %r11, #0;
jmpr %r5;
.global
printfloat: ori %r10, %r5, #0;
ori %r11, %r7, #0;
ftoi %r7, %r7;
jali %r5, printdecint; /* Print whole part */
ldi %r8, #1;
shli %r8, %r8, (__WORD*8 -1 );
/* Print dot */
ldi %r7, #0x2e;
st %r7, %r8, #0;
ldi %r7, #10;
itof %r7, %r7;
ldi %r12, #3
pfloop: /* Print next decimal place */
subi %r12, %r12, #1;
rtop @p0, %r12;
fmul %r11, %r11, %r7;
ftoi %r9, %r11;
modi %r9, %r9, #10;
addi %r9, %r9, #0x30;
st %r9, %r8, #0;
@p0 ? jmpi pfloop;
ldi %r9, #0x0a;
st %r9, %r8, #0;
jmpr %r10;
printdecint: ldi %r8, #1;
shli %r8, %r8, (__WORD*8 - 1);
and %r6, %r8, %r7;
rtop @p0, %r6;
@p0 ? ldi %r6, #0x2d;
@p0 ? st %r6, %r8, #0;
@p0 ? neg %r7, %r7;
ldi %r9, #0;
printdec_l1: modi %r6, %r7, #10;
divi %r7, %r7, #10;
addi %r6, %r6, #0x30;
st %r6, %r9, digstack;
addi %r9, %r9, __WORD;
rtop @p0, %r7;
@p0 ? jmpi printdec_l1;
printdec_l2: subi %r9, %r9, __WORD;
ld %r6, %r9, digstack;
st %r6, %r8, #0;
rtop @p0, %r9;
@p0 ? jmpi printdec_l2;
jmpr %r5
.global
printdec: ori %r10, %r5, #0;
jali %r5, printdecint;
ldi %r6, #0x0a;
st %r6, %r8, #0;
jmpr %r10;
.global
puts: ldi %r8, #1;
shli %r8, %r8, (__WORD*8 - 1);
puts_l: ld %r6, %r7, #0;
andi %r6, %r6, #0xff;
rtop @p0, %r6;
notp @p0, @p0;
@p0 ? jmpi puts_end;
st %r6, %r8, #0;
addi %r7, %r7, #1;
jmpi puts_l;
puts_end: jmpr %r5
.global
rand: ldi %r0, #0;
ld %r0, %r0, rseed;
mul %r0, %r0, %r0;
shri %r0, %r0, #8;
ldi %r9, #0xffff;
and %r0, %r0, %r9;
ldi %r9, #0;
st %r0, %r9, rseed;
jmpr %r5;
.global
randf: ori %r10, %r5, #0;
jali %r5, rand;
ldi %r9, #1;
shli %r9, %r9, #16;
itof %r9, %r9;
itof %r0, %r0;
fdiv %r0, %r0, %r9;
jmpr %r10;
.perm rw
rseed: .word 0xface
digstack: .space 10

66
src/test/matadd.s
View file

@ -1,66 +0,0 @@
/*******************************************************************************
Harptools by Chad D. Kersey, Summer 2011
********************************************************************************
Sample HARP assmebly program.
*******************************************************************************/
/* Divergent branch: test immediate postdominator branch divergence support. */
.def THREADS 8
.align 4096
.perm x
.entry
.global
entry:
ldi %r0, #1
ldi %r1, THREADS
tc_loop: clone %r0
addi %r0, %r0, #1
sub %r2, %r1, %r0
rtop @p0, %r2
@p0 ? jmpi tc_loop
ldi %r0, #0
jalis %r5, %r1, dthread;
ldi %r0, #0
ldi %r1, (__WORD * THREADS)
ploop: ld %r7, %r0, RESULT
jali %r5, printdec
addi %r0, %r0, __WORD
sub %r7, %r1, %r0
rtop @p0, %r7
@p0 ? jmpi ploop
trap;
dthread: shli %r10, %r0 , #3
ld %r11, %r10, Array1
ld %r12, %r10, Array2
subi %r13, %r0, #4
isneg @p0, %r13
@p0 ? split
@p0 ? jmpi SUBT
add %r14, %r11, %r12
jmpi after
SUBT: sub %r14, %r11, %r12
after: join
st %r14, %r10, RESULT
jmprt %r5;
.align 4096
Array1:
.word 1 5 10 0
.word 3 1 1 2
Array2:
.word 0 2 2 0
.word 5 0 1 1
RESULT: .space 512

147
src/test/matmul-mt.s
View file

@ -1,147 +0,0 @@
/*******************************************************************************
Harptools by Chad D. Kersey, Summer 2011
********************************************************************************
Sample HARP assmebly program.
*******************************************************************************/
/* Matrix multiply: find matrix product */
.def THREADS 4
.align 4096
.perm x
.entry
.global
entry:
ldi %r0, matrix_a;
ldi %r1, #3;
jali %r5, matgen;
ldi %r0, matrix_b;
ldi %r1, #3;
jali %r5, matgen;
ldi %r0, matrix_a;
ldi %r1, matrix_b;
ldi %r2, matrix_r;
ldi %r3, #3;
jali %r5, matmul;
ldi %r0, #64;
ldi %r1, matrix_r;
ploop: ld %r7, %r1, #0;
jali %r5, printfloat;
subi %r0, %r0, #1;
addi %r1, %r1, __WORD;
rtop @p0, %r0;
@p0 ? jmpi ploop;
trap;
/* Generate a random 2^Nx2^N matrix at %r0, with N in %r1 */
matgen: ldi %r2, #0;
st %r5, %r2, retaddr;
ldi %r2, #1;
shl %r2, %r2, %r1;
shl %r2, %r2, %r1;
ori %r3, %r0, #0;
mgloop: jali %r5, randf;
st %r0, %r3, #0;
addi %r3, %r3, __WORD;
subi %r2, %r2, #1;
rtop @p0, %r2;
@p0 ? jmpi mgloop;
ldi %r2, #0;
ld %r5, %r2, retaddr;
jmpr %r5;
/* Write the matrix product of square matrix at (%r0) and (%r1) to (%r2). The
size of these matrices is 2^Nx2^N, where N = %r3 */
matmul: ori %r22, %r5, #0;
ldi %r4, #1;
ldi %r10, (`__WORD); /* ` is the log base 2 operator */
shl %r4, %r4, %r3;
add %r10, %r10, %r3;
ldi %r14, #1;
shl %r14, %r14, %r10;
shl %r17, %r14, %r3;
divi %r24, %r4, THREADS;
divi %r17, %r17, THREADS; /* Spawn threads */
divi %r24, %r4, THREADS;
ori %r18, %r0, #0;
ori %r19, %r2, #0;
ldi %r20, #0;
sloop: add %r0, %r0, %r17;
add %r2, %r2, %r17;
addi %r20, %r20, #1;
subi %r21, %r20, THREADS;
rtop @p0, %r21;
@p0 ? clone %r20;
@p0 ? jmpi sloop;
ori %r0, %r18, #0;
ori %r2, %r19, #0;
ldi %r20, THREADS;
jalis %r5, %r20, matmulthd;
jmpr %r22;
/* One thread of matrix multiplication. Expected register values at start:
* %r0 - matrix a pointer (plus offset)
* %r1 - matrix b pointer
* %r2 - destination matrix pointer (plus offset)
* %r24 - row count
*/
matmulthd: ldi %r9, #0; /* result row: %r9 */
rloop: ldi %r6, #0; /* result col: %r6 */
cloop: shli %r16, %r6, (`__WORD);
shl %r15, %r9, %r10;
add %r11, %r15, %r0;
add %r12, %r16, %r1;
ldi %r8, #0 /* dot prod position: %r8 */
ldi %r13, #0;
iloop: ld %r7, %r11, #0;
ld %r23, %r12, #0;
fmul %r7, %r7, %r23
fadd %r13, %r13, %r7;
addi %r8, %r8, #1;
addi %r11, %r11, __WORD;
add %r12, %r12, %r14;
sub %r7, %r8, %r4;
rtop @p0, %r7;
@p0 ? jmpi iloop;
add %r15, %r15, %r16;
add %r15, %r15, %r2;
st %r13, %r15, #0;
addi %r6, %r6, #1;
sub %r7, %r6, %r4;
rtop @p0, %r7;
@p0 ? jmpi cloop;
addi %r9, %r9, #1;
sub %r7, %r9, %r24;
rtop @p0, %r7;
@p0 ? jmpi rloop;
jmprt %r5;
.perm rw
.align 4096
matrix_a: .space 64
matrix_b: .space 64
matrix_r: .space 64
retaddr: .word 0

101
src/test/matmul.s
View file

@ -1,101 +0,0 @@
/*******************************************************************************
HARPtools by Chad D. Kersey, Summer 2011
********************************************************************************
Sample HARP assmebly program.
*******************************************************************************/
/* Matrix multiply: find matrix product */
.def SIZE 0x1000
.align 4096
.perm x
.entry
.global
entry: ldi %r0, matrix_a;
ldi %r1, matrix_b;
ldi %r2, matrix_r;
ldi %r3, #3;
jali %r5, matmul;
ldi %r0, #64;
ldi %r1, matrix_r;
ploop: ld %r7, %r1, #0;
jali %r5, printfloat;
subi %r0, %r0, #1;
addi %r1, %r1, __WORD;
rtop @p0, %r0;
@p0 ? jmpi ploop;
trap;
/* Write the matrix product of square matrix at (%r0) and (%r1) to (%r2). The
size of these matrices is 2^Nx2^N, where N = %r3 */
matmul: ldi %r4, #1;
ldi %r10, (`__WORD); /* ` is the log base 2 operator */
shl %r4, %r4, %r3;
add %r10, %r10, %r3;
ldi %r14, #1;
shl %r14, %r14, %r10;
ldi %r9, #0; /* result row: %r9 */
rloop: ldi %r6, #0; /* result col: %r6 */
cloop: shli %r16, %r6, (`__WORD);
shl %r15, %r9, %r10;
add %r11, %r15, %r0;
add %r12, %r16, %r1;
ldi %r13, #0;
ldi %r8, #0 /* dot prod position: %r8 */
iloop: ld %r7, %r11, #0;
ld %r17, %r12, #0;
fmul %r7, %r7, %r17
fadd %r13, %r13, %r7;
addi %r8, %r8, #1;
addi %r11, %r11, __WORD;
add %r12, %r12, %r14;
sub %r7, %r8, %r4;
rtop @p0, %r7;
@p0 ? jmpi iloop;
add %r15, %r15, %r16;
add %r15, %r15, %r2;
st %r13, %r15, #0;
addi %r6, %r6, #1;
sub %r7, %r6, %r4;
rtop @p0, %r7;
@p0 ? jmpi cloop;
addi %r9, %r9, #1;
sub %r7, %r9, %r14;
rtop @p0, %r7;
@p0 ? jmpi rloop;
jmpr %r5;
.align 4096
.perm rw
matrix_a: .word 1f 2f 3f 4f 5f 6f 7f 8f
.word 2f 3f 4f 5f 6f 7f 8f 9f
.word 3f 4f 5f 6f 7f 8f 9f 10f
.word 4f 5f 6f 7f 8f 9f 10f 11f
.word 5f 6f 7f 8f 9f 10f 11f 12f
.word 6f 7f 8f 9f 10f 11f 12f 13f
.word 7f 8f 9f 10f 11f 12f 13f 14f
.word 8f 9f 10f 11f 12f 13f 14f 15f
matrix_b: .word 0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7
.word 1.0 1.1 1.2 1.3 1.4 1.5 1.6 1.7
.word 2.0 2.1 2.2 2.3 2.4 2.5 2.6 2.7
.word 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7
.word 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7
.word 5.0 5.1 5.2 5.3 5.4 5.5 5.6 5.7
.word 6.0 6.1 6.2 6.3 6.4 6.5 6.6 6.7
.word 7.0 7.1 7.2 7.3 7.4 7.5 7.6 7.7
matrix_r: .space 64
retaddr: .word 0

74
src/test/sieve.s
View file

@ -1,74 +0,0 @@
/*******************************************************************************
HARPtools by Chad D. Kersey, Summer 2011
********************************************************************************
Sample HARP assmebly program.
*******************************************************************************/
/* sieve of eratosthanes: Find some primes. */
.def SIZE 0x1000
.align 4096
.perm x
.entry
.global
entry:
ldi %r0, #2;
loop1: addi %r7, %r0, #0;
muli %r1, %r0, __WORD;
st %r0, %r1, array;
addi %r0, %r0, #1;
subi %r1, %r0, SIZE;
rtop @p0, %r1;
@p0 ? jmpi loop1;
ldi %r0, #1;
loop2: addi %r0, %r0, #1;
muli %r1, %r0, __WORD;
ld %r1, %r1, array;
rtop @p0, %r1;
notp @p0, @p0;
@p0 ? jmpi loop2;
mul %r2, %r1, %r1;
subi %r3, %r2, SIZE;
neg %r3, %r3
isneg @p0, %r3;
@p0 ? jmpi end;
ldi %r3, #0;
loop3: muli %r4, %r2, __WORD;
st %r3, %r4, array;
add %r2, %r2, %r1;
ldi %r4, SIZE;
sub %r4, %r2, %r4;
isneg @p0, %r4;
notp @p0, @p0;
@p0 ? jmpi loop2;
jmpi loop3;
end: ldi %r0, __WORD;
shli %r0, %r0, #1;
ldi %r11, #0;
loop4: ld %r1, %r0, array;
rtop @p0, %r1;
@p0 ? addi %r7, %r1, #0;
@p0 ? jali %r5, printdec;
rtop @p0, %r1;
@p0 ? addi %r11, %r11, #1;
addi %r0, %r0, __WORD;
ldi %r5, __WORD;
muli %r5, %r5, SIZE;
sub %r1, %r0, %r5;
rtop @p0, %r1;
@p0 ? jmpi loop4;
addi %r7, %r11, #0;
jali %r5, printdec;
trap; /* All traps currently cause a halt. */
.perm rw
.global
array: .space 0x1000 /* SIZE words of space. */

32
src/test/simple.s
View file

@ -1,32 +0,0 @@
/*******************************************************************************
HARPtools by Chad D. Kersey, Summer 2011
********************************************************************************
Sample HARP assmebly program.
*******************************************************************************/
/* Simple example. */
.align 4096
.perm x
.entry
.global
entry: ldi %r0, wentry
ldi %r7, hello2
/* wspawn %r0, %r7 */
ldi %r0, hello1
wentry: ori %r7, %r0, #0
jali %r5, puts
trap; /* All traps currently cause a halt. */
.perm rw
hello1:
.byte 0x22
.string "Harp!\" is how a harp seal says hello!\n"
hello2:
.string "This is a string for another thread!\n"

53
src/unit_test/float_test.cpp
View file

@ -1,53 +0,0 @@
#include "include/harpfloat.h"
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
using namespace Harp;
using namespace std;
static void try_val(double d, Size sz) {
Float f(d, sz);
Word w(f);
double e(Float(w, sz));
printf("%uB: %g -> 0x%llx -> %g\n", sz, d, (unsigned long long)w, e);
}
int main() {
/* Loop over available integer sizes. */
unsigned randseed(time(NULL));
for (unsigned sz = 1; sz <= 8; sz++) {
srand(randseed);
/* First test some random ordinary numbers and their conversions. */
for (unsigned i = 0; i < 2; i++) {
int n = rand() - RAND_MAX/2;
double d = n * 0.0000001;
// Sometimes do negative numbers.
if (rand() & 1) d = -d;
try_val(d, sz);
}
/* Next, let's try +/- infinity. */
for (unsigned i = 0; i < 2; i++) {
double d(i?HUGE_VAL:-HUGE_VAL);
try_val(d, sz);
}
/* Last, let's try some random subnormal numbers and their conversions. */
double mote;
if (sz < 4) mote = pow(2, int(-14 - (sz*8 - 6)));
else if (sz < 8) mote = pow(2, int(-126 - (sz*8 - 9)));
else mote = pow(2, int(-1022 - (sz*8 - 12)));
for (unsigned i = 0; i < 2; i++) {
int n = rand()%256;
double d = n * mote;
try_val(d, sz);
}
}
return 0;
}

25
src/unit_test/qsim_test.cpp
View file

@ -1,25 +0,0 @@
#include <iostream>
#include <iomanip>
#include "include/qsim-harp.h"
class CallbackAdaptor {
public:
void inst_cb(int c, uint64_t v, uint64_t p, uint8_t l, const uint8_t *b,
enum inst_type t)
{
std::cout << "Inst @ 0x" << std::hex << v << "(0x" << p << ")\n";
}
} cba;
int main(int argc, char** argv) {
Harp::ArchDef arch("8w32/32/8");
Harp::OSDomain osd(arch, std::string("../test/sieve.bin"));
osd.set_inst_cb(&cba, &CallbackAdaptor::inst_cb);
for (unsigned i = 0; i < 1000; ++i) {
osd.run(0, 1);
}
return 0;
}