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