:(before "End Primitive Recipe Declarations")
_BROWSE_TRACE,
:(before "End Primitive Recipe Numbers")
put(Recipe_ordinal, "$browse-trace", _BROWSE_TRACE);
:(before "End Primitive Recipe Checks")
case _BROWSE_TRACE: {
break;
}
:(before "End Primitive Recipe Implementations")
case _BROWSE_TRACE: {
start_trace_browser();
break;
}
:(before "End Globals")
set<long long int> Visible;
long long int Top_of_screen = 0;
long long int Last_printed_row = 0;
map<int, long long int> Trace_index; // screen row -> trace index
:(code)
void start_trace_browser() {
if (!Trace_stream) return;
cerr << "computing depth to display\n";
long long int min_depth = 9999;
for (long long int i = 0; i < SIZE(Trace_stream->past_lines); ++i) {
trace_line& curr_line = Trace_stream->past_lines.at(i);
if (curr_line.depth == 0) continue;
if (curr_line.depth < min_depth) min_depth = curr_line.depth;
}
cerr << "depth is " << min_depth << '\n';
cerr << "computing lines to display\n";
for (long long int i = 0; i < SIZE(Trace_stream->past_lines); ++i) {
if (Trace_stream->past_lines.at(i).depth == min_depth)
Visible.insert(i);
}
tb_init();
Display_row = Display_column = 0;
tb_event event;
Top_of_screen = 0;
refresh_screen_rows();
while (true) {
render();
do {
tb_poll_event(&event);
} while (event.type != TB_EVENT_KEY);
long long int key = event.key ? event.key : event.ch;
if (key == 'q' || key == 'Q') break;
if (key == 'j' || key == TB_KEY_ARROW_DOWN) {
// move cursor one line down
if (Display_row < Last_printed_row) ++Display_row;
}
if (key == 'k' || key == TB_KEY_ARROW_UP) {
// move cursor one line up
if (Display_row > 0) --Display_row;
}
if (key == 'H') {
// move cursor to top of screen
Display_row = 0;
}
if (key == 'M') {
// move cursor to center of screen
Display_row = tb_height()/2;
}
if (key == 'L') {
// move cursor to bottom of screen
Display_row = tb_height()-1;
}
if (key == 'J' || key == TB_KEY_PGDN) {
// page-down
if (Trace_index.find(tb_height()-1) != Trace_index.end()) {
Top_of_screen = Trace_index[tb_height()-1]+1;
refresh_screen_rows();
}
}
if (key == 'K' || key == TB_KEY_PGUP) {
// page-up is more convoluted
for (int screen_row = tb_height(); screen_row > 0 && Top_of_screen > 0; --screen_row) {
--Top_of_screen;
if (Top_of_screen <= 0) break;
while (Top_of_screen > 0 && !contains_key(Visible, Top_of_screen))
--Top_of_screen;
}
if (Top_of_screen > 0)
refresh_screen_rows();
}
if (key == 'G') {
// go to bottom of screen; largely like page-up, interestingly
Top_of_screen = SIZE(Trace_stream->past_lines)-1;
for (int screen_row = tb_height(); screen_row > 0 && Top_of_screen > 0; --screen_row) {
--Top_of_screen;
if (Top_of_screen <= 0) break;
while (Top_of_screen > 0 && !contains_key(Visible, Top_of_screen))
--Top_of_screen;
}
refresh_screen_rows();
// move cursor to bottom
Display_row = Last_printed_row;
refresh_screen_rows();
}
if (key == TB_KEY_CARRIAGE_RETURN) {
// expand lines under current by one level
assert(contains_key(Trace_index, Display_row));
long long int start_index = Trace_index[Display_row];
long long int index = 0;
// simultaneously compute end_index and min_depth
int min_depth = 9999;
for (index = start_index+1; index < SIZE(Trace_stream->past_lines); ++index) {
if (contains_key(Visible, index)) break;
trace_line& curr_line = Trace_stream->past_lines.at(index);
if (curr_line.depth == 0) continue;
assert(curr_line.depth > Trace_stream->past_lines.at(start_index).depth);
if (curr_line.depth < min_depth) min_depth = curr_line.depth;
}
long long int end_index = index;
// mark as visible all intervening indices at min_depth
for (index = start_index; index < end_index; ++index) {
trace_line& curr_line = Trace_stream->past_lines.at(index);
if (curr_line.depth == min_depth) {
Visible.insert(index);
}
}
refresh_screen_rows();
}
if (key == TB_KEY_BACKSPACE || key == TB_KEY_BACKSPACE2) {
// collapse all lines under current
assert(contains_key(Trace_index, Display_row));
long long int start_index = Trace_index[Display_row];
long long int index = 0;
// end_index is the next line at a depth same as or lower than start_index
int initial_depth = Trace_stream->past_lines.at(start_index).depth;
for (index = start_index+1; index < SIZE(Trace_stream->past_lines); pre { line-height: 125%; }
td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
.highlight .hll { background-color: #ffffcc }
.highlight .c { color: #888888 } /* Comment */
.highlight .err { color: #a61717; background-color: #e3d2d2 } /* Error */
.highlight .k { color: #008800; font-weight: bold } /* Keyword */
.highlight .ch { color: #888888 } /* Comment.Hashbang */
.highlight .cm { color: #888888 } /* Comment.Multiline */
.highlight .cp { color: #cc0000; font-weight: bold } /* Comment.Preproc */
.highlight .cpf { color: #888888 } /* Comment.PreprocFile */
.highlight .c1 { color: #888888 } /* Comment.Single */
.highlight .cs { color: #cc0000; font-weight: bold; background-color: #fff0f0 } /* Comment.Special */
.highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */
.highlight .ge { font-style: italic } /* Generic.Emph */
.highlight .ges { font-weight: bold; font-style: italic } /* Generic.EmphStrong */
.highlight .gr { color: #aa0000 } /* Generic.Error */
.highlight .gh { color: #333333 } /* Generic.Heading */
.highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */
.highlight .go { color: #888888 } /* Generic.Output */
.highlight .gp { color: #555555 } /* Generic.Prompt */
.highlight .gs { font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #666666 } /* Generic.Subheading */
.highlight .gt { color: #aa0000 } /* Generic.Traceback */
.highlight .kc { color: #008800; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #008800; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #008800; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #008800 } /* Keyword.Pseudo */
.highlight .kr { color: #008800; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #888888; font-weight: bold } /* Keyword.Type */
.highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */
.highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */
.highlight .na { color: #336699 } /* Name.Attribute */
.highlight .nb { color: #003388 } /* Name.Builtin */
.highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */
.highlight .no { color: #003366; font-weight: bold } /* Name.Constant */
.highlight .nd { color: #555555 } /* Name.Decorator */
.highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */
.highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */
.highlight .nl { color: #336699; font-style: italic } /* Name.Label */
.highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */
.highlight .py { color: #336699; font-weight: bold } /* Name.Property */
.highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #336699 } /* Name.Variable */
.highlight .ow { color: #008800 } /* Operator.Word */
.highlight .w { color: #bbbbbb } /* Text.Whitespace */
.highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */
.highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */
.highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */
.highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */
.highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */
.highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */
.highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */
.highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */
.highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */
.highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */
.highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */
.highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */
.highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */
.highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */
.highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */
.highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */
.highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */
.highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */
.highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */
.highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */
.highlight .vc { color: #336699 } /* Name.Variable.Class */
.highlight .vg { color: #dd7700 } /* Name.Variable.Global */
.highlight .vi { color: #3333bb } /* Name.Variable.Instance */
.highlight .vm { color: #336699 } /* Name.Variable.Magic */
.highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long *///: The bedrock level 1 of abstraction is now done, and we're going to start
//: building levels above it that make programming in x86 machine code a
//: little more ergonomic.
//:
//: All levels will be "pass through by default". Whatever they don't
//: understand they will silently pass through to lower levels.
//:
//: Since raw hex bytes of machine code are always possible to inject, SubX is
//: not a language, and we aren't building a compiler. This is something
//: deliberately leakier. Levels are more for improving auditing, checks and
//: error messages rather than for hiding low-level details.
//: Translator workflow: read 'source' file. Run a series of transforms on it,
//: each passing through what it doesn't understand. The final program should
//: be just machine code, suitable to write to an ELF binary.
//:
//: Higher levels usually transform code on the basis of metadata.
:(before "End Main")
if (is_equal(argv[1], "translate")) {
START_TRACING_UNTIL_END_OF_SCOPE;
reset();
// Begin subx translate
program p;
string output_filename;
for (int i = /*skip 'subx translate'*/2; i < argc; ++i) {
if (is_equal(argv[i], "-o")) {
++i;
if (i >= argc) {
print_translate_usage();
cerr << "'-o' must be followed by a filename to write results to\n";
exit(1);
}
output_filename = argv[i];
}
else {
ifstream fin(argv[i]);
if (!fin) {
cerr << "could not open " << argv[i] << '\n';
return 1;
}
parse(fin, p);
if (trace_contains_errors()) return 1;
}
}
if (p.segments.empty()) {
print_translate_usage();
cerr << "nothing to do; must provide at least one file to read\n";
exit(1);
}
if (output_filename.empty()) {
print_translate_usage();
cerr << "must provide a filename to write to using '-o'\n";
exit(1);
}
transform(p);
if (trace_contains_errors()) return 1;
save_elf(p, output_filename);
if (trace_contains_errors()) {
unlink(output_filename.c_str());
return 1;
}
// End subx translate
return 0;
}
:(code)
void print_translate_usage() {
cerr << "Usage: subx translate file1 file2 ... -o output\n";
}
// write out a program to a bare-bones ELF file
void save_elf(const program& p, const string& filename) {
ofstream out(filename.c_str(), ios::binary);
write_elf_header(out, p);
for (size_t i = 0; i < p.segments.size(); ++i)
write_segment(p.segments.at(i), out);
out.close();
}
void write_elf_header(ostream& out, const program& p) {
char c = '\0';
#define O(X) c = (X); out.write(&c, sizeof(c))
// host is required to be little-endian
#define emit(X) out.write(reinterpret_cast<const char*>(&X), sizeof(X))
//// ehdr
// e_ident
O(0x7f); O(/*E*/0x45); O(/*L*/0x4c); O(/*F*/0x46);
O(0x1); // 32-bit format
O(0x1); // little-endian
O(0x1); O(0x0);
for (size_t i = 0; i < 8; ++i) { O(0x0); }
// e_type
O(0x02); O(0x00);
// e_machine
O(0x03); O(0x00);
// e_version
O(0x01); O(0x00); O(0x00); O(0x00);
// e_entry
int e_entry = p.segments.at(0).start; // convention
emit(e_entry);
// e_phoff -- immediately after ELF header
int e_phoff = 0x34;
emit(e_phoff);
// e_shoff; unused
int dummy32 = 0;
emit(dummy32);
// e_flags; unused
emit(dummy32);
// e_ehsize
uint16_t e_ehsize = 0x34;
emit(e_ehsize);
// e_phentsize
uint16_t e_phentsize = 0x20;
emit(e_phentsize);
// e_phnum
uint16_t e_phnum = SIZE(p.segments);
emit(e_phnum);
// e_shentsize
uint16_t dummy16 = 0x0;
emit(dummy16);
// e_shnum
emit(dummy16);
// e_shstrndx
emit(dummy16);
uint32_t p_offset = /*size of ehdr*/0x34 + SIZE(p.segments)*0x20/*size of each phdr*/;
for (int i = 0; i < SIZE(p.segments); ++i) {
//// phdr
// p_type
uint32_t p_type = 0x1;
emit(p_type);
// p_offset
emit(p_offset);
// p_vaddr
uint32_t p_start = p.segments.at(i).start;
emit(p_start);
// p_paddr
emit(p_start);
// p_filesz
uint32_t size = num_words(p.segments.at(i));
assert(p_offset + size < SEGMENT_ALIGNMENT);
emit(size);
// p_memsz
emit(size);
// p_flags
uint32_t p_flags = (i == 0) ? /*r-x*/0x5 : /*rw-*/0x6; // convention: only first segment is code
emit(p_flags);
// p_align
// "As the system creates or augments a process image, it logically copies
// a file's segment to a virtual memory segment. When—and if— the system
// physically reads the file depends on the program's execution behavior,
// system load, and so on. A process does not require a physical page
// unless it references the logical page during execution, and processes
// commonly leave many pages unreferenced. Therefore delaying physical
// reads frequently obviates them, improving system performance. To obtain
// this efficiency in practice, executable and shared object files must
// have segment images whose file offsets and virtual addresses are
// congruent, modulo the page size." -- http://refspecs.linuxbase.org/elf/elf.pdf (page 95)
uint32_t p_align = 0x1000; // default page size on linux
emit(p_align);
if (p_offset % p_align != p_start % p_align) {
raise << "segment starting at 0x" << HEXWORD << p_start << " is improperly aligned; alignment for p_offset " << p_offset << " should be " << (p_offset % p_align) << " but is " << (p_start % p_align) << '\n' << end();
return;
}
// prepare for next segment
p_offset += size;
}
#undef O
#undef emit
}
void write_segment(const segment& s, ostream& out) {
for (int i = 0; i < SIZE(s.lines); ++i) {
const vector<word>& w = s.lines.at(i).words;
for (int j = 0; j < SIZE(w); ++j) {
uint8_t x = hex_byte(w.at(j).data); // we're done with metadata by this point
out.write(reinterpret_cast<const char*>(&x), /*sizeof(byte)*/1);
}
}
}
uint32_t num_words(const segment& s) {
uint32_t sum = 0;
for (int i = 0; i < SIZE(s.lines); ++i)
sum += SIZE(s.lines.at(i).words);
return sum;
}
:(before "End Includes")
using std::ios;