mu - Soul of a tiny new machine. More thorough tests → More comprehensible and rewrite-friendly software → More resilient society.

	Commit message (Collapse)	Author	Age	Files	Lines
*	fix a failing test in pack.subx	Kartik K. Agaram	2021-03-15	1	-0/+0
\|
*	boot.subx is now clean SubX	Kartik K. Agaram	2021-03-15	1	-0/+0
\|
*	.	Kartik K. Agaram	2021-03-14	1	-0/+0
\|
*	7867	Kartik K. Agaram	2021-03-07	1	-0/+0
\|
*	7842 - new directory organization	Kartik K. Agaram	2021-03-03	1	-0/+0
	Baremetal is now the default build target and therefore has its sources at the top-level. Baremetal programs build using the phase-2 Mu toolchain that requires a Linux kernel. This phase-2 codebase which used to be at the top-level is now under the linux/ directory. Finally, the phase-2 toolchain, while self-hosting, has a way to bootstrap from a C implementation, which is now stored in linux/bootstrap. The bootstrap C implementation uses some literate programming tools that are now in linux/bootstrap/tools. So the whole thing has gotten inverted. Each directory should build one artifact and include the main sources (along with standard library). Tools used for building it are relegated to sub-directories, even though those tools are often useful in their own right, and have had lots of interesting programs written using them. A couple of things have gotten dropped in this process: - I had old ways to run on just a Linux kernel, or with a Soso kernel. No more. - I had some old tooling for running a single test at the cursor. I haven't used that lately. Maybe I'll bring it back one day. The reorg isn't done yet. Still to do: - redo documentation everywhere. All the README files, all other markdown, particularly vocabulary.md. - clean up how-to-run comments at the start of programs everywhere - rethink what to do with the html/ directory. Do we even want to keep supporting it? In spite of these shortcomings, all the scripts at the top-level, linux/ and linux/bootstrap are working. The names of the scripts also feel reasonable. This is a good milestone to take stock at.

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> <html> <head> <meta http-equiv="content-type" content="text/html; charset=UTF-8"> <title>Mu - 031address.cc</title> <meta name="Generator" content="Vim/7.4"> <meta name="plugin-version" content="vim7.4_v1"> <meta name="syntax" content="cpp"> <meta name="settings" content="use_css,pre_wrap,no_foldcolumn,expand_tabs,prevent_copy="> <meta name="colorscheme" content="minimal"> <style type="text/css">  </style> <script type='text/javascript'>  </script> </head> <body> <pre id='vimCodeElement'> //: Instructions can read from addresses pointing at other locations using the //: 'lookup' property. :(scenario copy_indirect) recipe main [ 1:address:number <- copy 2/unsafe 2:number <- copy 34 # This loads location 1 as an address and looks up *that* location. 3:number <- copy 1:address:number/lookup ] +mem: storing 34 in location 3 :(before "long long int base = x.value" following "vector<double> read_memory(reagent x)") canonize(x); //: similarly, write to addresses pointing at other locations using the //: 'lookup' property :(scenario store_indirect) recipe main [ 1:address:number <- copy 2/unsafe 1:address:number/lookup <- copy 34 ] +mem: storing 34 in location 2 :(before "long long int base = x.value" following "void write_memory(reagent x, vector<double> data)") canonize(x); if (x.value == 0) { raise_error << "can't write to location 0 in '" << current_instruction().to_string() << "'\n" << end(); return; } //: writes to address 0 always loudly fail :(scenario store_to_0_fails) % Hide_errors = true; recipe main [ 1:address:number <- copy 0 1:address:number/lookup <- copy 34 ] -mem: storing 34 in location 0 +error: can't write to location 0 in '1:address:number/lookup <- copy 34' :(code) void canonize(reagent& x) { if (is_literal(x)) return; // End canonize(x) Special-cases while (has_property(x, "lookup")) lookup_memory(x); } void lookup_memory(reagent& x) { if (!x.type || x.type->value != get(Type_ordinal, "address")) { raise_error << maybe(current_recipe_name()) << "tried to /lookup " << x.original_string << " but it isn't an address\n" << end(); } // compute value if (x.value == 0) { raise_error << maybe(current_recipe_name()) << "tried to /lookup 0\n" << end(); } trace(9999, "mem") << "location " << x.value << " is " << no_scientific(get_or_insert(Memory, x.value)) << end(); x.set_value(get_or_insert(Memory, x.value)); drop_address_from_type(x); drop_one_lookup(x); } :(scenario canonize_non_pointer_fails_without_crashing) % Hide_errors = true; recipe foo [ 1:address:number <- get-address *p, x:offset ] # don't crash :(after "bool types_strictly_match(reagent lhs, reagent rhs)") if (!canonize_type(lhs)) return false; if (!canonize_type(rhs)) return false; :(after "bool is_mu_array(reagent r)") if (!canonize_type(r)) return false; :(after "bool is_mu_address(reagent r)") if (!canonize_type(r)) return false; :(after "bool is_mu_number(reagent r)") if (!canonize_type(r)) return false; :(code) bool canonize_type(reagent& r) { while (has_property(r, "lookup")) { if (!r.type || r.type->value != get(Type_ordinal, "address")) { raise_error << "can't lookup non-address: " << r.to_string() << ": " << debug_string(r.type) << '\n' << end(); return false; } drop_address_from_type(r); drop_one_lookup(r); } return true; } void drop_address_from_type(reagent& r) { if (!r.type) { raise_error << "can't drop address from " << debug_string(r) << '\n' << end(); return; } type_tree* tmp = r.type; r.type = tmp->right; tmp->right = NULL; delete tmp; // property if (r.properties.at(0).second) { string_tree* tmp2 = r.properties.at(0).second; r.properties.at(0).second = tmp2->right; tmp2->right = NULL; delete tmp2; } } void drop_one_lookup(reagent& r) { for (vector<pair<string, string_tree*> >::iterator p = r.properties.begin(); p != r.properties.end(); ++p) { if (p->first == "lookup") { r.properties.erase(p); return; } } assert(false); } //:: 'get' can read from container address :(scenario get_indirect) recipe main [ 1:number <- copy 2 2:number <- copy 34 3:number <- copy 35 4:number <- get 1:address:point/lookup, 0:offset ] +mem: storing 34 in location 4 :(scenario get_indirect2) recipe main [ 1:number <- copy 2 2:number <- copy 34 3:number <- copy 35 4:address:number <- copy 5/unsafe *4:address:number <- get 1:address:point/lookup, 0:offset ] +mem: storing 34 in location 5 :(scenario include_nonlookup_properties) recipe main [ 1:number <- copy 2 2:number <- copy 34 3:number <- copy 35 4:number <- get 1:address:point/lookup/foo, 0:offset ] +mem: storing 34 in location 4 :(after "Update GET base in Check") if (!canonize_type(base)) break; :(after "Update GET product in Check") if (!canonize_type(product)) break; :(after "Update GET base in Run") canonize(base); :(scenario get_address_indirect) # 'get' can read from container address recipe main [ 1:number <- copy 2 2:number <- copy 34 3:number <- copy 35 4:address:number <- get-address 1:address:point/lookup, 0:offset ] +mem: storing 2 in location 4 :(after "Update GET_ADDRESS base in Check") if (!canonize_type(base)) break; :(after "Update GET_ADDRESS product in Check") if (!canonize_type(base)) break; :(after "Update GET_ADDRESS base in Run") canonize(base); //:: abbreviation for '/lookup': a prefix '*' :(scenario lookup_abbreviation) recipe main [ 1:address:number <- copy 2/unsafe 2:number <- copy 34 3:number <- copy *1:address:number ] +parse: ingredient: {"1": <"address" : <"number" : <>>>, "lookup": <>} +mem: storing 34 in location 3 :(before "End Parsing reagent") { while (!name.empty() && name.at(0) == '*') { name.erase(0, 1); properties.push_back(pair<string, string_tree*>("lookup", NULL)); } if (name.empty()) raise_error << "illegal name " << original_string << '\n' << end(); properties.at(0).first = name; } //:: helpers for debugging :(before "End Primitive Recipe Declarations") _DUMP, :(before "End Primitive Recipe Numbers") put(Recipe_ordinal, "$dump", _DUMP); :(before "End Primitive Recipe Implementations") case _DUMP: { reagent after_canonize = current_instruction().ingredients.at(0); canonize(after_canonize); cerr << maybe(current_recipe_name()) << current_instruction().ingredients.at(0).name << ' ' << no_scientific(current_instruction().ingredients.at(0).value) << " => " << no_scientific(after_canonize.value) << " => " << no_scientific(get_or_insert(Memory, after_canonize.value)) << '\n'; break; } //: grab an address, and then dump its value at intervals //: useful for tracking down memory corruption (writing to an out-of-bounds address) :(before "End Globals") long long int foo = -1; :(before "End Primitive Recipe Declarations") _FOO, :(before "End Primitive Recipe Numbers") put(Recipe_ordinal, "$foo", _FOO); :(before "End Primitive Recipe Implementations") case _FOO: { if (current_instruction().ingredients.empty()) { if (foo != -1) cerr << foo << ": " << no_scientific(get_or_insert(Memory, foo)) << '\n'; else cerr << '\n'; } else { reagent tmp = current_instruction().ingredients.at(0); canonize(tmp); foo = tmp.value; } break; } </pre> </body> </html>