DEADSOFTWARE

GIT / REPO / FRED-BOY
Projects / dsw-obn.git / blob


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