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 void
 656 oberon_generate_end_module(oberon_context_t * ctx)
 657 {
 658         struct gen_class * class = ctx -> mod -> gen_mod -> class;
 659         gen_proc_t * p = class -> p;
 660
 661         jvm_generate(p, 0, 0, "return");
 662         jvm_generate_function_end(class -> p);
 663 }
 664
 665 static void
 666 jvm_init_local_object(gen_proc_t * p, oberon_object_t * x)
 667 {
 668         gen_var_t * v;
 669         bool wide;
 670         char * desc;
 671         struct gen_class * class;
 672
 673         v = x -> gen_var;
 674         class = p -> class;
 675         wide = jvm_is_wide_type(x -> type);
 676         desc = jvm_get_descriptor(x -> type);
 677
 678         // Убеждаемся что сейчас находимся в функции
 679         assert(class -> p);
 680         assert(x -> local);
 681
 682         switch(x -> class)
 683         {
 684                 case OBERON_CLASS_VAR:
 685                 case OBERON_CLASS_PARAM:
 686                         jvm_generate_and_init_named_local_var(v, p, wide, x -> name, desc);
 687                         break;
 688                 default:
 689                         gen_error("jvm_init_local_object: wat");
 690                         break;
 691         }
 692 }
 693
 694 void
 695 oberon_generate_begin_proc(oberon_context_t * ctx, oberon_object_t * proc)
 696 {
 697         gen_proc_t * p;
 698         char * signature;
 699
 700         p = proc -> gen_proc;
 701
 702         signature = jvm_get_procedure_signature(proc -> type);
 703
 704         jvm_generate_function_header(p, "public static", proc -> name, signature);
 705
 706         oberon_object_t * var = proc -> type -> decl;
 707         while(var)
 708         {
 709                 jvm_init_local_object(p, var);
 710                 var = var -> next;
 711         }
 712 }
 713
 714 void
 715 oberon_generate_end_proc(oberon_context_t * ctx)
 716 {
 717         gen_module_t * m;
 718         gen_proc_t * p;
 719
 720         m = ctx -> mod -> gen_mod;
 721         p = m -> class -> p;
 722
 723         jvm_generate_function_end(p);
 724 }
 725
 726 static void
 727 jvm_generate_call_proc(gen_proc_t * p, oberon_expr_t * desig)
 728 {
 729         assert(desig -> is_item);
 730         assert(desig -> item.mode == MODE_CALL);
 731
 732         oberon_object_t * proc;
 733         char * fullname;
 734         char * signature;
 735
 736         proc = desig -> item.var;
 737         fullname = jvm_get_field_full_name(proc);
 738         signature = jvm_get_procedure_signature(proc -> type);
 739
 740         int args_cells = 0;
 741         int result_cells = jvm_cell_size_for_type(proc -> type -> base);
 742
 743         int num = desig -> item.num_args;
 744         oberon_expr_t * arg = desig -> item.args;
 745         for(int i = 0; i < num; i++)
 746         {
 747                 args_cells += jvm_cell_size_for_type(arg -> result);
 748                 push_expr(p, arg);
 749                 arg = arg -> next;
 750         }
 751
 752         jvm_generate(p, args_cells, result_cells, "invokestatic %s%s", fullname, signature);
 753 }
 754
 755 void
 756 oberon_generate_call_proc(oberon_context_t * ctx, oberon_expr_t * desig)
 757 {
 758         jvm_generate_call_proc(ctx -> gen_context -> current_m -> class -> p, desig);
 759 }
 760
 761 void
 762 oberon_generate_return(oberon_context_t * ctx, oberon_expr_t * expr)
 763 {
 764         gen_module_t * m;
 765         gen_proc_t * p;
 766         char prefix;
 767         int cell_size;
 768
 769         m = ctx -> mod -> gen_mod;
 770         p = m -> class -> p;
 771
 772         if(expr)
 773         {
 774                 push_expr(p, expr);
 775                 prefix = jvm_get_prefix(expr -> result);
 776                 cell_size = jvm_cell_size_for_type(expr -> result);
 777                 jvm_generate(p, cell_size, 0, "%creturn", prefix);
 778         }
 779         else
 780         {
 781                 jvm_generate(p, 0, 0, "return");
 782         }
 783 }
 784
 785 static void
 786 jvm_push_var(gen_proc_t * p, oberon_object_t * var)
 787 {
 788         int cell_size = jvm_cell_size_for_type(var -> type);
 789
 790         if(var -> local)
 791         {
 792                 int reg = var -> gen_var -> reg;
 793                 char prefix = jvm_get_prefix(var -> type);
 794                 jvm_generate(p, 0, cell_size, "%cload %i", prefix, reg);
 795         }
 796         else
 797         {
 798                 char * fullname = jvm_get_field_full_name(var);
 799                 char * desc = jvm_get_descriptor(var -> type);
 800                 jvm_generate(p, 0, cell_size, "getstatic %s %s", fullname, desc);
 801         }
 802 }
 803
 804 static void
 805 jvm_generate_expr_new_static(gen_proc_t * p, oberon_type_t * type, int num, oberon_expr_t * arg)
 806 {
 807         assert(num == 0);
 808         jvm_generate_new_static(p, type);
 809 }
 810
 811 static void
 812 jvm_generate_expr_new_pointer(gen_proc_t * p, oberon_type_t * type, int num, oberon_expr_t * arg)
 813 {
 814         assert(type -> class == OBERON_TYPE_POINTER);
 815         jvm_generate_expr_new_static(p, type -> base, num, arg);
 816 }
 817
 818 static void
 819 push_item(gen_proc_t * p, oberon_item_t * item)
 820 {
 821         switch(item -> mode)
 822         {
 823                 case MODE_VAR:
 824                         jvm_push_var(p, item -> var);
 825                         break;
 826                 case MODE_INTEGER:
 827                         jvm_generate_push_int(p, item -> integer);
 828                         break;
 829                 case MODE_BOOLEAN:
 830                         jvm_generate_push_int(p, item -> boolean);
 831                         break;
 832                 case MODE_CALL:
 833                         jvm_generate_call_proc(p, (oberon_expr_t *) item);
 834                         break;
 835                 case MODE_INDEX:
 836                         ;
 837                         char postfix = jvm_get_postfix(item -> result);
 838                         int cell_size = jvm_cell_size_for_postfix(postfix);
 839                         push_item(p, item -> parent);
 840                         push_expr(p, item -> args);
 841                         jvm_generate(p, 1 + 1, cell_size, "%caload", postfix);
 842                         break;
 843                 case MODE_FIELD:
 844                         push_item(p, item -> parent);
 845                         char * field = jvm_get_field_full_name(item -> var);
 846                         char * desc = jvm_get_descriptor(item -> var -> type);
 847                         jvm_generate(p, 1, 1, "getfield %s %s", field, desc);
 848                         break;
 849                 case MODE_DEREF:
 850                         /* Все объекты представляются как увказатели */
 851                         push_item(p, item -> parent);
 852                         break;
 853                 case MODE_NIL:
 854                         jvm_generate(p, 0, 1, "aconst_null");
 855                         break;
 856                 case MODE_NEW:
 857                         jvm_generate_expr_new_pointer(p, item -> result, item -> num_args, item -> args);
 858                         break;
 859                 case MODE_REAL:
 860                         jvm_generate_push_float(p, item -> real, item -> result -> size);
 861                         break;
 862                 default:
 863                         gen_error("push_item: unk mode %i", item -> mode);
 864                         break;
 865         }
 866 }
 867
 868 static void
 869 jvm_generate_logical_not(gen_proc_t * p)
 870 {
 871         int label_done = jvm_new_label_id(p);
 872         int label_false = jvm_new_label_id(p);
 873         char * label_name_done = jvm_get_label_name(label_done);
 874         char * label_name_false = jvm_get_label_name(label_false);
 875
 876         jvm_generate(p, 1, 0, "ifne %s", label_name_false);
 877         jvm_generate(p, 0, 1, "iconst_1");
 878         jvm_generate(p, 0, 0, "goto %s", label_name_done);
 879         jvm_generate_label(p, label_false);
 880         jvm_generate(p, 0, 1, "iconst_0");
 881         jvm_generate_label(p, label_done);
 882 }
 883
 884 static void
 885 jvm_generate_abs(gen_proc_t * p, char prefix)
 886 {
 887         char t = jvm_get_type_of_prefix(prefix);
 888         int cell_size = jvm_cell_size_for_postfix(prefix);
 889         jvm_generate(p, cell_size, cell_size, "invokestatic java/lang/Math/abs(%c)%c", t, t);
 890 }
 891
 892 static void
 893 jvm_generate_compare_op(gen_proc_t * p, char prefix, int op)
 894 {
 895         int label_true = jvm_new_label_id(p);
 896         int label_done = jvm_new_label_id(p);
 897         char * label_name_true = jvm_get_label_name(label_true);
 898         char * label_name_done = jvm_get_label_name(label_done);
 899         int cell_size = 2 * jvm_cell_size_for_postfix(prefix);
 900
 901         assert(prefix == 'i' || prefix == 'a');
 902
 903         const char * cmpop = "";
 904         switch(op)
 905         {
 906                 case OP_EQ:
 907                         cmpop = "eq";
 908                         break;
 909                 case OP_NEQ:
 910                         cmpop = "ne";
 911                         break;
 912                 case OP_LSS:
 913                         cmpop = "lt";
 914                         break;
 915                 case OP_LEQ:
 916                         cmpop = "le";
 917                         break;
 918                 case OP_GRT:
 919                         cmpop = "gt";
 920                         break;
 921                 case OP_GEQ:
 922                         cmpop = "ge";
 923                         break;
 924                 default:
 925                         gen_error("jvm_generate_compare_op: wat");
 926                         break;
 927         }
 928
 929         jvm_generate(p, cell_size, 0, "if_%ccmp%s %s", prefix, cmpop, label_name_true);
 930         jvm_generate(p, 0, 1, "iconst_0");
 931         jvm_generate(p, 0, 0, "goto %s", label_name_done);
 932         jvm_generate_label(p, label_true);
 933         jvm_generate(p, 0, 1, "iconst_1");
 934         jvm_generate_label(p, label_done);
 935 }
 936
 937 static void
 938 jvm_generate_operator(gen_proc_t * p, char prefix, int op)
 939 {
 940         int cell_size = jvm_cell_size_for_postfix(prefix);
 941         switch(op)
 942         {
 943                 case OP_UNARY_MINUS:
 944                         jvm_generate(p, cell_size, cell_size, "%cneg", prefix);
 945                         break;
 946                 case OP_BITWISE_NOT:
 947                         jvm_generate_push_int(p, -1);
 948                         jvm_generate(p, 2 * cell_size, cell_size, "%cxor", prefix);
 949                         break;
 950                 case OP_LOGIC_NOT:
 951                         jvm_generate_logical_not(p);
 952                         break;
 953                 case OP_ABS:
 954                         jvm_generate_abs(p, prefix);
 955                         break;
 956
 957                 case OP_ADD:
 958                         jvm_generate(p, 2 * cell_size, cell_size, "%cadd", prefix);
 959                         break;
 960                 case OP_SUB:
 961                         jvm_generate(p, 2 * cell_size, cell_size, "%csub", prefix);
 962                         break;
 963                 case OP_MUL:
 964                         jvm_generate(p, 2 * cell_size, cell_size, "%cmul", prefix);
 965                         break;
 966                 case OP_DIV:
 967                         jvm_generate(p, 2 * cell_size, cell_size, "%cdiv", prefix);
 968                         break;
 969                 case OP_MOD:
 970                         jvm_generate(p, 2 * cell_size, cell_size, "%crem", prefix);
 971                         break;
 972                 case OP_BITWISE_AND:
 973                         jvm_generate(p, 2 * cell_size, cell_size, "%cand", prefix);
 974                         break;
 975                 case OP_BITWISE_XOR:
 976                         jvm_generate(p, 2 * cell_size, cell_size, "%cxor", prefix);
 977                         break;
 978                 case OP_BITWISE_OR:
 979                         jvm_generate(p, 2 * cell_size, cell_size, "%cor", prefix);
 980                         break;
 981
 982                 case OP_EQ:
 983                 case OP_NEQ:
 984                 case OP_LSS:
 985                 case OP_LEQ:
 986                 case OP_GRT:
 987                 case OP_GEQ:
 988                         jvm_generate_compare_op(p, prefix, op);
 989                         break;
 990                 default:
 991                         gen_error("jvm_generate_operator: unk op %i", op);
 992                         break;
 993         }
 994 }
 995
 996 static void
 997 jvm_generate_logical_or(gen_proc_t * p, oberon_expr_t * a, oberon_expr_t * b)
 998 {
 999         int label_calc_b = jvm_new_label_id(p);
1000         int label_done = jvm_new_label_id(p);
1001         char * label_name_calc_b = jvm_get_label_name(label_calc_b);
1002         char * label_name_done = jvm_get_label_name(label_done);
1003
1004         /* a OR b -- если a, то TRUE, иначе b */
1005
1006         push_expr(p, a);
1007         jvm_generate(p, 1, 0, "ifne %s", label_name_calc_b);
1008         jvm_generate(p, 0, 1, "iconst_1");
1009         jvm_generate(p, 0, 0, "goto %s", label_name_done);
1010         jvm_generate_label(p, label_calc_b);
1011         push_expr(p, b);
1012         jvm_generate_label(p, label_done);
1013 }
1014
1015 static void
1016 jvm_generate_logical_and(gen_proc_t * p, oberon_expr_t * a, oberon_expr_t * b)
1017 {
1018         int label_false = jvm_new_label_id(p);
1019         int label_done = jvm_new_label_id(p);
1020         char * label_name_false = jvm_get_label_name(label_false);
1021         char * label_name_done = jvm_get_label_name(label_done);
1022
1023         /* a AND b -- если a, то b, иначе FALSE */
1024
1025         push_expr(p, a);
1026         jvm_generate(p, 1, 0, "ifne %s", label_name_false);
1027         push_expr(p, b);
1028         jvm_generate(p, 0, 0, "goto %s", label_name_done);
1029         jvm_generate_label(p, label_false);
1030         jvm_generate(p, 0, 1, "iconst_0");
1031         jvm_generate_label(p, label_done);
1032 }
1033
1034 static void
1035 push_operator(gen_proc_t * p, oberon_oper_t * oper)
1036 {
1037         char prefix = jvm_get_prefix(oper -> result);
1038         int op = oper -> op;
1039         switch(op)
1040         {
1041                 case OP_UNARY_MINUS:
1042                 case OP_BITWISE_NOT:
1043                 case OP_LOGIC_NOT:
1044                 case OP_ABS:
1045                         push_expr(p, oper -> left);
1046                         jvm_generate_operator(p, prefix, op);
1047                         break;
1048
1049                 case OP_ADD:
1050                 case OP_SUB:
1051                 case OP_MUL:
1052                 case OP_DIV:
1053                 case OP_MOD:
1054                 case OP_BITWISE_AND:
1055                 case OP_BITWISE_XOR:
1056                 case OP_BITWISE_OR:
1057
1058                 case OP_EQ:
1059                 case OP_NEQ:
1060                 case OP_LSS:
1061                 case OP_LEQ:
1062                 case OP_GRT:
1063                 case OP_GEQ:
1064                         push_expr(p, oper -> left);
1065                         push_expr(p, oper -> right);
1066                         jvm_generate_operator(p, prefix, op);
1067                         break;
1068
1069                 case OP_LOGIC_OR:
1070                         jvm_generate_logical_or(p, oper -> left, oper -> right);
1071                         break;
1072                 case OP_LOGIC_AND:
1073                         jvm_generate_logical_and(p, oper -> left, oper -> right);
1074                         break;
1075                 default:
1076                         gen_error("push_oper: unk op %i", op);
1077                         break;
1078         }
1079 }
1080
1081 static void
1082 push_expr(gen_proc_t * p, oberon_expr_t * expr)
1083 {
1084         if(expr -> is_item)
1085         {
1086                 push_item(p, (oberon_item_t *) expr);
1087         }
1088         else
1089         {
1090                 push_operator(p, (oberon_oper_t *) expr);
1091         }
1092 }
1093
1094 static void
1095 store_expr(gen_proc_t * p, oberon_expr_t * dst, oberon_expr_t * src)
1096 {
1097         assert(dst -> is_item);
1098         oberon_item_t * item = (oberon_item_t *) dst;
1099
1100         if(dst -> result -> class == OBERON_TYPE_ARRAY
1101                 || src -> result -> class == OBERON_TYPE_ARRAY)
1102         {
1103                 gen_error("array copy not implemented");
1104         }
1105         else if(dst -> result -> class == OBERON_TYPE_RECORD
1106                 || src -> result -> class == OBERON_TYPE_RECORD)
1107         {
1108                 gen_error("record copy not implemented");
1109         }
1110
1111         switch(item -> mode)
1112         {
1113                 case MODE_VAR:
1114                         push_expr(p, src);
1115                         jvm_generate_store(p, src -> result, item -> var -> gen_var);
1116                         break;
1117                 case MODE_INDEX:
1118                         ;
1119                         char postfix = jvm_get_postfix(src -> result);
1120                         int cell_size = jvm_cell_size_for_postfix(postfix);
1121                         push_item(p, item -> parent);
1122                         push_expr(p, item -> args);
1123                         push_expr(p, src);
1124                         jvm_generate(p, 1 + 1 + cell_size, 0, "%castore", postfix);
1125                         break;
1126                 case MODE_FIELD:
1127                         push_item(p, item -> parent);
1128                         push_expr(p, src);
1129                         jvm_generate_store(p, src -> result, item -> var -> gen_var);
1130                         break;
1131                 default:
1132                         gen_error("store_expr: unk mode %i", item -> mode);
1133                         break;
1134         }
1135 }
1136
1137 void
1138 oberon_generate_assign(oberon_context_t * ctx, oberon_expr_t * src, oberon_expr_t * dst)
1139 {
1140         gen_module_t * m;
1141         gen_proc_t * p;
1142
1143         m = ctx -> mod -> gen_mod;
1144         p = m -> class -> p;
1145
1146         store_expr(p, dst, src);
1147 }
1148
1149 void
1150 oberon_generate_code(oberon_context_t * ctx)
1151 {
1152         printf("generate code\n");
1153 }
1154
1155 void
1156 oberon_generator_dump(oberon_context_t * ctx, char * path)
1157 {
1158         printf("jit: dump code\n");
1159 }
1160
1161 void *
1162 oberon_generator_get_procedure(oberon_context_t * ctx, const char * name)
1163 {
1164         printf("jit: get pointer to procedure %s\n", name);
1165         return NULL;
1166 }
1167
1168 void *
1169 oberon_generator_get_var(oberon_context_t * ctx, const char * name)
1170 {
1171         printf("jit: get pointer to var %s\n", name);
1172         return NULL;
1173 }