summary refs log blame commit diff stats
path: root/test.lisp
Not found
lain/043space.cc?h=hlt&id=c8c5065869d7500ab8ad80b135bb7b31262e597f'>plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
//: Spaces help isolate recipes from each other. You can create them at will,
//: and all addresses in arguments are implicitly based on the 'default-space'
//: (unless they have the /raw property)
//:
//: Spaces are often called 'scopes' in other languages. Stack frames are a
//: limited form of space that can't outlive callers.
//:
//: Warning: messing with 'default-space' can corrupt memory. Don't share
//: default-space between recipes. Later we'll see how to chain spaces safely.
//:
//: Tests in this layer can write to a location as part of one type, and read
//: it as part of another. This is unsafe and insecure, and we'll stop doing
//: this once we switch to variable names.

//: Under the hood, a space is an array of locations in memory.
:(before "End Mu Types Initialization")
put(Type_abbreviations, "space", new_type_tree("address:array:location"));

:(scenario set_default_space)
def main [
  # prepare default-space address
  10:num/alloc-id, 11:num <- copy 0, 1000
  # prepare default-space payload
  1000:num <- copy 0  # alloc id of payload
  1001:num <- copy 5  # length
  # actual start of this recipe
  default-space:space <- copy 10:&:@:location
  # if default-space is 1000, then:
  #   1000: alloc id
  #   1001: array size
  #   1002: location 0 (space for the chaining slot; described later; often unused)
  #   1003: location 1 (space for the chaining slot; described later; often unused)
  #   1004: local 2 (assuming it is a scalar)
  2:num <- copy 93
]
+mem: storing 93 in location 1004

:(scenario lookup_sidesteps_default_space)
def main [
  # prepare default-space address
  10:num/alloc-id, 11:num <- copy 0, 1000
  # prepare default-space payload
  1000:num <- copy 0  # alloc id of payload
  1001:num <- copy 5  # length
  # prepare payload outside the local scope
  2000:num/alloc-id, 2001:num <- copy 0, 34
  # actual start of this recipe
  default-space:space <- copy 10:&:@:location
  # a local address
  2:num, 3:num <- copy 0, 2000
  20:num/raw <- copy *2:&:num
]
+mem: storing 2000 in location 1005
+mem: storing 34 in location 20

//: precondition: disable name conversion for 'default-space'

:(scenarios transform)
:(scenario convert_names_passes_default_space)
% Hide_errors = true;
def main [
  default-space:num <- copy 0
  x:num <- copy 1
]
+name: assign x 2
-name: assign default-space 1
-name: assign default-space 2
:(scenarios run)

:(before "End is_disqualified Special-cases")
if (x.name == "default-space")
  x.initialized = true;
:(before "End is_special_name Special-cases")
if (s == "default-space") return true;

//: core implementation

:(before "End call Fields")
int default_space;
:(before "End call Constructor")
default_space = 0;

:(before "Begin canonize(x) Lookups")
absolutize(x);
:(code)
void absolutize(reagent& x) {
  if (is_raw(x) || is_dummy(x)) return;
  if (x.name == "default-space") return;
  if (!x.initialized)
    raise << to_original_string(current_instruction()) << ": reagent not initialized: '" << x.original_string << "'\n" << end();
  x.set_value(address(x.value, space_base(x)));
  x.properties.push_back(pair<string, string_tree*>("raw", NULL));
  assert(is_raw(x));
}

//: hook replaced in a later layer
int space_base(const reagent& x) {
  return current_call().default_space ? (current_call().default_space + /*skip alloc id*/1) : 0;
}

int address(int offset, int base) {
  assert(offset >= 0);
  if (base == 0) return offset;  // raw
  int size = get_or_insert(Memory, base);
  if (offset >= size) {
    // todo: test
    raise << current_recipe_name() << ": location " << offset << " is out of bounds " << size << " at " << base << '\n' << end();
    DUMP("");
    exit(1);
    return 0;
  }
  return base + /*skip length*/1 + offset;
}

//: reads and writes to the 'default-space' variable have special behavior

:(after "Begin Preprocess write_memory(x, data)")
if (x.name == "default-space") {
  if (!is_mu_space(x))
    raise << maybe(current_recipe_name()) << "'default-space' should be of type address:array:location, but is " << to_string(x.type) << '\n' << end();
  if (SIZE(data) != 2)
    raise << maybe(current_recipe_name()) << "'default-space' getting data from non-address\n" << end();
  current_call().default_space = data.at(/*skip alloc id*/1);
  return;
}
:(code)
bool is_mu_space(reagent/*copy*/ x) {
  canonize_type(x);
  if (!is_compound_type_starting_with(x.type, "address")) return false;
  drop_from_type(x, "address");
  if (!is_compound_type_starting_with(x.type, "array")) return false;
  drop_from_type(x, "array");
  return x.type && x.type->atom && x.type->name == "location";
}

:(scenario get_default_space)
def main [
  # prepare default-space address
  10:num/alloc-id, 11:num <- copy 0, 1000
  # prepare default-space payload
  1000:num <- copy 0  # alloc id of payload
  1001:num <- copy 5  # length
  # actual start of this recipe
  default-space:space <- copy 10:space
  2:space/raw <- copy default-space:space
]
+mem: storing 1000 in location 3

:(after "Begin Preprocess read_memory(x)")
if (x.name == "default-space") {
  vector<double> result;
  result.push_back(/*alloc id*/0);
  result.push_back(current_call().default_space);
  return result;
}

//:: fix 'get'

:(scenario lookup_sidesteps_default_space_in_get)
def main [
  # prepare default-space address
  10:num/alloc-id, 11:num <- copy 0, 1000
  # prepare default-space payload
  1000:num <- copy 0  # alloc id of payload
  1001:num <- copy 5  # length
  # prepare payload outside the local scope
  2000:num/alloc-id, 2001:num/x, 2002:num/y <- copy 0, 34, 35
  # actual start of this recipe
  default-space:space <- copy 10:space
  # a local address
  2:num, 3:num <- copy 0, 2000
  3000:num/raw <- get *2:&:point, 1:offset
]
+mem: storing 35 in location 3000

:(before "Read element" following "case GET:")
element.properties.push_back(pair<string, string_tree*>("raw", NULL));

//:: fix 'index'

:(scenario lookup_sidesteps_default_space_in_index)
def main [
  # prepare default-space address
  10:num/alloc-id, 11:num <- copy 0, 1000
  # prepare default-space payload
  1000:num <- copy 0  # alloc id of payload
  1001:num <- copy 5  # length
  # prepare an array address
  20:num/alloc-id, 21:num <- copy 0, 2000
  # prepare an array payload
  2000:num/alloc-id, 2001:num/length, 2002:num/index:0, 2003:num/index:1 <- copy 0, 2, 34, 35
  # actual start of this recipe
  default-space:space <- copy 10:&:@:location
  1:&:@:num <- copy 20:&:@:num/raw
  3000:num/raw <- index *1:&:@:num, 1
]
+mem: storing 35 in location 3000

:(before "Read element" following "case INDEX:")
element.properties.push_back(pair<string, string_tree*>("raw", NULL));

//:: 'local-scope' is a convenience operation to automatically deduce
//:: the amount of space to allocate in a default space with names

:(scenario local_scope)
def main [
  local-scope
  x:num <- copy 0
  y:num <- copy 3
]
# allocate space for x and y, as well as the chaining slot at indices 0 and 1
+mem: array length is 4

:(before "End is_disqualified Special-cases")
if (x.name == "number-of-locals")
  x.initialized = true;
:(before "End is_special_name Special-cases")
if (s == "number-of-locals") return true;

:(before "End Rewrite Instruction(curr, recipe result)")
// rewrite 'local-scope' to
//   ```
//   default-space:space <- new location:type, number-of-locals:literal
//   ```
// where number-of-locals is Name[recipe][""]
if (curr.name == "local-scope") {
  rewrite_default_space_instruction(curr);
}
:(code)
void rewrite_default_space_instruction(instruction& curr) {
  if (!curr.ingredients.empty())
    raise << "'" << to_original_string(curr) << "' can't take any ingredients\n" << end();
  curr.name = "new";
  curr.ingredients.push_back(reagent("location:type"));
  curr.ingredients.push_back(reagent("number-of-locals:literal"));
  if (!curr.products.empty())
    raise << "local-scope can't take any results\n" << end();
  curr.products.push_back(reagent("default-space:space"));
}
:(after "Begin Preprocess read_memory(x)")
if (x.name == "number-of-locals") {
  vector<double> result;
  result.push_back(Name[get(Recipe_ordinal, current_recipe_name())][""]);
  if (result.back() == 0)
    raise << "no space allocated for default-space in recipe " << current_recipe_name() << "; are you using names?\n" << end();
  return result;
}
:(after "Begin Preprocess write_memory(x, data)")
if (x.name == "number-of-locals") {
  raise << maybe(current_recipe_name()) << "can't write to special name 'number-of-locals'\n" << end();
  return;
}

//:: all recipes must set default-space one way or another

:(before "End Globals")
bool Hide_missing_default_space_errors = true;
:(before "End Checks")
Transform.push_back(check_default_space);  // idempotent
:(code)
void check_default_space(const recipe_ordinal r) {
  if (Hide_missing_default_space_errors) return;  // skip previous core tests; this is only for Mu code
  const recipe& caller = get(Recipe, r);
  // End check_default_space Special-cases
  // assume recipes with only numeric addresses know what they're doing (usually tests)
  if (!contains_non_special_name(r)) return;
  trace(9991, "transform") << "--- check that recipe " << caller.name << " sets default-space" << end();
  if (caller.steps.empty()) return;
  if (!starts_by_setting_default_space(caller))
    raise << caller.name << " does not seem to start with 'local-scope' or 'default-space'\n" << end();
}
bool starts_by_setting_default_space(const recipe& r) {
  return !r.steps.empty()
      && !r.steps.at(0).products.empty()
      && r.steps.at(0).products.at(0).name == "default-space";
}

:(after "Load Mu Prelude")
Hide_missing_default_space_errors = false;
:(after "Test Runs")
Hide_missing_default_space_errors = true;
:(after "Running Main")
Hide_missing_default_space_errors = false;

:(code)
bool contains_non_special_name(const recipe_ordinal r) {
  for (map<string, int>::iterator p = Name[r].begin();  p != Name[r].end();  ++p) {
    if (p->first.empty()) continue;
    if (p->first.find("stash_") == 0) continue;  // generated by rewrite_stashes_to_text (cross-layer)
    if (!is_special_name(p->first))
      return true;
  }
  return false;
}