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