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 }