DEADSOFTWARE

GIT / REPO / FRED-BOY
Projects / dsw-obn.git / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Добавлен счёт строк
[dsw-obn.git] / src / backends / jvm / generator-jvm-abi.c
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <stdarg.h>
4 #include <stdint.h>
5 #include <stdbool.h>
6 #include <string.h>
7 #include <assert.h>
8
9 #include <gc.h>
10
11 #include "../../oberon-internals.h"
12 #include "generator-jvm.h"
13 #include "generator-jvm-abi.h"
14 #include "generator-jvm-asm.h"
15 #include "generator-jvm-basic.h"
16
17 void
18 jvm_generate_ldst_prepare(gen_proc_t * p, gen_var_t * v)
19 {
20 char * desc = v -> type -> desc;
21 char * full_name = v -> full_name;
22 switch(v -> storage)
23 {
24 case JVM_STORAGE_REGISTER:
25 case JVM_STORAGE_STATIC:
26 case JVM_STORAGE_FIELD:
27 case JVM_STORAGE_PARAM:
28 break;
29 case JVM_STORAGE_REGISTER_VAR:
30 case JVM_STORAGE_PARAM_VAR:
31 jvm_generate(p, 0, 1, "aload %i", v -> reg);
32 jvm_generate(p, 0, 1, "iconst_0");
33 break;
34 case JVM_STORAGE_STATIC_VAR:
35 jvm_generate(p, 0, 1, "getstatic %s [%s", full_name, desc);
36 jvm_generate(p, 0, 1, "iconst_0");
37 break;
38 case JVM_STORAGE_FIELD_VAR:
39 jvm_generate(p, 1, 1, "getfield %s [%s", full_name, desc);
40 jvm_generate(p, 0, 1, "iconst_0");
41 break;
42 case JVM_STORAGE_PARAM_VARPTR:
43 jvm_generate(p, 0, 1, "aload %i", v -> reg);
44 jvm_generate(p, 0, 1, "iload %i", v -> reg + 1);
45 break;
46 case JVM_STORAGE_FRAME:
47 case JVM_STORAGE_FRAME_PARAM:
48 jvm_generate(p, 0, 1, "aload %i", p -> reg_frame[v -> level]);
49 break;
50 case JVM_STORAGE_FRAME_VAR:
51 case JVM_STORAGE_FRAME_PARAM_VAR:
52 jvm_generate(p, 0, 1, "aload %i", p -> reg_frame[v -> level]);
53 jvm_generate(p, 1, 1, "getfield %s [%s", full_name, desc);
54 jvm_generate(p, 0, 1, "iconst_0");
55 break;
56 case JVM_STORAGE_FRAME_PARAM_VARPTR:
57 jvm_generate(p, 0, 1, "aload %i", p -> reg_frame[v -> level]);
58 jvm_generate(p, 1, 1, "getfield %s [%s", full_name, desc);
59 jvm_generate(p, 0, 1, "aload %i", p -> reg_frame[v -> level]);
60 jvm_generate(p, 1, 1, "getfield %s$offset I", full_name);
61 break;
62 default:
63 gen_error("jvm_abi_obn_generate_ldst_prepare: wat %i", v -> storage);
64 }
65 }
66
67 void
68 jvm_generate_load(gen_proc_t * p, gen_var_t * src)
69 {
70 char prefix = src -> type -> prefix;
71 char postfix = src -> type -> postfix;
72 int cell_size = src -> type -> cell_size;
73 char * full_name = src -> full_name;
74 char * desc = src -> type -> desc;
75
76 switch(src -> storage)
77 {
78 case JVM_STORAGE_REGISTER:
79 case JVM_STORAGE_PARAM:
80 jvm_generate(p, 0, cell_size, "%cload %i", prefix, src -> reg);
81 break;
82 case JVM_STORAGE_STATIC:
83 jvm_generate(p, 0, cell_size, "getstatic %s %s", full_name, desc);
84 break;
85 case JVM_STORAGE_FIELD:
86 jvm_generate(p, 0, cell_size, "getfield %s %s", full_name, desc);
87 break;
88 case JVM_STORAGE_REGISTER_VAR:
89 case JVM_STORAGE_STATIC_VAR:
90 case JVM_STORAGE_FIELD_VAR:
91 case JVM_STORAGE_PARAM_VAR:
92 case JVM_STORAGE_PARAM_VARPTR:
93 case JVM_STORAGE_FRAME_VAR:
94 case JVM_STORAGE_FRAME_PARAM_VAR:
95 case JVM_STORAGE_FRAME_PARAM_VARPTR:
96 jvm_generate_ldst_prepare(p, src);
97 jvm_generate(p, 1 + 1, cell_size, "%caload", postfix);
98 break;
99 case JVM_STORAGE_FRAME:
100 case JVM_STORAGE_FRAME_PARAM:
101 jvm_generate_ldst_prepare(p, src);
102 jvm_generate(p, 1, cell_size, "getfield %s %s", full_name, desc);
103 break;
104 default:
105 gen_error("jvm_generate_load: unknow storage type %i", src -> storage);
106 break;
107 }
108 }
109
110 void
111 jvm_generate_store(gen_proc_t * p, gen_var_t * dst)
112 {
113 char prefix = dst -> type -> prefix;
114 char postfix = dst -> type -> postfix;
115 int cell_size = dst -> type -> cell_size;
116 char * full_name = dst -> full_name;
117 char * desc = dst -> type -> desc;
118
119 switch(dst -> storage)
120 {
121 case JVM_STORAGE_REGISTER:
122 case JVM_STORAGE_PARAM:
123 jvm_generate(p, cell_size, 0, "%cstore %i", prefix, dst -> reg);
124 break;
125 case JVM_STORAGE_STATIC:
126 jvm_generate(p, 0, cell_size, "putstatic %s %s", full_name, desc);
127 break;
128 case JVM_STORAGE_FIELD:
129 jvm_generate(p, 0, cell_size, "putfield %s %s", full_name, desc);
130 break;
131 case JVM_STORAGE_REGISTER_VAR:
132 case JVM_STORAGE_STATIC_VAR:
133 case JVM_STORAGE_FIELD_VAR:
134 case JVM_STORAGE_PARAM_VAR:
135 case JVM_STORAGE_PARAM_VARPTR:
136 case JVM_STORAGE_FRAME_VAR:
137 case JVM_STORAGE_FRAME_PARAM_VAR:
138 case JVM_STORAGE_FRAME_PARAM_VARPTR:
139 jvm_generate(p, 1 + 1 + cell_size, 0, "%castore", postfix);
140 break;
141 case JVM_STORAGE_FRAME:
142 case JVM_STORAGE_FRAME_PARAM:
143 jvm_generate(p, 0, cell_size, "putfield %s %s", full_name, desc);
144 break;
145 default:
146 gen_error("jvm_generate_store: unknow storage type %i", dst -> storage);
147 break;
148 }
149 }
150
151 static gen_var_t *
152 jvm_new_var()
153 {
154 gen_var_t * v = GC_MALLOC(sizeof *v);
155 memset(v, 0, sizeof *v);
156 return v;
157 }
158
159 gen_var_t *
160 jvm_create_class_var(struct gen_class * class, enum gen_storage storage, char * name, gen_type_t * t)
161 {
162 gen_var_t * v = jvm_new_var();
163 v -> storage = storage;
164 v -> name = new_string(name);
165 v -> type = t;
166 v -> class = class;
167
168 assert(class -> p == NULL);
169 switch(storage)
170 {
171 case JVM_STORAGE_STATIC:
172 case JVM_STORAGE_FIELD:
173 case JVM_STORAGE_STATIC_VAR:
174 case JVM_STORAGE_FIELD_VAR:
175 v -> full_name = new_string("%s/%s", class -> full_name, name);
176 break;
177 default:
178 gen_error("jvm_create_class_var: invalid storage %i", storage);
179 break;
180 }
181
182 return v;
183 }
184
185 gen_var_t *
186 jvm_create_function_var(gen_proc_t * p, enum gen_storage storage, char * name, gen_type_t * t)
187 {
188 gen_var_t * v = jvm_new_var();
189 v -> storage = storage;
190 v -> name = new_string(name);
191 v -> type = t;
192 v -> p = p;
193 v -> level = p -> level;
194
195 switch(storage)
196 {
197 case JVM_STORAGE_REGISTER:
198 case JVM_STORAGE_PARAM:
199 case JVM_STORAGE_PARAM_VAR:
200 v -> reg = jvm_alloc_register_untyped(p -> rf, t -> wide);
201 break;
202 case JVM_STORAGE_PARAM_VARPTR:
203 /* Содержит пару массив+индекс */
204 v -> reg = jvm_alloc_register_untyped(p -> rf, true);
205 break;
206 case JVM_STORAGE_REGISTER_VAR:
207 /* Содержит массив */
208 v -> reg = jvm_alloc_register_untyped(p -> rf, false);
209 break;
210 case JVM_STORAGE_FRAME:
211 case JVM_STORAGE_FRAME_VAR:
212 v -> full_name = new_string("%s$FRAME/%s", p -> full_name, name);
213 break;
214 case JVM_STORAGE_FRAME_PARAM:
215 case JVM_STORAGE_FRAME_PARAM_VAR:
216 v -> reg = jvm_alloc_register_untyped(p -> rf, t -> wide);
217 v -> full_name = new_string("%s$FRAME/%s", p -> full_name, name);
218 break;
219 case JVM_STORAGE_FRAME_PARAM_VARPTR:
220 /* Содержит пару массив+индекс */
221 v -> reg = jvm_alloc_register_untyped(p -> rf, true);
222 v -> full_name = new_string("%s$FRAME/%s", p -> full_name, name);
223 break;
224 default:
225 gen_error("jvm_create_class_var: invalid storage %i", storage);
226 break;
227 }
228
229 return v;
230 }
231
232 gen_var_t *
233 jvm_create_function_temp_var(gen_proc_t * p, gen_type_t * t)
234 {
235 gen_var_t * v = jvm_new_var();
236 v -> storage = JVM_STORAGE_REGISTER;
237 v -> reg = jvm_alloc_register_untyped(p -> rf, t -> wide);
238 v -> name = new_string("$TEMP_%i$", v -> reg);
239 v -> type = t;
240 v -> p = p;
241 v -> level = p -> level;
242 return v;
243 }
244
245 void
246 jvm_generate_var(gen_var_t * v)
247 {
248 enum gen_storage storage = v -> storage;
249 int reg = v -> reg;
250 char * name = v -> name;
251 char * desc = v -> type -> desc;
252 gen_proc_t * p = v -> p;
253
254 switch(v -> storage)
255 {
256 case JVM_STORAGE_REGISTER:
257 case JVM_STORAGE_PARAM:
258 case JVM_STORAGE_PARAM_VAR:
259 case JVM_STORAGE_FRAME:
260 case JVM_STORAGE_FRAME_VAR:
261 case JVM_STORAGE_FRAME_PARAM:
262 case JVM_STORAGE_FRAME_PARAM_VAR:
263 jvm_generate(p, 0, 0, ".var %i is '%s' %s from start to end", reg, name, desc);
264 break;
265 case JVM_STORAGE_REGISTER_VAR:
266 jvm_generate(p, 0, 0, ".var %i is '%s' [%s from start to end", reg, name, desc);
267 break;
268 case JVM_STORAGE_PARAM_VARPTR:
269 case JVM_STORAGE_FRAME_PARAM_VARPTR:
270 jvm_generate(p, 0, 0, ".var %i is '%s' [%s from start to end", reg, name, desc);
271 jvm_generate(p, 0, 0, ".var %i is '%s$offset' I from start to end", reg + 1, name);
272 break;
273 case JVM_STORAGE_STATIC:
274 fprintf(v -> class -> fp, ".field public static '%s' %s\n\n", name, desc);
275 break;
276 case JVM_STORAGE_STATIC_VAR:
277 fprintf(v -> class -> fp, ".field public static '%s' [%s\n\n", name, desc);
278 break;
279 case JVM_STORAGE_FIELD:
280 fprintf(v -> class -> fp, ".field public '%s' %s\n\n", name, desc);
281 break;
282 case JVM_STORAGE_FIELD_VAR:
283 fprintf(v -> class -> fp, ".field public '%s' [%s\n\n", name, desc);
284 break;
285 default:
286 gen_error("jvm_generate_var: invalid storage %i", storage);
287 break;
288 }
289 }
290
291 static void
292 jvm_generate_param_initialization(gen_proc_t * p, gen_var_t * v)
293 {
294 int old_reg = v -> reg;
295 int cell_size = v -> type -> cell_size;
296 char prefix = v -> type -> prefix;
297 char postfix = v -> type -> postfix;
298 char * name = v -> name;
299 char * desc = v -> type -> desc;
300
301 v -> reg = jvm_alloc_register_untyped(p -> rf, false);
302 jvm_generate(p, 0, 0, ".var %i is $%s [%s from start to end", v -> reg, name, desc);
303
304 jvm_generate(p, 0, 1, "iconst_1");
305 jvm_generate(p, 1, 1, "multianewarray [%s 1", desc);
306 jvm_generate(p, 1, 2, "dup");
307 jvm_generate(p, 1, 0, "astore %i", v -> reg);
308
309 jvm_generate(p, 0, 1, "iconst_0");
310 jvm_generate(p, 0, cell_size, "%cload %i", prefix, old_reg);
311 jvm_generate(p, 1 + 1 + cell_size, 0, "%castore", postfix);
312 }
313
314 void
315 jvm_generate_var_initialization(gen_proc_t * p, gen_var_t * v)
316 {
317 if(v -> storage == JVM_STORAGE_REGISTER_VAR)
318 {
319 jvm_generate(p, 0, 1, "iconst_1");
320 jvm_generate(p, 1, 1, "multianewarray [%s 1", v -> type -> desc);
321 jvm_generate(p, 1, 0, "astore %i", v -> reg);
322 }
323 else if(v -> storage == JVM_STORAGE_STATIC_VAR)
324 {
325 jvm_generate(p, 0, 1, "iconst_1");
326 jvm_generate(p, 1, 1, "multianewarray [%s 1", v -> type -> desc);
327 jvm_generate(p, 1, 0, "putstatic %s [%s", v -> full_name, v -> type -> desc);
328 }
329 else if(v -> storage == JVM_STORAGE_FIELD_VAR)
330 {
331 jvm_generate(p, 0, 1, "iconst_1");
332 jvm_generate(p, 1, 1, "multianewarray [%s 1", v -> type -> desc);
333 jvm_generate(p, 1, 0, "putfield %s [%s", v -> full_name, v -> type -> desc);
334 }
335 else if(v -> storage == JVM_STORAGE_PARAM_VAR)
336 {
337 jvm_generate_param_initialization(p, v);
338 }
339 else if(v -> storage == JVM_STORAGE_FRAME_PARAM
340 || v -> storage == JVM_STORAGE_FRAME_PARAM_VAR)
341 {
342 jvm_generate_ldst_prepare(p, v);
343 jvm_generate(p, 0, v -> type -> cell_size, "%cload %i", v -> type -> prefix, v -> reg);
344 jvm_generate_store(p, v);
345 }
346 else if(v -> storage == JVM_STORAGE_FRAME_PARAM_VARPTR)
347 {
348 jvm_generate(p, 0, 1, "aload %i", p -> reg_frame[v -> level]);
349 jvm_generate(p, 0, 1, "aload %i", v -> reg);
350 jvm_generate(p, 1, 0, "putfield %s [%s", v -> full_name, v -> type -> desc);
351
352 jvm_generate(p, 0, 1, "aload %i", p -> reg_frame[v -> level]);
353 jvm_generate(p, 0, 1, "iload %i", v -> reg + 1);
354 jvm_generate(p, 1, 0, "putfield %s$offset I", v -> full_name);
355 }
356 }
357
358 /*
359 static void
360 jvm_generate_abstract_frame_class()
361 {
362 FILE * fp;
363 char * cname;
364 struct gen_class * class;
365
366 cname = "SYSTEM$FRAME";
367 class = jvm_create_class(cname);
368 fp = class -> fp;
369
370 fprintf(fp, ".source SYSTEM\n");
371 fprintf(fp, ".class public abstract %s\n", cname);
372 fprintf(fp, ".super java/lang/Object\n\n");
373
374 fprintf(fp, ".field public $UP L%s;\n\n", cname);
375
376 fprintf(fp, ".method <init>()V\n");
377 fprintf(fp, " aload_0\n");
378 fprintf(fp, " invokespecial java/lang/Object/<init>()V\n");
379 fprintf(fp, " return\n");
380 fprintf(fp, ".end method\n\n");
381
382 jvm_destroy_class(class);
383 }
384 */
385
386 static struct gen_class *
387 jvm_generate_frame_class(oberon_object_t * proc)
388 {
389 FILE * fp;
390 char * cname;
391 char * abscname;
392 struct gen_class * class;
393 oberon_object_t * var;
394
395 abscname = "SYSTEM$FRAME";
396 cname = jvm_get_field_full_name_safe(proc);
397 cname = new_string("%s$FRAME", cname);
398 class = jvm_create_class(proc -> gen_proc -> class -> dir, cname);
399 fp = class -> fp;
400
401 class -> full_name = cname;
402
403 fprintf(fp, ".source %s\n", proc -> module -> name);
404 fprintf(fp, ".class public %s\n", cname);
405 fprintf(fp, ".super %s\n\n", abscname);
406
407 var = proc -> scope -> list -> next;
408 while(var)
409 {
410 if(var -> class == OBERON_CLASS_VAR
411 || var -> class == OBERON_CLASS_PARAM
412 || var -> class == OBERON_CLASS_VAR_PARAM)
413 {
414 gen_var_t * v = var -> gen_var;
415 if(v -> storage == JVM_STORAGE_FRAME
416 || v -> storage == JVM_STORAGE_FRAME_PARAM)
417 {
418 fprintf(fp, "; LEVEL %i\n", v -> level);
419 fprintf(fp, ".field public '%s' %s\n\n", v -> name, v -> type -> desc);
420 }
421 else if(v -> storage == JVM_STORAGE_FRAME_VAR
422 || v -> storage == JVM_STORAGE_FRAME_PARAM_VAR)
423 {
424 fprintf(fp, "; LEVEL %i\n", v -> level);
425 fprintf(fp, ".field public '%s' [%s\n\n", v -> name, v -> type -> desc);
426 }
427 else if(v -> storage == JVM_STORAGE_FRAME_PARAM_VARPTR)
428 {
429 fprintf(fp, "; LEVEL %i\n", v -> level);
430 fprintf(fp, ".field public '%s' [%s\n", v -> name, v -> type -> desc);
431 fprintf(fp, ".field public '%s$offset' I\n\n", v -> name);
432 }
433 }
434 var = var -> next;
435 }
436
437 fprintf(fp, ".method <init>()V\n");
438 fprintf(fp, " .limit stack 2\n");
439 fprintf(fp, " aload_0\n");
440 fprintf(fp, " invokespecial %s/<init>()V\n", abscname);
441
442 var = proc -> scope -> list -> next;
443 while(var)
444 {
445 if(var -> class == OBERON_CLASS_VAR
446 || var -> class == OBERON_CLASS_PARAM
447 || var -> class == OBERON_CLASS_VAR_PARAM)
448 {
449 gen_var_t * v = var -> gen_var;
450 if(v -> storage == JVM_STORAGE_FRAME_VAR
451 || v -> storage == JVM_STORAGE_FRAME_PARAM_VAR)
452 {
453 fprintf(fp, " aload_0\n");
454 fprintf(fp, " iconst_1\n");
455 fprintf(fp, " multianewarray [%s 1\n", v -> type -> desc);
456 fprintf(fp, " putfield %s [%s\n", v -> full_name, v -> type -> desc);
457 }
458 }
459 var = var -> next;
460 }
461
462 fprintf(fp, " return\n");
463 fprintf(fp, ".end method\n\n");
464
465 jvm_destroy_class(class);
466
467 return class;
468 }
469
470 void
471 jvm_generate_procedure_frame(oberon_object_t * proc)
472 {
473 gen_proc_t * p;
474 gen_type_t * t;
475 gen_var_t * v;
476 struct gen_class * class;
477
478 p = proc -> gen_proc;
479
480 // jvm_generate_abstract_frame_class();
481
482 class = jvm_generate_frame_class(proc);
483
484 t = GC_MALLOC(sizeof *t);
485 memset(t, 0, sizeof *t);
486 t -> class = class;
487 t -> wide = false;
488 t -> prefix = 'a';
489 t -> postfix = 'a';
490 t -> cell_size = 1;
491 t -> desc = new_string("L%s;", class -> full_name);
492
493 v = jvm_create_function_var(p, JVM_STORAGE_REGISTER, "$FP$", t);
494 p -> frame_v = v;
495 p -> reg_frame[p -> level] = v -> reg;
496 }
497
498 void
499 jvm_generate_frame_initialization(gen_proc_t * p)
500 {
501 jvm_generate_var(p -> frame_v);
502 jvm_generate_ldst_prepare(p, p -> frame_v);
503 jvm_generate(p, 0, 1, "new %s", p -> frame_v -> type -> class -> full_name);
504 jvm_generate(p, 1, 2, "dup");
505 jvm_generate(p, 1, 0, "invokespecial %s/<init>()V", p -> frame_v -> type -> class -> full_name);
506 jvm_generate_store(p, p -> frame_v);
507 }
508
509 char *
510 jvm_get_procedure_signature(oberon_type_t * ps)
511 {
512 char * signature;
513 char * desc;
514 int num;
515 oberon_object_t * arg;
516
517 signature = new_string("(");
518
519 num = ps -> num_decl;
520 arg = ps -> decl;
521 for(int i = 0; i < num; i++)
522 {
523 desc = jvm_get_descriptor(arg -> type);
524 if(arg -> class == OBERON_CLASS_VAR_PARAM)
525 {
526 signature = new_string("%s[%sI", signature, desc);
527 }
528 else
529 {
530 signature = new_string("%s%s", signature, desc);
531 }
532 arg = arg -> next;
533 }
534
535 desc = jvm_get_descriptor(ps -> base);
536 signature = new_string("%s)%s", signature, desc);
537
538 return signature;
539 }
540
541 static char *
542 jvm_get_frame_descriptor(oberon_object_t * proc)
543 {
544 char * full_name = jvm_get_field_full_name_safe(proc);
545 return new_string("L%s$FRAME;", full_name);
546 }
547
548 static char *
549 jvm_get_oberon_signature_static_links(oberon_object_t * parent)
550 {
551 if(parent == NULL)
552 {
553 return "";
554 }
555
556 char * up = jvm_get_oberon_signature_static_links(parent -> parent);
557 char * desc = jvm_get_frame_descriptor(parent);
558 return new_string("%s%s", up, desc);
559 }
560
561 char *
562 jvm_get_local_procedure_signature(oberon_object_t * proc)
563 {
564 char * stlinks;
565 char * signature;
566 char * desc;
567 int num;
568 oberon_object_t * arg;
569 oberon_type_t * ps;
570
571 ps = proc -> type;
572
573 signature = new_string("(");
574
575 if(proc -> local)
576 {
577 stlinks = jvm_get_oberon_signature_static_links(proc -> parent);
578 signature = new_string("%s%s", signature, stlinks);
579 }
580
581 num = ps -> num_decl;
582 arg = ps -> decl;
583 for(int i = 0; i < num; i++)
584 {
585 desc = jvm_get_descriptor(arg -> type);
586 if(arg -> class == OBERON_CLASS_VAR_PARAM)
587 {
588 signature = new_string("%s[%sI", signature, desc);
589 }
590 else
591 {
592 signature = new_string("%s%s", signature, desc);
593 }
594 arg = arg -> next;
595 }
596
597 desc = jvm_get_descriptor(ps -> base);
598 signature = new_string("%s)%s", signature, desc);
599
600 return signature;
601 }
602
603
604 static void
605 jvm_generate_staticlinks_recursive(gen_proc_t * p, oberon_object_t * parent, int level)
606 {
607 if(parent == NULL)
608 {
609 return;
610 }
611
612 jvm_generate_staticlinks_recursive(p, parent -> parent, level - 1);
613 int reg = p -> reg_frame[level];
614 char * desc = jvm_get_frame_descriptor(parent);
615 jvm_generate(p, 0, 0, ".var %i is SL$%i %s from start to end", reg, level, desc);
616 }
617
618 void
619 jvm_generate_staticlinks(oberon_object_t * proc)
620 {
621 gen_proc_t * p;
622
623 p = proc -> gen_proc;
624
625 jvm_generate_staticlinks_recursive(p, proc -> parent, p -> level);
626 }
627
628 static void
629 jvm_create_staticlinks_recursive(gen_proc_t * p, oberon_object_t * parent, int level)
630 {
631 if(parent == NULL)
632 {
633 return;
634 }
635
636 jvm_create_staticlinks_recursive(p, parent -> parent, level - 1);
637 p -> reg_frame[level] = jvm_alloc_register_untyped(p -> rf, false);
638 }
639
640 void
641 jvm_create_static_links(oberon_object_t * proc)
642 {
643 gen_proc_t * p;
644 p = proc -> gen_proc;
645
646 int max_frames = 0;
647 oberon_object_t * prc = proc;
648 while(prc)
649 {
650 max_frames += 1;
651 prc = prc -> parent;
652 }
653
654 size_t sz = sizeof(*p -> reg_frame) * max_frames;
655 p -> max_frames = max_frames;
656 p -> reg_frame = GC_MALLOC(sz);
657 memset(p -> reg_frame, 0, sz);
658
659 p -> level = max_frames - 1;
660 jvm_create_staticlinks_recursive(p, proc -> parent, p -> level);
661 }
662
663 static void
664 jvm_generate_push_static_links_recursive(gen_proc_t * p, oberon_object_t * parent)
665 {
666 if(parent == NULL)
667 {
668 return;
669 }
670
671 jvm_generate_push_static_links_recursive(p, parent -> parent);
672 int level = parent -> gen_proc -> level;
673 jvm_generate(p, 0, 1, "aload %i", p -> reg_frame[level]);
674 }
675
676 void
677 jvm_generate_push_static_links(gen_proc_t * p, oberon_object_t * proc)
678 {
679 jvm_generate_push_static_links_recursive(p, proc -> parent);
680 }
Another attempt to make Oberon compiler
[25/02/2024 19:55:35]
DEADSOFTWARE 2012-2024