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