DEADSOFTWARE

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


0db2cc88b29bf3454d99b390ea5ff4bc151e0804
[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_load(p, p -> frame_v);
64 break;
65 case JVM_STORAGE_FRAME_VAR:
66 case JVM_STORAGE_FRAME_PARAM_VAR:
67 jvm_generate_load(p, p -> frame_v);
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_load(p, p -> frame_v);
73 jvm_generate(p, 1, 1, "getfield %s [%s", full_name, desc);
74 jvm_generate_load(p, p -> frame_v);
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
207 switch(storage)
208 {
209 case JVM_STORAGE_REGISTER:
210 case JVM_STORAGE_PARAM:
211 case JVM_STORAGE_PARAM_VAR:
212 v -> reg = jvm_alloc_register_untyped(p -> rf, t -> wide);
213 break;
214 case JVM_STORAGE_PARAM_VARPTR:
215 /* Содержит пару массив+индекс */
216 v -> reg = jvm_alloc_register_untyped(p -> rf, true);
217 break;
218 case JVM_STORAGE_REGISTER_VAR:
219 /* Содержит массив */
220 v -> reg = jvm_alloc_register_untyped(p -> rf, false);
221 break;
222 case JVM_STORAGE_FRAME:
223 case JVM_STORAGE_FRAME_VAR:
224 v -> full_name = new_string("%s$FRAME/%s", p -> full_name, name);
225 break;
226 case JVM_STORAGE_FRAME_PARAM:
227 case JVM_STORAGE_FRAME_PARAM_VAR:
228 v -> reg = jvm_alloc_register_untyped(p -> rf, t -> wide);
229 v -> full_name = new_string("%s$FRAME/%s", p -> full_name, name);
230 break;
231 case JVM_STORAGE_FRAME_PARAM_VARPTR:
232 /* Содержит пару массив+индекс */
233 v -> reg = jvm_alloc_register_untyped(p -> rf, true);
234 v -> full_name = new_string("%s$FRAME/%s", p -> full_name, name);
235 break;
236 default:
237 gen_error("jvm_create_class_var: invalid storage %i", storage);
238 break;
239 }
240
241 return v;
242 }
243
244 gen_var_t *
245 jvm_create_function_temp_var(gen_proc_t * p, gen_type_t * t)
246 {
247 gen_var_t * v = jvm_new_var();
248 v -> storage = JVM_STORAGE_REGISTER;
249 v -> reg = jvm_alloc_register_untyped(p -> rf, t -> wide);
250 v -> name = new_string("$TEMP_%i$", v -> reg);
251 v -> type = t;
252 v -> p = p;
253 return v;
254 }
255
256 void
257 jvm_generate_var(gen_var_t * v)
258 {
259 enum gen_storage storage = v -> storage;
260 int reg = v -> reg;
261 char * name = v -> name;
262 char * desc = v -> type -> desc;
263 gen_proc_t * p = v -> p;
264
265 switch(v -> storage)
266 {
267 case JVM_STORAGE_REGISTER:
268 case JVM_STORAGE_PARAM:
269 case JVM_STORAGE_PARAM_VAR:
270 jvm_generate(p, 0, 0, ".var %i is %s %s from start to end", reg, name, desc);
271 break;
272 case JVM_STORAGE_REGISTER_VAR:
273 jvm_generate(p, 0, 0, ".var %i is %s [%s from start to end", reg, name, desc);
274 break;
275 case JVM_STORAGE_PARAM_VARPTR:
276 jvm_generate(p, 0, 0, ".var %i is %s [%s from start to end", reg, name, desc);
277 jvm_generate(p, 0, 0, ".var %i is %s$offset I from start to end", reg + 1, name);
278 break;
279 case JVM_STORAGE_STATIC:
280 fprintf(v -> class -> fp, ".field public static %s %s\n\n", name, desc);
281 break;
282 case JVM_STORAGE_STATIC_VAR:
283 fprintf(v -> class -> fp, ".field public static %s [%s\n\n", name, desc);
284 break;
285 case JVM_STORAGE_FIELD:
286 fprintf(v -> class -> fp, ".field public %s %s\n\n", name, desc);
287 break;
288 case JVM_STORAGE_FIELD_VAR:
289 fprintf(v -> class -> fp, ".field public %s [%s\n\n", name, desc);
290 break;
291 case JVM_STORAGE_FRAME:
292 case JVM_STORAGE_FRAME_VAR:
293 case JVM_STORAGE_FRAME_PARAM:
294 case JVM_STORAGE_FRAME_PARAM_VAR:
295 case JVM_STORAGE_FRAME_PARAM_VARPTR:
296 /* См. ниже jvm_generate_frame_class() */
297 break;
298 default:
299 gen_error("jvm_generate_var: invalid storage %i", storage);
300 break;
301 }
302 }
303
304 static void
305 jvm_generate_param_initialization(gen_proc_t * p, gen_var_t * v)
306 {
307 int old_reg = v -> reg;
308 int cell_size = v -> type -> cell_size;
309 char prefix = v -> type -> prefix;
310 char * name = v -> name;
311 char * desc = v -> type -> desc;
312
313 v -> reg = jvm_alloc_register_untyped(p -> rf, false);
314 jvm_generate(p, 0, 0, ".var %i is $%s [%s from start to end", v -> reg, name, desc);
315
316 jvm_generate(p, 0, 1, "iconst_1");
317 jvm_generate(p, 1, 1, "multianewarray [%s 1", desc);
318 jvm_generate(p, 1, 2, "dup");
319 jvm_generate(p, 1, 0, "astore %i", v -> reg);
320
321 jvm_generate(p, 0, 1, "iconst_0");
322 jvm_generate(p, 0, cell_size, "%cload %i", prefix, old_reg);
323 jvm_generate(p, 1 + 1 + cell_size, 0, "%castore", prefix);
324 }
325
326 void
327 jvm_generate_var_initialization(gen_proc_t * p, gen_var_t * v)
328 {
329 if(v -> storage == JVM_STORAGE_REGISTER_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, "astore %i", v -> reg);
334 }
335 else if(v -> storage == JVM_STORAGE_STATIC_VAR)
336 {
337 jvm_generate(p, 0, 1, "iconst_1");
338 jvm_generate(p, 1, 1, "multianewarray [%s 1", v -> type -> desc);
339 jvm_generate(p, 1, 0, "putstatic %s [%s", v -> full_name, v -> type -> desc);
340 }
341 else if(v -> storage == JVM_STORAGE_FIELD_VAR)
342 {
343 jvm_generate(p, 0, 1, "iconst_1");
344 jvm_generate(p, 1, 1, "multianewarray [%s 1", v -> type -> desc);
345 jvm_generate(p, 1, 0, "putfield %s [%s", v -> full_name, v -> type -> desc);
346 }
347 else if(v -> storage == JVM_STORAGE_PARAM_VAR)
348 {
349 jvm_generate_param_initialization(p, v);
350 }
351 else if(v -> storage == JVM_STORAGE_FRAME_PARAM
352 || v -> storage == JVM_STORAGE_FRAME_PARAM_VAR)
353 {
354 jvm_generate_ldst_prepare(p, v);
355 jvm_generate(p, 0, v -> type -> cell_size, "%cload %i", v -> type -> prefix, v -> reg);
356 jvm_generate_store(p, v);
357 }
358 else if(v -> storage == JVM_STORAGE_FRAME_PARAM_VARPTR)
359 {
360 jvm_generate_load(p, p -> frame_v);
361 jvm_generate(p, 0, 1, "aload %i", v -> reg);
362 jvm_generate(p, 1, 0, "putfield %s [%s", v -> full_name, v -> type -> desc);
363
364 jvm_generate_load(p, p -> frame_v);
365 jvm_generate(p, 0, 1, "iload %i", v -> reg + 1);
366 jvm_generate(p, 1, 0, "putfield %s$offset I", v -> full_name);
367 }
368 }
369
370 static void
371 jvm_generate_abstract_frame_class()
372 {
373 FILE * fp;
374 char * cname;
375 struct gen_class * class;
376
377 cname = "SYSTEM$FRAME";
378 class = jvm_create_class(cname);
379 fp = class -> fp;
380
381 fprintf(fp, ".source SYSTEM\n");
382 fprintf(fp, ".class public abstract %s\n", cname);
383 fprintf(fp, ".super java/lang/Object\n\n");
384
385 fprintf(fp, ".field public $UP L%s;\n\n", cname);
386
387 fprintf(fp, ".method <init>()V\n");
388 fprintf(fp, " aload_0\n");
389 fprintf(fp, " invokespecial java/lang/Object/<init>()V\n");
390 fprintf(fp, " return\n");
391 fprintf(fp, ".end method\n\n");
392
393 jvm_destroy_class(class);
394 }
395
396 static struct gen_class *
397 jvm_generate_frame_class(oberon_object_t * proc)
398 {
399 FILE * fp;
400 char * cname;
401 char * abscname;
402 struct gen_class * class;
403 oberon_object_t * var;
404
405 abscname = "SYSTEM$FRAME";
406 cname = jvm_get_field_full_name_safe(proc);
407 cname = new_string("%s$FRAME", cname);
408 class = jvm_create_class(cname);
409 fp = class -> fp;
410
411 class -> full_name = cname;
412
413 fprintf(fp, ".source %s\n", proc -> module -> name);
414 fprintf(fp, ".class public %s\n", cname);
415 fprintf(fp, ".super %s\n\n", abscname);
416
417 var = proc -> scope -> list -> next;
418 while(var)
419 {
420 if(var -> class == OBERON_CLASS_VAR
421 || var -> class == OBERON_CLASS_PARAM
422 || var -> class == OBERON_CLASS_VAR_PARAM)
423 {
424 gen_var_t * v = var -> gen_var;
425 if(v -> storage == JVM_STORAGE_FRAME
426 || v -> storage == JVM_STORAGE_FRAME_PARAM)
427 {
428 fprintf(fp, ".field public %s %s\n\n", v -> name, v -> type -> desc);
429 }
430 else if(v -> storage == JVM_STORAGE_FRAME_VAR
431 || v -> storage == JVM_STORAGE_FRAME_PARAM_VAR)
432 {
433 fprintf(fp, ".field public %s [%s\n\n", v -> name, v -> type -> desc);
434 }
435 else if(v -> storage == JVM_STORAGE_FRAME_PARAM_VARPTR)
436 {
437 fprintf(fp, ".field public %s [%s\n", v -> name, v -> type -> desc);
438 fprintf(fp, ".field public %s$offset I\n\n", v -> name);
439 }
440 }
441 var = var -> next;
442 }
443
444 fprintf(fp, ".method <init>()V\n");
445 fprintf(fp, " .limit stack 2\n");
446 fprintf(fp, " aload_0\n");
447 fprintf(fp, " invokespecial %s/<init>()V\n", abscname);
448
449 var = proc -> scope -> list -> next;
450 while(var)
451 {
452 if(var -> class == OBERON_CLASS_VAR
453 || var -> class == OBERON_CLASS_PARAM
454 || var -> class == OBERON_CLASS_VAR_PARAM)
455 {
456 gen_var_t * v = var -> gen_var;
457 if(v -> storage == JVM_STORAGE_FRAME_VAR
458 || v -> storage == JVM_STORAGE_FRAME_PARAM_VAR)
459 {
460 fprintf(fp, " aload_0\n");
461 fprintf(fp, " iconst_1\n");
462 fprintf(fp, " multianewarray [%s 1\n", v -> type -> desc);
463 fprintf(fp, " putfield %s [%s\n", v -> full_name, v -> type -> desc);
464 }
465 }
466 var = var -> next;
467 }
468
469 fprintf(fp, " return\n");
470 fprintf(fp, ".end method\n\n");
471
472 jvm_destroy_class(class);
473
474 return class;
475 }
476
477 void
478 jvm_generate_procedure_frame(oberon_object_t * proc)
479 {
480 gen_proc_t * p;
481 gen_type_t * t;
482 gen_var_t * v;
483 struct gen_class * class;
484
485 p = proc -> gen_proc;
486
487 jvm_generate_abstract_frame_class();
488 class = jvm_generate_frame_class(proc);
489
490 t = GC_MALLOC(sizeof *t);
491 memset(t, 0, sizeof *t);
492 t -> class = class;
493 t -> wide = false;
494 t -> prefix = 'a';
495 t -> postfix = 'a';
496 t -> cell_size = 1;
497 t -> desc = new_string("L%s;", class -> full_name);
498
499 v = jvm_create_function_var(p, JVM_STORAGE_REGISTER, "$FP$", t);
500
501 p -> frame_v = v;
502 p -> frame_t = t;
503 }
504
505 void
506 jvm_generate_frame_initialization(gen_proc_t * p)
507 {
508 jvm_generate_var(p -> frame_v);
509 jvm_generate_ldst_prepare(p, p -> frame_v);
510 jvm_generate(p, 0, 1, "new %s", p -> frame_t -> class -> full_name);
511 jvm_generate(p, 1, 2, "dup");
512 jvm_generate(p, 1, 0, "invokespecial %s/<init>()V", p -> frame_t -> class -> full_name);
513 jvm_generate_store(p, p -> frame_v);
514 }
Another attempt to make Oberon compiler
[25/02/2024 19:55:35]
DEADSOFTWARE 2012-2024