generator.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <stdarg.h>
   4 #include <ctype.h>
   5 #include <string.h>
   6 #include <assert.h>
   7 #include <stdbool.h>
   8
   9 #include <gc.h>
  10
  11 #include "oberon.h"
  12 #include "generator.h"
  13
  14 // =======================================================================
  15 //   INTERNAL FUNCTIONS
  16 // =======================================================================
  17
  18 static void *
  19 __OBERON_ALLOC__ (size_t bytes)
  20 {
  21         void * p = GC_MALLOC(bytes);
  22         memset(p, 0, bytes);
  23         printf("allocated %lu bytes\n", bytes);
  24         return p;
  25 }
  26
  27 // =======================================================================
  28 //   ALLOC
  29 // =======================================================================
  30
  31 static void
  32 oberon_generator_open_block(gen_context_t * gen_context, gcc_jit_block * gcc_block)
  33 {
  34         gen_block_t * block = malloc(sizeof *block);
  35         memset(block, 0, sizeof *block);
  36
  37         block -> gcc_block = gcc_block;
  38         block -> up = gen_context -> block;
  39
  40         gen_context -> block = block;
  41 }
  42
  43 static void
  44 oberon_generator_close_block(gen_context_t * gen_context)
  45 {
  46         gen_context -> block = gen_context -> block -> up;
  47 }
  48
  49 void
  50 oberon_generator_init_context(oberon_context_t * ctx)
  51 {
  52         gen_context_t * gen_context = malloc(sizeof *gen_context);
  53         memset(gen_context, 0, sizeof *gen_context);
  54
  55         gcc_jit_context * gcc_context;
  56         gcc_context = gcc_jit_context_acquire();
  57
  58         ctx -> gen_context = gen_context;
  59         gen_context -> gcc_context = gcc_context;
  60
  61         gcc_jit_type * void_ptr_type = gcc_jit_context_get_type(gcc_context, GCC_JIT_TYPE_VOID_PTR);
  62         gcc_jit_type * size_type = gcc_jit_context_get_type(gcc_context, GCC_JIT_TYPE_SIZE_T);
  63         gcc_jit_type * alloc_ptr_type = gcc_jit_context_new_function_ptr_type(
  64                 gcc_context, NULL, void_ptr_type, 1, &size_type, 0
  65         );
  66         gen_context -> gcc_alloc = gcc_jit_context_new_global(
  67                 gcc_context, NULL, GCC_JIT_GLOBAL_EXPORTED, alloc_ptr_type, "__OBERON_ALLOC__"
  68         );
  69 }
  70
  71 void
  72 oberon_generator_destroy_context(oberon_context_t * ctx)
  73 {
  74         gen_context_t * gen_context = ctx -> gen_context;
  75         gcc_jit_context * gcc_context = gen_context -> gcc_context;
  76
  77         gcc_jit_context_release(gcc_context);
  78 }
  79
  80 void
  81 oberon_generator_init_type(oberon_context_t * ctx, oberon_type_t * type)
  82 {
  83         gen_type_t * gen_type = malloc(sizeof *gen_type);
  84         memset(gen_type, 0, sizeof *gen_type);
  85         type -> gen_type = gen_type;
  86
  87         gen_context_t * gen_context = ctx -> gen_context;
  88         gcc_jit_context * gcc_context = gen_context -> gcc_context;
  89
  90         gcc_jit_type * gcc_type = NULL;
  91         gcc_jit_struct * gcc_struct = NULL;
  92         if(type -> class == OBERON_TYPE_VOID)
  93         {
  94                 gcc_type = gcc_jit_context_get_type(gcc_context, GCC_JIT_TYPE_VOID);
  95         }
  96         else if(type -> class == OBERON_TYPE_INTEGER)
  97         {
  98                 gcc_type = gcc_jit_context_get_int_type(gcc_context, type -> size, 1);
  99         }
 100         else if(type -> class == OBERON_TYPE_BOOLEAN)
 101         {
 102                 gcc_type = gcc_jit_context_get_type(gcc_context, GCC_JIT_TYPE_BOOL);
 103         }
 104         else if(type -> class == OBERON_TYPE_ARRAY)
 105         {
 106                 gen_type_t * gen_base = type -> base -> gen_type;
 107                 gcc_jit_type * gcc_base = gen_base -> gcc_type;
 108                 gcc_type = gcc_jit_context_new_array_type(gcc_context, NULL, gcc_base, type -> size);
 109         }
 110         else if(type -> class == OBERON_TYPE_RECORD)
 111         {
 112                 char name[32];
 113                 snprintf(name, 32, "RECORD%u", gen_context -> record_count);
 114                 gen_context -> record_count += 1;
 115
 116                 gcc_struct = gcc_jit_context_new_opaque_struct(gcc_context, NULL, name);
 117                 gcc_type = gcc_jit_struct_as_type(gcc_struct);
 118         }
 119         else if(type -> class == OBERON_TYPE_POINTER)
 120         {
 121                 gen_type_t * gen_base = type -> base -> gen_type;
 122                 gcc_jit_type * gcc_base = gen_base -> gcc_type;
 123                 gcc_type = gcc_jit_type_get_pointer(gcc_base);
 124         }
 125         else if(type -> class == OBERON_TYPE_PROCEDURE)
 126         {
 127                 int num_params = type -> num_decl;
 128                 gcc_jit_type * params[num_params];
 129                 oberon_object_t * o = type -> decl;
 130                 for(int i = 0; i < num_params; i++)
 131                 {
 132                         gen_type_t * gen_type = o -> type -> gen_type;
 133                         params[i] = gen_type -> gcc_type;
 134                         o = o -> next;
 135                 }
 136
 137                 gen_type_t * base = type -> base -> gen_type;
 138                 gcc_jit_type * result_type = base -> gcc_type;
 139
 140                 gcc_type = gcc_jit_context_new_function_ptr_type(
 141                         gcc_context, NULL, result_type, num_params, params, 0
 142                 );
 143         }
 144         else
 145         {
 146                 oberon_error(ctx, "oberon_generator_init_type: invalid type class %i", type -> class);
 147         }
 148
 149         assert(gcc_type);
 150         gen_type -> gcc_type = gcc_type;
 151         gen_type -> gcc_struct = gcc_struct;
 152 }
 153
 154 void
 155 oberon_generator_init_record(oberon_context_t * ctx, oberon_type_t * type)
 156 {
 157         assert(type -> class == OBERON_TYPE_RECORD);
 158
 159         gen_type_t * gen_type = type -> gen_type;
 160         gcc_jit_struct * gcc_struct = gen_type -> gcc_struct;
 161
 162         // TODO type exstension
 163
 164         int num_fields = type -> num_decl;
 165         gcc_jit_field * fields[num_fields];
 166         oberon_object_t * o = type -> decl;
 167         for(int i = 0; i < num_fields; i++)
 168         {
 169                 assert(o -> class == OBERON_CLASS_FIELD);
 170                 gen_var_t * var = o -> gen_var;
 171                 fields[i] = var -> gcc_field;
 172                 o = o -> next;
 173         }
 174
 175         gcc_jit_struct_set_fields (gcc_struct, NULL, num_fields, fields);
 176
 177         //gcc_struct = gcc_jit_context_new_struct_type(gcc_context, NULL, "", num_fields, fields);
 178 }
 179
 180 static void
 181 oberon_generator_get_full_name(char * name, int max_len, oberon_object_t * x)
 182 {
 183         if(!x)
 184         {
 185                 name[0] = 0;
 186                 return;
 187         }
 188
 189         int add_module_prefix;
 190         switch(x -> class)
 191         {
 192                 case OBERON_CLASS_FIELD:
 193                 case OBERON_CLASS_PARAM:
 194                 case OBERON_CLASS_VAR_PARAM:
 195                         /* В локальных областях префиксы излишни */
 196                         add_module_prefix = 0;
 197                         break;
 198                 default:
 199                         add_module_prefix = 1;
 200                         break;
 201         }
 202
 203         char parent[256];
 204         oberon_generator_get_full_name(parent, 256, x -> parent);
 205
 206         if(strlen(parent) > 0)
 207         {
 208                 snprintf(name, max_len, "%s_%s", parent, x -> name);
 209         }
 210         else if(add_module_prefix)
 211         {
 212                 snprintf(name, max_len, "%s_%s", x -> module -> name, x -> name);
 213         }
 214         else
 215         {
 216                 snprintf(name, max_len, "%s", x -> name);
 217         }
 218 }
 219
 220 void
 221 oberon_generator_init_var(oberon_context_t * ctx, oberon_object_t * var)
 222 {
 223         gen_context_t * gen_context = ctx -> gen_context;
 224         gen_type_t * gen_type = var -> type -> gen_type;
 225
 226         gen_var_t * gen_var = malloc(sizeof *gen_var);
 227         memset(gen_var, 0, sizeof *gen_var);
 228         var -> gen_var = gen_var;
 229
 230         gcc_jit_context * gcc_context = gen_context -> gcc_context;
 231         gcc_jit_type * gcc_type = gen_type -> gcc_type;
 232
 233         char name[256];
 234         oberon_generator_get_full_name(name, 256, var);
 235
 236         gcc_jit_lvalue * gcc_lvalue = NULL;
 237         gcc_jit_param * gcc_param = NULL;
 238         gcc_jit_field * gcc_field = NULL;
 239         if(var -> class == OBERON_CLASS_VAR)
 240         {
 241                 if(var -> local)
 242                 {
 243                         gen_proc_t * gen_func = var -> parent -> gen_proc;
 244                         gcc_jit_function * func = gen_func -> gcc_func;
 245
 246                         gcc_lvalue = gcc_jit_function_new_local(func, NULL, gcc_type, name);
 247                 }
 248                 else
 249                 {
 250                         gcc_lvalue = gcc_jit_context_new_global(
 251                                 gcc_context, NULL, GCC_JIT_GLOBAL_EXPORTED, gcc_type, name
 252                         );
 253                 }
 254         }
 255         else if(var -> class == OBERON_CLASS_PARAM)
 256         {
 257                 gcc_param = gcc_jit_context_new_param(gcc_context, NULL, gcc_type, name);
 258                 gcc_lvalue = gcc_jit_param_as_lvalue(gcc_param);
 259         }
 260         else if(var -> class == OBERON_CLASS_VAR_PARAM)
 261         {
 262                 gcc_type = gcc_jit_type_get_pointer(gcc_type);
 263                 gcc_param = gcc_jit_context_new_param(gcc_context, NULL, gcc_type, name);
 264                 gcc_lvalue = gcc_jit_param_as_lvalue(gcc_param);
 265         }
 266         else if(var -> class == OBERON_CLASS_FIELD)
 267         {
 268                 gcc_field = gcc_jit_context_new_field(gcc_context, NULL, gcc_type, name);
 269         }
 270         else
 271         {
 272                 oberon_error(ctx, "oberon_generator_init_var: invalid class %i", var -> class);
 273         }
 274
 275         gen_var -> gcc_lvalue = gcc_lvalue;
 276         gen_var -> gcc_param = gcc_param;
 277         gen_var -> gcc_field = gcc_field;
 278 }
 279
 280 void
 281 oberon_generator_init_proc(oberon_context_t * ctx, oberon_object_t * proc)
 282 {
 283         if(proc -> local)
 284         {
 285                 oberon_error(ctx, "generator: local procedures not supported");
 286         }
 287
 288         gen_context_t * gen_context = ctx -> gen_context;
 289         gcc_jit_context * gcc_context = gen_context -> gcc_context;
 290
 291         gen_proc_t * gen_proc = malloc(sizeof *gen_proc);
 292         memset(gen_proc, 0, sizeof *gen_proc);
 293         proc -> gen_proc = gen_proc;
 294
 295         char name[256];
 296         oberon_generator_get_full_name(name, 256, proc);
 297
 298         gen_type_t * gen_result_type = proc -> type -> base -> gen_type;
 299         gcc_jit_type * result_type = gen_result_type -> gcc_type;
 300
 301         /* Строим список параметров */
 302         int num_param = proc -> type -> num_decl;
 303         oberon_object_t * o = proc -> type -> decl;
 304         gcc_jit_param * params[num_param];
 305         for(int i = 0; i < num_param; i++)
 306         {
 307                 gen_var_t * param_var = o -> gen_var;
 308                 params[i] = param_var -> gcc_param;
 309                 o = o -> next;
 310         }
 311
 312         gcc_jit_function * gcc_func;
 313         gcc_func = gcc_jit_context_new_function(
 314                 gcc_context, NULL, GCC_JIT_FUNCTION_EXPORTED, result_type, name, num_param, params, 0
 315         );
 316
 317         gen_proc -> gcc_func = gcc_func;
 318 }
 319
 320 // =======================================================================
 321 //   GENERATOR
 322 // =======================================================================
 323
 324 static gcc_jit_rvalue * rvalue_from_item(oberon_context_t * ctx, oberon_item_t * item);
 325 static gcc_jit_rvalue * rvalue_from_expr(oberon_context_t * ctx, oberon_expr_t * expr);
 326
 327 static int
 328 oberon_generator_get_type_size(oberon_context_t * ctx, oberon_type_t * type)
 329 {
 330         int size = 0;
 331         switch(type -> class)
 332         {
 333                 case OBERON_TYPE_INTEGER:
 334                         size = type -> size;
 335                         printf("int size: %i\n", size);
 336                         break;
 337                 case OBERON_TYPE_BOOLEAN:
 338                         size = sizeof(bool);
 339                         printf("bool size: %i\n", size);
 340                         break;
 341                 case OBERON_TYPE_PROCEDURE:
 342                 case OBERON_TYPE_POINTER:
 343                         size = sizeof(void*);
 344                         printf("ptr size: %i\n", size);
 345                         break;
 346                 case OBERON_TYPE_ARRAY:
 347                         size = type -> size;
 348                         type = type -> base;
 349                         size *= oberon_generator_get_type_size(ctx, type);
 350                         printf("array size: %i\n", size);
 351                         break;
 352                 case OBERON_TYPE_RECORD:
 353                         {
 354                                 int num = type -> num_decl;
 355                                 oberon_object_t * arg = type -> decl;
 356                                 for(int i = 0; i < num; i++)
 357                                 {
 358                                         oberon_type_t * x;
 359                                         x = arg -> type;
 360                                         size += oberon_generator_get_type_size(ctx, x);
 361                                         arg = arg -> next;
 362                                 }
 363                         }
 364                         printf("struct size: %i\n", size);
 365                         break;
 366                 default:
 367                         oberon_error(ctx, "oberon_generator_get_type_size: wat");
 368                         break;
 369         }
 370
 371         return size;
 372 }
 373
 374 void
 375 oberon_generate_begin_module(oberon_context_t * ctx)
 376 {
 377         gen_context_t * gen_context = ctx -> gen_context;
 378         gcc_jit_context * gcc_context = gen_context -> gcc_context;
 379
 380         char name[256];
 381         snprintf(name, 256, "%s_BEGIN", ctx -> mod -> name);
 382
 383         gcc_jit_type * void_type = gcc_jit_context_get_type(gcc_context, GCC_JIT_TYPE_VOID);
 384         gcc_jit_function * func = gcc_jit_context_new_function(
 385                 gcc_context, NULL, GCC_JIT_FUNCTION_EXPORTED, void_type, name, 0, NULL, 0
 386         );
 387         gcc_jit_block * gcc_block = gcc_jit_function_new_block(func, NULL);
 388
 389         oberon_generator_open_block(gen_context, gcc_block);
 390 }
 391
 392 void
 393 oberon_generate_end_module(oberon_context_t * ctx)
 394 {
 395         gen_context_t * gen_context = ctx -> gen_context;
 396         gcc_jit_block * gcc_block = gen_context -> block -> gcc_block;
 397
 398         gcc_jit_block_end_with_void_return(gcc_block, NULL);
 399
 400         oberon_generator_close_block(gen_context);
 401 }
 402
 403 void
 404 oberon_generate_begin_proc(oberon_context_t * ctx, oberon_object_t * proc)
 405 {
 406         gen_context_t * gen_context = ctx -> gen_context;
 407         gen_proc_t * gen_proc = proc -> gen_proc;
 408
 409         gcc_jit_function * func = gen_proc -> gcc_func;
 410         gcc_jit_block * gcc_block = gcc_jit_function_new_block(func, NULL);
 411
 412         oberon_generator_open_block(gen_context, gcc_block);
 413 }
 414
 415 void
 416 oberon_generate_call_proc(oberon_context_t * ctx, oberon_expr_t * desig)
 417 {
 418         gen_context_t * gen_context = ctx -> gen_context;
 419         gen_block_t * gen_block = gen_context -> block;
 420         gcc_jit_block * block = gen_block -> gcc_block;
 421
 422         gcc_jit_rvalue * return_value;
 423         return_value = rvalue_from_expr(ctx, desig);
 424         gcc_jit_block_add_eval(block, NULL, return_value);
 425 }
 426
 427 void
 428 oberon_generate_end_proc(oberon_context_t * ctx)
 429 {
 430         gen_context_t * gen_context = ctx -> gen_context;
 431         oberon_generator_close_block(gen_context);
 432 }
 433
 434 void
 435 oberon_generate_return(oberon_context_t * ctx, oberon_expr_t * expr)
 436 {
 437         gen_context_t * gen_context = ctx -> gen_context;
 438         gen_block_t * gen_block = gen_context -> block;
 439         gcc_jit_block * gcc_block = gen_block -> gcc_block;
 440
 441         if(expr == NULL)
 442         {
 443                 gcc_jit_block_end_with_void_return(gcc_block, NULL);
 444         }
 445         else
 446         {
 447                 gcc_jit_rvalue * r = rvalue_from_expr(ctx, expr);
 448                 gcc_jit_block_end_with_return(gcc_block, NULL, r);
 449         }
 450 }
 451
 452 static gcc_jit_lvalue *
 453 lvalue_from_item(oberon_context_t * ctx, oberon_item_t * item)
 454 {
 455         gen_context_t * gen_context = ctx -> gen_context;
 456         gcc_jit_context * gcc_context = gen_context -> gcc_context;
 457
 458         gcc_jit_lvalue * left;
 459
 460         if(item -> mode == MODE_VAR)
 461         {
 462                 if(item -> var -> class == OBERON_CLASS_PROC)
 463                 {
 464                         oberon_error(ctx, "casting static procedure to pointer not supported by generator");
 465                 }
 466
 467                 gen_var_t * gen_var = item -> var -> gen_var;
 468                 left = gen_var -> gcc_lvalue;
 469                 if(item -> var -> class == OBERON_CLASS_VAR_PARAM)
 470                 {
 471                         gcc_jit_rvalue * r = gcc_jit_lvalue_as_rvalue(left);
 472                         left = gcc_jit_rvalue_dereference(r, NULL);
 473                 }
 474         }
 475         else if(item -> mode == MODE_INDEX)
 476         {
 477                 assert(item -> num_args == 1);
 478                 gcc_jit_rvalue * parent = rvalue_from_item(ctx, item -> parent);
 479                 gcc_jit_rvalue * index = rvalue_from_expr(ctx, item -> args);
 480                 left = gcc_jit_context_new_array_access(gcc_context, NULL, parent, index);
 481         }
 482         else if(item -> mode == MODE_FIELD)
 483         {
 484                 printf("lvalue_from_item: %s\n", item -> var -> name);
 485                 gen_var_t * gen_var = item -> var -> gen_var;
 486                 gcc_jit_field * gcc_field = gen_var -> gcc_field;
 487
 488                 gcc_jit_lvalue * parent = lvalue_from_item(ctx, item -> parent);
 489                 left = gcc_jit_lvalue_access_field(parent, NULL, gcc_field);
 490         }
 491         else if(item -> mode == MODE_DEREF)
 492         {
 493                 gcc_jit_rvalue * parent = rvalue_from_item(ctx, item -> parent);
 494                 left = gcc_jit_rvalue_dereference(parent, NULL);
 495         }
 496         else
 497         {
 498                 oberon_error(ctx, "lvalue_from_item: invalid mode %i", item -> mode);
 499         }
 500
 501         return left;
 502 }
 503
 504 static gcc_jit_lvalue *
 505 lvalue_from_expr(oberon_context_t *ctx, oberon_expr_t * expr)
 506 {
 507         gcc_jit_lvalue * left;
 508         oberon_item_t * item;
 509
 510         if(expr -> is_item)
 511         {
 512                 item = (oberon_item_t *) expr;
 513                 left = lvalue_from_item(ctx, item);
 514         }
 515         else
 516         {
 517                 oberon_error(ctx, "invalid lvalue expression");
 518         }
 519
 520         return left;
 521 }
 522
 523 static gcc_jit_rvalue *
 524 rvalue_from_item(oberon_context_t * ctx, oberon_item_t * item)
 525 {
 526         gen_context_t * gen_context = ctx -> gen_context;
 527         gcc_jit_context * gcc_context = gen_context -> gcc_context;
 528
 529         gcc_jit_rvalue * right;
 530         if(item -> mode == MODE_VAR)
 531         {
 532                 gcc_jit_lvalue * left = lvalue_from_item(ctx, item);
 533                 right = gcc_jit_lvalue_as_rvalue(left);
 534         }
 535         else if(item -> mode == MODE_INTEGER)
 536         {
 537                 gcc_jit_type * int_type = gcc_jit_context_get_type(gcc_context, GCC_JIT_TYPE_INT);
 538                 right = gcc_jit_context_new_rvalue_from_int(gcc_context, int_type, item -> integer);
 539         }
 540         else if(item -> mode == MODE_BOOLEAN)
 541         {
 542                 gcc_jit_type * bool_type = gcc_jit_context_get_type(gcc_context, GCC_JIT_TYPE_BOOL);
 543                 if(item -> boolean)
 544                 {
 545                         right = gcc_jit_context_one(gcc_context, bool_type);
 546                 }
 547                 else
 548                 {
 549                         right = gcc_jit_context_zero(gcc_context, bool_type);
 550                 }
 551         }
 552         else if(item -> mode == MODE_CALL)
 553         {
 554                 oberon_type_t * signature = item -> var -> type;
 555                 gen_proc_t * gen_proc = item -> var -> gen_proc;
 556
 557                 int num_args = item -> num_args;
 558                 gcc_jit_rvalue *args[num_args];
 559
 560                 oberon_expr_t * expr = item -> args;
 561                 oberon_object_t * arg_param = signature -> decl;
 562                 for(int i = 0; i < num_args; i++)
 563                 {
 564                         if(arg_param -> class == OBERON_CLASS_VAR_PARAM)
 565                         {
 566                                 gcc_jit_lvalue * left = lvalue_from_expr(ctx, expr);
 567                                 args[i] = gcc_jit_lvalue_get_address(left, NULL);
 568                         }
 569                         else
 570                         {
 571                                 args[i] = rvalue_from_expr(ctx, expr);
 572                         }
 573                         expr = expr -> next;
 574                         arg_param = arg_param -> next;
 575                 }
 576
 577                 gcc_jit_rvalue * fnptr;
 578                 gcc_jit_function * func;
 579                 switch(item -> var -> class)
 580                 {
 581                         case OBERON_CLASS_PROC:
 582                                 func = gen_proc -> gcc_func;
 583                                 right = gcc_jit_context_new_call(
 584                                         gcc_context, NULL, func, num_args, args
 585                                 );
 586                                 break;
 587                         case OBERON_CLASS_VAR:
 588                         case OBERON_CLASS_VAR_PARAM:
 589                         case OBERON_CLASS_PARAM:
 590                                 fnptr = gcc_jit_lvalue_as_rvalue(item -> var -> gen_var -> gcc_lvalue);
 591                                 right = gcc_jit_context_new_call_through_ptr(
 592                                         gcc_context, NULL, fnptr, num_args, args
 593                                 );
 594                                 break;
 595                         default:
 596                                 assert(0);
 597                                 break;
 598                 }
 599         }
 600         else if(item -> mode == MODE_INDEX)
 601         {
 602                 gcc_jit_lvalue * left = lvalue_from_item(ctx, item);
 603                 right = gcc_jit_lvalue_as_rvalue(left);
 604         }
 605         else if(item -> mode == MODE_FIELD)
 606         {
 607                 gen_var_t * gen_var = item -> var -> gen_var;
 608                 gcc_jit_field * gcc_field = gen_var -> gcc_field;
 609
 610                 gcc_jit_rvalue * parent = rvalue_from_item(ctx, item -> parent);
 611                 right = gcc_jit_rvalue_access_field(parent, NULL, gcc_field);
 612         }
 613         else if(item -> mode == MODE_DEREF)
 614         {
 615                 gcc_jit_lvalue * left = lvalue_from_item(ctx, item);
 616                 right = gcc_jit_lvalue_as_rvalue(left);
 617         }
 618         else if(item -> mode == MODE_NIL)
 619         {
 620                 gcc_jit_type * type = gcc_jit_context_get_type(gcc_context, GCC_JIT_TYPE_VOID_PTR);
 621                 right = gcc_jit_context_null(gcc_context, type);
 622         }
 623         else if(item -> mode == MODE_NEW)
 624         {
 625                 assert(item -> result -> class == OBERON_TYPE_POINTER);
 626
 627                 oberon_type_t * type = item -> result -> base;
 628                 int type_size = oberon_generator_get_type_size(ctx, type);
 629                 int array_size = type_size;
 630
 631                 int num = item -> num_args;
 632                 oberon_expr_t * arg = item -> args;
 633                 for(int i = 0; i < num; i++)
 634                 {
 635                         array_size *= arg -> item.integer;
 636                         arg = arg -> next;
 637                 }
 638
 639                 gcc_jit_type * size_type;
 640                 size_type = gcc_jit_context_get_type(gcc_context, GCC_JIT_TYPE_SIZE_T);
 641
 642                 gcc_jit_rvalue * fnarg;
 643                 fnarg = gcc_jit_context_new_rvalue_from_int(gcc_context, size_type, array_size);
 644
 645                 gcc_jit_type * result_type = item -> result -> gen_type -> gcc_type;
 646                 gcc_jit_rvalue * gcc_alloc = gcc_jit_lvalue_as_rvalue(gen_context -> gcc_alloc);
 647                 right = gcc_jit_context_new_call_through_ptr(gcc_context, NULL, gcc_alloc, 1, &fnarg);
 648                 right = gcc_jit_context_new_cast(gcc_context, NULL, right, result_type);
 649         }
 650         else
 651         {
 652                 oberon_error(ctx, "rvalue_from_item: invalid mode %i", item -> mode);
 653         }
 654
 655         return right;
 656 }
 657
 658 struct {
 659         int type; // 0 - unary, 1 - binary, 2 - comp
 660         union {
 661                 enum gcc_jit_unary_op unary_op;
 662                 enum gcc_jit_binary_op binary_op;
 663                 enum gcc_jit_comparison comp_op;
 664         };
 665 } op_table[] = {
 666         { 0, .unary_op = GCC_JIT_UNARY_OP_MINUS },
 667         { 0, .unary_op = GCC_JIT_UNARY_OP_BITWISE_NEGATE },
 668         { 0, .unary_op = GCC_JIT_UNARY_OP_LOGICAL_NEGATE },
 669         { 0, .unary_op = GCC_JIT_UNARY_OP_ABS },
 670
 671         { 1, .binary_op = GCC_JIT_BINARY_OP_PLUS },
 672         { 1, .binary_op = GCC_JIT_BINARY_OP_MINUS },
 673         { 1, .binary_op = GCC_JIT_BINARY_OP_MULT },
 674         { 1, .binary_op = GCC_JIT_BINARY_OP_DIVIDE },
 675         { 1, .binary_op = GCC_JIT_BINARY_OP_MODULO },
 676         { 1, .binary_op = GCC_JIT_BINARY_OP_BITWISE_AND },
 677         { 1, .binary_op = GCC_JIT_BINARY_OP_BITWISE_XOR },
 678         { 1, .binary_op = GCC_JIT_BINARY_OP_BITWISE_OR },
 679         { 1, .binary_op = GCC_JIT_BINARY_OP_LOGICAL_AND },
 680         { 1, .binary_op = GCC_JIT_BINARY_OP_LOGICAL_OR },
 681
 682         { 2, .comp_op = GCC_JIT_COMPARISON_EQ },
 683         { 2, .comp_op = GCC_JIT_COMPARISON_NE },
 684         { 2, .comp_op = GCC_JIT_COMPARISON_LT },
 685         { 2, .comp_op = GCC_JIT_COMPARISON_LE },
 686         { 2, .comp_op = GCC_JIT_COMPARISON_GT },
 687         { 2, .comp_op = GCC_JIT_COMPARISON_GE }
 688 };
 689
 690 static gcc_jit_rvalue *
 691 rvalue_from_operator(oberon_context_t * ctx, oberon_oper_t * operator)
 692 {
 693         gcc_jit_rvalue * right;
 694
 695         gen_context_t * gen_context = ctx -> gen_context;
 696         gen_type_t * gen_type = operator -> result -> gen_type;
 697         gcc_jit_context * gcc_context = gen_context -> gcc_context;
 698         gcc_jit_type * result_type = gen_type -> gcc_type;
 699
 700         int expr_type = op_table[operator -> op].type;
 701         if(expr_type == 0)
 702         {
 703                 enum gcc_jit_unary_op op = op_table[operator -> op].unary_op;
 704                 gcc_jit_rvalue * l = rvalue_from_expr(ctx, operator -> left);
 705                 right = gcc_jit_context_new_unary_op(gcc_context, NULL, op, result_type, l);
 706         }
 707         else if(expr_type == 1)
 708         {
 709                 enum gcc_jit_unary_op op = op_table[operator -> op].binary_op;
 710                 gcc_jit_rvalue * l = rvalue_from_expr(ctx, operator -> left);
 711                 gcc_jit_rvalue * r = rvalue_from_expr(ctx, operator -> right);
 712                 right = gcc_jit_context_new_binary_op(gcc_context, NULL, op, result_type, l, r);
 713         }
 714         else if(expr_type == 2)
 715         {
 716                 enum gcc_jit_comparison op = op_table[operator -> op].comp_op;
 717                 gcc_jit_rvalue * l = rvalue_from_expr(ctx, operator -> left);
 718                 gcc_jit_rvalue * r = rvalue_from_expr(ctx, operator -> right);
 719                 right = gcc_jit_context_new_comparison(gcc_context, NULL, op, l, r);
 720         }
 721         else
 722         {
 723                 oberon_error(ctx, "rvalue_from_operator: wat");
 724         }
 725
 726         return right;
 727 }
 728
 729 static gcc_jit_rvalue *
 730 rvalue_from_expr(oberon_context_t * ctx, oberon_expr_t * expr)
 731 {
 732         gcc_jit_rvalue * right;
 733
 734         if(expr -> is_item)
 735         {
 736                 oberon_item_t * item = (oberon_item_t *) expr;
 737                 right = rvalue_from_item(ctx, item);
 738         }
 739         else
 740         {
 741                 oberon_oper_t * operator = (oberon_oper_t *) expr;
 742                 right = rvalue_from_operator(ctx, operator);
 743         }
 744
 745         return right;
 746 }
 747
 748 void
 749 oberon_generate_assign(oberon_context_t * ctx, oberon_expr_t * src, oberon_expr_t * dst)
 750 {
 751         gcc_jit_lvalue * left;
 752         left = lvalue_from_expr(ctx, dst);
 753
 754         gcc_jit_rvalue * right;
 755         right = rvalue_from_expr(ctx, src);
 756
 757         if(src -> is_item)
 758         {
 759                 if(src -> item.mode == MODE_NIL)
 760                 {
 761                         gen_context_t * gen_context = ctx -> gen_context;
 762                         gcc_jit_context * gcc_context = gen_context -> gcc_context;
 763                         gen_type_t * gen_type = dst -> result -> gen_type;
 764                         gcc_jit_type * cast_to_type = gen_type -> gcc_type;
 765                         right = gcc_jit_context_new_cast(gcc_context, NULL, right, cast_to_type);
 766                 }
 767         }
 768
 769         printf("oberon_generate_assign: class %i := class %i\n", dst -> result -> class, src -> result -> class);
 770
 771         gen_context_t * gen_context = ctx -> gen_context;
 772         gen_block_t * gen_block = gen_context -> block;
 773         gcc_jit_block * gcc_block = gen_block -> gcc_block;
 774         gcc_jit_block_add_assignment(gcc_block, NULL, left, right);
 775 }
 776
 777 void
 778 oberon_generate_code(oberon_context_t * ctx)
 779 {
 780         gen_context_t * gen_context = ctx -> gen_context;
 781         gcc_jit_context * gcc_context = gen_context -> gcc_context;
 782
 783         gcc_jit_result * gcc_result;
 784         gcc_result = gcc_jit_context_compile(gcc_context);
 785
 786         gen_context -> gcc_result = gcc_result;
 787
 788         typedef void * (*TOberonAlloc)(size_t);
 789         TOberonAlloc * fn_alloc_ptr = gcc_jit_result_get_global(gcc_result, "__OBERON_ALLOC__");
 790         *fn_alloc_ptr = __OBERON_ALLOC__;
 791
 792 //      ctx -> mod -> begin = gcc_jit_result_get_code(gcc_result, "BEGIN");
 793 }
 794
 795 void
 796 oberon_generator_dump(oberon_context_t * ctx, char * path)
 797 {
 798         gen_context_t * gen_context = ctx -> gen_context;
 799         gcc_jit_context * gcc_context = gen_context -> gcc_context;
 800         gcc_jit_context_dump_to_file(gcc_context, path, 0);
 801 }
 802
 803 void *
 804 oberon_generator_get_procedure(oberon_context_t * ctx, const char * name)
 805 {
 806         gen_context_t * gen_context = ctx -> gen_context;
 807         gcc_jit_result * gcc_result = gen_context -> gcc_result;
 808
 809         return gcc_jit_result_get_code(gcc_result, name);
 810 }
 811
 812 void *
 813 oberon_generator_get_var(oberon_context_t * ctx, const char * name)
 814 {
 815         gen_context_t * gen_context = ctx -> gen_context;
 816         gcc_jit_result * gcc_result = gen_context -> gcc_result;
 817
 818         return gcc_jit_result_get_global(gcc_result, name);
 819 }