# Mu - 043space.cc

      1 //: Spaces help isolate recipes from each other. You can create them at will,
      2 //: and all addresses in arguments are implicitly based on the 'default-space'
      3 //: (unless they have the /raw property)
      4 //:
      5 //: Spaces are often called 'scopes' in other languages. Stack frames are a
      6 //: limited form of space that can't outlive callers.
      7 //:
      8 //: Warning: messing with 'default-space' can corrupt memory. Don't share
      9 //: default-space between recipes. Later we'll see how to chain spaces safely.
     10 //:
     11 //: Tests in this layer can write to a location as part of one type, and read
     12 //: it as part of another. This is unsafe and insecure, and we'll stop doing
     13 //: this once we switch to variable names.
     14
     15 //: Under the hood, a space is an array of locations in memory.
     16 :(before "End Mu Types Initialization")
     17 put(Type_abbreviations, "space", new_type_tree("address:array:location"));
     18
     19 :(scenario set_default_space)
     20 def main [
     21   # prepare default-space address
     22   10:num/alloc-id, 11:num <- copy 0, 1000
     23   # prepare default-space payload
     24   1000:num <- copy 0  # alloc id of payload
     25   1001:num <- copy 5  # length
     26   # actual start of this recipe
     27   default-space:space <- copy 10:&:@:location
     28   # if default-space is 1000, then:
     29   #   1000: alloc id
     30   #   1001: array size
     31   #   1002: location 0 (space for the chaining slot; described later; often unused)
     32   #   1003: location 1 (space for the chaining slot; described later; often unused)
     33   #   1004: local 2 (assuming it is a scalar)
     34   2:num <- copy 93
     35 ]
     36 +mem: storing 93 in location 1004
     37
     38 :(scenario lookup_sidesteps_default_space)
     39 def main [
     40   # prepare default-space address
     41   10:num/alloc-id, 11:num <- copy 0, 1000
     42   # prepare default-space payload
     43   1000:num <- copy 0  # alloc id of payload
     44   1001:num <- copy 5  # length
     45   # prepare payload outside the local scope
     46   2000:num/alloc-id, 2001:num <- copy 0, 34
     47   # actual start of this recipe
     48   default-space:space <- copy 10:&:@:location
     49   # a local address
     50   2:num, 3:num <- copy 0, 2000
     51   20:num/raw <- copy *2:&:num
     52 ]
     53 +mem: storing 2000 in location 1005
     54 +mem: storing 34 in location 20
     55
     56 //: precondition: disable name conversion for 'default-space'
     57
     58 :(scenarios transform)
     59 :(scenario convert_names_passes_default_space)
     60 % Hide_errors = true;
     61 def main [
     62   default-space:num <- copy 0
     63   x:num <- copy 1
     64 ]
     65 +name: assign x 2
     66 -name: assign default-space 1
     67 -name: assign default-space 2
     68 :(scenarios run)
     69
     70 :(before "End is_disqualified Special-cases")
     71 if (x.name == "default-space")
     72   x.initialized = true;
     73 :(before "End is_special_name Special-cases")
     74 if (s == "default-space") return true;
     75
     76 //: core implementation
     77
     78 :(before "End call Fields")
     79 int default_space;
     80 :(before "End call Constructor")
     81 default_space = 0;
     82
     83 :(before "Begin canonize(x) Lookups")
     84 absolutize(x);
     85 :(code)
     86 void absolutize(reagent& x) {
     87   if (is_raw(x) || is_dummy(x)) return;
     88   if (x.name == "default-space") return;
     89   if (!x.initialized)
     90     raise << to_original_string(current_instruction()) << ": reagent not initialized: '" << x.original_string << "'\n" << end();
     91   x.set_value(address(x.value, space_base(x)));
     92   x.properties.push_back(pair<string, string_tree*>("raw", NULL));
     93   assert(is_raw(x));
     94 }
     95
     96 //: hook replaced in a later layer
     97 int space_base(const reagent& x) {
     98   return current_call().default_space ? (current_call().default_space + /*skip alloc id*/1) : 0;
     99 }
    100
    101 int address(int offset, int base) {
    102   assert(offset >= 0);
    103   if (base == 0) return offset;  // raw
    104   int size = get_or_insert(Memory, base);
    105   if (offset >= size) {
    106     // todo: test
    107     raise << current_recipe_name() << ": location " << offset << " is out of bounds " << size << " at " << base << '\n' << end();
    108     DUMP("");
    109     exit(1);
    110     return 0;
    111   }
    112   return base + /*skip length*/1 + offset;
    113 }
    114
    115 //: reads and writes to the 'default-space' variable have special behavior
    116
    117 :(after "Begin Preprocess write_memory(x, data)")
    118 if (x.name == "default-space") {
    119   if (!is_mu_space(x))
    120     raise << maybe(current_recipe_name()) << "'default-space' should be of type address:array:location, but is " << to_string(x.type) << '\n' << end();
    121   if (SIZE(data) != 2)
    122     raise << maybe(current_recipe_name()) << "'default-space' getting data from non-address\n" << end();
    123   current_call().default_space = data.at(/*skip alloc id*/1);
    124   return;
    125 }
    126 :(code)
    127 bool is_mu_space(reagent/*copy*/ x) {
    128   canonize_type(x);
    129   if (!is_compound_type_starting_with(x.type, "address")) return false;
    130   drop_from_type(x, "address");
    131   if (!is_compound_type_starting_with(x.type, "array")) return false;
    132   drop_from_type(x, "array");
    133   return x.type && x.type->atom && x.type->name == "location";
    134 }
    135
    136 :(scenario get_default_space)
    137 def main [
    138   # prepare default-space address
    139   10:num/alloc-id, 11:num <- copy 0, 1000
    140   # prepare default-space payload
    141   1000:num <- copy 0  # alloc id of payload
    142   1001:num <- copy 5  # length
    143   # actual start of this recipe
    144   default-space:space <- copy 10:space
    145   2:space/raw <- copy default-space:space
    146 ]
    147 +mem: storing 1000 in location 3
    148
    149 :(after "Begin Preprocess read_memory(x)")
    150 if (x.name == "default-space") {
    151   vector<double> result;
    152   result.push_back(/*alloc id*/0);
    153   result.push_back(current_call().default_space);
    154   return result;
    155 }
    156
    157 //:: fix 'get'
    158
    159 :(scenario lookup_sidesteps_default_space_in_get)
    160 def main [
    161   # prepare default-space address
    162   10:num/alloc-id, 11:num <- copy 0, 1000
    163   # prepare default-space payload
    164   1000:num <- copy 0  # alloc id of payload
    165   1001:num <- copy 5  # length
    166   # prepare payload outside the local scope
    167   2000:num/alloc-id, 2001:num/x, 2002:num/y <- copy 0, 34, 35
    168   # actual start of this recipe
    169   default-space:space <- copy 10:space
    170   # a local address
    171   2:num, 3:num <- copy 0, 2000
    172   3000:num/raw <- get *2:&:point, 1:offset
    173 ]
    174 +mem: storing 35 in location 3000
    175
    176 :(before "Read element" following "case GET:")
    177 element.properties.push_back(pair<string, string_tree*>("raw", NULL));
    178
    179 //:: fix 'index'
    180
    181 :(scenario lookup_sidesteps_default_space_in_index)
    182 def main [
    183   # prepare default-space address
    184   10:num/alloc-id, 11:num <- copy 0, 1000
    185   # prepare default-space payload
    186   1000:num <- copy 0  # alloc id of payload
    187   1001:num <- copy 5  # length
    188   # prepare an array address
    189   20:num/alloc-id, 21:num <- copy 0, 2000
    190   # prepare an array payload
    191   2000:num/alloc-id, 2001:num/length, 2002:num/index:0, 2003:num/index:1 <- copy 0, 2, 34, 35
    192   # actual start of this recipe
    193   default-space:space <- copy 10:&:@:location
    194   1:&:@:num <- copy 20:&:@:num/raw
    195   3000:num/raw <- index *1:&:@:num, 1
    196 ]
    197 +mem: storing 35 in location 3000
    198
    199 :(before "Read element" following "case INDEX:")
    200 element.properties.push_back(pair<string, string_tree*>("raw", NULL));
    201
    202 //:: 'local-scope' is a convenience operation to automatically deduce
    203 //:: the amount of space to allocate in a default space with names
    204
    205 :(scenario local_scope)
    206 def main [
    207   local-scope
    208   x:num <- copy 0
    209   y:num <- copy 3
    210 ]
    211 # allocate space for x and y, as well as the chaining slot at indices 0 and 1
    212 +mem: array length is 4
    213
    214 :(before "End is_disqualified Special-cases")
    215 if (x.name == "number-of-locals")
    216   x.initialized = true;
    217 :(before "End is_special_name Special-cases")
    218 if (s == "number-of-locals") return true;
    219
    220 :(before "End Rewrite Instruction(curr, recipe result)")
    221 // rewrite 'local-scope' to
    222 //   ```
    223 //   default-space:space <- new location:type, number-of-locals:literal
    224 //   ```
    225 // where number-of-locals is Name[recipe][""]
    226 if (curr.name == "local-scope") {
    227   rewrite_default_space_instruction(curr);
    228 }
    229 :(code)
    230 void rewrite_default_space_instruction(instruction& curr) {
    231   if (!curr.ingredients.empty())
    232     raise << "'" << to_original_string(curr) << "' can't take any ingredients\n" << end();
    233   curr.name = "new";
    234   curr.ingredients.push_back(reagent("location:type"));
    235   curr.ingredients.push_back(reagent("number-of-locals:literal"));
    236   if (!curr.products.empty())
    237     raise << "local-scope can't take any results\n" << end();
    238   curr.products.push_back(reagent("default-space:space"));
    239 }
    240 :(after "Begin Preprocess read_memory(x)")
    241 if (x.name == "number-of-locals") {
    242   vector<double> result;
    243   result.push_back(Name[get(Recipe_ordinal, current_recipe_name())][""]);
    244   if (result.back() == 0)
    245     raise << "no space allocated for default-space in recipe " << current_recipe_name() << "; are you using names?\n" << end();
    246   return result;
    247 }
    248 :(after "Begin Preprocess write_memory(x, data)")
    249 if (x.name == "number-of-locals") {
    250   raise << maybe(current_recipe_name()) << "can't write to special name 'number-of-locals'\n" << end();
    251   return;
    252 }
    253
    254 //:: all recipes must set default-space one way or another
    255
    256 :(before "End Globals")
    257 bool Hide_missing_default_space_errors = true;
    258 :(before "End Checks")
    259 Transform.push_back(check_default_space);  // idempotent
    260 :(code)
    261 void check_default_space(const recipe_ordinal r) {
    262   if (Hide_missing_default_space_errors) return;  // skip previous core tests; this is only for Mu code
    263   const recipe& caller = get(Recipe, r);
    264   // End check_default_space Special-cases
    265   // assume recipes with only numeric addresses know what they're doing (usually tests)
    266   if (!contains_non_special_name(r)) return;
    267   trace(9991, "transform") << "--- check that recipe " << caller.name << " sets default-space" << end();
    268   if (caller.steps.empty()) return;
    269   if (!starts_by_setting_default_space(caller))
    270     raise << caller.name << " does not seem to start with 'local-scope' or 'default-space'\n" << end();
    271 }
    272 bool starts_by_setting_default_space(const recipe& r) {
    273   return !r.steps.empty()
    274       && !r.steps.at(0).products.empty()
    275       && r.steps.at(0).products.at(0).name == "default-space";
    276 }
    277
    278 :(after "Load Mu Prelude")
    279 Hide_missing_default_space_errors = false;
    280 :(after "Test Runs")
    281 Hide_missing_default_space_errors = true;
    282 :(after "Running Main")
    283 Hide_missing_default_space_errors = false;
    284
    285 :(code)
    286 bool contains_non_special_name(const recipe_ordinal r) {
    287   for (map<string, int>::iterator p = Name[r].begin();  p != Name[r].end();  ++p) {
    288     if (p->first.empty()) continue;
    289     if (p->first.find("stash_") == 0) continue;  // generated by rewrite_stashes_to_text (cross-layer)
    290     if (!is_special_name(p->first))
    291       return true;
    292   }
    293   return false;
    294 }