src/backends/jvm/generator-jvm.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-basic.h"
  15
  16 // ==========================================
  17 // ==========================================
  18 // ==========================================
  19
  20 gen_proc_t *
  21 jvm_create_proc(struct gen_class * class)
  22 {
  23         gen_proc_t * p = GC_MALLOC(sizeof *p);
  24         memset(p, 0, sizeof *p);
  25
  26         struct gen_register_file * rf = GC_MALLOC(sizeof *rf);
  27         memset(rf, 0, sizeof *rf);
  28
  29         struct gen_stack * stack = GC_MALLOC(sizeof *stack);
  30         memset(rf, 0, sizeof *stack);
  31
  32         p -> rf = rf;
  33         p -> stack = stack;
  34         p -> class = class;
  35         p -> label_id = 0;
  36
  37         return p;
  38 }
  39
  40 void
  41 jvm_generate_function_header(gen_proc_t * p, char * access, char * name, char * signature)
  42 {
  43         struct gen_class * class;
  44         class = p -> class;
  45
  46         /* Делаем процедуру текущей в этом классе */
  47         assert(class -> p == NULL);
  48         class -> p = p;
  49
  50         fprintf(class -> fp, ".method %s %s%s\n", access, name, signature);
  51         fprintf(class -> fp, "  start:\n");
  52 }
  53
  54 void
  55 jvm_generate_function_end(gen_proc_t * p)
  56 {
  57         struct gen_class * class;
  58         class = p -> class;
  59
  60         assert(class -> p);
  61         class -> p = NULL;
  62
  63         int pointer = p -> stack -> pointer;
  64         int max_pointer = p -> stack -> max_pointer;
  65         int locals = p -> rf -> num_used;
  66         int max_locals = p -> rf -> max_used;
  67
  68         fprintf(class -> fp, "  .limit stack %i \t; current(%i)\n", max_pointer, pointer);
  69         fprintf(class -> fp, "  .limit locals %i \t; current(%i)\n", max_locals, locals);
  70         fprintf(class -> fp, "  end:\n");
  71         fprintf(class -> fp, ".end method\n\n");
  72 }
  73
  74 struct gen_class *
  75 jvm_create_class(char * full_name)
  76 {
  77         struct gen_class * class = GC_MALLOC(sizeof *class);
  78         memset(class, 0, sizeof *class);
  79
  80         char * fname = new_string("%s.j", full_name);
  81         class -> full_name = new_string(full_name);
  82         class -> fp = fopen(fname, "w");
  83         assert(class -> fp);
  84
  85         return class;
  86 }
  87
  88 static void
  89 jvm_destroy_class(struct gen_class * class)
  90 {
  91         assert(class -> p == NULL);
  92         fclose(class -> fp);
  93 }
  94
  95 static void
  96 jvm_stack_push(gen_proc_t * p, unsigned size)
  97 {
  98         p -> stack -> pointer += size;
  99         if(p -> stack -> pointer > p -> stack -> max_pointer)
 100         {
 101                 p -> stack -> max_pointer = p -> stack -> pointer;
 102         }
 103 }
 104
 105 static void
 106 jvm_stack_pop(gen_proc_t * p, unsigned size)
 107 {
 108         p -> stack -> pointer -= size;
 109
 110         if(p -> stack -> pointer < 0)
 111         {
 112                 printf("WARING: stack pointer %i\n", p -> stack -> pointer);
 113         }
 114 }
 115
 116 static void
 117 jvm_generate(gen_proc_t * p, unsigned get, unsigned push, char * format, ...)
 118 {
 119         va_list ptr;
 120         va_start(ptr, format);
 121
 122         jvm_stack_pop(p, get);
 123         fprintf(p -> class -> fp, "  ");
 124         vfprintf(p -> class -> fp, format, ptr);
 125         jvm_stack_push(p, push);
 126         fprintf(p -> class -> fp, " \t ;>>>> %i -- %i : current_stack(%i)\n", get, push, p -> stack -> pointer);
 127
 128         va_end(ptr);
 129 }
 130
 131 static void
 132 jvm_generate_push_int(gen_proc_t * p, int64_t i)
 133 {
 134         if(i == -1)
 135         {
 136                 jvm_generate(p, 0, 1, "iconst_m1");
 137         }
 138         else if(i >= 0 && i <= 5)
 139         {
 140                 jvm_generate(p, 0, 1, "iconst_%li", i);
 141         }
 142         else if(i >= -128 && i <= 127)
 143         {
 144                 jvm_generate(p, 0, 1, "bipush %li", i);
 145         }
 146         else if(i >= -32768 && i <= 32767)
 147         {
 148                 jvm_generate(p, 0, 1, "sipush %li", i);
 149         }
 150         else if(i >= -2147483648 && i <= 2147483647)
 151         {
 152                 jvm_generate(p, 0, 1, "ldc %li", i);
 153         }
 154         else
 155         {
 156                 jvm_generate(p, 0, 2, "ldc2 %li", i);
 157         }
 158 }
 159
 160 static void
 161 jvm_generate_push_float(gen_proc_t * p, double f, int size)
 162 {
 163         if(size <= 4)
 164         {
 165                 if(f == 0.0)
 166                 {
 167                         jvm_generate(p, 0, 1, "fconst_0");
 168                 }
 169                 if(f == 1.0)
 170                 {
 171                         jvm_generate(p, 0, 1, "fconst_1");
 172                 }
 173                 if(f == 2.0)
 174                 {
 175                         jvm_generate(p, 0, 1, "fconst_2");
 176                 }
 177                 else
 178                 {
 179                         jvm_generate(p, 0, 1, "ldc %lf", f);
 180                 }
 181         }
 182         else
 183         {
 184                 if(f == 0.0)
 185                 {
 186                         jvm_generate(p, 0, 2, "dconst_0");
 187                 }
 188                 if(f == 1.0)
 189                 {
 190                         jvm_generate(p, 0, 2, "dconst_1");
 191                 }
 192                 else
 193                 {
 194                         jvm_generate(p, 0, 2, "ldc2 %lf", f);
 195                 }
 196         }
 197 }
 198
 199 static gen_var_t *
 200 oberon_generator_new_var()
 201 {
 202         gen_var_t * v = GC_MALLOC(sizeof *v);
 203         memset(v, 0, sizeof *v);
 204         return v;
 205 }
 206
 207 static void
 208 jvm_generate_and_init_global_var(gen_var_t * v, struct gen_class * class, char * access, char * name, char * desc)
 209 {
 210         assert(class -> p == NULL);
 211         fprintf(class -> fp, ".field %s static %s %s\n\n", access, name, desc);
 212
 213         v -> storage = JVM_STORAGE_STATIC;
 214         v -> full_name = new_string("%s/%s", class -> full_name, name);
 215         v -> desc = new_string(desc);
 216 }
 217
 218 static void
 219 jvm_generate_and_init_field(gen_var_t * v, struct gen_class * class, char * access, char * name, char * desc)
 220 {
 221         assert(class -> p == NULL);
 222         fprintf(class -> fp, ".field %s %s %s\n\n", access, name, desc);
 223
 224         v -> storage = JVM_STORAGE_FIELD;
 225         v -> full_name = new_string("%s/%s", class -> full_name, name);
 226         v -> desc = new_string(desc);
 227 }
 228
 229 static void
 230 jvm_generate_and_init_local_var(gen_var_t * v, gen_proc_t * p, bool wide)
 231 {
 232         v -> storage = JVM_STORAGE_REGISTER;
 233         v -> reg = jvm_alloc_register_untyped(p -> rf, wide);
 234 }
 235
 236 static void
 237 jvm_generate_and_init_named_local_var(gen_var_t * v, gen_proc_t * p, bool wide, char * name, char * desc)
 238 {
 239         jvm_generate_and_init_local_var(v, p, wide);
 240         v -> desc = new_string(desc);
 241         jvm_generate(p, 0, 0, ".var %i is %s %s from start to end", v -> reg, name, desc);
 242 }
 243
 244 static int
 245 jvm_new_label_id(gen_proc_t * p)
 246 {
 247         int label_id = p -> label_id;
 248         p -> label_id += 1;
 249         return label_id;
 250 }
 251
 252 static char *
 253 jvm_get_label_name(int label_id)
 254 {
 255         return new_string("L%i", label_id);
 256 }
 257
 258 static void
 259 jvm_generate_label(gen_proc_t * p, int label_id)
 260 {
 261         jvm_generate(p, 0, 0, "L%i:", label_id);
 262 }
 263
 264 static void
 265 jvm_generate_new(gen_proc_t * p, oberon_type_t * type, int num);
 266
 267 /*
 268  * Функция jvm_generate_static_array_initialization генерирует код для
 269  * статической инициализации массива. На входе массив, на выходе тот же массив.
 270  * (arrayref -- arrayref)
 271  */
 272
 273 static void
 274 jvm_generate_static_array_initialization(gen_proc_t * p, oberon_type_t * type)
 275 {
 276         /* for(int i = 0; i < a.length; i++) */
 277         /*   a[i] := new(base); */
 278         /*   init(a[i]) */
 279
 280         /* a := pop(array) */
 281         gen_var_t * va = oberon_generator_new_var();
 282         jvm_generate_and_init_local_var(va, p, false);
 283         int reg_a = va -> reg;
 284         /* ссылка уже на стеке */
 285         jvm_generate(p, 1, 0, "astore %i", reg_a);
 286
 287         /* int i = 0; */
 288         gen_var_t * vi = oberon_generator_new_var();
 289         jvm_generate_and_init_local_var(vi, p, false);
 290         int reg_i = vi -> reg;
 291         jvm_generate(p, 0, 1, "iconst_0");
 292         jvm_generate(p, 1, 0, "istore %i", reg_i);
 293
 294         /* int l := a.length */
 295         gen_var_t * vl = oberon_generator_new_var();
 296         jvm_generate_and_init_local_var(vl, p, false);
 297         int reg_l = vl -> reg;
 298         jvm_generate(p, 0, 1, "aload %i", reg_a);
 299         jvm_generate(p, 1, 1, "arraylength");
 300         jvm_generate(p, 1, 0, "istore %i", reg_l);
 301
 302         int label_start = jvm_new_label_id(p);
 303         int label_end = jvm_new_label_id(p);
 304
 305         /* start: */
 306         /* if (i >= l) goto end; */
 307         /*   body*/
 308         /*   i += 1;*/
 309         /*   goto start;*/
 310         /* end: */
 311         /* push a */
 312
 313         jvm_generate_label(p, label_start);
 314         jvm_generate(p, 0, 1, "iload %i", reg_i);
 315         jvm_generate(p, 0, 1, "iload %i", reg_l);
 316         jvm_generate(p, 2, 0, "if_icmpge L%i", label_end);
 317
 318         if(type -> base -> class == OBERON_TYPE_ARRAY)
 319         {
 320                 /* Инициализируем следующую размерность */
 321                 jvm_generate(p, 0, 1, "aload %i", reg_a);
 322                 jvm_generate(p, 0, 1, "iload %i", reg_i);
 323                 jvm_generate(p, 0, 1, "aaload");
 324                 jvm_generate_static_array_initialization(p, type -> base);
 325                 jvm_generate(p, 1, 0, "pop");
 326         }
 327         else if(type -> base -> class == OBERON_TYPE_RECORD)
 328         {
 329                 jvm_generate(p, 0, 1, "aload %i", reg_a);
 330                 jvm_generate(p, 0, 1, "iload %i", reg_i);
 331                 jvm_generate_new(p, type -> base, 0);
 332                 jvm_generate(p, 3, 0, "aastore");
 333         }
 334         else
 335         {
 336                 assert(0);
 337         }
 338
 339         /* i += 1; */
 340         /* goto start */
 341
 342         jvm_generate(p, 0, 0, "iinc %i %i", reg_i, 1);
 343         jvm_generate(p, 0, 0, "goto L%i", label_start);
 344         jvm_generate_label(p, label_end);
 345
 346         /* push(a) */
 347         jvm_generate(p, 0, 1, "aload %i", reg_a);
 348
 349         /* TODO освобождение регистров */
 350 }
 351
 352 static void
 353 jvm_generate_new(gen_proc_t * p, oberon_type_t * type, int num)
 354 {
 355         int dim;
 356         char * cname;
 357         char * desc;
 358         oberon_type_t * base;
 359
 360         switch(type -> class)
 361         {
 362                 case OBERON_TYPE_INTEGER:
 363                 case OBERON_TYPE_BOOLEAN:
 364                 case OBERON_TYPE_PROCEDURE:
 365                 case OBERON_TYPE_REAL:
 366                 case OBERON_TYPE_POINTER:
 367                         gen_error("jvm_generate_new_static: static alocation not allowed");
 368                         break;
 369                 case OBERON_TYPE_RECORD:
 370                         cname = jvm_get_class_full_name(type);
 371                         jvm_generate(p, 0, 1, "new %s", cname);
 372                         jvm_generate(p, 1, 2, "dup");
 373                         jvm_generate(p, 1, 0, "invokespecial %s/<init>()V", cname);
 374                         break;
 375                 case OBERON_TYPE_ARRAY:
 376                         dim = 0;
 377                         base = type;
 378                         desc = jvm_get_descriptor(type);
 379                         while(base -> class == OBERON_TYPE_ARRAY)
 380                         {
 381                                 if(num > 0)
 382                                 {
 383                                         assert(base -> size == 0);
 384                                         num -= 1;
 385                                 }
 386                                 else
 387                                 {
 388                                         assert(base -> size > 0);
 389                                         jvm_generate_push_int(p, base -> size);
 390                                 }
 391                                 dim += 1;
 392                                 base = base -> base;
 393                         }
 394
 395                         assert(num == 0);
 396                         jvm_generate(p, dim, 1, "multianewarray %s %i", desc, dim);
 397
 398                         if(base -> class == OBERON_TYPE_RECORD)
 399                         {
 400                                 jvm_generate_static_array_initialization(p, type);
 401                         }
 402                         break;
 403                 default:
 404                         gen_error("jvm_generate_new_static: unk type class %i", type -> class);
 405                         break;
 406         }
 407 }
 408
 409 static void
 410 jvm_generate_load(gen_proc_t * p, oberon_type_t * src_type, gen_var_t * src)
 411 {
 412         char prefix;
 413         int cell_size;
 414
 415         cell_size = jvm_cell_size_for_type(src_type);
 416
 417         switch(src -> storage)
 418         {
 419                 case JVM_STORAGE_REGISTER:
 420                         prefix = jvm_get_prefix(src_type);
 421                         jvm_generate(p, 0, cell_size, "%cload %i", prefix, src -> reg);
 422                         break;
 423                 case JVM_STORAGE_STATIC:
 424                         jvm_generate(p, 0, cell_size, "getstatic %s %s", src -> full_name, src -> desc);
 425                         break;
 426                 case JVM_STORAGE_FIELD:
 427                         jvm_generate(p, 1, cell_size, "getfield %s %s", src -> full_name, src -> desc);
 428                         break;
 429                 default:
 430                         gen_error("jvm_generate_load: unknow storage type %i", src -> storage);
 431                         break;
 432         }
 433 }
 434
 435 static void
 436 jvm_generate_store(gen_proc_t * p, oberon_type_t * src_type, gen_var_t * dst)
 437 {
 438         char prefix;
 439         int cell_size;
 440
 441         cell_size = jvm_cell_size_for_type(src_type);
 442
 443         switch(dst -> storage)
 444         {
 445                 case JVM_STORAGE_REGISTER:
 446                         prefix = jvm_get_prefix(src_type);
 447                         jvm_generate(p, cell_size, 0, "%cstore %i", prefix, dst -> reg);
 448                         break;
 449                 case JVM_STORAGE_STATIC:
 450                         jvm_generate(p, cell_size, 0, "putstatic %s %s", dst -> full_name, dst -> desc);
 451                         break;
 452                 case JVM_STORAGE_FIELD:
 453                         jvm_generate(p, 1 + cell_size, 0, "putfield %s %s", dst -> full_name, dst -> desc);
 454                         break;
 455                 default:
 456                         gen_error("jvm_generate_store: unknow storage type %i", dst -> storage);
 457                         break;
 458         }
 459 }
 460
 461 /*
 462  * Генерирует код для копирования полей из первой записи во вторую.
 463  *  ( aref_dst aref_src -- )
 464  *  dst := src;
 465  */
 466
 467 static void
 468 jvm_generate_copy_record(gen_proc_t * p, oberon_type_t * rec)
 469 {
 470         assert(rec -> class == OBERON_TYPE_RECORD);
 471         char * desc = jvm_get_descriptor(rec);
 472         char * cname = jvm_get_class_full_name(rec);
 473         jvm_generate(p, 1 + 1, 0, "invokestatic %s/$COPY$(%s%s)V", cname, desc, desc);
 474 }
 475
 476
 477 // ==========================================
 478 // ==========================================
 479 // ==========================================
 480
 481 void
 482 oberon_generator_init_context(oberon_context_t * ctx)
 483 {
 484         gen_context_t * gen_context = GC_MALLOC(sizeof *gen_context);
 485         memset(gen_context, 0, sizeof *gen_context);
 486
 487         ctx -> gen_context = gen_context;
 488 }
 489
 490 void
 491 oberon_generator_destroy_context(oberon_context_t * ctx)
 492 {
 493 }
 494
 495 static void
 496 oberon_generate_procedure_class(oberon_type_t * proc)
 497 {
 498         FILE * fp;
 499         char * cname;
 500         char * signature;
 501         struct gen_class * class;
 502
 503         cname = jvm_get_class_full_name(proc);
 504         class = jvm_create_class(cname);
 505         fp = class -> fp;
 506
 507         fprintf(fp, ".source SYSTEM\n");
 508         fprintf(fp, ".class  public abstract %s\n", cname);
 509         fprintf(fp, ".super  java/lang/Object\n\n");
 510
 511         fprintf(fp, ".method public <init>()V\n");
 512         fprintf(fp, "  aload_0\n");
 513         fprintf(fp, "  invokespecial java/lang/Object/<init>()V\n");
 514         fprintf(fp, "  return\n");
 515         fprintf(fp, ".end method\n\n");
 516
 517         signature = jvm_get_procedure_signature(proc);
 518
 519         fprintf(fp, ".method public abstract invoke%s\n", signature);
 520         fprintf(fp, ".end method\n\n");
 521
 522         jvm_destroy_class(class);
 523 }
 524
 525 static void
 526 oberon_generate_record_class(gen_module_t * m, oberon_type_t * rec)
 527 {
 528         char * cname;
 529         struct gen_class * class;
 530
 531         /* Устанавливаем новоый id */
 532         rec -> gen_type -> rec_id = m -> rec_id;
 533         m -> rec_id += 1;
 534
 535         cname = jvm_get_class_full_name(rec);
 536         class = jvm_create_class(cname);
 537
 538         fprintf(class -> fp, ".source %s\n", rec -> module -> name);
 539         fprintf(class -> fp, ".class  public %s\n", cname);
 540         fprintf(class -> fp, ".super  java/lang/Object\n\n");
 541
 542         rec -> gen_type -> class = class;
 543 }
 544
 545 void
 546 oberon_generator_init_type(oberon_context_t * ctx, oberon_type_t * type)
 547 {
 548         gen_type_t * t = GC_MALLOC(sizeof *t);
 549         memset(t, 0, sizeof *t);
 550         type -> gen_type = t;
 551
 552         switch(type -> class)
 553         {
 554                 case OBERON_TYPE_VOID:
 555                 case OBERON_TYPE_INTEGER:
 556                 case OBERON_TYPE_BOOLEAN:
 557                 case OBERON_TYPE_ARRAY:
 558                 case OBERON_TYPE_REAL:
 559                         break;
 560                 case OBERON_TYPE_RECORD:
 561                         ;
 562                         gen_module_t * m;
 563                         m = type -> module -> gen_mod;
 564                         oberon_generate_record_class(m, type);
 565                         break;
 566                 case OBERON_TYPE_PROCEDURE:
 567                         oberon_generate_procedure_class(type);
 568                         break;
 569                 case OBERON_TYPE_POINTER:
 570                         break;
 571                 default:
 572                         gen_error("oberon_generator_init_type: unk calss %i", type -> class);
 573                         break;
 574         }
 575 }
 576
 577 void
 578 oberon_generator_init_record(oberon_context_t * ctx, oberon_type_t * rec)
 579 {
 580         struct gen_class * class;
 581         class = rec -> gen_type -> class;
 582
 583         int num = rec -> num_decl;
 584         oberon_object_t * field = rec -> decl;
 585         for(int i = 0; i < num; i++)
 586         {
 587                 gen_var_t * v = field -> gen_var;
 588                 char * name = field -> name;
 589                 char * desc = jvm_get_descriptor(field -> type);
 590                 jvm_generate_and_init_field(v, class, "public", name, desc);
 591                 field = field -> next;
 592         }
 593
 594         /* Стандартный конструктор класса */
 595         /* Инициализирует внутренние статические записи и массивы */
 596         gen_proc_t * p = jvm_create_proc(class);
 597         jvm_generate_function_header(p, "public", "<init>", "()V");
 598         jvm_alloc_register_untyped(p -> rf, false);
 599         jvm_generate(p, 0, 1, "aload_0");
 600         jvm_generate(p, 1, 0, "invokespecial java/lang/Object/<init>()V");
 601         num = rec -> num_decl;
 602         field = rec -> decl;
 603         for(int i = 0; i < num; i++)
 604         {
 605                 if(field -> type -> class == OBERON_TYPE_RECORD
 606                         || field -> type -> class == OBERON_TYPE_ARRAY)
 607                 {
 608                         jvm_generate(p, 0, 1, "aload_0");
 609                         jvm_generate_new(p, field -> type, 0);
 610                         jvm_generate_store(p, field -> type, field -> gen_var);
 611                 }
 612                 field = field -> next;
 613         }
 614         jvm_generate(p, 0, 0, "return");
 615         jvm_generate_function_end(p);
 616
 617         /* Метод для копирования полей класса */
 618         /* reg0 == src -> reg1 == dst */
 619         p = jvm_create_proc(class);
 620         gen_var_t * copy_dst = oberon_generator_new_var();
 621         gen_var_t * copy_src = oberon_generator_new_var();
 622         char * desc = jvm_get_descriptor(rec);
 623         char * signature = new_string("(%s%s)V", desc, desc);
 624         jvm_generate_function_header(p, "public static", "$COPY$", signature);
 625         jvm_generate_and_init_named_local_var(copy_dst, p, false, "dst", desc);
 626         jvm_generate_and_init_named_local_var(copy_src, p, false, "src", desc);
 627         num = rec -> num_decl;
 628         field = rec -> decl;
 629         for(int i = 0; i < num; i++)
 630         {
 631                 if(field -> type -> class == OBERON_TYPE_RECORD)
 632                 {
 633                         jvm_generate_load(p, rec, copy_dst);
 634                         jvm_generate_load(p, field -> type, field -> gen_var);
 635                         jvm_generate_load(p, rec, copy_src);
 636                         jvm_generate_load(p, field -> type, field -> gen_var);
 637                         jvm_generate_copy_record(p, field -> type);
 638                 }
 639                 else if(field -> type -> class == OBERON_TYPE_ARRAY)
 640                 {
 641                         gen_error("copy array not implemented");
 642                 }
 643                 else
 644                 {
 645                         jvm_generate_load(p, rec, copy_dst);
 646                         jvm_generate_load(p, rec, copy_src);
 647                         jvm_generate_load(p, field -> type, field -> gen_var);
 648                         jvm_generate_store(p, field -> type, field -> gen_var);
 649                 }
 650                 field = field -> next;
 651         }
 652         jvm_generate(p, 0, 0, "return");
 653         jvm_generate_function_end(p);
 654
 655         jvm_destroy_class(class);
 656 }
 657
 658 void
 659 oberon_generator_init_var(oberon_context_t * ctx, oberon_object_t * var)
 660 {
 661         gen_var_t * v = oberon_generator_new_var();
 662         var -> gen_var = v;
 663
 664         gen_module_t * m;
 665         m = ctx -> mod -> gen_mod;
 666
 667         struct gen_class * class;
 668         class = m -> class;
 669
 670         char * desc;
 671         switch(var -> class)
 672         {
 673                 case OBERON_CLASS_VAR_PARAM:
 674                         gen_error("generator: VAR-parameters not implemented");
 675                         break;
 676                 case OBERON_CLASS_PARAM:
 677                         /* Заполняется при генерации функции */
 678                         /* смотри jvm_init_local_object() */
 679                         break;
 680                 case OBERON_CLASS_FIELD:
 681                         /* Заполняются при инициализации структуры */
 682                         /* смотри oberon_generator_init_record() */
 683                         break;
 684                 case OBERON_CLASS_VAR:
 685                         /* Локальные заполняются при генерации функции */
 686                         /* смотри jvm_init_local_object() */
 687                         if(var -> local == 0)
 688                         {
 689                                 desc = jvm_get_descriptor(var -> type);
 690                                 jvm_generate_and_init_global_var(v, class, "public", var -> name, desc);
 691                         }
 692                         break;
 693                 default:
 694                         gen_error("oberon_generator_init_var: unk var class %i", var -> class);
 695                         break;
 696         }
 697 }
 698
 699 void
 700 oberon_generator_init_proc(oberon_context_t * ctx, oberon_object_t * proc)
 701 {
 702         struct gen_class * class = proc -> module -> gen_mod -> class;
 703         proc -> gen_proc = jvm_create_proc(class);
 704
 705         if(proc -> local)
 706         {
 707                 gen_error("generator: local procedures not implemented");
 708         }
 709 }
 710
 711 void
 712 oberon_generator_init_module(oberon_context_t * ctx, oberon_module_t * mod)
 713 {
 714         gen_module_t * m = GC_MALLOC(sizeof *m);
 715         memset(m, 0, sizeof *m);
 716         mod -> gen_mod = m;
 717
 718         struct gen_class * class;
 719         class = jvm_create_class(mod -> name);
 720
 721         fprintf(class -> fp, ".source %s\n", mod -> name);
 722         fprintf(class -> fp, ".class %s\n", mod -> name);
 723         fprintf(class -> fp, ".super java/lang/Object\n\n");
 724
 725         m -> class = class;
 726
 727         ctx -> gen_context -> current_m = m;
 728 }
 729
 730 void
 731 oberon_generator_fini_module(oberon_module_t * mod)
 732 {
 733         jvm_destroy_class(mod -> gen_mod -> class);
 734 }
 735
 736 static void
 737 push_expr(gen_proc_t * p, oberon_expr_t * expr);
 738
 739 void
 740 oberon_generate_begin_module(oberon_context_t * ctx)
 741 {
 742         struct gen_class * class = ctx -> mod -> gen_mod -> class;
 743         gen_proc_t * p = jvm_create_proc(class);
 744
 745         jvm_generate_function_header(p, "public", "<init>", "()V");
 746         jvm_alloc_register_untyped(p -> rf, false);
 747         jvm_generate(p, 0, 1, "aload_0");
 748         jvm_generate(p, 1, 0, "invokespecial java/lang/Object/<init>()V");
 749
 750         /* Инициализация переменных объявленных в модуле */
 751         oberon_object_t * x = ctx -> mod -> decl -> list -> next;
 752         while(x != NULL)
 753         {
 754                 if(x -> class == OBERON_CLASS_VAR)
 755                 {
 756                         if(x -> type -> class == OBERON_TYPE_ARRAY
 757                                 || x -> type -> class == OBERON_TYPE_RECORD)
 758                         {
 759                                 jvm_generate_new(p, x -> type, 0);
 760                                 jvm_generate_store(p, x -> type, x -> gen_var);
 761                         }
 762                 }
 763                 x = x -> next;
 764         }
 765 }
 766
 767 void
 768 oberon_generate_end_module(oberon_context_t * ctx)
 769 {
 770         struct gen_class * class = ctx -> mod -> gen_mod -> class;
 771         gen_proc_t * p = class -> p;
 772
 773         jvm_generate(p, 0, 0, "return");
 774         jvm_generate_function_end(class -> p);
 775 }
 776
 777 static void
 778 jvm_init_local_object(gen_proc_t * p, oberon_object_t * x)
 779 {
 780         gen_var_t * v;
 781         bool wide;
 782         char * desc;
 783         struct gen_class * class;
 784
 785         v = x -> gen_var;
 786         class = p -> class;
 787         wide = jvm_is_wide_type(x -> type);
 788         desc = jvm_get_descriptor(x -> type);
 789
 790         // Убеждаемся что сейчас находимся в функции
 791         assert(class -> p);
 792         assert(x -> local);
 793
 794         switch(x -> class)
 795         {
 796                 case OBERON_CLASS_VAR:
 797                 case OBERON_CLASS_PARAM:
 798                         jvm_generate_and_init_named_local_var(v, p, wide, x -> name, desc);
 799                         break;
 800                 default:
 801                         gen_error("jvm_init_local_object: wat");
 802                         break;
 803         }
 804 }
 805
 806 void
 807 oberon_generate_begin_proc(oberon_context_t * ctx, oberon_object_t * proc)
 808 {
 809         gen_proc_t * p;
 810         char * signature;
 811
 812         p = proc -> gen_proc;
 813
 814         signature = jvm_get_procedure_signature(proc -> type);
 815
 816         jvm_generate_function_header(p, "public static", proc -> name, signature);
 817
 818         oberon_object_t * var = proc -> type -> decl;
 819         while(var)
 820         {
 821                 jvm_init_local_object(p, var);
 822                 var = var -> next;
 823         }
 824 }
 825
 826 void
 827 oberon_generate_end_proc(oberon_context_t * ctx)
 828 {
 829         gen_module_t * m;
 830         gen_proc_t * p;
 831
 832         m = ctx -> mod -> gen_mod;
 833         p = m -> class -> p;
 834
 835         jvm_generate_function_end(p);
 836 }
 837
 838 static void
 839 jvm_generate_call_proc(gen_proc_t * p, oberon_expr_t * desig)
 840 {
 841         assert(desig -> is_item);
 842         assert(desig -> item.mode == MODE_CALL);
 843
 844         oberon_object_t * proc;
 845         char * fullname;
 846         char * signature;
 847
 848         proc = desig -> item.var;
 849         fullname = jvm_get_field_full_name(proc);
 850         signature = jvm_get_procedure_signature(proc -> type);
 851
 852         int args_cells = 0;
 853         int result_cells = jvm_cell_size_for_type(proc -> type -> base);
 854
 855         int num = desig -> item.num_args;
 856         oberon_expr_t * arg = desig -> item.args;
 857         for(int i = 0; i < num; i++)
 858         {
 859                 args_cells += jvm_cell_size_for_type(arg -> result);
 860                 push_expr(p, arg);
 861                 arg = arg -> next;
 862         }
 863
 864         jvm_generate(p, args_cells, result_cells, "invokestatic %s%s", fullname, signature);
 865 }
 866
 867 void
 868 oberon_generate_call_proc(oberon_context_t * ctx, oberon_expr_t * desig)
 869 {
 870         jvm_generate_call_proc(ctx -> gen_context -> current_m -> class -> p, desig);
 871 }
 872
 873 void
 874 oberon_generate_return(oberon_context_t * ctx, oberon_expr_t * expr)
 875 {
 876         gen_module_t * m;
 877         gen_proc_t * p;
 878         char prefix;
 879         int cell_size;
 880
 881         m = ctx -> mod -> gen_mod;
 882         p = m -> class -> p;
 883
 884         if(expr)
 885         {
 886                 push_expr(p, expr);
 887                 prefix = jvm_get_prefix(expr -> result);
 888                 cell_size = jvm_cell_size_for_type(expr -> result);
 889                 jvm_generate(p, cell_size, 0, "%creturn", prefix);
 890         }
 891         else
 892         {
 893                 jvm_generate(p, 0, 0, "return");
 894         }
 895 }
 896
 897 static void
 898 jvm_push_var(gen_proc_t * p, oberon_object_t * var)
 899 {
 900         int cell_size = jvm_cell_size_for_type(var -> type);
 901
 902         if(var -> local)
 903         {
 904                 int reg = var -> gen_var -> reg;
 905                 char prefix = jvm_get_prefix(var -> type);
 906                 jvm_generate(p, 0, cell_size, "%cload %i", prefix, reg);
 907         }
 908         else
 909         {
 910                 char * fullname = jvm_get_field_full_name(var);
 911                 char * desc = jvm_get_descriptor(var -> type);
 912                 jvm_generate(p, 0, cell_size, "getstatic %s %s", fullname, desc);
 913         }
 914 }
 915
 916 static void
 917 jvm_generate_expr_new_pointer(gen_proc_t * p, oberon_type_t * type, int num, oberon_expr_t * arg)
 918 {
 919         assert(type -> class == OBERON_TYPE_POINTER);
 920
 921         for(int i = 0; i < num; i++)
 922         {
 923                 push_expr(p, arg);
 924                 arg = arg -> next;
 925         }
 926
 927         jvm_generate_new(p, type -> base, num);
 928 }
 929
 930 static void
 931 push_item(gen_proc_t * p, oberon_item_t * item)
 932 {
 933         switch(item -> mode)
 934         {
 935                 case MODE_VAR:
 936                         jvm_push_var(p, item -> var);
 937                         break;
 938                 case MODE_INTEGER:
 939                         jvm_generate_push_int(p, item -> integer);
 940                         break;
 941                 case MODE_BOOLEAN:
 942                         jvm_generate_push_int(p, item -> boolean);
 943                         break;
 944                 case MODE_CALL:
 945                         jvm_generate_call_proc(p, (oberon_expr_t *) item);
 946                         break;
 947                 case MODE_INDEX:
 948                         ;
 949                         char postfix = jvm_get_postfix(item -> result);
 950                         int cell_size = jvm_cell_size_for_postfix(postfix);
 951                         push_item(p, item -> parent);
 952                         push_expr(p, item -> args);
 953                         jvm_generate(p, 1 + 1, cell_size, "%caload", postfix);
 954                         break;
 955                 case MODE_FIELD:
 956                         push_item(p, item -> parent);
 957                         char * field = jvm_get_field_full_name(item -> var);
 958                         char * desc = jvm_get_descriptor(item -> var -> type);
 959                         jvm_generate(p, 1, 1, "getfield %s %s", field, desc);
 960                         break;
 961                 case MODE_DEREF:
 962                         /* Все объекты представляются как увказатели */
 963                         push_item(p, item -> parent);
 964                         break;
 965                 case MODE_NIL:
 966                         jvm_generate(p, 0, 1, "aconst_null");
 967                         break;
 968                 case MODE_NEW:
 969                         jvm_generate_expr_new_pointer(p, item -> result, item -> num_args, item -> args);
 970                         break;
 971                 case MODE_REAL:
 972                         jvm_generate_push_float(p, item -> real, item -> result -> size);
 973                         break;
 974                 default:
 975                         gen_error("push_item: unk mode %i", item -> mode);
 976                         break;
 977         }
 978 }
 979
 980 static void
 981 jvm_generate_logical_not(gen_proc_t * p)
 982 {
 983         int label_done = jvm_new_label_id(p);
 984         int label_false = jvm_new_label_id(p);
 985         char * label_name_done = jvm_get_label_name(label_done);
 986         char * label_name_false = jvm_get_label_name(label_false);
 987
 988         jvm_generate(p, 1, 0, "ifne %s", label_name_false);
 989         jvm_generate(p, 0, 1, "iconst_1");
 990         jvm_generate(p, 0, 0, "goto %s", label_name_done);
 991         jvm_generate_label(p, label_false);
 992         jvm_generate(p, 0, 1, "iconst_0");
 993         jvm_generate_label(p, label_done);
 994 }
 995
 996 static void
 997 jvm_generate_abs(gen_proc_t * p, char prefix)
 998 {
 999         char t = jvm_get_type_of_prefix(prefix);
1000         int cell_size = jvm_cell_size_for_postfix(prefix);
1001         jvm_generate(p, cell_size, cell_size, "invokestatic java/lang/Math/abs(%c)%c", t, t);
1002 }
1003
1004 static void
1005 jvm_generate_compare_op(gen_proc_t * p, char prefix, int op)
1006 {
1007         int label_true = jvm_new_label_id(p);
1008         int label_done = jvm_new_label_id(p);
1009         char * label_name_true = jvm_get_label_name(label_true);
1010         char * label_name_done = jvm_get_label_name(label_done);
1011         int cell_size = 2 * jvm_cell_size_for_postfix(prefix);
1012
1013         assert(prefix == 'i' || prefix == 'a');
1014
1015         const char * cmpop = "";
1016         switch(op)
1017         {
1018                 case OP_EQ:
1019                         cmpop = "eq";
1020                         break;
1021                 case OP_NEQ:
1022                         cmpop = "ne";
1023                         break;
1024                 case OP_LSS:
1025                         cmpop = "lt";
1026                         break;
1027                 case OP_LEQ:
1028                         cmpop = "le";
1029                         break;
1030                 case OP_GRT:
1031                         cmpop = "gt";
1032                         break;
1033                 case OP_GEQ:
1034                         cmpop = "ge";
1035                         break;
1036                 default:
1037                         gen_error("jvm_generate_compare_op: wat");
1038                         break;
1039         }
1040
1041         jvm_generate(p, cell_size, 0, "if_%ccmp%s %s", prefix, cmpop, label_name_true);
1042         jvm_generate(p, 0, 1, "iconst_0");
1043         jvm_generate(p, 0, 0, "goto %s", label_name_done);
1044         jvm_generate_label(p, label_true);
1045         jvm_generate(p, 0, 1, "iconst_1");
1046         jvm_generate_label(p, label_done);
1047 }
1048
1049 static void
1050 jvm_generate_operator(gen_proc_t * p, char prefix, int op)
1051 {
1052         int cell_size = jvm_cell_size_for_postfix(prefix);
1053         switch(op)
1054         {
1055                 case OP_UNARY_MINUS:
1056                         jvm_generate(p, cell_size, cell_size, "%cneg", prefix);
1057                         break;
1058                 case OP_BITWISE_NOT:
1059                         jvm_generate_push_int(p, -1);
1060                         jvm_generate(p, 2 * cell_size, cell_size, "%cxor", prefix);
1061                         break;
1062                 case OP_LOGIC_NOT:
1063                         jvm_generate_logical_not(p);
1064                         break;
1065                 case OP_ABS:
1066                         jvm_generate_abs(p, prefix);
1067                         break;
1068
1069                 case OP_ADD:
1070                         jvm_generate(p, 2 * cell_size, cell_size, "%cadd", prefix);
1071                         break;
1072                 case OP_SUB:
1073                         jvm_generate(p, 2 * cell_size, cell_size, "%csub", prefix);
1074                         break;
1075                 case OP_MUL:
1076                         jvm_generate(p, 2 * cell_size, cell_size, "%cmul", prefix);
1077                         break;
1078                 case OP_DIV:
1079                         jvm_generate(p, 2 * cell_size, cell_size, "%cdiv", prefix);
1080                         break;
1081                 case OP_MOD:
1082                         jvm_generate(p, 2 * cell_size, cell_size, "%crem", prefix);
1083                         break;
1084                 case OP_BITWISE_AND:
1085                         jvm_generate(p, 2 * cell_size, cell_size, "%cand", prefix);
1086                         break;
1087                 case OP_BITWISE_XOR:
1088                         jvm_generate(p, 2 * cell_size, cell_size, "%cxor", prefix);
1089                         break;
1090                 case OP_BITWISE_OR:
1091                         jvm_generate(p, 2 * cell_size, cell_size, "%cor", prefix);
1092                         break;
1093
1094                 case OP_EQ:
1095                 case OP_NEQ:
1096                 case OP_LSS:
1097                 case OP_LEQ:
1098                 case OP_GRT:
1099                 case OP_GEQ:
1100                         jvm_generate_compare_op(p, prefix, op);
1101                         break;
1102                 default:
1103                         gen_error("jvm_generate_operator: unk op %i", op);
1104                         break;
1105         }
1106 }
1107
1108 static void
1109 jvm_generate_logical_or(gen_proc_t * p, oberon_expr_t * a, oberon_expr_t * b)
1110 {
1111         int label_calc_b = jvm_new_label_id(p);
1112         int label_done = jvm_new_label_id(p);
1113         char * label_name_calc_b = jvm_get_label_name(label_calc_b);
1114         char * label_name_done = jvm_get_label_name(label_done);
1115
1116         /* a OR b -- если a, то TRUE, иначе b */
1117
1118         push_expr(p, a);
1119         jvm_generate(p, 1, 0, "ifne %s", label_name_calc_b);
1120         jvm_generate(p, 0, 1, "iconst_1");
1121         jvm_generate(p, 0, 0, "goto %s", label_name_done);
1122         jvm_generate_label(p, label_calc_b);
1123         push_expr(p, b);
1124         jvm_generate_label(p, label_done);
1125 }
1126
1127 static void
1128 jvm_generate_logical_and(gen_proc_t * p, oberon_expr_t * a, oberon_expr_t * b)
1129 {
1130         int label_false = jvm_new_label_id(p);
1131         int label_done = jvm_new_label_id(p);
1132         char * label_name_false = jvm_get_label_name(label_false);
1133         char * label_name_done = jvm_get_label_name(label_done);
1134
1135         /* a AND b -- если a, то b, иначе FALSE */
1136
1137         push_expr(p, a);
1138         jvm_generate(p, 1, 0, "ifne %s", label_name_false);
1139         push_expr(p, b);
1140         jvm_generate(p, 0, 0, "goto %s", label_name_done);
1141         jvm_generate_label(p, label_false);
1142         jvm_generate(p, 0, 1, "iconst_0");
1143         jvm_generate_label(p, label_done);
1144 }
1145
1146 static void
1147 push_operator(gen_proc_t * p, oberon_oper_t * oper)
1148 {
1149         char prefix = jvm_get_prefix(oper -> result);
1150         int op = oper -> op;
1151         switch(op)
1152         {
1153                 case OP_UNARY_MINUS:
1154                 case OP_BITWISE_NOT:
1155                 case OP_LOGIC_NOT:
1156                 case OP_ABS:
1157                         push_expr(p, oper -> left);
1158                         jvm_generate_operator(p, prefix, op);
1159                         break;
1160
1161                 case OP_ADD:
1162                 case OP_SUB:
1163                 case OP_MUL:
1164                 case OP_DIV:
1165                 case OP_MOD:
1166                 case OP_BITWISE_AND:
1167                 case OP_BITWISE_XOR:
1168                 case OP_BITWISE_OR:
1169
1170                 case OP_EQ:
1171                 case OP_NEQ:
1172                 case OP_LSS:
1173                 case OP_LEQ:
1174                 case OP_GRT:
1175                 case OP_GEQ:
1176                         push_expr(p, oper -> left);
1177                         push_expr(p, oper -> right);
1178                         jvm_generate_operator(p, prefix, op);
1179                         break;
1180
1181                 case OP_LOGIC_OR:
1182                         jvm_generate_logical_or(p, oper -> left, oper -> right);
1183                         break;
1184                 case OP_LOGIC_AND:
1185                         jvm_generate_logical_and(p, oper -> left, oper -> right);
1186                         break;
1187                 default:
1188                         gen_error("push_oper: unk op %i", op);
1189                         break;
1190         }
1191 }
1192
1193 static void
1194 push_expr(gen_proc_t * p, oberon_expr_t * expr)
1195 {
1196         if(expr -> is_item)
1197         {
1198                 push_item(p, (oberon_item_t *) expr);
1199         }
1200         else
1201         {
1202                 push_operator(p, (oberon_oper_t *) expr);
1203         }
1204 }
1205
1206 static void
1207 store_expr(gen_proc_t * p, oberon_expr_t * dst, oberon_expr_t * src)
1208 {
1209         assert(dst -> is_item);
1210         oberon_item_t * item = (oberon_item_t *) dst;
1211
1212         if(dst -> result -> class == OBERON_TYPE_ARRAY
1213                 || src -> result -> class == OBERON_TYPE_ARRAY)
1214         {
1215                 gen_error("array copy not implemented");
1216         }
1217         else if(dst -> result -> class == OBERON_TYPE_RECORD
1218                 || src -> result -> class == OBERON_TYPE_RECORD)
1219         {
1220                 push_expr(p, dst);
1221                 push_expr(p, src);
1222                 jvm_generate_copy_record(p, dst -> result);
1223         }
1224         else switch(item -> mode)
1225         {
1226                 case MODE_VAR:
1227                         push_expr(p, src);
1228                         jvm_generate_store(p, src -> result, item -> var -> gen_var);
1229                         break;
1230                 case MODE_INDEX:
1231                         ;
1232                         char postfix = jvm_get_postfix(src -> result);
1233                         int cell_size = jvm_cell_size_for_postfix(postfix);
1234                         push_item(p, item -> parent);
1235                         push_expr(p, item -> args);
1236                         push_expr(p, src);
1237                         jvm_generate(p, 1 + 1 + cell_size, 0, "%castore", postfix);
1238                         break;
1239                 case MODE_FIELD:
1240                         push_item(p, item -> parent);
1241                         push_expr(p, src);
1242                         jvm_generate_store(p, src -> result, item -> var -> gen_var);
1243                         break;
1244                 default:
1245                         gen_error("store_expr: unk mode %i", item -> mode);
1246                         break;
1247         }
1248 }
1249
1250 void
1251 oberon_generate_assign(oberon_context_t * ctx, oberon_expr_t * src, oberon_expr_t * dst)
1252 {
1253         gen_module_t * m;
1254         gen_proc_t * p;
1255
1256         m = ctx -> mod -> gen_mod;
1257         p = m -> class -> p;
1258
1259         store_expr(p, dst, src);
1260 }
1261
1262 void
1263 oberon_generate_code(oberon_context_t * ctx)
1264 {
1265         printf("generate code\n");
1266 }
1267
1268 void
1269 oberon_generator_dump(oberon_context_t * ctx, char * path)
1270 {
1271         printf("jit: dump code\n");
1272 }
1273
1274 void *
1275 oberon_generator_get_procedure(oberon_context_t * ctx, const char * name)
1276 {
1277         printf("jit: get pointer to procedure %s\n", name);
1278         return NULL;
1279 }
1280
1281 void *
1282 oberon_generator_get_var(oberon_context_t * ctx, const char * name)
1283 {
1284         printf("jit: get pointer to var %s\n", name);
1285         return NULL;
1286 }