ir.c

   1 /*
   2  * Copyright (C) 2012, 2013
   3  *     Wolfgang Bumiller
   4  *     Dale Weiler
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy of
   7  * this software and associated documentation files (the "Software"), to deal in
   8  * the Software without restriction, including without limitation the rights to
   9  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
  10  * of the Software, and to permit persons to whom the Software is furnished to do
  11  * so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in all
  14  * copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  22  * SOFTWARE.
  23  */
  24 #include <stdlib.h>
  25 #include <string.h>
  26
  27 #include "gmqcc.h"
  28 #include "ir.h"
  29
  30 /***********************************************************************
  31  * Type sizes used at multiple points in the IR codegen
  32  */
  33
  34 const char *type_name[TYPE_COUNT] = {
  35     "void",
  36     "string",
  37     "float",
  38     "vector",
  39     "entity",
  40     "field",
  41     "function",
  42     "pointer",
  43     "integer",
  44     "variant",
  45     "struct",
  46     "union",
  47     "array",
  48
  49     "nil",
  50     "<no-expression>"
  51 };
  52
  53 static size_t type_sizeof_[TYPE_COUNT] = {
  54     1, /* TYPE_VOID     */
  55     1, /* TYPE_STRING   */
  56     1, /* TYPE_FLOAT    */
  57     3, /* TYPE_VECTOR   */
  58     1, /* TYPE_ENTITY   */
  59     1, /* TYPE_FIELD    */
  60     1, /* TYPE_FUNCTION */
  61     1, /* TYPE_POINTER  */
  62     1, /* TYPE_INTEGER  */
  63     3, /* TYPE_VARIANT  */
  64     0, /* TYPE_STRUCT   */
  65     0, /* TYPE_UNION    */
  66     0, /* TYPE_ARRAY    */
  67     0, /* TYPE_NIL      */
  68     0, /* TYPE_NOESPR   */
  69 };
  70
  71 const uint16_t type_store_instr[TYPE_COUNT] = {
  72     INSTR_STORE_F, /* should use I when having integer support */
  73     INSTR_STORE_S,
  74     INSTR_STORE_F,
  75     INSTR_STORE_V,
  76     INSTR_STORE_ENT,
  77     INSTR_STORE_FLD,
  78     INSTR_STORE_FNC,
  79     INSTR_STORE_ENT, /* should use I */
  80 #if 0
  81     INSTR_STORE_I, /* integer type */
  82 #else
  83     INSTR_STORE_F,
  84 #endif
  85
  86     INSTR_STORE_V, /* variant, should never be accessed */
  87
  88     VINSTR_END, /* struct */
  89     VINSTR_END, /* union  */
  90     VINSTR_END, /* array  */
  91     VINSTR_END, /* nil    */
  92     VINSTR_END, /* noexpr */
  93 };
  94
  95 const uint16_t field_store_instr[TYPE_COUNT] = {
  96     INSTR_STORE_FLD,
  97     INSTR_STORE_FLD,
  98     INSTR_STORE_FLD,
  99     INSTR_STORE_V,
 100     INSTR_STORE_FLD,
 101     INSTR_STORE_FLD,
 102     INSTR_STORE_FLD,
 103     INSTR_STORE_FLD,
 104 #if 0
 105     INSTR_STORE_FLD, /* integer type */
 106 #else
 107     INSTR_STORE_FLD,
 108 #endif
 109
 110     INSTR_STORE_V, /* variant, should never be accessed */
 111
 112     VINSTR_END, /* struct */
 113     VINSTR_END, /* union  */
 114     VINSTR_END, /* array  */
 115     VINSTR_END, /* nil    */
 116     VINSTR_END, /* noexpr */
 117 };
 118
 119 const uint16_t type_storep_instr[TYPE_COUNT] = {
 120     INSTR_STOREP_F, /* should use I when having integer support */
 121     INSTR_STOREP_S,
 122     INSTR_STOREP_F,
 123     INSTR_STOREP_V,
 124     INSTR_STOREP_ENT,
 125     INSTR_STOREP_FLD,
 126     INSTR_STOREP_FNC,
 127     INSTR_STOREP_ENT, /* should use I */
 128 #if 0
 129     INSTR_STOREP_ENT, /* integer type */
 130 #else
 131     INSTR_STOREP_F,
 132 #endif
 133
 134     INSTR_STOREP_V, /* variant, should never be accessed */
 135
 136     VINSTR_END, /* struct */
 137     VINSTR_END, /* union  */
 138     VINSTR_END, /* array  */
 139     VINSTR_END, /* nil    */
 140     VINSTR_END, /* noexpr */
 141 };
 142
 143 const uint16_t type_eq_instr[TYPE_COUNT] = {
 144     INSTR_EQ_F, /* should use I when having integer support */
 145     INSTR_EQ_S,
 146     INSTR_EQ_F,
 147     INSTR_EQ_V,
 148     INSTR_EQ_E,
 149     INSTR_EQ_E, /* FLD has no comparison */
 150     INSTR_EQ_FNC,
 151     INSTR_EQ_E, /* should use I */
 152 #if 0
 153     INSTR_EQ_I,
 154 #else
 155     INSTR_EQ_F,
 156 #endif
 157
 158     INSTR_EQ_V, /* variant, should never be accessed */
 159
 160     VINSTR_END, /* struct */
 161     VINSTR_END, /* union  */
 162     VINSTR_END, /* array  */
 163     VINSTR_END, /* nil    */
 164     VINSTR_END, /* noexpr */
 165 };
 166
 167 const uint16_t type_ne_instr[TYPE_COUNT] = {
 168     INSTR_NE_F, /* should use I when having integer support */
 169     INSTR_NE_S,
 170     INSTR_NE_F,
 171     INSTR_NE_V,
 172     INSTR_NE_E,
 173     INSTR_NE_E, /* FLD has no comparison */
 174     INSTR_NE_FNC,
 175     INSTR_NE_E, /* should use I */
 176 #if 0
 177     INSTR_NE_I,
 178 #else
 179     INSTR_NE_F,
 180 #endif
 181
 182     INSTR_NE_V, /* variant, should never be accessed */
 183
 184     VINSTR_END, /* struct */
 185     VINSTR_END, /* union  */
 186     VINSTR_END, /* array  */
 187     VINSTR_END, /* nil    */
 188     VINSTR_END, /* noexpr */
 189 };
 190
 191 const uint16_t type_not_instr[TYPE_COUNT] = {
 192     INSTR_NOT_F, /* should use I when having integer support */
 193     VINSTR_END,  /* not to be used, depends on string related -f flags */
 194     INSTR_NOT_F,
 195     INSTR_NOT_V,
 196     INSTR_NOT_ENT,
 197     INSTR_NOT_ENT,
 198     INSTR_NOT_FNC,
 199     INSTR_NOT_ENT, /* should use I */
 200 #if 0
 201     INSTR_NOT_I, /* integer type */
 202 #else
 203     INSTR_NOT_F,
 204 #endif
 205
 206     INSTR_NOT_V, /* variant, should never be accessed */
 207
 208     VINSTR_END, /* struct */
 209     VINSTR_END, /* union  */
 210     VINSTR_END, /* array  */
 211     VINSTR_END, /* nil    */
 212     VINSTR_END, /* noexpr */
 213 };
 214
 215 /* protos */
 216 static ir_value*       ir_value_var(const char *name, int st, int vtype);
 217 static bool            ir_value_set_name(ir_value*, const char *name);
 218 static void            ir_value_dump(ir_value*, int (*oprintf)(const char*,...));
 219
 220 static ir_value*       ir_gen_extparam_proto(ir_builder *ir);
 221 static void            ir_gen_extparam      (ir_builder *ir);
 222
 223 static bool            ir_builder_set_name(ir_builder *self, const char *name);
 224
 225 static ir_function*    ir_function_new(struct ir_builder_s *owner, int returntype);
 226 static bool            ir_function_set_name(ir_function*, const char *name);
 227 static void            ir_function_delete(ir_function*);
 228 static void            ir_function_dump(ir_function*, char *ind, int (*oprintf)(const char*,...));
 229
 230 static ir_value*       ir_block_create_general_instr(ir_block *self, lex_ctx_t, const char *label,
 231                                         int op, ir_value *a, ir_value *b, int outype);
 232 static void            ir_block_delete(ir_block*);
 233 static ir_block*       ir_block_new(struct ir_function_s *owner, const char *label);
 234 static bool GMQCC_WARN ir_block_create_store(ir_block*, lex_ctx_t, ir_value *target, ir_value *what);
 235 static bool            ir_block_set_label(ir_block*, const char *label);
 236 static void            ir_block_dump(ir_block*, char *ind, int (*oprintf)(const char*,...));
 237
 238 static bool            ir_instr_op(ir_instr*, int op, ir_value *value, bool writing);
 239 static void            ir_instr_delete(ir_instr*);
 240 static void            ir_instr_dump(ir_instr* in, char *ind, int (*oprintf)(const char*,...));
 241 /* error functions */
 242
 243 static void irerror(lex_ctx_t ctx, const char *msg, ...)
 244 {
 245     va_list ap;
 246     va_start(ap, msg);
 247     con_cvprintmsg(ctx, LVL_ERROR, "internal error", msg, ap);
 248     va_end(ap);
 249 }
 250
 251 static bool GMQCC_WARN irwarning(lex_ctx_t ctx, int warntype, const char *fmt, ...)
 252 {
 253     bool    r;
 254     va_list ap;
 255     va_start(ap, fmt);
 256     r = vcompile_warning(ctx, warntype, fmt, ap);
 257     va_end(ap);
 258     return r;
 259 }
 260
 261 /***********************************************************************
 262  * Vector utility functions
 263  */
 264
 265 static bool GMQCC_WARN vec_ir_value_find(ir_value **vec, const ir_value *what, size_t *idx)
 266 {
 267     size_t i;
 268     size_t len = vec_size(vec);
 269     for (i = 0; i < len; ++i) {
 270         if (vec[i] == what) {
 271             if (idx) *idx = i;
 272             return true;
 273         }
 274     }
 275     return false;
 276 }
 277
 278 static bool GMQCC_WARN vec_ir_block_find(ir_block **vec, ir_block *what, size_t *idx)
 279 {
 280     size_t i;
 281     size_t len = vec_size(vec);
 282     for (i = 0; i < len; ++i) {
 283         if (vec[i] == what) {
 284             if (idx) *idx = i;
 285             return true;
 286         }
 287     }
 288     return false;
 289 }
 290
 291 static bool GMQCC_WARN vec_ir_instr_find(ir_instr **vec, ir_instr *what, size_t *idx)
 292 {
 293     size_t i;
 294     size_t len = vec_size(vec);
 295     for (i = 0; i < len; ++i) {
 296         if (vec[i] == what) {
 297             if (idx) *idx = i;
 298             return true;
 299         }
 300     }
 301     return false;
 302 }
 303
 304 /***********************************************************************
 305  * IR Builder
 306  */
 307
 308 static void ir_block_delete_quick(ir_block* self);
 309 static void ir_instr_delete_quick(ir_instr *self);
 310 static void ir_function_delete_quick(ir_function *self);
 311
 312 ir_builder* ir_builder_new(const char *modulename)
 313 {
 314     ir_builder* self;
 315     size_t      i;
 316
 317     self = (ir_builder*)mem_a(sizeof(*self));
 318     if (!self)
 319         return NULL;
 320
 321     self->functions   = NULL;
 322     self->globals     = NULL;
 323     self->fields      = NULL;
 324     self->filenames   = NULL;
 325     self->filestrings = NULL;
 326     self->htglobals   = util_htnew(IR_HT_SIZE);
 327     self->htfields    = util_htnew(IR_HT_SIZE);
 328     self->htfunctions = util_htnew(IR_HT_SIZE);
 329
 330     self->extparams       = NULL;
 331     self->extparam_protos = NULL;
 332
 333     self->first_common_globaltemp = 0;
 334     self->max_globaltemps         = 0;
 335     self->first_common_local      = 0;
 336     self->max_locals              = 0;
 337
 338     self->str_immediate = 0;
 339     self->name = NULL;
 340     if (!ir_builder_set_name(self, modulename)) {
 341         mem_d(self);
 342         return NULL;
 343     }
 344
 345     self->nil = ir_value_var("nil", store_value, TYPE_NIL);
 346     self->nil->cvq = CV_CONST;
 347
 348     for (i = 0; i != IR_MAX_VINSTR_TEMPS; ++i) {
 349         /* we write to them, but they're not supposed to be used outside the IR, so
 350          * let's not allow the generation of ir_instrs which use these.
 351          * So it's a constant noexpr.
 352          */
 353         self->vinstr_temp[i] = ir_value_var("vinstr_temp", store_value, TYPE_NOEXPR);
 354         self->vinstr_temp[i]->cvq = CV_CONST;
 355     }
 356
 357     self->reserved_va_count = NULL;
 358     self->code              = code_init();
 359
 360     return self;
 361 }
 362
 363 void ir_builder_delete(ir_builder* self)
 364 {
 365     size_t i;
 366     util_htdel(self->htglobals);
 367     util_htdel(self->htfields);
 368     util_htdel(self->htfunctions);
 369     mem_d((void*)self->name);
 370     for (i = 0; i != vec_size(self->functions); ++i) {
 371         ir_function_delete_quick(self->functions[i]);
 372     }
 373     vec_free(self->functions);
 374     for (i = 0; i != vec_size(self->extparams); ++i) {
 375         ir_value_delete(self->extparams[i]);
 376     }
 377     vec_free(self->extparams);
 378     vec_free(self->extparam_protos);
 379     for (i = 0; i != vec_size(self->globals); ++i) {
 380         ir_value_delete(self->globals[i]);
 381     }
 382     vec_free(self->globals);
 383     for (i = 0; i != vec_size(self->fields); ++i) {
 384         ir_value_delete(self->fields[i]);
 385     }
 386     ir_value_delete(self->nil);
 387     for (i = 0; i != IR_MAX_VINSTR_TEMPS; ++i) {
 388         ir_value_delete(self->vinstr_temp[i]);
 389     }
 390     vec_free(self->fields);
 391     vec_free(self->filenames);
 392     vec_free(self->filestrings);
 393
 394     code_cleanup(self->code);
 395     mem_d(self);
 396 }
 397
 398 bool ir_builder_set_name(ir_builder *self, const char *name)
 399 {
 400     if (self->name)
 401         mem_d((void*)self->name);
 402     self->name = util_strdup(name);
 403     return !!self->name;
 404 }
 405
 406 static ir_function* ir_builder_get_function(ir_builder *self, const char *name)
 407 {
 408     return (ir_function*)util_htget(self->htfunctions, name);
 409 }
 410
 411 ir_function* ir_builder_create_function(ir_builder *self, const char *name, int outtype)
 412 {
 413     ir_function *fn = ir_builder_get_function(self, name);
 414     if (fn) {
 415         return NULL;
 416     }
 417
 418     fn = ir_function_new(self, outtype);
 419     if (!ir_function_set_name(fn, name))
 420     {
 421         ir_function_delete(fn);
 422         return NULL;
 423     }
 424     vec_push(self->functions, fn);
 425     util_htset(self->htfunctions, name, fn);
 426
 427     fn->value = ir_builder_create_global(self, fn->name, TYPE_FUNCTION);
 428     if (!fn->value) {
 429         ir_function_delete(fn);
 430         return NULL;
 431     }
 432
 433     fn->value->hasvalue = true;
 434     fn->value->outtype = outtype;
 435     fn->value->constval.vfunc = fn;
 436     fn->value->context = fn->context;
 437
 438     return fn;
 439 }
 440
 441 static ir_value* ir_builder_get_global(ir_builder *self, const char *name)
 442 {
 443     return (ir_value*)util_htget(self->htglobals, name);
 444 }
 445
 446 ir_value* ir_builder_create_global(ir_builder *self, const char *name, int vtype)
 447 {
 448     ir_value *ve;
 449
 450     if (name[0] != '#')
 451     {
 452         ve = ir_builder_get_global(self, name);
 453         if (ve) {
 454             return NULL;
 455         }
 456     }
 457
 458     ve = ir_value_var(name, store_global, vtype);
 459     vec_push(self->globals, ve);
 460     util_htset(self->htglobals, name, ve);
 461     return ve;
 462 }
 463
 464 ir_value* ir_builder_get_va_count(ir_builder *self)
 465 {
 466     if (self->reserved_va_count)
 467         return self->reserved_va_count;
 468     return (self->reserved_va_count = ir_builder_create_global(self, "reserved:va_count", TYPE_FLOAT));
 469 }
 470
 471 static ir_value* ir_builder_get_field(ir_builder *self, const char *name)
 472 {
 473     return (ir_value*)util_htget(self->htfields, name);
 474 }
 475
 476
 477 ir_value* ir_builder_create_field(ir_builder *self, const char *name, int vtype)
 478 {
 479     ir_value *ve = ir_builder_get_field(self, name);
 480     if (ve) {
 481         return NULL;
 482     }
 483
 484     ve = ir_value_var(name, store_global, TYPE_FIELD);
 485     ve->fieldtype = vtype;
 486     vec_push(self->fields, ve);
 487     util_htset(self->htfields, name, ve);
 488     return ve;
 489 }
 490
 491 /***********************************************************************
 492  *IR Function
 493  */
 494
 495 static bool ir_function_naive_phi(ir_function*);
 496 static void ir_function_enumerate(ir_function*);
 497 static bool ir_function_calculate_liferanges(ir_function*);
 498 static bool ir_function_allocate_locals(ir_function*);
 499
 500 ir_function* ir_function_new(ir_builder* owner, int outtype)
 501 {
 502     ir_function *self;
 503     self = (ir_function*)mem_a(sizeof(*self));
 504
 505     if (!self)
 506         return NULL;
 507
 508     memset(self, 0, sizeof(*self));
 509
 510     self->name = NULL;
 511     if (!ir_function_set_name(self, "<@unnamed>")) {
 512         mem_d(self);
 513         return NULL;
 514     }
 515     self->flags = 0;
 516
 517     self->owner = owner;
 518     self->context.file = "<@no context>";
 519     self->context.line = 0;
 520     self->outtype = outtype;
 521     self->value = NULL;
 522     self->builtin = 0;
 523
 524     self->params = NULL;
 525     self->blocks = NULL;
 526     self->values = NULL;
 527     self->locals = NULL;
 528
 529     self->max_varargs = 0;
 530
 531     self->code_function_def = -1;
 532     self->allocated_locals = 0;
 533     self->globaltemps      = 0;
 534
 535     self->run_id = 0;
 536     return self;
 537 }
 538
 539 bool ir_function_set_name(ir_function *self, const char *name)
 540 {
 541     if (self->name)
 542         mem_d((void*)self->name);
 543     self->name = util_strdup(name);
 544     return !!self->name;
 545 }
 546
 547 static void ir_function_delete_quick(ir_function *self)
 548 {
 549     size_t i;
 550     mem_d((void*)self->name);
 551
 552     for (i = 0; i != vec_size(self->blocks); ++i)
 553         ir_block_delete_quick(self->blocks[i]);
 554     vec_free(self->blocks);
 555
 556     vec_free(self->params);
 557
 558     for (i = 0; i != vec_size(self->values); ++i)
 559         ir_value_delete(self->values[i]);
 560     vec_free(self->values);
 561
 562     for (i = 0; i != vec_size(self->locals); ++i)
 563         ir_value_delete(self->locals[i]);
 564     vec_free(self->locals);
 565
 566     /* self->value is deleted by the builder */
 567
 568     mem_d(self);
 569 }
 570
 571 void ir_function_delete(ir_function *self)
 572 {
 573     size_t i;
 574     mem_d((void*)self->name);
 575
 576     for (i = 0; i != vec_size(self->blocks); ++i)
 577         ir_block_delete(self->blocks[i]);
 578     vec_free(self->blocks);
 579
 580     vec_free(self->params);
 581
 582     for (i = 0; i != vec_size(self->values); ++i)
 583         ir_value_delete(self->values[i]);
 584     vec_free(self->values);
 585
 586     for (i = 0; i != vec_size(self->locals); ++i)
 587         ir_value_delete(self->locals[i]);
 588     vec_free(self->locals);
 589
 590     /* self->value is deleted by the builder */
 591
 592     mem_d(self);
 593 }
 594
 595 static void ir_function_collect_value(ir_function *self, ir_value *v)
 596 {
 597     vec_push(self->values, v);
 598 }
 599
 600 ir_block* ir_function_create_block(lex_ctx_t ctx, ir_function *self, const char *label)
 601 {
 602     ir_block* bn = ir_block_new(self, label);
 603     bn->context = ctx;
 604     vec_push(self->blocks, bn);
 605     return bn;
 606 }
 607
 608 static bool instr_is_operation(uint16_t op)
 609 {
 610     return ( (op >= INSTR_MUL_F  && op <= INSTR_GT) ||
 611              (op >= INSTR_LOAD_F && op <= INSTR_LOAD_FNC) ||
 612              (op == INSTR_ADDRESS) ||
 613              (op >= INSTR_NOT_F  && op <= INSTR_NOT_FNC) ||
 614              (op >= INSTR_AND    && op <= INSTR_BITOR) ||
 615              (op >= INSTR_CALL0  && op <= INSTR_CALL8) ||
 616              (op >= VINSTR_BITAND_V && op <= VINSTR_NEG_V) );
 617 }
 618
 619 static bool ir_function_pass_peephole(ir_function *self)
 620 {
 621     size_t b;
 622
 623     for (b = 0; b < vec_size(self->blocks); ++b) {
 624         size_t    i;
 625         ir_block *block = self->blocks[b];
 626
 627         for (i = 0; i < vec_size(block->instr); ++i) {
 628             ir_instr *inst;
 629             inst = block->instr[i];
 630
 631             if (i >= 1 &&
 632                 (inst->opcode >= INSTR_STORE_F &&
 633                  inst->opcode <= INSTR_STORE_FNC))
 634             {
 635                 ir_instr *store;
 636                 ir_instr *oper;
 637                 ir_value *value;
 638
 639                 store = inst;
 640
 641                 oper  = block->instr[i-1];
 642                 if (!instr_is_operation(oper->opcode))
 643                     continue;
 644
 645                 /* Don't change semantics of MUL_VF in engines where these may not alias. */
 646                 if (OPTS_FLAG(LEGACY_VECTOR_MATHS)) {
 647                     if (oper->opcode == INSTR_MUL_VF && oper->_ops[2]->memberof == oper->_ops[1])
 648                         continue;
 649                     if (oper->opcode == INSTR_MUL_FV && oper->_ops[1]->memberof == oper->_ops[2])
 650                         continue;
 651                 }
 652
 653                 value = oper->_ops[0];
 654
 655                 /* only do it for SSA values */
 656                 if (value->store != store_value)
 657                     continue;
 658
 659                 /* don't optimize out the temp if it's used later again */
 660                 if (vec_size(value->reads) != 1)
 661                     continue;
 662
 663                 /* The very next store must use this value */
 664                 if (value->reads[0] != store)
 665                     continue;
 666
 667                 /* And of course the store must _read_ from it, so it's in
 668                  * OP 1 */
 669                 if (store->_ops[1] != value)
 670                     continue;
 671
 672                 ++opts_optimizationcount[OPTIM_PEEPHOLE];
 673                 (void)!ir_instr_op(oper, 0, store->_ops[0], true);
 674
 675                 vec_remove(block->instr, i, 1);
 676                 ir_instr_delete(store);
 677             }
 678             else if (inst->opcode == VINSTR_COND)
 679             {
 680                 /* COND on a value resulting from a NOT could
 681                  * remove the NOT and swap its operands
 682                  */
 683                 while (true) {
 684                     ir_block *tmp;
 685                     size_t    inotid;
 686                     ir_instr *inot;
 687                     ir_value *value;
 688                     value = inst->_ops[0];
 689
 690                     if (value->store != store_value ||
 691                         vec_size(value->reads) != 1 ||
 692                         value->reads[0] != inst)
 693                     {
 694                         break;
 695                     }
 696
 697                     inot = value->writes[0];
 698                     if (inot->_ops[0] != value ||
 699                         inot->opcode < INSTR_NOT_F ||
 700                         inot->opcode > INSTR_NOT_FNC ||
 701                         inot->opcode == INSTR_NOT_V || /* can't do these */
 702                         inot->opcode == INSTR_NOT_S)
 703                     {
 704                         break;
 705                     }
 706
 707                     /* count */
 708                     ++opts_optimizationcount[OPTIM_PEEPHOLE];
 709                     /* change operand */
 710                     (void)!ir_instr_op(inst, 0, inot->_ops[1], false);
 711                     /* remove NOT */
 712                     tmp = inot->owner;
 713                     for (inotid = 0; inotid < vec_size(tmp->instr); ++inotid) {
 714                         if (tmp->instr[inotid] == inot)
 715                             break;
 716                     }
 717                     if (inotid >= vec_size(tmp->instr)) {
 718                         compile_error(inst->context, "sanity-check failed: failed to find instruction to optimize out");
 719                         return false;
 720                     }
 721                     vec_remove(tmp->instr, inotid, 1);
 722                     ir_instr_delete(inot);
 723                     /* swap ontrue/onfalse */
 724                     tmp = inst->bops[0];
 725                     inst->bops[0] = inst->bops[1];
 726                     inst->bops[1] = tmp;
 727                 }
 728                 continue;
 729             }
 730         }
 731     }
 732
 733     return true;
 734 }
 735
 736 static bool ir_function_pass_tailrecursion(ir_function *self)
 737 {
 738     size_t b, p;
 739
 740     for (b = 0; b < vec_size(self->blocks); ++b) {
 741         ir_value *funcval;
 742         ir_instr *ret, *call, *store = NULL;
 743         ir_block *block = self->blocks[b];
 744
 745         if (!block->final || vec_size(block->instr) < 2)
 746             continue;
 747
 748         ret = block->instr[vec_size(block->instr)-1];
 749         if (ret->opcode != INSTR_DONE && ret->opcode != INSTR_RETURN)
 750             continue;
 751
 752         call = block->instr[vec_size(block->instr)-2];
 753         if (call->opcode >= INSTR_STORE_F && call->opcode <= INSTR_STORE_FNC) {
 754             /* account for the unoptimized
 755              * CALL
 756              * STORE %return, %tmp
 757              * RETURN %tmp
 758              * version
 759              */
 760             if (vec_size(block->instr) < 3)
 761                 continue;
 762
 763             store = call;
 764             call = block->instr[vec_size(block->instr)-3];
 765         }
 766
 767         if (call->opcode < INSTR_CALL0 || call->opcode > INSTR_CALL8)
 768             continue;
 769
 770         if (store) {
 771             /* optimize out the STORE */
 772             if (ret->_ops[0]   &&
 773                 ret->_ops[0]   == store->_ops[0] &&
 774                 store->_ops[1] == call->_ops[0])
 775             {
 776                 ++opts_optimizationcount[OPTIM_PEEPHOLE];
 777                 call->_ops[0] = store->_ops[0];
 778                 vec_remove(block->instr, vec_size(block->instr) - 2, 1);
 779                 ir_instr_delete(store);
 780             }
 781             else
 782                 continue;
 783         }
 784
 785         if (!call->_ops[0])
 786             continue;
 787
 788         funcval = call->_ops[1];
 789         if (!funcval)
 790             continue;
 791         if (funcval->vtype != TYPE_FUNCTION || funcval->constval.vfunc != self)
 792             continue;
 793
 794         /* now we have a CALL and a RET, check if it's a tailcall */
 795         if (ret->_ops[0] && call->_ops[0] != ret->_ops[0])
 796             continue;
 797
 798         ++opts_optimizationcount[OPTIM_TAIL_RECURSION];
 799         vec_shrinkby(block->instr, 2);
 800
 801         block->final = false; /* open it back up */
 802
 803         /* emite parameter-stores */
 804         for (p = 0; p < vec_size(call->params); ++p) {
 805             /* assert(call->params_count <= self->locals_count); */
 806             if (!ir_block_create_store(block, call->context, self->locals[p], call->params[p])) {
 807                 irerror(call->context, "failed to create tailcall store instruction for parameter %i", (int)p);
 808                 return false;
 809             }
 810         }
 811         if (!ir_block_create_jump(block, call->context, self->blocks[0])) {
 812             irerror(call->context, "failed to create tailcall jump");
 813             return false;
 814         }
 815
 816         ir_instr_delete(call);
 817         ir_instr_delete(ret);
 818     }
 819
 820     return true;
 821 }
 822
 823 bool ir_function_finalize(ir_function *self)
 824 {
 825     size_t i;
 826
 827     if (self->builtin)
 828         return true;
 829
 830     if (OPTS_OPTIMIZATION(OPTIM_PEEPHOLE)) {
 831         if (!ir_function_pass_peephole(self)) {
 832             irerror(self->context, "generic optimization pass broke something in `%s`", self->name);
 833             return false;
 834         }
 835     }
 836
 837     if (OPTS_OPTIMIZATION(OPTIM_TAIL_RECURSION)) {
 838         if (!ir_function_pass_tailrecursion(self)) {
 839             irerror(self->context, "tail-recursion optimization pass broke something in `%s`", self->name);
 840             return false;
 841         }
 842     }
 843
 844     if (!ir_function_naive_phi(self)) {
 845         irerror(self->context, "internal error: ir_function_naive_phi failed");
 846         return false;
 847     }
 848
 849     for (i = 0; i < vec_size(self->locals); ++i) {
 850         ir_value *v = self->locals[i];
 851         if (v->vtype == TYPE_VECTOR ||
 852             (v->vtype == TYPE_FIELD && v->outtype == TYPE_VECTOR))
 853         {
 854             ir_value_vector_member(v, 0);
 855             ir_value_vector_member(v, 1);
 856             ir_value_vector_member(v, 2);
 857         }
 858     }
 859     for (i = 0; i < vec_size(self->values); ++i) {
 860         ir_value *v = self->values[i];
 861         if (v->vtype == TYPE_VECTOR ||
 862             (v->vtype == TYPE_FIELD && v->outtype == TYPE_VECTOR))
 863         {
 864             ir_value_vector_member(v, 0);
 865             ir_value_vector_member(v, 1);
 866             ir_value_vector_member(v, 2);
 867         }
 868     }
 869
 870     ir_function_enumerate(self);
 871
 872     if (!ir_function_calculate_liferanges(self))
 873         return false;
 874     if (!ir_function_allocate_locals(self))
 875         return false;
 876     return true;
 877 }
 878
 879 ir_value* ir_function_create_local(ir_function *self, const char *name, int vtype, bool param)
 880 {
 881     ir_value *ve;
 882
 883     if (param &&
 884         vec_size(self->locals) &&
 885         self->locals[vec_size(self->locals)-1]->store != store_param) {
 886         irerror(self->context, "cannot add parameters after adding locals");
 887         return NULL;
 888     }
 889
 890     ve = ir_value_var(name, (param ? store_param : store_local), vtype);
 891     if (param)
 892         ve->locked = true;
 893     vec_push(self->locals, ve);
 894     return ve;
 895 }
 896
 897 /***********************************************************************
 898  *IR Block
 899  */
 900
 901 ir_block* ir_block_new(ir_function* owner, const char *name)
 902 {
 903     ir_block *self;
 904     self = (ir_block*)mem_a(sizeof(*self));
 905     if (!self)
 906         return NULL;
 907
 908     memset(self, 0, sizeof(*self));
 909
 910     self->label = NULL;
 911     if (name && !ir_block_set_label(self, name)) {
 912         mem_d(self);
 913         return NULL;
 914     }
 915     self->owner = owner;
 916     self->context.file = "<@no context>";
 917     self->context.line = 0;
 918     self->final = false;
 919
 920     self->instr   = NULL;
 921     self->entries = NULL;
 922     self->exits   = NULL;
 923
 924     self->eid = 0;
 925     self->is_return = false;
 926
 927     self->living = NULL;
 928
 929     self->generated = false;
 930
 931     return self;
 932 }
 933
 934 static void ir_block_delete_quick(ir_block* self)
 935 {
 936     size_t i;
 937     if (self->label) mem_d(self->label);
 938     for (i = 0; i != vec_size(self->instr); ++i)
 939         ir_instr_delete_quick(self->instr[i]);
 940     vec_free(self->instr);
 941     vec_free(self->entries);
 942     vec_free(self->exits);
 943     vec_free(self->living);
 944     mem_d(self);
 945 }
 946
 947 void ir_block_delete(ir_block* self)
 948 {
 949     size_t i;
 950     if (self->label) mem_d(self->label);
 951     for (i = 0; i != vec_size(self->instr); ++i)
 952         ir_instr_delete(self->instr[i]);
 953     vec_free(self->instr);
 954     vec_free(self->entries);
 955     vec_free(self->exits);
 956     vec_free(self->living);
 957     mem_d(self);
 958 }
 959
 960 bool ir_block_set_label(ir_block *self, const char *name)
 961 {
 962     if (self->label)
 963         mem_d((void*)self->label);
 964     self->label = util_strdup(name);
 965     return !!self->label;
 966 }
 967
 968 /***********************************************************************
 969  *IR Instructions
 970  */
 971
 972 static ir_instr* ir_instr_new(lex_ctx_t ctx, ir_block* owner, int op)
 973 {
 974     ir_instr *self;
 975     self = (ir_instr*)mem_a(sizeof(*self));
 976     if (!self)
 977         return NULL;
 978
 979     self->owner = owner;
 980     self->context = ctx;
 981     self->opcode = op;
 982     self->_ops[0] = NULL;
 983     self->_ops[1] = NULL;
 984     self->_ops[2] = NULL;
 985     self->bops[0] = NULL;
 986     self->bops[1] = NULL;
 987
 988     self->phi    = NULL;
 989     self->params = NULL;
 990
 991     self->eid = 0;
 992
 993     self->likely = true;
 994     return self;
 995 }
 996
 997 static void ir_instr_delete_quick(ir_instr *self)
 998 {
 999     vec_free(self->phi);
1000     vec_free(self->params);
1001     mem_d(self);
1002 }
1003
1004 static void ir_instr_delete(ir_instr *self)
1005 {
1006     size_t i;
1007     /* The following calls can only delete from
1008      * vectors, we still want to delete this instruction
1009      * so ignore the return value. Since with the warn_unused_result attribute
1010      * gcc doesn't care about an explicit: (void)foo(); to ignore the result,
1011      * I have to improvise here and use if(foo());
1012      */
1013     for (i = 0; i < vec_size(self->phi); ++i) {
1014         size_t idx;
1015         if (vec_ir_instr_find(self->phi[i].value->writes, self, &idx))
1016             vec_remove(self->phi[i].value->writes, idx, 1);
1017         if (vec_ir_instr_find(self->phi[i].value->reads, self, &idx))
1018             vec_remove(self->phi[i].value->reads, idx, 1);
1019     }
1020     vec_free(self->phi);
1021     for (i = 0; i < vec_size(self->params); ++i) {
1022         size_t idx;
1023         if (vec_ir_instr_find(self->params[i]->writes, self, &idx))
1024             vec_remove(self->params[i]->writes, idx, 1);
1025         if (vec_ir_instr_find(self->params[i]->reads, self, &idx))
1026             vec_remove(self->params[i]->reads, idx, 1);
1027     }
1028     vec_free(self->params);
1029     (void)!ir_instr_op(self, 0, NULL, false);
1030     (void)!ir_instr_op(self, 1, NULL, false);
1031     (void)!ir_instr_op(self, 2, NULL, false);
1032     mem_d(self);
1033 }
1034
1035 static bool ir_instr_op(ir_instr *self, int op, ir_value *v, bool writing)
1036 {
1037     if (v && v->vtype == TYPE_NOEXPR) {
1038         irerror(self->context, "tried to use a NOEXPR value");
1039         return false;
1040     }
1041
1042     if (self->_ops[op]) {
1043         size_t idx;
1044         if (writing && vec_ir_instr_find(self->_ops[op]->writes, self, &idx))
1045             vec_remove(self->_ops[op]->writes, idx, 1);
1046         else if (vec_ir_instr_find(self->_ops[op]->reads, self, &idx))
1047             vec_remove(self->_ops[op]->reads, idx, 1);
1048     }
1049     if (v) {
1050         if (writing)
1051             vec_push(v->writes, self);
1052         else
1053             vec_push(v->reads, self);
1054     }
1055     self->_ops[op] = v;
1056     return true;
1057 }
1058
1059 /***********************************************************************
1060  *IR Value
1061  */
1062
1063 static void ir_value_code_setaddr(ir_value *self, int32_t gaddr)
1064 {
1065     self->code.globaladdr = gaddr;
1066     if (self->members[0]) self->members[0]->code.globaladdr = gaddr;
1067     if (self->members[1]) self->members[1]->code.globaladdr = gaddr;
1068     if (self->members[2]) self->members[2]->code.globaladdr = gaddr;
1069 }
1070
1071 static int32_t ir_value_code_addr(const ir_value *self)
1072 {
1073     if (self->store == store_return)
1074         return OFS_RETURN + self->code.addroffset;
1075     return self->code.globaladdr + self->code.addroffset;
1076 }
1077
1078 ir_value* ir_value_var(const char *name, int storetype, int vtype)
1079 {
1080     ir_value *self;
1081     self = (ir_value*)mem_a(sizeof(*self));
1082     self->vtype = vtype;
1083     self->fieldtype = TYPE_VOID;
1084     self->outtype = TYPE_VOID;
1085     self->store = storetype;
1086     self->flags = 0;
1087
1088     self->reads  = NULL;
1089     self->writes = NULL;
1090
1091     self->cvq          = CV_NONE;
1092     self->hasvalue     = false;
1093     self->context.file = "<@no context>";
1094     self->context.line = 0;
1095     self->name = NULL;
1096     if (name && !ir_value_set_name(self, name)) {
1097         irerror(self->context, "out of memory");
1098         mem_d(self);
1099         return NULL;
1100     }
1101
1102     memset(&self->constval, 0, sizeof(self->constval));
1103     memset(&self->code,     0, sizeof(self->code));
1104
1105     self->members[0] = NULL;
1106     self->members[1] = NULL;
1107     self->members[2] = NULL;
1108     self->memberof = NULL;
1109
1110     self->unique_life = false;
1111     self->locked      = false;
1112     self->callparam   = false;
1113
1114     self->life = NULL;
1115     return self;
1116 }
1117
1118 ir_value* ir_value_vector_member(ir_value *self, unsigned int member)
1119 {
1120     char     *name;
1121     size_t    len;
1122     ir_value *m;
1123     if (member >= 3)
1124         return NULL;
1125
1126     if (self->members[member])
1127         return self->members[member];
1128
1129     if (self->name) {
1130         len = strlen(self->name);
1131         name = (char*)mem_a(len + 3);
1132         memcpy(name, self->name, len);
1133         name[len+0] = '_';
1134         name[len+1] = 'x' + member;
1135         name[len+2] = '\0';
1136     }
1137     else
1138         name = NULL;
1139
1140     if (self->vtype == TYPE_VECTOR)
1141     {
1142         m = ir_value_var(name, self->store, TYPE_FLOAT);
1143         if (name)
1144             mem_d(name);
1145         if (!m)
1146             return NULL;
1147         m->context = self->context;
1148
1149         self->members[member] = m;
1150         m->code.addroffset = member;
1151     }
1152     else if (self->vtype == TYPE_FIELD)
1153     {
1154         if (self->fieldtype != TYPE_VECTOR)
1155             return NULL;
1156         m = ir_value_var(name, self->store, TYPE_FIELD);
1157         if (name)
1158             mem_d(name);
1159         if (!m)
1160             return NULL;
1161         m->fieldtype = TYPE_FLOAT;
1162         m->context = self->context;
1163
1164         self->members[member] = m;
1165         m->code.addroffset = member;
1166     }
1167     else
1168     {
1169         irerror(self->context, "invalid member access on %s", self->name);
1170         return NULL;
1171     }
1172
1173     m->memberof = self;
1174     return m;
1175 }
1176
1177 static GMQCC_INLINE size_t ir_value_sizeof(const ir_value *self)
1178 {
1179     if (self->vtype == TYPE_FIELD && self->fieldtype == TYPE_VECTOR)
1180         return type_sizeof_[TYPE_VECTOR];
1181     return type_sizeof_[self->vtype];
1182 }
1183
1184 static ir_value* ir_value_out(ir_function *owner, const char *name, int storetype, int vtype)
1185 {
1186     ir_value *v = ir_value_var(name, storetype, vtype);
1187     if (!v)
1188         return NULL;
1189     ir_function_collect_value(owner, v);
1190     return v;
1191 }
1192
1193 void ir_value_delete(ir_value* self)
1194 {
1195     size_t i;
1196     if (self->name)
1197         mem_d((void*)self->name);
1198     if (self->hasvalue)
1199     {
1200         if (self->vtype == TYPE_STRING)
1201             mem_d((void*)self->constval.vstring);
1202     }
1203     for (i = 0; i < 3; ++i) {
1204         if (self->members[i])
1205             ir_value_delete(self->members[i]);
1206     }
1207     vec_free(self->reads);
1208     vec_free(self->writes);
1209     vec_free(self->life);
1210     mem_d(self);
1211 }
1212
1213 bool ir_value_set_name(ir_value *self, const char *name)
1214 {
1215     if (self->name)
1216         mem_d((void*)self->name);
1217     self->name = util_strdup(name);
1218     return !!self->name;
1219 }
1220
1221 bool ir_value_set_float(ir_value *self, float f)
1222 {
1223     if (self->vtype != TYPE_FLOAT)
1224         return false;
1225     self->constval.vfloat = f;
1226     self->hasvalue = true;
1227     return true;
1228 }
1229
1230 bool ir_value_set_func(ir_value *self, int f)
1231 {
1232     if (self->vtype != TYPE_FUNCTION)
1233         return false;
1234     self->constval.vint = f;
1235     self->hasvalue = true;
1236     return true;
1237 }
1238
1239 bool ir_value_set_vector(ir_value *self, vec3_t v)
1240 {
1241     if (self->vtype != TYPE_VECTOR)
1242         return false;
1243     self->constval.vvec = v;
1244     self->hasvalue = true;
1245     return true;
1246 }
1247
1248 bool ir_value_set_field(ir_value *self, ir_value *fld)
1249 {
1250     if (self->vtype != TYPE_FIELD)
1251         return false;
1252     self->constval.vpointer = fld;
1253     self->hasvalue = true;
1254     return true;
1255 }
1256
1257 bool ir_value_set_string(ir_value *self, const char *str)
1258 {
1259     if (self->vtype != TYPE_STRING)
1260         return false;
1261     self->constval.vstring = util_strdupe(str);
1262     self->hasvalue = true;
1263     return true;
1264 }
1265
1266 #if 0
1267 bool ir_value_set_int(ir_value *self, int i)
1268 {
1269     if (self->vtype != TYPE_INTEGER)
1270         return false;
1271     self->constval.vint = i;
1272     self->hasvalue = true;
1273     return true;
1274 }
1275 #endif
1276
1277 bool ir_value_lives(ir_value *self, size_t at)
1278 {
1279     size_t i;
1280     for (i = 0; i < vec_size(self->life); ++i)
1281     {
1282         ir_life_entry_t *life = &self->life[i];
1283         if (life->start <= at && at <= life->end)
1284             return true;
1285         if (life->start > at) /* since it's ordered */
1286             return false;
1287     }
1288     return false;
1289 }
1290
1291 static bool ir_value_life_insert(ir_value *self, size_t idx, ir_life_entry_t e)
1292 {
1293     size_t k;
1294     vec_push(self->life, e);
1295     for (k = vec_size(self->life)-1; k > idx; --k)
1296         self->life[k] = self->life[k-1];
1297     self->life[idx] = e;
1298     return true;
1299 }
1300
1301 static bool ir_value_life_merge(ir_value *self, size_t s)
1302 {
1303     size_t i;
1304     const size_t vs = vec_size(self->life);
1305     ir_life_entry_t *life = NULL;
1306     ir_life_entry_t *before = NULL;
1307     ir_life_entry_t new_entry;
1308
1309     /* Find the first range >= s */
1310     for (i = 0; i < vs; ++i)
1311     {
1312         before = life;
1313         life = &self->life[i];
1314         if (life->start > s)
1315             break;
1316     }
1317     /* nothing found? append */
1318     if (i == vs) {
1319         ir_life_entry_t e;
1320         if (life && life->end+1 == s)
1321         {
1322             /* previous life range can be merged in */
1323             life->end++;
1324             return true;
1325         }
1326         if (life && life->end >= s)
1327             return false;
1328         e.start = e.end = s;
1329         vec_push(self->life, e);
1330         return true;
1331     }
1332     /* found */
1333     if (before)
1334     {
1335         if (before->end + 1 == s &&
1336             life->start - 1 == s)
1337         {
1338             /* merge */
1339             before->end = life->end;
1340             vec_remove(self->life, i, 1);
1341             return true;
1342         }
1343         if (before->end + 1 == s)
1344         {
1345             /* extend before */
1346             before->end++;
1347             return true;
1348         }
1349         /* already contained */
1350         if (before->end >= s)
1351             return false;
1352     }
1353     /* extend */
1354     if (life->start - 1 == s)
1355     {
1356         life->start--;
1357         return true;
1358     }
1359     /* insert a new entry */
1360     new_entry.start = new_entry.end = s;
1361     return ir_value_life_insert(self, i, new_entry);
1362 }
1363
1364 static bool ir_value_life_merge_into(ir_value *self, const ir_value *other)
1365 {
1366     size_t i, myi;
1367
1368     if (!vec_size(other->life))
1369         return true;
1370
1371     if (!vec_size(self->life)) {
1372         size_t count = vec_size(other->life);
1373         ir_life_entry_t *life = vec_add(self->life, count);
1374         memcpy(life, other->life, count * sizeof(*life));
1375         return true;
1376     }
1377
1378     myi = 0;
1379     for (i = 0; i < vec_size(other->life); ++i)
1380     {
1381         const ir_life_entry_t *life = &other->life[i];
1382         while (true)
1383         {
1384             ir_life_entry_t *entry = &self->life[myi];
1385
1386             if (life->end+1 < entry->start)
1387             {
1388                 /* adding an interval before entry */
1389                 if (!ir_value_life_insert(self, myi, *life))
1390                     return false;
1391                 ++myi;
1392                 break;
1393             }
1394
1395             if (life->start <  entry->start &&
1396                 life->end+1 >= entry->start)
1397             {
1398                 /* starts earlier and overlaps */
1399                 entry->start = life->start;
1400             }
1401
1402             if (life->end   >  entry->end &&
1403                 life->start <= entry->end+1)
1404             {
1405                 /* ends later and overlaps */
1406                 entry->end = life->end;
1407             }
1408
1409             /* see if our change combines it with the next ranges */
1410             while (myi+1 < vec_size(self->life) &&
1411                    entry->end+1 >= self->life[1+myi].start)
1412             {
1413                 /* overlaps with (myi+1) */
1414                 if (entry->end < self->life[1+myi].end)
1415                     entry->end = self->life[1+myi].end;
1416                 vec_remove(self->life, myi+1, 1);
1417                 entry = &self->life[myi];
1418             }
1419
1420             /* see if we're after the entry */
1421             if (life->start > entry->end)
1422             {
1423                 ++myi;
1424                 /* append if we're at the end */
1425                 if (myi >= vec_size(self->life)) {
1426                     vec_push(self->life, *life);
1427                     break;
1428                 }
1429                 /* otherweise check the next range */
1430                 continue;
1431             }
1432             break;
1433         }
1434     }
1435     return true;
1436 }
1437
1438 static bool ir_values_overlap(const ir_value *a, const ir_value *b)
1439 {
1440     /* For any life entry in A see if it overlaps with
1441      * any life entry in B.
1442      * Note that the life entries are orderes, so we can make a
1443      * more efficient algorithm there than naively translating the
1444      * statement above.
1445      */
1446
1447     ir_life_entry_t *la, *lb, *enda, *endb;
1448
1449     /* first of all, if either has no life range, they cannot clash */
1450     if (!vec_size(a->life) || !vec_size(b->life))
1451         return false;
1452
1453     la = a->life;
1454     lb = b->life;
1455     enda = la + vec_size(a->life);
1456     endb = lb + vec_size(b->life);
1457     while (true)
1458     {
1459         /* check if the entries overlap, for that,
1460          * both must start before the other one ends.
1461          */
1462         if (la->start < lb->end &&
1463             lb->start < la->end)
1464         {
1465             return true;
1466         }
1467
1468         /* entries are ordered
1469          * one entry is earlier than the other
1470          * that earlier entry will be moved forward
1471          */
1472         if (la->start < lb->start)
1473         {
1474             /* order: A B, move A forward
1475              * check if we hit the end with A
1476              */
1477             if (++la == enda)
1478                 break;
1479         }
1480         else /* if (lb->start < la->start)  actually <= */
1481         {
1482             /* order: B A, move B forward
1483              * check if we hit the end with B
1484              */
1485             if (++lb == endb)
1486                 break;
1487         }
1488     }
1489     return false;
1490 }
1491
1492 /***********************************************************************
1493  *IR main operations
1494  */
1495
1496 static bool ir_check_unreachable(ir_block *self)
1497 {
1498     /* The IR should never have to deal with unreachable code */
1499     if (!self->final/* || OPTS_FLAG(ALLOW_UNREACHABLE_CODE)*/)
1500         return true;
1501     irerror(self->context, "unreachable statement (%s)", self->label);
1502     return false;
1503 }
1504
1505 bool ir_block_create_store_op(ir_block *self, lex_ctx_t ctx, int op, ir_value *target, ir_value *what)
1506 {
1507     ir_instr *in;
1508     if (!ir_check_unreachable(self))
1509         return false;
1510
1511     if (target->store == store_value &&
1512         (op < INSTR_STOREP_F || op > INSTR_STOREP_FNC))
1513     {
1514         irerror(self->context, "cannot store to an SSA value");
1515         irerror(self->context, "trying to store: %s <- %s", target->name, what->name);
1516         irerror(self->context, "instruction: %s", util_instr_str[op]);
1517         return false;
1518     }
1519
1520     in = ir_instr_new(ctx, self, op);
1521     if (!in)
1522         return false;
1523
1524     if (!ir_instr_op(in, 0, target, (op < INSTR_STOREP_F || op > INSTR_STOREP_FNC)) ||
1525         !ir_instr_op(in, 1, what, false))
1526     {
1527         ir_instr_delete(in);
1528         return false;
1529     }
1530     vec_push(self->instr, in);
1531     return true;
1532 }
1533
1534 static bool ir_block_create_store(ir_block *self, lex_ctx_t ctx, ir_value *target, ir_value *what)
1535 {
1536     int op = 0;
1537     int vtype;
1538     if (target->vtype == TYPE_VARIANT)
1539         vtype = what->vtype;
1540     else
1541         vtype = target->vtype;
1542
1543 #if 0
1544     if      (vtype == TYPE_FLOAT   && what->vtype == TYPE_INTEGER)
1545         op = INSTR_CONV_ITOF;
1546     else if (vtype == TYPE_INTEGER && what->vtype == TYPE_FLOAT)
1547         op = INSTR_CONV_FTOI;
1548 #endif
1549         op = type_store_instr[vtype];
1550
1551     if (OPTS_FLAG(ADJUST_VECTOR_FIELDS)) {
1552         if (op == INSTR_STORE_FLD && what->fieldtype == TYPE_VECTOR)
1553             op = INSTR_STORE_V;
1554     }
1555
1556     return ir_block_create_store_op(self, ctx, op, target, what);
1557 }
1558
1559 bool ir_block_create_storep(ir_block *self, lex_ctx_t ctx, ir_value *target, ir_value *what)
1560 {
1561     int op = 0;
1562     int vtype;
1563
1564     if (target->vtype != TYPE_POINTER)
1565         return false;
1566
1567     /* storing using pointer - target is a pointer, type must be
1568      * inferred from source
1569      */
1570     vtype = what->vtype;
1571
1572     op = type_storep_instr[vtype];
1573     if (OPTS_FLAG(ADJUST_VECTOR_FIELDS)) {
1574         if (op == INSTR_STOREP_FLD && what->fieldtype == TYPE_VECTOR)
1575             op = INSTR_STOREP_V;
1576     }
1577
1578     return ir_block_create_store_op(self, ctx, op, target, what);
1579 }
1580
1581 bool ir_block_create_return(ir_block *self, lex_ctx_t ctx, ir_value *v)
1582 {
1583     ir_instr *in;
1584     if (!ir_check_unreachable(self))
1585         return false;
1586
1587     self->final = true;
1588
1589     self->is_return = true;
1590     in = ir_instr_new(ctx, self, INSTR_RETURN);
1591     if (!in)
1592         return false;
1593
1594     if (v && !ir_instr_op(in, 0, v, false)) {
1595         ir_instr_delete(in);
1596         return false;
1597     }
1598
1599     vec_push(self->instr, in);
1600     return true;
1601 }
1602
1603 bool ir_block_create_if(ir_block *self, lex_ctx_t ctx, ir_value *v,
1604                         ir_block *ontrue, ir_block *onfalse)
1605 {
1606     ir_instr *in;
1607     if (!ir_check_unreachable(self))
1608         return false;
1609     self->final = true;
1610     /*in = ir_instr_new(ctx, self, (v->vtype == TYPE_STRING ? INSTR_IF_S : INSTR_IF_F));*/
1611     in = ir_instr_new(ctx, self, VINSTR_COND);
1612     if (!in)
1613         return false;
1614
1615     if (!ir_instr_op(in, 0, v, false)) {
1616         ir_instr_delete(in);
1617         return false;
1618     }
1619
1620     in->bops[0] = ontrue;
1621     in->bops[1] = onfalse;
1622
1623     vec_push(self->instr, in);
1624
1625     vec_push(self->exits, ontrue);
1626     vec_push(self->exits, onfalse);
1627     vec_push(ontrue->entries,  self);
1628     vec_push(onfalse->entries, self);
1629     return true;
1630 }
1631
1632 bool ir_block_create_jump(ir_block *self, lex_ctx_t ctx, ir_block *to)
1633 {
1634     ir_instr *in;
1635     if (!ir_check_unreachable(self))
1636         return false;
1637     self->final = true;
1638     in = ir_instr_new(ctx, self, VINSTR_JUMP);
1639     if (!in)
1640         return false;
1641
1642     in->bops[0] = to;
1643     vec_push(self->instr, in);
1644
1645     vec_push(self->exits, to);
1646     vec_push(to->entries, self);
1647     return true;
1648 }
1649
1650 bool ir_block_create_goto(ir_block *self, lex_ctx_t ctx, ir_block *to)
1651 {
1652     self->owner->flags |= IR_FLAG_HAS_GOTO;
1653     return ir_block_create_jump(self, ctx, to);
1654 }
1655
1656 ir_instr* ir_block_create_phi(ir_block *self, lex_ctx_t ctx, const char *label, int ot)
1657 {
1658     ir_value *out;
1659     ir_instr *in;
1660     if (!ir_check_unreachable(self))
1661         return NULL;
1662     in = ir_instr_new(ctx, self, VINSTR_PHI);
1663     if (!in)
1664         return NULL;
1665     out = ir_value_out(self->owner, label, store_value, ot);
1666     if (!out) {
1667         ir_instr_delete(in);
1668         return NULL;
1669     }
1670     if (!ir_instr_op(in, 0, out, true)) {
1671         ir_instr_delete(in);
1672         ir_value_delete(out);
1673         return NULL;
1674     }
1675     vec_push(self->instr, in);
1676     return in;
1677 }
1678
1679 ir_value* ir_phi_value(ir_instr *self)
1680 {
1681     return self->_ops[0];
1682 }
1683
1684 void ir_phi_add(ir_instr* self, ir_block *b, ir_value *v)
1685 {
1686     ir_phi_entry_t pe;
1687
1688     if (!vec_ir_block_find(self->owner->entries, b, NULL)) {
1689         /* Must not be possible to cause this, otherwise the AST
1690          * is doing something wrong.
1691          */
1692         irerror(self->context, "Invalid entry block for PHI");
1693         exit(EXIT_FAILURE);
1694     }
1695
1696     pe.value = v;
1697     pe.from = b;
1698     vec_push(v->reads, self);
1699     vec_push(self->phi, pe);
1700 }
1701
1702 /* call related code */
1703 ir_instr* ir_block_create_call(ir_block *self, lex_ctx_t ctx, const char *label, ir_value *func, bool noreturn)
1704 {
1705     ir_value *out;
1706     ir_instr *in;
1707     if (!ir_check_unreachable(self))
1708         return NULL;
1709     in = ir_instr_new(ctx, self, (noreturn ? VINSTR_NRCALL : INSTR_CALL0));
1710     if (!in)
1711         return NULL;
1712     if (noreturn) {
1713         self->final = true;
1714         self->is_return = true;
1715     }
1716     out = ir_value_out(self->owner, label, (func->outtype == TYPE_VOID) ? store_return : store_value, func->outtype);
1717     if (!out) {
1718         ir_instr_delete(in);
1719         return NULL;
1720     }
1721     if (!ir_instr_op(in, 0, out, true) ||
1722         !ir_instr_op(in, 1, func, false))
1723     {
1724         ir_instr_delete(in);
1725         ir_value_delete(out);
1726         return NULL;
1727     }
1728     vec_push(self->instr, in);
1729     /*
1730     if (noreturn) {
1731         if (!ir_block_create_return(self, ctx, NULL)) {
1732             compile_error(ctx, "internal error: failed to generate dummy-return instruction");
1733             ir_instr_delete(in);
1734             return NULL;
1735         }
1736     }
1737     */
1738     return in;
1739 }
1740
1741 ir_value* ir_call_value(ir_instr *self)
1742 {
1743     return self->_ops[0];
1744 }
1745
1746 void ir_call_param(ir_instr* self, ir_value *v)
1747 {
1748     vec_push(self->params, v);
1749     vec_push(v->reads, self);
1750 }
1751
1752 /* binary op related code */
1753
1754 ir_value* ir_block_create_binop(ir_block *self, lex_ctx_t ctx,
1755                                 const char *label, int opcode,
1756                                 ir_value *left, ir_value *right)
1757 {
1758     int ot = TYPE_VOID;
1759     switch (opcode) {
1760         case INSTR_ADD_F:
1761         case INSTR_SUB_F:
1762         case INSTR_DIV_F:
1763         case INSTR_MUL_F:
1764         case INSTR_MUL_V:
1765         case INSTR_AND:
1766         case INSTR_OR:
1767 #if 0
1768         case INSTR_AND_I:
1769         case INSTR_AND_IF:
1770         case INSTR_AND_FI:
1771         case INSTR_OR_I:
1772         case INSTR_OR_IF:
1773         case INSTR_OR_FI:
1774 #endif
1775         case INSTR_BITAND:
1776         case INSTR_BITOR:
1777         case VINSTR_BITXOR:
1778 #if 0
1779         case INSTR_SUB_S: /* -- offset of string as float */
1780         case INSTR_MUL_IF:
1781         case INSTR_MUL_FI:
1782         case INSTR_DIV_IF:
1783         case INSTR_DIV_FI:
1784         case INSTR_BITOR_IF:
1785         case INSTR_BITOR_FI:
1786         case INSTR_BITAND_FI:
1787         case INSTR_BITAND_IF:
1788         case INSTR_EQ_I:
1789         case INSTR_NE_I:
1790 #endif
1791             ot = TYPE_FLOAT;
1792             break;
1793 #if 0
1794         case INSTR_ADD_I:
1795         case INSTR_ADD_IF:
1796         case INSTR_ADD_FI:
1797         case INSTR_SUB_I:
1798         case INSTR_SUB_FI:
1799         case INSTR_SUB_IF:
1800         case INSTR_MUL_I:
1801         case INSTR_DIV_I:
1802         case INSTR_BITAND_I:
1803         case INSTR_BITOR_I:
1804         case INSTR_XOR_I:
1805         case INSTR_RSHIFT_I:
1806         case INSTR_LSHIFT_I:
1807             ot = TYPE_INTEGER;
1808             break;
1809 #endif
1810         case INSTR_ADD_V:
1811         case INSTR_SUB_V:
1812         case INSTR_MUL_VF:
1813         case INSTR_MUL_FV:
1814         case VINSTR_BITAND_V:
1815         case VINSTR_BITOR_V:
1816         case VINSTR_BITXOR_V:
1817         case VINSTR_BITAND_VF:
1818         case VINSTR_BITOR_VF:
1819         case VINSTR_BITXOR_VF:
1820         case VINSTR_CROSS:
1821 #if 0
1822         case INSTR_DIV_VF:
1823         case INSTR_MUL_IV:
1824         case INSTR_MUL_VI:
1825 #endif
1826             ot = TYPE_VECTOR;
1827             break;
1828 #if 0
1829         case INSTR_ADD_SF:
1830             ot = TYPE_POINTER;
1831             break;
1832 #endif
1833     /*
1834      * after the following default case, the value of opcode can never
1835      * be 1, 2, 3, 4, 5, 6, 7, 8, 9, 62, 63, 64, 65
1836      */
1837         default:
1838             /* ranges: */
1839             /* boolean operations result in floats */
1840
1841             /*
1842              * opcode >= 10 takes true branch opcode is at least 10
1843              * opcode <= 23 takes false branch opcode is at least 24
1844              */
1845             if (opcode >= INSTR_EQ_F && opcode <= INSTR_GT)
1846                 ot = TYPE_FLOAT;
1847
1848             /*
1849              * At condition "opcode <= 23", the value of "opcode" must be
1850              * at least 24.
1851              * At condition "opcode <= 23", the value of "opcode" cannot be
1852              * equal to any of {1, 2, 3, 4, 5, 6, 7, 8, 9, 62, 63, 64, 65}.
1853              * The condition "opcode <= 23" cannot be true.
1854              *
1855              * Thus ot=2 (TYPE_FLOAT) can never be true
1856              */
1857 #if 0
1858             else if (opcode >= INSTR_LE && opcode <= INSTR_GT)
1859                 ot = TYPE_FLOAT;
1860             else if (opcode >= INSTR_LE_I && opcode <= INSTR_EQ_FI)
1861                 ot = TYPE_FLOAT;
1862 #endif
1863             break;
1864     };
1865     if (ot == TYPE_VOID) {
1866         /* The AST or parser were supposed to check this! */
1867         return NULL;
1868     }
1869
1870     return ir_block_create_general_instr(self, ctx, label, opcode, left, right, ot);
1871 }
1872
1873 ir_value* ir_block_create_unary(ir_block *self, lex_ctx_t ctx,
1874                                 const char *label, int opcode,
1875                                 ir_value *operand)
1876 {
1877     int ot = TYPE_FLOAT;
1878     switch (opcode) {
1879         case INSTR_NOT_F:
1880         case INSTR_NOT_V:
1881         case INSTR_NOT_S:
1882         case INSTR_NOT_ENT:
1883         case INSTR_NOT_FNC: /*
1884         case INSTR_NOT_I:   */
1885             ot = TYPE_FLOAT;
1886             break;
1887
1888         /*
1889          * Negation for virtual instructions is emulated with 0-value. Thankfully
1890          * the operand for 0 already exists so we just source it from here.
1891          */
1892         case VINSTR_NEG_F:
1893             return ir_block_create_general_instr(self, ctx, label, INSTR_SUB_F, NULL, operand, ot);
1894         case VINSTR_NEG_V:
1895             return ir_block_create_general_instr(self, ctx, label, INSTR_SUB_V, NULL, operand, TYPE_VECTOR);
1896
1897         default:
1898             ot = operand->vtype;
1899             break;
1900     };
1901     if (ot == TYPE_VOID) {
1902         /* The AST or parser were supposed to check this! */
1903         return NULL;
1904     }
1905
1906     /* let's use the general instruction creator and pass NULL for OPB */
1907     return ir_block_create_general_instr(self, ctx, label, opcode, operand, NULL, ot);
1908 }
1909
1910 static ir_value* ir_block_create_general_instr(ir_block *self, lex_ctx_t ctx, const char *label,
1911                                         int op, ir_value *a, ir_value *b, int outype)
1912 {
1913     ir_instr *instr;
1914     ir_value *out;
1915
1916     out = ir_value_out(self->owner, label, store_value, outype);
1917     if (!out)
1918         return NULL;
1919
1920     instr = ir_instr_new(ctx, self, op);
1921     if (!instr) {
1922         ir_value_delete(out);
1923         return NULL;
1924     }
1925
1926     if (!ir_instr_op(instr, 0, out, true) ||
1927         !ir_instr_op(instr, 1, a, false) ||
1928         !ir_instr_op(instr, 2, b, false) )
1929     {
1930         goto on_error;
1931     }
1932
1933     vec_push(self->instr, instr);
1934
1935     return out;
1936 on_error:
1937     ir_instr_delete(instr);
1938     ir_value_delete(out);
1939     return NULL;
1940 }
1941
1942 ir_value* ir_block_create_fieldaddress(ir_block *self, lex_ctx_t ctx, const char *label, ir_value *ent, ir_value *field)
1943 {
1944     ir_value *v;
1945
1946     /* Support for various pointer types todo if so desired */
1947     if (ent->vtype != TYPE_ENTITY)
1948         return NULL;
1949
1950     if (field->vtype != TYPE_FIELD)
1951         return NULL;
1952
1953     v = ir_block_create_general_instr(self, ctx, label, INSTR_ADDRESS, ent, field, TYPE_POINTER);
1954     v->fieldtype = field->fieldtype;
1955     return v;
1956 }
1957
1958 ir_value* ir_block_create_load_from_ent(ir_block *self, lex_ctx_t ctx, const char *label, ir_value *ent, ir_value *field, int outype)
1959 {
1960     int op;
1961     if (ent->vtype != TYPE_ENTITY)
1962         return NULL;
1963
1964     /* at some point we could redirect for TYPE_POINTER... but that could lead to carelessness */
1965     if (field->vtype != TYPE_FIELD)
1966         return NULL;
1967
1968     switch (outype)
1969     {
1970         case TYPE_FLOAT:    op = INSTR_LOAD_F;   break;
1971         case TYPE_VECTOR:   op = INSTR_LOAD_V;   break;
1972         case TYPE_STRING:   op = INSTR_LOAD_S;   break;
1973         case TYPE_FIELD:    op = INSTR_LOAD_FLD; break;
1974         case TYPE_ENTITY:   op = INSTR_LOAD_ENT; break;
1975         case TYPE_FUNCTION: op = INSTR_LOAD_FNC; break;
1976 #if 0
1977         case TYPE_POINTER: op = INSTR_LOAD_I;   break;
1978         case TYPE_INTEGER: op = INSTR_LOAD_I;   break;
1979 #endif
1980         default:
1981             irerror(self->context, "invalid type for ir_block_create_load_from_ent: %s", type_name[outype]);
1982             return NULL;
1983     }
1984
1985     return ir_block_create_general_instr(self, ctx, label, op, ent, field, outype);
1986 }
1987
1988 /* PHI resolving breaks the SSA, and must thus be the last
1989  * step before life-range calculation.
1990  */
1991
1992 static bool ir_block_naive_phi(ir_block *self);
1993 bool ir_function_naive_phi(ir_function *self)
1994 {
1995     size_t i;
1996
1997     for (i = 0; i < vec_size(self->blocks); ++i)
1998     {
1999         if (!ir_block_naive_phi(self->blocks[i]))
2000             return false;
2001     }
2002     return true;
2003 }
2004
2005 static bool ir_block_naive_phi(ir_block *self)
2006 {
2007     size_t i, p; /*, w;*/
2008     /* FIXME: optionally, create_phi can add the phis
2009      * to a list so we don't need to loop through blocks
2010      * - anyway: "don't optimize YET"
2011      */
2012     for (i = 0; i < vec_size(self->instr); ++i)
2013     {
2014         ir_instr *instr = self->instr[i];
2015         if (instr->opcode != VINSTR_PHI)
2016             continue;
2017
2018         vec_remove(self->instr, i, 1);
2019         --i; /* NOTE: i+1 below */
2020
2021         for (p = 0; p < vec_size(instr->phi); ++p)
2022         {
2023             ir_value *v = instr->phi[p].value;
2024             ir_block *b = instr->phi[p].from;
2025
2026             if (v->store == store_value &&
2027                 vec_size(v->reads) == 1 &&
2028                 vec_size(v->writes) == 1)
2029             {
2030                 /* replace the value */
2031                 if (!ir_instr_op(v->writes[0], 0, instr->_ops[0], true))
2032                     return false;
2033             }
2034             else
2035             {
2036                 /* force a move instruction */
2037                 ir_instr *prevjump = vec_last(b->instr);
2038                 vec_pop(b->instr);
2039                 b->final = false;
2040                 instr->_ops[0]->store = store_global;
2041                 if (!ir_block_create_store(b, instr->context, instr->_ops[0], v))
2042                     return false;
2043                 instr->_ops[0]->store = store_value;
2044                 vec_push(b->instr, prevjump);
2045                 b->final = true;
2046             }
2047         }
2048         ir_instr_delete(instr);
2049     }
2050     return true;
2051 }
2052
2053 /***********************************************************************
2054  *IR Temp allocation code
2055  * Propagating value life ranges by walking through the function backwards
2056  * until no more changes are made.
2057  * In theory this should happen once more than once for every nested loop
2058  * level.
2059  * Though this implementation might run an additional time for if nests.
2060  */
2061
2062 /* Enumerate instructions used by value's life-ranges
2063  */
2064 static void ir_block_enumerate(ir_block *self, size_t *_eid)
2065 {
2066     size_t i;
2067     size_t eid = *_eid;
2068     for (i = 0; i < vec_size(self->instr); ++i)
2069     {
2070         self->instr[i]->eid = eid++;
2071     }
2072     *_eid = eid;
2073 }
2074
2075 /* Enumerate blocks and instructions.
2076  * The block-enumeration is unordered!
2077  * We do not really use the block enumreation, however
2078  * the instruction enumeration is important for life-ranges.
2079  */
2080 void ir_function_enumerate(ir_function *self)
2081 {
2082     size_t i;
2083     size_t instruction_id = 0;
2084     for (i = 0; i < vec_size(self->blocks); ++i)
2085     {
2086         /* each block now gets an additional "entry" instruction id
2087          * we can use to avoid point-life issues
2088          */
2089         self->blocks[i]->entry_id = instruction_id;
2090         ++instruction_id;
2091
2092         self->blocks[i]->eid = i;
2093         ir_block_enumerate(self->blocks[i], &instruction_id);
2094     }
2095 }
2096
2097 /* Local-value allocator
2098  * After finishing creating the liferange of all values used in a function
2099  * we can allocate their global-positions.
2100  * This is the counterpart to register-allocation in register machines.
2101  */
2102 typedef struct {
2103     ir_value **locals;
2104     size_t    *sizes;
2105     size_t    *positions;
2106     bool      *unique;
2107 } function_allocator;
2108
2109 static bool function_allocator_alloc(function_allocator *alloc, ir_value *var)
2110 {
2111     ir_value *slot;
2112     size_t vsize = ir_value_sizeof(var);
2113
2114     var->code.local = vec_size(alloc->locals);
2115
2116     slot = ir_value_var("reg", store_global, var->vtype);
2117     if (!slot)
2118         return false;
2119
2120     if (!ir_value_life_merge_into(slot, var))
2121         goto localerror;
2122
2123     vec_push(alloc->locals, slot);
2124     vec_push(alloc->sizes, vsize);
2125     vec_push(alloc->unique, var->unique_life);
2126
2127     return true;
2128
2129 localerror:
2130     ir_value_delete(slot);
2131     return false;
2132 }
2133
2134 static bool ir_function_allocator_assign(ir_function *self, function_allocator *alloc, ir_value *v)
2135 {
2136     size_t a;
2137     ir_value *slot;
2138
2139     if (v->unique_life)
2140         return function_allocator_alloc(alloc, v);
2141
2142     for (a = 0; a < vec_size(alloc->locals); ++a)
2143     {
2144         /* if it's reserved for a unique liferange: skip */
2145         if (alloc->unique[a])
2146             continue;
2147
2148         slot = alloc->locals[a];
2149
2150         /* never resize parameters
2151          * will be required later when overlapping temps + locals
2152          */
2153         if (a < vec_size(self->params) &&
2154             alloc->sizes[a] < ir_value_sizeof(v))
2155         {
2156             continue;
2157         }
2158
2159         if (ir_values_overlap(v, slot))
2160             continue;
2161
2162         if (!ir_value_life_merge_into(slot, v))
2163             return false;
2164
2165         /* adjust size for this slot */
2166         if (alloc->sizes[a] < ir_value_sizeof(v))
2167             alloc->sizes[a] = ir_value_sizeof(v);
2168
2169         v->code.local = a;
2170         return true;
2171     }
2172     if (a >= vec_size(alloc->locals)) {
2173         if (!function_allocator_alloc(alloc, v))
2174             return false;
2175     }
2176     return true;
2177 }
2178
2179 bool ir_function_allocate_locals(ir_function *self)
2180 {
2181     size_t i;
2182     bool   retval = true;
2183     size_t pos;
2184     bool   opt_gt = OPTS_OPTIMIZATION(OPTIM_GLOBAL_TEMPS);
2185
2186     ir_value *v;
2187
2188     function_allocator lockalloc, globalloc;
2189
2190     if (!vec_size(self->locals) && !vec_size(self->values))
2191         return true;
2192
2193     globalloc.locals    = NULL;
2194     globalloc.sizes     = NULL;
2195     globalloc.positions = NULL;
2196     globalloc.unique    = NULL;
2197     lockalloc.locals    = NULL;
2198     lockalloc.sizes     = NULL;
2199     lockalloc.positions = NULL;
2200     lockalloc.unique    = NULL;
2201
2202     for (i = 0; i < vec_size(self->locals); ++i)
2203     {
2204         v = self->locals[i];
2205         if ((self->flags & IR_FLAG_MASK_NO_LOCAL_TEMPS) || !OPTS_OPTIMIZATION(OPTIM_LOCAL_TEMPS)) {
2206             v->locked      = true;
2207             v->unique_life = true;
2208         }
2209         else if (i >= vec_size(self->params))
2210             break;
2211         else
2212             v->locked = true; /* lock parameters locals */
2213         if (!function_allocator_alloc((v->locked || !opt_gt ? &lockalloc : &globalloc), v))
2214             goto error;
2215     }
2216     for (; i < vec_size(self->locals); ++i)
2217     {
2218         v = self->locals[i];
2219         if (!vec_size(v->life))
2220             continue;
2221         if (!ir_function_allocator_assign(self, (v->locked || !opt_gt ? &lockalloc : &globalloc), v))
2222             goto error;
2223     }
2224
2225     /* Allocate a slot for any value that still exists */
2226     for (i = 0; i < vec_size(self->values); ++i)
2227     {
2228         v = self->values[i];
2229
2230         if (!vec_size(v->life))
2231             continue;
2232
2233         /* CALL optimization:
2234          * If the value is a parameter-temp: 1 write, 1 read from a CALL
2235          * and it's not "locked", write it to the OFS_PARM directly.
2236          */
2237         if (OPTS_OPTIMIZATION(OPTIM_CALL_STORES) && !v->locked && !v->unique_life) {
2238             if (vec_size(v->reads) == 1 && vec_size(v->writes) == 1 &&
2239                 (v->reads[0]->opcode == VINSTR_NRCALL ||
2240                  (v->reads[0]->opcode >= INSTR_CALL0 && v->reads[0]->opcode <= INSTR_CALL8)
2241                 )
2242                )
2243             {
2244                 size_t    param;
2245                 ir_instr *call = v->reads[0];
2246                 if (!vec_ir_value_find(call->params, v, &param)) {
2247                     irerror(call->context, "internal error: unlocked parameter %s not found", v->name);
2248                     goto error;
2249                 }
2250                 ++opts_optimizationcount[OPTIM_CALL_STORES];
2251                 v->callparam = true;
2252                 if (param < 8)
2253                     ir_value_code_setaddr(v, OFS_PARM0 + 3*param);
2254                 else {
2255                     size_t nprotos = vec_size(self->owner->extparam_protos);
2256                     ir_value *ep;
2257                     param -= 8;
2258                     if (nprotos > param)
2259                         ep = self->owner->extparam_protos[param];
2260                     else
2261                     {
2262                         ep = ir_gen_extparam_proto(self->owner);
2263                         while (++nprotos <= param)
2264                             ep = ir_gen_extparam_proto(self->owner);
2265                     }
2266                     ir_instr_op(v->writes[0], 0, ep, true);
2267                     call->params[param+8] = ep;
2268                 }
2269                 continue;
2270             }
2271             if (vec_size(v->writes) == 1 && v->writes[0]->opcode == INSTR_CALL0)
2272             {
2273                 v->store = store_return;
2274                 if (v->members[0]) v->members[0]->store = store_return;
2275                 if (v->members[1]) v->members[1]->store = store_return;
2276                 if (v->members[2]) v->members[2]->store = store_return;
2277                 ++opts_optimizationcount[OPTIM_CALL_STORES];
2278                 continue;
2279             }
2280         }
2281
2282         if (!ir_function_allocator_assign(self, (v->locked || !opt_gt ? &lockalloc : &globalloc), v))
2283             goto error;
2284     }
2285
2286     if (!lockalloc.sizes && !globalloc.sizes) {
2287         goto cleanup;
2288     }
2289     vec_push(lockalloc.positions, 0);
2290     vec_push(globalloc.positions, 0);
2291
2292     /* Adjust slot positions based on sizes */
2293     if (lockalloc.sizes) {
2294         pos = (vec_size(lockalloc.sizes) ? lockalloc.positions[0] : 0);
2295         for (i = 1; i < vec_size(lockalloc.sizes); ++i)
2296         {
2297             pos = lockalloc.positions[i-1] + lockalloc.sizes[i-1];
2298             vec_push(lockalloc.positions, pos);
2299         }
2300         self->allocated_locals = pos + vec_last(lockalloc.sizes);
2301     }
2302     if (globalloc.sizes) {
2303         pos = (vec_size(globalloc.sizes) ? globalloc.positions[0] : 0);
2304         for (i = 1; i < vec_size(globalloc.sizes); ++i)
2305         {
2306             pos = globalloc.positions[i-1] + globalloc.sizes[i-1];
2307             vec_push(globalloc.positions, pos);
2308         }
2309         self->globaltemps = pos + vec_last(globalloc.sizes);
2310     }
2311
2312     /* Locals need to know their new position */
2313     for (i = 0; i < vec_size(self->locals); ++i) {
2314         v = self->locals[i];
2315         if (v->locked || !opt_gt)
2316             v->code.local = lockalloc.positions[v->code.local];
2317         else
2318             v->code.local = globalloc.positions[v->code.local];
2319     }
2320     /* Take over the actual slot positions on values */
2321     for (i = 0; i < vec_size(self->values); ++i) {
2322         v = self->values[i];
2323         if (v->locked || !opt_gt)
2324             v->code.local = lockalloc.positions[v->code.local];
2325         else
2326             v->code.local = globalloc.positions[v->code.local];
2327     }
2328
2329     goto cleanup;
2330
2331 error:
2332     retval = false;
2333 cleanup:
2334     for (i = 0; i < vec_size(lockalloc.locals); ++i)
2335         ir_value_delete(lockalloc.locals[i]);
2336     for (i = 0; i < vec_size(globalloc.locals); ++i)
2337         ir_value_delete(globalloc.locals[i]);
2338     vec_free(globalloc.unique);
2339     vec_free(globalloc.locals);
2340     vec_free(globalloc.sizes);
2341     vec_free(globalloc.positions);
2342     vec_free(lockalloc.unique);
2343     vec_free(lockalloc.locals);
2344     vec_free(lockalloc.sizes);
2345     vec_free(lockalloc.positions);
2346     return retval;
2347 }
2348
2349 /* Get information about which operand
2350  * is read from, or written to.
2351  */
2352 static void ir_op_read_write(int op, size_t *read, size_t *write)
2353 {
2354     switch (op)
2355     {
2356     case VINSTR_JUMP:
2357     case INSTR_GOTO:
2358         *write = 0;
2359         *read = 0;
2360         break;
2361     case INSTR_IF:
2362     case INSTR_IFNOT:
2363 #if 0
2364     case INSTR_IF_S:
2365     case INSTR_IFNOT_S:
2366 #endif
2367     case INSTR_RETURN:
2368     case VINSTR_COND:
2369         *write = 0;
2370         *read = 1;
2371         break;
2372     case INSTR_STOREP_F:
2373     case INSTR_STOREP_V:
2374     case INSTR_STOREP_S:
2375     case INSTR_STOREP_ENT:
2376     case INSTR_STOREP_FLD:
2377     case INSTR_STOREP_FNC:
2378         *write = 0;
2379         *read  = 7;
2380         break;
2381     default:
2382         *write = 1;
2383         *read = 6;
2384         break;
2385     };
2386 }
2387
2388 static bool ir_block_living_add_instr(ir_block *self, size_t eid)
2389 {
2390     size_t       i;
2391     const size_t vs = vec_size(self->living);
2392     bool         changed = false;
2393     for (i = 0; i != vs; ++i)
2394     {
2395         if (ir_value_life_merge(self->living[i], eid))
2396             changed = true;
2397     }
2398     return changed;
2399 }
2400
2401 static bool ir_block_living_lock(ir_block *self)
2402 {
2403     size_t i;
2404     bool changed = false;
2405     for (i = 0; i != vec_size(self->living); ++i)
2406     {
2407         if (!self->living[i]->locked) {
2408             self->living[i]->locked = true;
2409             changed = true;
2410         }
2411     }
2412     return changed;
2413 }
2414
2415 static bool ir_block_life_propagate(ir_block *self, bool *changed)
2416 {
2417     ir_instr *instr;
2418     ir_value *value;
2419     size_t i, o, p, mem, cnt;
2420     /* bitmasks which operands are read from or written to */
2421     size_t read, write;
2422     char dbg_ind[16];
2423     dbg_ind[0] = '#';
2424     dbg_ind[1] = '0';
2425     (void)dbg_ind;
2426
2427     vec_free(self->living);
2428
2429     p = vec_size(self->exits);
2430     for (i = 0; i < p; ++i) {
2431         ir_block *prev = self->exits[i];
2432         cnt = vec_size(prev->living);
2433         for (o = 0; o < cnt; ++o) {
2434             if (!vec_ir_value_find(self->living, prev->living[o], NULL))
2435                 vec_push(self->living, prev->living[o]);
2436         }
2437     }
2438
2439     i = vec_size(self->instr);
2440     while (i)
2441     { --i;
2442         instr = self->instr[i];
2443
2444         /* See which operands are read and write operands */
2445         ir_op_read_write(instr->opcode, &read, &write);
2446
2447         /* Go through the 3 main operands
2448          * writes first, then reads
2449          */
2450         for (o = 0; o < 3; ++o)
2451         {
2452             if (!instr->_ops[o]) /* no such operand */
2453                 continue;
2454
2455             value = instr->_ops[o];
2456
2457             /* We only care about locals */
2458             /* we also calculate parameter liferanges so that locals
2459              * can take up parameter slots */
2460             if (value->store != store_value &&
2461                 value->store != store_local &&
2462                 value->store != store_param)
2463                 continue;
2464
2465             /* write operands */
2466             /* When we write to a local, we consider it "dead" for the
2467              * remaining upper part of the function, since in SSA a value
2468              * can only be written once (== created)
2469              */
2470             if (write & (1<<o))
2471             {
2472                 size_t idx;
2473                 bool in_living = vec_ir_value_find(self->living, value, &idx);
2474                 if (!in_living)
2475                 {
2476                     /* If the value isn't alive it hasn't been read before... */
2477                     /* TODO: See if the warning can be emitted during parsing or AST processing
2478                      * otherwise have warning printed here.
2479                      * IF printing a warning here: include filecontext_t,
2480                      * and make sure it's only printed once
2481                      * since this function is run multiple times.
2482                      */
2483                     /* con_err( "Value only written %s\n", value->name); */
2484                     if (ir_value_life_merge(value, instr->eid))
2485                         *changed = true;
2486                 } else {
2487                     /* since 'living' won't contain it
2488                      * anymore, merge the value, since
2489                      * (A) doesn't.
2490                      */
2491                     if (ir_value_life_merge(value, instr->eid))
2492                         *changed = true;
2493                     /* Then remove */
2494                     vec_remove(self->living, idx, 1);
2495                 }
2496                 /* Removing a vector removes all members */
2497                 for (mem = 0; mem < 3; ++mem) {
2498                     if (value->members[mem] && vec_ir_value_find(self->living, value->members[mem], &idx)) {
2499                         if (ir_value_life_merge(value->members[mem], instr->eid))
2500                             *changed = true;
2501                         vec_remove(self->living, idx, 1);
2502                     }
2503                 }
2504                 /* Removing the last member removes the vector */
2505                 if (value->memberof) {
2506                     value = value->memberof;
2507                     for (mem = 0; mem < 3; ++mem) {
2508                         if (value->members[mem] && vec_ir_value_find(self->living, value->members[mem], NULL))
2509                             break;
2510                     }
2511                     if (mem == 3 && vec_ir_value_find(self->living, value, &idx)) {
2512                         if (ir_value_life_merge(value, instr->eid))
2513                             *changed = true;
2514                         vec_remove(self->living, idx, 1);
2515                     }
2516                 }
2517             }
2518         }
2519
2520         /* These operations need a special case as they can break when using
2521          * same source and destination operand otherwise, as the engine may
2522          * read the source multiple times. */
2523         if (instr->opcode == INSTR_MUL_VF ||
2524             instr->opcode == VINSTR_BITAND_VF ||
2525             instr->opcode == VINSTR_BITOR_VF ||
2526             instr->opcode == VINSTR_BITXOR ||
2527             instr->opcode == VINSTR_BITXOR_VF ||
2528             instr->opcode == VINSTR_BITXOR_V ||
2529             instr->opcode == VINSTR_CROSS)
2530         {
2531             value = instr->_ops[2];
2532             /* the float source will get an additional lifetime */
2533             if (ir_value_life_merge(value, instr->eid+1))
2534                 *changed = true;
2535             if (value->memberof && ir_value_life_merge(value->memberof, instr->eid+1))
2536                 *changed = true;
2537         }
2538
2539         if (instr->opcode == INSTR_MUL_FV ||
2540             instr->opcode == INSTR_LOAD_V ||
2541             instr->opcode == VINSTR_BITXOR ||
2542             instr->opcode == VINSTR_BITXOR_VF ||
2543             instr->opcode == VINSTR_BITXOR_V ||
2544             instr->opcode == VINSTR_CROSS)
2545         {
2546             value = instr->_ops[1];
2547             /* the float source will get an additional lifetime */
2548             if (ir_value_life_merge(value, instr->eid+1))
2549                 *changed = true;
2550             if (value->memberof && ir_value_life_merge(value->memberof, instr->eid+1))
2551                 *changed = true;
2552         }
2553
2554         for (o = 0; o < 3; ++o)
2555         {
2556             if (!instr->_ops[o]) /* no such operand */
2557                 continue;
2558
2559             value = instr->_ops[o];
2560
2561             /* We only care about locals */
2562             /* we also calculate parameter liferanges so that locals
2563              * can take up parameter slots */
2564             if (value->store != store_value &&
2565                 value->store != store_local &&
2566                 value->store != store_param)
2567                 continue;
2568
2569             /* read operands */
2570             if (read & (1<<o))
2571             {
2572                 if (!vec_ir_value_find(self->living, value, NULL))
2573                     vec_push(self->living, value);
2574                 /* reading adds the full vector */
2575                 if (value->memberof && !vec_ir_value_find(self->living, value->memberof, NULL))
2576                     vec_push(self->living, value->memberof);
2577                 for (mem = 0; mem < 3; ++mem) {
2578                     if (value->members[mem] && !vec_ir_value_find(self->living, value->members[mem], NULL))
2579                         vec_push(self->living, value->members[mem]);
2580                 }
2581             }
2582         }
2583         /* PHI operands are always read operands */
2584         for (p = 0; p < vec_size(instr->phi); ++p)
2585         {
2586             value = instr->phi[p].value;
2587             if (!vec_ir_value_find(self->living, value, NULL))
2588                 vec_push(self->living, value);
2589             /* reading adds the full vector */
2590             if (value->memberof && !vec_ir_value_find(self->living, value->memberof, NULL))
2591                 vec_push(self->living, value->memberof);
2592             for (mem = 0; mem < 3; ++mem) {
2593                 if (value->members[mem] && !vec_ir_value_find(self->living, value->members[mem], NULL))
2594                     vec_push(self->living, value->members[mem]);
2595             }
2596         }
2597
2598         /* on a call, all these values must be "locked" */
2599         if (instr->opcode >= INSTR_CALL0 && instr->opcode <= INSTR_CALL8) {
2600             if (ir_block_living_lock(self))
2601                 *changed = true;
2602         }
2603         /* call params are read operands too */
2604         for (p = 0; p < vec_size(instr->params); ++p)
2605         {
2606             value = instr->params[p];
2607             if (!vec_ir_value_find(self->living, value, NULL))
2608                 vec_push(self->living, value);
2609             /* reading adds the full vector */
2610             if (value->memberof && !vec_ir_value_find(self->living, value->memberof, NULL))
2611                 vec_push(self->living, value->memberof);
2612             for (mem = 0; mem < 3; ++mem) {
2613                 if (value->members[mem] && !vec_ir_value_find(self->living, value->members[mem], NULL))
2614                     vec_push(self->living, value->members[mem]);
2615             }
2616         }
2617
2618         /* (A) */
2619         if (ir_block_living_add_instr(self, instr->eid))
2620             *changed = true;
2621     }
2622     /* the "entry" instruction ID */
2623     if (ir_block_living_add_instr(self, self->entry_id))
2624         *changed = true;
2625
2626     return true;
2627 }
2628
2629 bool ir_function_calculate_liferanges(ir_function *self)
2630 {
2631     size_t i, s;
2632     bool changed;
2633
2634     /* parameters live at 0 */
2635     for (i = 0; i < vec_size(self->params); ++i)
2636         if (!ir_value_life_merge(self->locals[i], 0))
2637             compile_error(self->context, "internal error: failed value-life merging");
2638
2639     do {
2640         self->run_id++;
2641         changed = false;
2642         i = vec_size(self->blocks);
2643         while (i--) {
2644             ir_block_life_propagate(self->blocks[i], &changed);
2645         }
2646     } while (changed);
2647
2648     if (vec_size(self->blocks)) {
2649         ir_block *block = self->blocks[0];
2650         for (i = 0; i < vec_size(block->living); ++i) {
2651             ir_value *v = block->living[i];
2652             if (v->store != store_local)
2653                 continue;
2654             if (v->vtype == TYPE_VECTOR)
2655                 continue;
2656             self->flags |= IR_FLAG_HAS_UNINITIALIZED;
2657             /* find the instruction reading from it */
2658             for (s = 0; s < vec_size(v->reads); ++s) {
2659                 if (v->reads[s]->eid == v->life[0].end)
2660                     break;
2661             }
2662             if (s < vec_size(v->reads)) {
2663                 if (irwarning(v->context, WARN_USED_UNINITIALIZED,
2664                               "variable `%s` may be used uninitialized in this function\n"
2665                               " -> %s:%i",
2666                               v->name,
2667                               v->reads[s]->context.file, v->reads[s]->context.line)
2668                    )
2669                 {
2670                     return false;
2671                 }
2672                 continue;
2673             }
2674             if (v->memberof) {
2675                 ir_value *vec = v->memberof;
2676                 for (s = 0; s < vec_size(vec->reads); ++s) {
2677                     if (vec->reads[s]->eid == v->life[0].end)
2678                         break;
2679                 }
2680                 if (s < vec_size(vec->reads)) {
2681                     if (irwarning(v->context, WARN_USED_UNINITIALIZED,
2682                                   "variable `%s` may be used uninitialized in this function\n"
2683                                   " -> %s:%i",
2684                                   v->name,
2685                                   vec->reads[s]->context.file, vec->reads[s]->context.line)
2686                        )
2687                     {
2688                         return false;
2689                     }
2690                     continue;
2691                 }
2692             }
2693             if (irwarning(v->context, WARN_USED_UNINITIALIZED,
2694                           "variable `%s` may be used uninitialized in this function", v->name))
2695             {
2696                 return false;
2697             }
2698         }
2699     }
2700     return true;
2701 }
2702
2703 /***********************************************************************
2704  *IR Code-Generation
2705  *
2706  * Since the IR has the convention of putting 'write' operands
2707  * at the beginning, we have to rotate the operands of instructions
2708  * properly in order to generate valid QCVM code.
2709  *
2710  * Having destinations at a fixed position is more convenient. In QC
2711  * this is *mostly* OPC,  but FTE adds at least 2 instructions which
2712  * read from from OPA,  and store to OPB rather than OPC.   Which is
2713  * partially the reason why the implementation of these instructions
2714  * in darkplaces has been delayed for so long.
2715  *
2716  * Breaking conventions is annoying...
2717  */
2718 static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool islocal);
2719
2720 static bool gen_global_field(code_t *code, ir_value *global)
2721 {
2722     if (global->hasvalue)
2723     {
2724         ir_value *fld = global->constval.vpointer;
2725         if (!fld) {
2726             irerror(global->context, "Invalid field constant with no field: %s", global->name);
2727             return false;
2728         }
2729
2730         /* copy the field's value */
2731         ir_value_code_setaddr(global, vec_size(code->globals));
2732         vec_push(code->globals, fld->code.fieldaddr);
2733         if (global->fieldtype == TYPE_VECTOR) {
2734             vec_push(code->globals, fld->code.fieldaddr+1);
2735             vec_push(code->globals, fld->code.fieldaddr+2);
2736         }
2737     }
2738     else
2739     {
2740         ir_value_code_setaddr(global, vec_size(code->globals));
2741         vec_push(code->globals, 0);
2742         if (global->fieldtype == TYPE_VECTOR) {
2743             vec_push(code->globals, 0);
2744             vec_push(code->globals, 0);
2745         }
2746     }
2747     if (global->code.globaladdr < 0)
2748         return false;
2749     return true;
2750 }
2751
2752 static bool gen_global_pointer(code_t *code, ir_value *global)
2753 {
2754     if (global->hasvalue)
2755     {
2756         ir_value *target = global->constval.vpointer;
2757         if (!target) {
2758             irerror(global->context, "Invalid pointer constant: %s", global->name);
2759             /* NULL pointers are pointing to the NULL constant, which also
2760              * sits at address 0, but still has an ir_value for itself.
2761              */
2762             return false;
2763         }
2764
2765         /* Here, relocations ARE possible - in fteqcc-enhanced-qc:
2766          * void() foo; <- proto
2767          * void() *fooptr = &foo;
2768          * void() foo = { code }
2769          */
2770         if (!target->code.globaladdr) {
2771             /* FIXME: Check for the constant nullptr ir_value!
2772              * because then code.globaladdr being 0 is valid.
2773              */
2774             irerror(global->context, "FIXME: Relocation support");
2775             return false;
2776         }
2777
2778         ir_value_code_setaddr(global, vec_size(code->globals));
2779         vec_push(code->globals, target->code.globaladdr);
2780     }
2781     else
2782     {
2783         ir_value_code_setaddr(global, vec_size(code->globals));
2784         vec_push(code->globals, 0);
2785     }
2786     if (global->code.globaladdr < 0)
2787         return false;
2788     return true;
2789 }
2790
2791 static bool gen_blocks_recursive(code_t *code, ir_function *func, ir_block *block)
2792 {
2793     prog_section_statement_t stmt;
2794     ir_instr *instr;
2795     ir_block *target;
2796     ir_block *ontrue;
2797     ir_block *onfalse;
2798     size_t    stidx;
2799     size_t    i;
2800     int       j;
2801
2802     block->generated = true;
2803     block->code_start = vec_size(code->statements);
2804     for (i = 0; i < vec_size(block->instr); ++i)
2805     {
2806         instr = block->instr[i];
2807
2808         if (instr->opcode == VINSTR_PHI) {
2809             irerror(block->context, "cannot generate virtual instruction (phi)");
2810             return false;
2811         }
2812
2813         if (instr->opcode == VINSTR_JUMP) {
2814             target = instr->bops[0];
2815             /* for uncoditional jumps, if the target hasn't been generated
2816              * yet, we generate them right here.
2817              */
2818             if (!target->generated)
2819                 return gen_blocks_recursive(code, func, target);
2820
2821             /* otherwise we generate a jump instruction */
2822             stmt.opcode = INSTR_GOTO;
2823             stmt.o1.s1 = (target->code_start) - vec_size(code->statements);
2824             stmt.o2.s1 = 0;
2825             stmt.o3.s1 = 0;
2826             if (stmt.o1.s1 != 1)
2827                 code_push_statement(code, &stmt, instr->context);
2828
2829             /* no further instructions can be in this block */
2830             return true;
2831         }
2832
2833         if (instr->opcode == VINSTR_BITXOR) {
2834             stmt.opcode = INSTR_BITOR;
2835             stmt.o1.s1 = ir_value_code_addr(instr->_ops[1]);
2836             stmt.o2.s1 = ir_value_code_addr(instr->_ops[2]);
2837             stmt.o3.s1 = ir_value_code_addr(instr->_ops[0]);
2838             code_push_statement(code, &stmt, instr->context);
2839             stmt.opcode = INSTR_BITAND;
2840             stmt.o1.s1 = ir_value_code_addr(instr->_ops[1]);
2841             stmt.o2.s1 = ir_value_code_addr(instr->_ops[2]);
2842             stmt.o3.s1 = ir_value_code_addr(func->owner->vinstr_temp[0]);
2843             code_push_statement(code, &stmt, instr->context);
2844             stmt.opcode = INSTR_SUB_F;
2845             stmt.o1.s1 = ir_value_code_addr(instr->_ops[0]);
2846             stmt.o2.s1 = ir_value_code_addr(func->owner->vinstr_temp[0]);
2847             stmt.o3.s1 = ir_value_code_addr(instr->_ops[0]);
2848             code_push_statement(code, &stmt, instr->context);
2849
2850             /* instruction generated */
2851             continue;
2852         }
2853
2854         if (instr->opcode == VINSTR_BITAND_V) {
2855             stmt.opcode = INSTR_BITAND;
2856             stmt.o1.s1 = ir_value_code_addr(instr->_ops[1]);
2857             stmt.o2.s1 = ir_value_code_addr(instr->_ops[2]);
2858             stmt.o3.s1 = ir_value_code_addr(instr->_ops[0]);
2859             code_push_statement(code, &stmt, instr->context);
2860             ++stmt.o1.s1;
2861             ++stmt.o2.s1;
2862             ++stmt.o3.s1;
2863             code_push_statement(code, &stmt, instr->context);
2864             ++stmt.o1.s1;
2865             ++stmt.o2.s1;
2866             ++stmt.o3.s1;
2867             code_push_statement(code, &stmt, instr->context);
2868
2869             /* instruction generated */
2870             continue;
2871         }
2872
2873         if (instr->opcode == VINSTR_BITOR_V) {
2874             stmt.opcode = INSTR_BITOR;
2875             stmt.o1.s1 = ir_value_code_addr(instr->_ops[1]);
2876             stmt.o2.s1 = ir_value_code_addr(instr->_ops[2]);
2877             stmt.o3.s1 = ir_value_code_addr(instr->_ops[0]);
2878             code_push_statement(code, &stmt, instr->context);
2879             ++stmt.o1.s1;
2880             ++stmt.o2.s1;
2881             ++stmt.o3.s1;
2882             code_push_statement(code, &stmt, instr->context);
2883             ++stmt.o1.s1;
2884             ++stmt.o2.s1;
2885             ++stmt.o3.s1;
2886             code_push_statement(code, &stmt, instr->context);
2887
2888             /* instruction generated */
2889             continue;
2890         }
2891
2892         if (instr->opcode == VINSTR_BITXOR_V) {
2893             for (j = 0; j < 3; ++j) {
2894                 stmt.opcode = INSTR_BITOR;
2895                 stmt.o1.s1 = ir_value_code_addr(instr->_ops[1]) + j;
2896                 stmt.o2.s1 = ir_value_code_addr(instr->_ops[2]) + j;
2897                 stmt.o3.s1 = ir_value_code_addr(instr->_ops[0]) + j;
2898                 code_push_statement(code, &stmt, instr->context);
2899                 stmt.opcode = INSTR_BITAND;
2900                 stmt.o1.s1 = ir_value_code_addr(instr->_ops[1]) + j;
2901                 stmt.o2.s1 = ir_value_code_addr(instr->_ops[2]) + j;
2902                 stmt.o3.s1 = ir_value_code_addr(func->owner->vinstr_temp[0]) + j;
2903                 code_push_statement(code, &stmt, instr->context);
2904             }
2905             stmt.opcode = INSTR_SUB_V;
2906             stmt.o1.s1 = ir_value_code_addr(instr->_ops[0]);
2907             stmt.o2.s1 = ir_value_code_addr(func->owner->vinstr_temp[0]);
2908             stmt.o3.s1 = ir_value_code_addr(instr->_ops[0]);
2909             code_push_statement(code, &stmt, instr->context);
2910
2911             /* instruction generated */
2912             continue;
2913         }
2914
2915         if (instr->opcode == VINSTR_BITAND_VF) {
2916             stmt.opcode = INSTR_BITAND;
2917             stmt.o1.s1 = ir_value_code_addr(instr->_ops[1]);
2918             stmt.o2.s1 = ir_value_code_addr(instr->_ops[2]);
2919             stmt.o3.s1 = ir_value_code_addr(instr->_ops[0]);
2920             code_push_statement(code, &stmt, instr->context);
2921             ++stmt.o1.s1;
2922             ++stmt.o3.s1;
2923             code_push_statement(code, &stmt, instr->context);
2924             ++stmt.o1.s1;
2925             ++stmt.o3.s1;
2926             code_push_statement(code, &stmt, instr->context);
2927
2928             /* instruction generated */
2929             continue;
2930         }
2931
2932         if (instr->opcode == VINSTR_BITOR_VF) {
2933             stmt.opcode = INSTR_BITOR;
2934             stmt.o1.s1 = ir_value_code_addr(instr->_ops[1]);
2935             stmt.o2.s1 = ir_value_code_addr(instr->_ops[2]);
2936             stmt.o3.s1 = ir_value_code_addr(instr->_ops[0]);
2937             code_push_statement(code, &stmt, instr->context);
2938             ++stmt.o1.s1;
2939             ++stmt.o3.s1;
2940             code_push_statement(code, &stmt, instr->context);
2941             ++stmt.o1.s1;
2942             ++stmt.o3.s1;
2943             code_push_statement(code, &stmt, instr->context);
2944
2945             /* instruction generated */
2946             continue;
2947         }
2948
2949         if (instr->opcode == VINSTR_BITXOR_VF) {
2950             for (j = 0; j < 3; ++j) {
2951                 stmt.opcode = INSTR_BITOR;
2952                 stmt.o1.s1 = ir_value_code_addr(instr->_ops[1]) + j;
2953                 stmt.o2.s1 = ir_value_code_addr(instr->_ops[2]);
2954                 stmt.o3.s1 = ir_value_code_addr(instr->_ops[0]) + j;
2955                 code_push_statement(code, &stmt, instr->context);
2956                 stmt.opcode = INSTR_BITAND;
2957                 stmt.o1.s1 = ir_value_code_addr(instr->_ops[1]) + j;
2958                 stmt.o2.s1 = ir_value_code_addr(instr->_ops[2]);
2959                 stmt.o3.s1 = ir_value_code_addr(func->owner->vinstr_temp[0]) + j;
2960                 code_push_statement(code, &stmt, instr->context);
2961             }
2962             stmt.opcode = INSTR_SUB_V;
2963             stmt.o1.s1 = ir_value_code_addr(instr->_ops[0]);
2964             stmt.o2.s1 = ir_value_code_addr(func->owner->vinstr_temp[0]);
2965             stmt.o3.s1 = ir_value_code_addr(instr->_ops[0]);
2966             code_push_statement(code, &stmt, instr->context);
2967
2968             /* instruction generated */
2969             continue;
2970         }
2971
2972         if (instr->opcode == VINSTR_CROSS) {
2973             stmt.opcode = INSTR_MUL_F;
2974             for (j = 0; j < 3; ++j) {
2975                 stmt.o1.s1 = ir_value_code_addr(instr->_ops[1]) + (j + 1) % 3;
2976                 stmt.o2.s1 = ir_value_code_addr(instr->_ops[2]) + (j + 2) % 3;
2977                 stmt.o3.s1 = ir_value_code_addr(instr->_ops[0]) + j;
2978                 code_push_statement(code, &stmt, instr->context);
2979                 stmt.o1.s1 = ir_value_code_addr(instr->_ops[1]) + (j + 2) % 3;
2980                 stmt.o2.s1 = ir_value_code_addr(instr->_ops[2]) + (j + 1) % 3;
2981                 stmt.o3.s1 = ir_value_code_addr(func->owner->vinstr_temp[0]) + j;
2982                 code_push_statement(code, &stmt, instr->context);
2983             }
2984             stmt.opcode = INSTR_SUB_V;
2985             stmt.o1.s1 = ir_value_code_addr(instr->_ops[0]);
2986             stmt.o2.s1 = ir_value_code_addr(func->owner->vinstr_temp[0]);
2987             stmt.o3.s1 = ir_value_code_addr(instr->_ops[0]);
2988             code_push_statement(code, &stmt, instr->context);
2989
2990             /* instruction generated */
2991             continue;
2992         }
2993
2994         if (instr->opcode == VINSTR_COND) {
2995             ontrue  = instr->bops[0];
2996             onfalse = instr->bops[1];
2997             /* TODO: have the AST signal which block should
2998              * come first: eg. optimize IFs without ELSE...
2999              */
3000
3001             stmt.o1.u1 = ir_value_code_addr(instr->_ops[0]);
3002             stmt.o2.u1 = 0;
3003             stmt.o3.s1 = 0;
3004
3005             if (ontrue->generated) {
3006                 stmt.opcode = INSTR_IF;
3007                 stmt.o2.s1 = (ontrue->code_start) - vec_size(code->statements);
3008                 if (stmt.o2.s1 != 1)
3009                     code_push_statement(code, &stmt, instr->context);
3010             }
3011             if (onfalse->generated) {
3012                 stmt.opcode = INSTR_IFNOT;
3013                 stmt.o2.s1 = (onfalse->code_start) - vec_size(code->statements);
3014                 if (stmt.o2.s1 != 1)
3015                     code_push_statement(code, &stmt, instr->context);
3016             }
3017             if (!ontrue->generated) {
3018                 if (onfalse->generated)
3019                     return gen_blocks_recursive(code, func, ontrue);
3020             }
3021             if (!onfalse->generated) {
3022                 if (ontrue->generated)
3023                     return gen_blocks_recursive(code, func, onfalse);
3024             }
3025             /* neither ontrue nor onfalse exist */
3026             stmt.opcode = INSTR_IFNOT;
3027             if (!instr->likely) {
3028                 /* Honor the likelyhood hint */
3029                 ir_block *tmp = onfalse;
3030                 stmt.opcode = INSTR_IF;
3031                 onfalse = ontrue;
3032                 ontrue = tmp;
3033             }
3034             stidx = vec_size(code->statements);
3035             code_push_statement(code, &stmt, instr->context);
3036             /* on false we jump, so add ontrue-path */
3037             if (!gen_blocks_recursive(code, func, ontrue))
3038                 return false;
3039             /* fixup the jump address */
3040             code->statements[stidx].o2.s1 = vec_size(code->statements) - stidx;
3041             /* generate onfalse path */
3042             if (onfalse->generated) {
3043                 /* fixup the jump address */
3044                 code->statements[stidx].o2.s1 = (onfalse->code_start) - (stidx);
3045                 if (stidx+2 == vec_size(code->statements) && code->statements[stidx].o2.s1 == 1) {
3046                     code->statements[stidx] = code->statements[stidx+1];
3047                     if (code->statements[stidx].o1.s1 < 0)
3048                         code->statements[stidx].o1.s1++;
3049                     code_pop_statement(code);
3050                 }
3051                 stmt.opcode = vec_last(code->statements).opcode;
3052                 if (stmt.opcode == INSTR_GOTO ||
3053                     stmt.opcode == INSTR_IF ||
3054                     stmt.opcode == INSTR_IFNOT ||
3055                     stmt.opcode == INSTR_RETURN ||
3056                     stmt.opcode == INSTR_DONE)
3057                 {
3058                     /* no use jumping from here */
3059                     return true;
3060                 }
3061                 /* may have been generated in the previous recursive call */
3062                 stmt.opcode = INSTR_GOTO;
3063                 stmt.o1.s1 = (onfalse->code_start) - vec_size(code->statements);
3064                 stmt.o2.s1 = 0;
3065                 stmt.o3.s1 = 0;
3066                 if (stmt.o1.s1 != 1)
3067                     code_push_statement(code, &stmt, instr->context);
3068                 return true;
3069             }
3070             else if (stidx+2 == vec_size(code->statements) && code->statements[stidx].o2.s1 == 1) {
3071                 code->statements[stidx] = code->statements[stidx+1];
3072                 if (code->statements[stidx].o1.s1 < 0)
3073                     code->statements[stidx].o1.s1++;
3074                 code_pop_statement(code);
3075             }
3076             /* if not, generate now */
3077             return gen_blocks_recursive(code, func, onfalse);
3078         }
3079
3080         if ( (instr->opcode >= INSTR_CALL0 && instr->opcode <= INSTR_CALL8)
3081            || instr->opcode == VINSTR_NRCALL)
3082         {
3083             size_t p, first;
3084             ir_value *retvalue;
3085
3086             first = vec_size(instr->params);
3087             if (first > 8)
3088                 first = 8;
3089             for (p = 0; p < first; ++p)
3090             {
3091                 ir_value *param = instr->params[p];
3092                 if (param->callparam)
3093                     continue;
3094
3095                 stmt.opcode = INSTR_STORE_F;
3096                 stmt.o3.u1 = 0;
3097
3098                 if (param->vtype == TYPE_FIELD)
3099                     stmt.opcode = field_store_instr[param->fieldtype];
3100                 else if (param->vtype == TYPE_NIL)
3101                     stmt.opcode = INSTR_STORE_V;
3102                 else
3103                     stmt.opcode = type_store_instr[param->vtype];
3104                 stmt.o1.u1 = ir_value_code_addr(param);
3105                 stmt.o2.u1 = OFS_PARM0 + 3 * p;
3106                 code_push_statement(code, &stmt, instr->context);
3107             }
3108             /* Now handle extparams */
3109             first = vec_size(instr->params);
3110             for (; p < first; ++p)
3111             {
3112                 ir_builder *ir = func->owner;
3113                 ir_value *param = instr->params[p];
3114                 ir_value *targetparam;
3115
3116                 if (param->callparam)
3117                     continue;
3118
3119                 if (p-8 >= vec_size(ir->extparams))
3120                     ir_gen_extparam(ir);
3121
3122                 targetparam = ir->extparams[p-8];
3123
3124                 stmt.opcode = INSTR_STORE_F;
3125                 stmt.o3.u1 = 0;
3126
3127                 if (param->vtype == TYPE_FIELD)
3128                     stmt.opcode = field_store_instr[param->fieldtype];
3129                 else if (param->vtype == TYPE_NIL)
3130                     stmt.opcode = INSTR_STORE_V;
3131                 else
3132                     stmt.opcode = type_store_instr[param->vtype];
3133                 stmt.o1.u1 = ir_value_code_addr(param);
3134                 stmt.o2.u1 = ir_value_code_addr(targetparam);
3135                 code_push_statement(code, &stmt, instr->context);
3136             }
3137
3138             stmt.opcode = INSTR_CALL0 + vec_size(instr->params);
3139             if (stmt.opcode > INSTR_CALL8)
3140                 stmt.opcode = INSTR_CALL8;
3141             stmt.o1.u1 = ir_value_code_addr(instr->_ops[1]);
3142             stmt.o2.u1 = 0;
3143             stmt.o3.u1 = 0;
3144             code_push_statement(code, &stmt, instr->context);
3145
3146             retvalue = instr->_ops[0];
3147             if (retvalue && retvalue->store != store_return &&
3148                 (retvalue->store == store_global || vec_size(retvalue->life)))
3149             {
3150                 /* not to be kept in OFS_RETURN */
3151                 if (retvalue->vtype == TYPE_FIELD && OPTS_FLAG(ADJUST_VECTOR_FIELDS))
3152                     stmt.opcode = field_store_instr[retvalue->fieldtype];
3153                 else
3154                     stmt.opcode = type_store_instr[retvalue->vtype];
3155                 stmt.o1.u1 = OFS_RETURN;
3156                 stmt.o2.u1 = ir_value_code_addr(retvalue);
3157                 stmt.o3.u1 = 0;
3158                 code_push_statement(code, &stmt, instr->context);
3159             }
3160             continue;
3161         }
3162
3163         if (instr->opcode == INSTR_STATE) {
3164             irerror(block->context, "TODO: state instruction");
3165             return false;
3166         }
3167
3168         stmt.opcode = instr->opcode;
3169         stmt.o1.u1 = 0;
3170         stmt.o2.u1 = 0;
3171         stmt.o3.u1 = 0;
3172
3173         /* This is the general order of operands */
3174         if (instr->_ops[0])
3175             stmt.o3.u1 = ir_value_code_addr(instr->_ops[0]);
3176
3177         if (instr->_ops[1])
3178             stmt.o1.u1 = ir_value_code_addr(instr->_ops[1]);
3179
3180         if (instr->_ops[2])
3181             stmt.o2.u1 = ir_value_code_addr(instr->_ops[2]);
3182
3183         if (stmt.opcode == INSTR_RETURN || stmt.opcode == INSTR_DONE)
3184         {
3185             stmt.o1.u1 = stmt.o3.u1;
3186             stmt.o3.u1 = 0;
3187         }
3188         else if ((stmt.opcode >= INSTR_STORE_F &&
3189                   stmt.opcode <= INSTR_STORE_FNC) ||
3190                  (stmt.opcode >= INSTR_STOREP_F &&
3191                   stmt.opcode <= INSTR_STOREP_FNC))
3192         {
3193             /* 2-operand instructions with A -> B */
3194             stmt.o2.u1 = stmt.o3.u1;
3195             stmt.o3.u1 = 0;
3196
3197             /* tiny optimization, don't output
3198              * STORE a, a
3199              */
3200             if (stmt.o2.u1 == stmt.o1.u1 &&
3201                 OPTS_OPTIMIZATION(OPTIM_PEEPHOLE))
3202             {
3203                 ++opts_optimizationcount[OPTIM_PEEPHOLE];
3204                 continue;
3205             }
3206         }
3207         code_push_statement(code, &stmt, instr->context);
3208     }
3209     return true;
3210 }
3211
3212 static bool gen_function_code(code_t *code, ir_function *self)
3213 {
3214     ir_block *block;
3215     prog_section_statement_t stmt, *retst;
3216
3217     /* Starting from entry point, we generate blocks "as they come"
3218      * for now. Dead blocks will not be translated obviously.
3219      */
3220     if (!vec_size(self->blocks)) {
3221         irerror(self->context, "Function '%s' declared without body.", self->name);
3222         return false;
3223     }
3224
3225     block = self->blocks[0];
3226     if (block->generated)
3227         return true;
3228
3229     if (!gen_blocks_recursive(code, self, block)) {
3230         irerror(self->context, "failed to generate blocks for '%s'", self->name);
3231         return false;
3232     }
3233
3234     /* code_write and qcvm -disasm need to know that the function ends here */
3235     retst = &vec_last(code->statements);
3236     if (OPTS_OPTIMIZATION(OPTIM_VOID_RETURN) &&
3237         self->outtype == TYPE_VOID &&
3238         retst->opcode == INSTR_RETURN &&
3239         !retst->o1.u1 && !retst->o2.u1 && !retst->o3.u1)
3240     {
3241         retst->opcode = INSTR_DONE;
3242         ++opts_optimizationcount[OPTIM_VOID_RETURN];
3243     } else {
3244         lex_ctx_t last;
3245
3246         stmt.opcode = INSTR_DONE;
3247         stmt.o1.u1  = 0;
3248         stmt.o2.u1  = 0;
3249         stmt.o3.u1  = 0;
3250         last.line   = vec_last(code->linenums);
3251         last.column = vec_last(code->columnnums);
3252
3253         code_push_statement(code, &stmt, last);
3254     }
3255     return true;
3256 }
3257
3258 static qcint_t ir_builder_filestring(ir_builder *ir, const char *filename)
3259 {
3260     /* NOTE: filename pointers are copied, we never strdup them,
3261      * thus we can use pointer-comparison to find the string.
3262      */
3263     size_t i;
3264     qcint_t  str;
3265
3266     for (i = 0; i < vec_size(ir->filenames); ++i) {
3267         if (ir->filenames[i] == filename)
3268             return ir->filestrings[i];
3269     }
3270
3271     str = code_genstring(ir->code, filename);
3272     vec_push(ir->filenames, filename);
3273     vec_push(ir->filestrings, str);
3274     return str;
3275 }
3276
3277 static bool gen_global_function(ir_builder *ir, ir_value *global)
3278 {
3279     prog_section_function_t fun;
3280     ir_function            *irfun;
3281
3282     size_t i;
3283
3284     if (!global->hasvalue || (!global->constval.vfunc))
3285     {
3286         irerror(global->context, "Invalid state of function-global: not constant: %s", global->name);
3287         return false;
3288     }
3289
3290     irfun = global->constval.vfunc;
3291
3292     fun.name    = global->code.name;
3293     fun.file    = ir_builder_filestring(ir, global->context.file);
3294     fun.profile = 0; /* always 0 */
3295     fun.nargs   = vec_size(irfun->params);
3296     if (fun.nargs > 8)
3297         fun.nargs = 8;
3298
3299     for (i = 0;i < 8; ++i) {
3300         if ((int32_t)i >= fun.nargs)
3301             fun.argsize[i] = 0;
3302         else
3303             fun.argsize[i] = type_sizeof_[irfun->params[i]];
3304     }
3305
3306     fun.firstlocal = 0;
3307     fun.locals     = irfun->allocated_locals;
3308
3309     if (irfun->builtin)
3310         fun.entry = irfun->builtin+1;
3311     else {
3312         irfun->code_function_def = vec_size(ir->code->functions);
3313         fun.entry                = vec_size(ir->code->statements);
3314     }
3315
3316     vec_push(ir->code->functions, fun);
3317     return true;
3318 }
3319
3320 static ir_value* ir_gen_extparam_proto(ir_builder *ir)
3321 {
3322     ir_value *global;
3323     char      name[128];
3324
3325     util_snprintf(name, sizeof(name), "EXTPARM#%i", (int)(vec_size(ir->extparam_protos)));
3326     global = ir_value_var(name, store_global, TYPE_VECTOR);
3327
3328     vec_push(ir->extparam_protos, global);
3329     return global;
3330 }
3331
3332 static void ir_gen_extparam(ir_builder *ir)
3333 {
3334     prog_section_def_t def;
3335     ir_value          *global;
3336
3337     if (vec_size(ir->extparam_protos) < vec_size(ir->extparams)+1)
3338         global = ir_gen_extparam_proto(ir);
3339     else
3340         global = ir->extparam_protos[vec_size(ir->extparams)];
3341
3342     def.name   = code_genstring(ir->code, global->name);
3343     def.type   = TYPE_VECTOR;
3344     def.offset = vec_size(ir->code->globals);
3345
3346     vec_push(ir->code->defs, def);
3347
3348     ir_value_code_setaddr(global, def.offset);
3349
3350     vec_push(ir->code->globals, 0);
3351     vec_push(ir->code->globals, 0);
3352     vec_push(ir->code->globals, 0);
3353
3354     vec_push(ir->extparams, global);
3355 }
3356
3357 static bool gen_function_extparam_copy(code_t *code, ir_function *self)
3358 {
3359     size_t i, ext, numparams;
3360
3361     ir_builder *ir = self->owner;
3362     ir_value   *ep;
3363     prog_section_statement_t stmt;
3364
3365     numparams = vec_size(self->params);
3366     if (!numparams)
3367         return true;
3368
3369     stmt.opcode = INSTR_STORE_F;
3370     stmt.o3.s1 = 0;
3371     for (i = 8; i < numparams; ++i) {
3372         ext = i - 8;
3373         if (ext >= vec_size(ir->extparams))
3374             ir_gen_extparam(ir);
3375
3376         ep = ir->extparams[ext];
3377
3378         stmt.opcode = type_store_instr[self->locals[i]->vtype];
3379         if (self->locals[i]->vtype == TYPE_FIELD &&
3380             self->locals[i]->fieldtype == TYPE_VECTOR)
3381         {
3382             stmt.opcode = INSTR_STORE_V;
3383         }
3384         stmt.o1.u1 = ir_value_code_addr(ep);
3385         stmt.o2.u1 = ir_value_code_addr(self->locals[i]);
3386         code_push_statement(code, &stmt, self->context);
3387     }
3388
3389     return true;
3390 }
3391
3392 static bool gen_function_varargs_copy(code_t *code, ir_function *self)
3393 {
3394     size_t i, ext, numparams, maxparams;
3395
3396     ir_builder *ir = self->owner;
3397     ir_value   *ep;
3398     prog_section_statement_t stmt;
3399
3400     numparams = vec_size(self->params);
3401     if (!numparams)
3402         return true;
3403
3404     stmt.opcode = INSTR_STORE_V;
3405     stmt.o3.s1 = 0;
3406     maxparams = numparams + self->max_varargs;
3407     for (i = numparams; i < maxparams; ++i) {
3408         if (i < 8) {
3409             stmt.o1.u1 = OFS_PARM0 + 3*i;
3410             stmt.o2.u1 = ir_value_code_addr(self->locals[i]);
3411             code_push_statement(code, &stmt, self->context);
3412             continue;
3413         }
3414         ext = i - 8;
3415         while (ext >= vec_size(ir->extparams))
3416             ir_gen_extparam(ir);
3417
3418         ep = ir->extparams[ext];
3419
3420         stmt.o1.u1 = ir_value_code_addr(ep);
3421         stmt.o2.u1 = ir_value_code_addr(self->locals[i]);
3422         code_push_statement(code, &stmt, self->context);
3423     }
3424
3425     return true;
3426 }
3427
3428 static bool gen_function_locals(ir_builder *ir, ir_value *global)
3429 {
3430     prog_section_function_t *def;
3431     ir_function             *irfun;
3432     size_t                   i;
3433     uint32_t                 firstlocal, firstglobal;
3434
3435     irfun = global->constval.vfunc;
3436     def   = ir->code->functions + irfun->code_function_def;
3437
3438     if (OPTS_OPTION_BOOL(OPTION_G) ||
3439         !OPTS_OPTIMIZATION(OPTIM_OVERLAP_LOCALS)        ||
3440         (irfun->flags & IR_FLAG_MASK_NO_OVERLAP))
3441     {
3442         firstlocal = def->firstlocal = vec_size(ir->code->globals);
3443     } else {
3444         firstlocal = def->firstlocal = ir->first_common_local;
3445         ++opts_optimizationcount[OPTIM_OVERLAP_LOCALS];
3446     }
3447
3448     firstglobal = (OPTS_OPTIMIZATION(OPTIM_GLOBAL_TEMPS) ? ir->first_common_globaltemp : firstlocal);
3449
3450     for (i = vec_size(ir->code->globals); i < firstlocal + irfun->allocated_locals; ++i)
3451         vec_push(ir->code->globals, 0);
3452     for (i = 0; i < vec_size(irfun->locals); ++i) {
3453         ir_value *v = irfun->locals[i];
3454         if (v->locked || !OPTS_OPTIMIZATION(OPTIM_GLOBAL_TEMPS)) {
3455             ir_value_code_setaddr(v, firstlocal + v->code.local);
3456             if (!ir_builder_gen_global(ir, irfun->locals[i], true)) {
3457                 irerror(irfun->locals[i]->context, "failed to generate local %s", irfun->locals[i]->name);
3458                 return false;
3459             }
3460         }
3461         else
3462             ir_value_code_setaddr(v, firstglobal + v->code.local);
3463     }
3464     for (i = 0; i < vec_size(irfun->values); ++i)
3465     {
3466         ir_value *v = irfun->values[i];
3467         if (v->callparam)
3468             continue;
3469         if (v->locked)
3470             ir_value_code_setaddr(v, firstlocal + v->code.local);
3471         else
3472             ir_value_code_setaddr(v, firstglobal + v->code.local);
3473     }
3474     return true;
3475 }
3476
3477 static bool gen_global_function_code(ir_builder *ir, ir_value *global)
3478 {
3479     prog_section_function_t *fundef;
3480     ir_function             *irfun;
3481
3482     (void)ir;
3483
3484     irfun = global->constval.vfunc;
3485     if (!irfun) {
3486         if (global->cvq == CV_NONE) {
3487             if (irwarning(global->context, WARN_IMPLICIT_FUNCTION_POINTER,
3488                           "function `%s` has no body and in QC implicitly becomes a function-pointer",
3489                           global->name))
3490             {
3491                 /* Not bailing out just now. If this happens a lot you don't want to have
3492                  * to rerun gmqcc for each such function.
3493                  */
3494
3495                 /* return false; */
3496             }
3497         }
3498         /* this was a function pointer, don't generate code for those */
3499         return true;
3500     }
3501
3502     if (irfun->builtin)
3503         return true;
3504
3505     /*
3506      * If there is no definition and the thing is eraseable, we can ignore
3507      * outputting the function to begin with.
3508      */
3509     if (global->flags & IR_FLAG_ERASEABLE && irfun->code_function_def < 0) {
3510         return true;
3511     }
3512
3513     if (irfun->code_function_def < 0) {
3514         irerror(irfun->context, "`%s`: IR global wasn't generated, failed to access function-def", irfun->name);
3515         return false;
3516     }
3517     fundef = &ir->code->functions[irfun->code_function_def];
3518
3519     fundef->entry = vec_size(ir->code->statements);
3520     if (!gen_function_locals(ir, global)) {
3521         irerror(irfun->context, "Failed to generate locals for function %s", irfun->name);
3522         return false;
3523     }
3524     if (!gen_function_extparam_copy(ir->code, irfun)) {
3525         irerror(irfun->context, "Failed to generate extparam-copy code for function %s", irfun->name);
3526         return false;
3527     }
3528     if (irfun->max_varargs && !gen_function_varargs_copy(ir->code, irfun)) {
3529         irerror(irfun->context, "Failed to generate vararg-copy code for function %s", irfun->name);
3530         return false;
3531     }
3532     if (!gen_function_code(ir->code, irfun)) {
3533         irerror(irfun->context, "Failed to generate code for function %s", irfun->name);
3534         return false;
3535     }
3536     return true;
3537 }
3538
3539 static void gen_vector_defs(code_t *code, prog_section_def_t def, const char *name)
3540 {
3541     char  *component;
3542     size_t len, i;
3543
3544     if (!name || name[0] == '#' || OPTS_FLAG(SINGLE_VECTOR_DEFS))
3545         return;
3546
3547     def.type = TYPE_FLOAT;
3548
3549     len = strlen(name);
3550
3551     component = (char*)mem_a(len+3);
3552     memcpy(component, name, len);
3553     len += 2;
3554     component[len-0] = 0;
3555     component[len-2] = '_';
3556
3557     component[len-1] = 'x';
3558
3559     for (i = 0; i < 3; ++i) {
3560         def.name = code_genstring(code, component);
3561         vec_push(code->defs, def);
3562         def.offset++;
3563         component[len-1]++;
3564     }
3565
3566     mem_d(component);
3567 }
3568
3569 static void gen_vector_fields(code_t *code, prog_section_field_t fld, const char *name)
3570 {
3571     char  *component;
3572     size_t len, i;
3573
3574     if (!name || OPTS_FLAG(SINGLE_VECTOR_DEFS))
3575         return;
3576
3577     fld.type = TYPE_FLOAT;
3578
3579     len = strlen(name);
3580
3581     component = (char*)mem_a(len+3);
3582     memcpy(component, name, len);
3583     len += 2;
3584     component[len-0] = 0;
3585     component[len-2] = '_';
3586
3587     component[len-1] = 'x';
3588
3589     for (i = 0; i < 3; ++i) {
3590         fld.name = code_genstring(code, component);
3591         vec_push(code->fields, fld);
3592         fld.offset++;
3593         component[len-1]++;
3594     }
3595
3596     mem_d(component);
3597 }
3598
3599 static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool islocal)
3600 {
3601     size_t             i;
3602     int32_t           *iptr;
3603     prog_section_def_t def;
3604     bool               pushdef = opts.optimizeoff;
3605
3606     def.type   = global->vtype;
3607     def.offset = vec_size(self->code->globals);
3608     def.name   = 0;
3609     if (OPTS_OPTION_BOOL(OPTION_G) || !islocal)
3610     {
3611         pushdef = true;
3612
3613         /*
3614          * if we're eraseable and the function isn't referenced ignore outputting
3615          * the function.
3616          */
3617         if (global->flags & IR_FLAG_ERASEABLE && vec_size(global->reads) == 0) {
3618             return true;
3619         }
3620
3621         if (OPTS_OPTIMIZATION(OPTIM_STRIP_CONSTANT_NAMES) &&
3622             !(global->flags & IR_FLAG_INCLUDE_DEF) &&
3623             (global->name[0] == '#' || global->cvq == CV_CONST))
3624         {
3625             pushdef = false;
3626         }
3627
3628         if (pushdef) {
3629             if (global->name[0] == '#') {
3630                 if (!self->str_immediate)
3631                     self->str_immediate = code_genstring(self->code, "IMMEDIATE");
3632                 def.name = global->code.name = self->str_immediate;
3633             }
3634             else
3635                 def.name = global->code.name = code_genstring(self->code, global->name);
3636         }
3637         else
3638             def.name   = 0;
3639         if (islocal) {
3640             def.offset = ir_value_code_addr(global);
3641             vec_push(self->code->defs, def);
3642             if (global->vtype == TYPE_VECTOR)
3643                 gen_vector_defs(self->code, def, global->name);
3644             else if (global->vtype == TYPE_FIELD && global->fieldtype == TYPE_VECTOR)
3645                 gen_vector_defs(self->code, def, global->name);
3646             return true;
3647         }
3648     }
3649     if (islocal)
3650         return true;
3651
3652     switch (global->vtype)
3653     {
3654     case TYPE_VOID:
3655         if (!strcmp(global->name, "end_sys_globals")) {
3656             /* TODO: remember this point... all the defs before this one
3657              * should be checksummed and added to progdefs.h when we generate it.
3658              */
3659         }
3660         else if (!strcmp(global->name, "end_sys_fields")) {
3661             /* TODO: same as above but for entity-fields rather than globsl
3662              */
3663         }
3664         else if(irwarning(global->context, WARN_VOID_VARIABLES, "unrecognized variable of type void `%s`",
3665                           global->name))
3666         {
3667             /* Not bailing out */
3668             /* return false; */
3669         }
3670         /* I'd argue setting it to 0 is sufficient, but maybe some depend on knowing how far
3671          * the system fields actually go? Though the engine knows this anyway...
3672          * Maybe this could be an -foption
3673          * fteqcc creates data for end_sys_* - of size 1, so let's do the same
3674          */
3675         ir_value_code_setaddr(global, vec_size(self->code->globals));
3676         vec_push(self->code->globals, 0);
3677         /* Add the def */
3678         if (pushdef) vec_push(self->code->defs, def);
3679         return true;
3680     case TYPE_POINTER:
3681         if (pushdef) vec_push(self->code->defs, def);
3682         return gen_global_pointer(self->code, global);
3683     case TYPE_FIELD:
3684         if (pushdef) {
3685             vec_push(self->code->defs, def);
3686             if (global->fieldtype == TYPE_VECTOR)
3687                 gen_vector_defs(self->code, def, global->name);
3688         }
3689         return gen_global_field(self->code, global);
3690     case TYPE_ENTITY:
3691         /* fall through */
3692     case TYPE_FLOAT:
3693     {
3694         ir_value_code_setaddr(global, vec_size(self->code->globals));
3695         if (global->hasvalue) {
3696             iptr = (int32_t*)&global->constval.ivec[0];
3697             vec_push(self->code->globals, *iptr);
3698         } else {
3699             vec_push(self->code->globals, 0);
3700         }
3701         if (!islocal && global->cvq != CV_CONST)
3702             def.type |= DEF_SAVEGLOBAL;
3703         if (pushdef) vec_push(self->code->defs, def);
3704
3705         return global->code.globaladdr >= 0;
3706     }
3707     case TYPE_STRING:
3708     {
3709         ir_value_code_setaddr(global, vec_size(self->code->globals));
3710         if (global->hasvalue) {
3711             uint32_t load = code_genstring(self->code, global->constval.vstring);
3712             vec_push(self->code->globals, load);
3713         } else {
3714             vec_push(self->code->globals, 0);
3715         }
3716         if (!islocal && global->cvq != CV_CONST)
3717             def.type |= DEF_SAVEGLOBAL;
3718         if (pushdef) vec_push(self->code->defs, def);
3719         return global->code.globaladdr >= 0;
3720     }
3721     case TYPE_VECTOR:
3722     {
3723         size_t d;
3724         ir_value_code_setaddr(global, vec_size(self->code->globals));
3725         if (global->hasvalue) {
3726             iptr = (int32_t*)&global->constval.ivec[0];
3727             vec_push(self->code->globals, iptr[0]);
3728             if (global->code.globaladdr < 0)
3729                 return false;
3730             for (d = 1; d < type_sizeof_[global->vtype]; ++d) {
3731                 vec_push(self->code->globals, iptr[d]);
3732             }
3733         } else {
3734             vec_push(self->code->globals, 0);
3735             if (global->code.globaladdr < 0)
3736                 return false;
3737             for (d = 1; d < type_sizeof_[global->vtype]; ++d) {
3738                 vec_push(self->code->globals, 0);
3739             }
3740         }
3741         if (!islocal && global->cvq != CV_CONST)
3742             def.type |= DEF_SAVEGLOBAL;
3743
3744         if (pushdef) {
3745             vec_push(self->code->defs, def);
3746             def.type &= ~DEF_SAVEGLOBAL;
3747             gen_vector_defs(self->code, def, global->name);
3748         }
3749         return global->code.globaladdr >= 0;
3750     }
3751     case TYPE_FUNCTION:
3752         ir_value_code_setaddr(global, vec_size(self->code->globals));
3753         if (!global->hasvalue) {
3754             vec_push(self->code->globals, 0);
3755             if (global->code.globaladdr < 0)
3756                 return false;
3757         } else {
3758             vec_push(self->code->globals, vec_size(self->code->functions));
3759             if (!gen_global_function(self, global))
3760                 return false;
3761         }
3762         if (!islocal && global->cvq != CV_CONST)
3763             def.type |= DEF_SAVEGLOBAL;
3764         if (pushdef) vec_push(self->code->defs, def);
3765         return true;
3766     case TYPE_VARIANT:
3767         /* assume biggest type */
3768             ir_value_code_setaddr(global, vec_size(self->code->globals));
3769             vec_push(self->code->globals, 0);
3770             for (i = 1; i < type_sizeof_[TYPE_VARIANT]; ++i)
3771                 vec_push(self->code->globals, 0);
3772             return true;
3773     default:
3774         /* refuse to create 'void' type or any other fancy business. */
3775         irerror(global->context, "Invalid type for global variable `%s`: %s",
3776                 global->name, type_name[global->vtype]);
3777         return false;
3778     }
3779 }
3780
3781 static GMQCC_INLINE void ir_builder_prepare_field(code_t *code, ir_value *field)
3782 {
3783     field->code.fieldaddr = code_alloc_field(code, type_sizeof_[field->fieldtype]);
3784 }
3785
3786 static bool ir_builder_gen_field(ir_builder *self, ir_value *field)
3787 {
3788     prog_section_def_t def;
3789     prog_section_field_t fld;
3790
3791     (void)self;
3792
3793     def.type   = (uint16_t)field->vtype;
3794     def.offset = (uint16_t)vec_size(self->code->globals);
3795
3796     /* create a global named the same as the field */
3797     if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_GMQCC) {
3798         /* in our standard, the global gets a dot prefix */
3799         size_t len = strlen(field->name);
3800         char name[1024];
3801
3802         /* we really don't want to have to allocate this, and 1024
3803          * bytes is more than enough for a variable/field name
3804          */
3805         if (len+2 >= sizeof(name)) {
3806             irerror(field->context, "invalid field name size: %u", (unsigned int)len);
3807             return false;
3808         }
3809
3810         name[0] = '.';
3811         memcpy(name+1, field->name, len); /* no strncpy - we used strlen above */
3812         name[len+1] = 0;
3813
3814         def.name = code_genstring(self->code, name);
3815         fld.name = def.name + 1; /* we reuse that string table entry */
3816     } else {
3817         /* in plain QC, there cannot be a global with the same name,
3818          * and so we also name the global the same.
3819          * FIXME: fteqcc should create a global as well
3820          * check if it actually uses the same name. Probably does
3821          */
3822         def.name = code_genstring(self->code, field->name);
3823         fld.name = def.name;
3824     }
3825
3826     field->code.name = def.name;
3827
3828     vec_push(self->code->defs, def);
3829
3830     fld.type = field->fieldtype;
3831
3832     if (fld.type == TYPE_VOID) {
3833         irerror(field->context, "field is missing a type: %s - don't know its size", field->name);
3834         return false;
3835     }
3836
3837     fld.offset = field->code.fieldaddr;
3838
3839     vec_push(self->code->fields, fld);
3840
3841     ir_value_code_setaddr(field, vec_size(self->code->globals));
3842     vec_push(self->code->globals, fld.offset);
3843     if (fld.type == TYPE_VECTOR) {
3844         vec_push(self->code->globals, fld.offset+1);
3845         vec_push(self->code->globals, fld.offset+2);
3846     }
3847
3848     if (field->fieldtype == TYPE_VECTOR) {
3849         gen_vector_defs  (self->code, def, field->name);
3850         gen_vector_fields(self->code, fld, field->name);
3851     }
3852
3853     return field->code.globaladdr >= 0;
3854 }
3855
3856 bool ir_builder_generate(ir_builder *self, const char *filename)
3857 {
3858     prog_section_statement_t stmt;
3859     size_t i;
3860     char  *lnofile = NULL;
3861
3862     for (i = 0; i < vec_size(self->fields); ++i)
3863     {
3864         ir_builder_prepare_field(self->code, self->fields[i]);
3865     }
3866
3867     for (i = 0; i < vec_size(self->globals); ++i)
3868     {
3869         if (!ir_builder_gen_global(self, self->globals[i], false)) {
3870             return false;
3871         }
3872         if (self->globals[i]->vtype == TYPE_FUNCTION) {
3873             ir_function *func = self->globals[i]->constval.vfunc;
3874             if (func && self->max_locals < func->allocated_locals &&
3875                 !(func->flags & IR_FLAG_MASK_NO_OVERLAP))
3876             {
3877                 self->max_locals = func->allocated_locals;
3878             }
3879             if (func && self->max_globaltemps < func->globaltemps)
3880                 self->max_globaltemps = func->globaltemps;
3881         }
3882     }
3883
3884     for (i = 0; i < vec_size(self->fields); ++i)
3885     {
3886         if (!ir_builder_gen_field(self, self->fields[i])) {
3887             return false;
3888         }
3889     }
3890
3891     /* generate nil */
3892     ir_value_code_setaddr(self->nil, vec_size(self->code->globals));
3893     vec_push(self->code->globals, 0);
3894     vec_push(self->code->globals, 0);
3895     vec_push(self->code->globals, 0);
3896
3897     /* generate virtual-instruction temps */
3898     for (i = 0; i < IR_MAX_VINSTR_TEMPS; ++i) {
3899         ir_value_code_setaddr(self->vinstr_temp[i], vec_size(self->code->globals));
3900         vec_push(self->code->globals, 0);
3901         vec_push(self->code->globals, 0);
3902         vec_push(self->code->globals, 0);
3903     }
3904
3905     /* generate global temps */
3906     self->first_common_globaltemp = vec_size(self->code->globals);
3907     for (i = 0; i < self->max_globaltemps; ++i) {
3908         vec_push(self->code->globals, 0);
3909     }
3910     /* generate common locals */
3911     self->first_common_local = vec_size(self->code->globals);
3912     for (i = 0; i < self->max_locals; ++i) {
3913         vec_push(self->code->globals, 0);
3914     }
3915
3916     /* generate function code */
3917     for (i = 0; i < vec_size(self->globals); ++i)
3918     {
3919         if (self->globals[i]->vtype == TYPE_FUNCTION) {
3920             if (!gen_global_function_code(self, self->globals[i])) {
3921                 return false;
3922             }
3923         }
3924     }
3925
3926     if (vec_size(self->code->globals) >= 65536) {
3927         irerror(vec_last(self->globals)->context, "This progs file would require more globals than the metadata can handle. Bailing out.");
3928         return false;
3929     }
3930
3931     /* DP errors if the last instruction is not an INSTR_DONE. */
3932     if (vec_last(self->code->statements).opcode != INSTR_DONE)
3933     {
3934         lex_ctx_t last;
3935
3936         stmt.opcode = INSTR_DONE;
3937         stmt.o1.u1  = 0;
3938         stmt.o2.u1  = 0;
3939         stmt.o3.u1  = 0;
3940         last.line   = vec_last(self->code->linenums);
3941         last.column = vec_last(self->code->columnnums);
3942
3943         code_push_statement(self->code, &stmt, last);
3944     }
3945
3946     if (OPTS_OPTION_BOOL(OPTION_PP_ONLY))
3947         return true;
3948
3949     if (vec_size(self->code->statements) != vec_size(self->code->linenums)) {
3950         con_err("Linecounter wrong: %lu != %lu\n",
3951                 (unsigned long)vec_size(self->code->statements),
3952                 (unsigned long)vec_size(self->code->linenums));
3953     } else if (OPTS_FLAG(LNO)) {
3954         char  *dot;
3955         size_t filelen = strlen(filename);
3956
3957         memcpy(vec_add(lnofile, filelen+1), filename, filelen+1);
3958         dot = strrchr(lnofile, '.');
3959         if (!dot) {
3960             vec_pop(lnofile);
3961         } else {
3962             vec_shrinkto(lnofile, dot - lnofile);
3963         }
3964         memcpy(vec_add(lnofile, 5), ".lno", 5);
3965     }
3966
3967     if (!code_write(self->code, filename, lnofile)) {
3968         vec_free(lnofile);
3969         return false;
3970     }
3971
3972     vec_free(lnofile);
3973     return true;
3974 }
3975
3976 /***********************************************************************
3977  *IR DEBUG Dump functions...
3978  */
3979
3980 #define IND_BUFSZ 1024
3981
3982 static const char *qc_opname(int op)
3983 {
3984     if (op < 0) return "<INVALID>";
3985     if (op < VINSTR_END)
3986         return util_instr_str[op];
3987     switch (op) {
3988         case VINSTR_END:       return "END";
3989         case VINSTR_PHI:       return "PHI";
3990         case VINSTR_JUMP:      return "JUMP";
3991         case VINSTR_COND:      return "COND";
3992         case VINSTR_BITXOR:    return "BITXOR";
3993         case VINSTR_BITAND_V:  return "BITAND_V";
3994         case VINSTR_BITOR_V:   return "BITOR_V";
3995         case VINSTR_BITXOR_V:  return "BITXOR_V";
3996         case VINSTR_BITAND_VF: return "BITAND_VF";
3997         case VINSTR_BITOR_VF:  return "BITOR_VF";
3998         case VINSTR_BITXOR_VF: return "BITXOR_VF";
3999         case VINSTR_CROSS:     return "CROSS";
4000         case VINSTR_NEG_F:     return "NEG_F";
4001         case VINSTR_NEG_V:     return "NEG_V";
4002         default:               return "<UNK>";
4003     }
4004 }
4005
4006 void ir_builder_dump(ir_builder *b, int (*oprintf)(const char*, ...))
4007 {
4008     size_t i;
4009     char indent[IND_BUFSZ];
4010     indent[0] = '\t';
4011     indent[1] = 0;
4012
4013     oprintf("module %s\n", b->name);
4014     for (i = 0; i < vec_size(b->globals); ++i)
4015     {
4016         oprintf("global ");
4017         if (b->globals[i]->hasvalue)
4018             oprintf("%s = ", b->globals[i]->name);
4019         ir_value_dump(b->globals[i], oprintf);
4020         oprintf("\n");
4021     }
4022     for (i = 0; i < vec_size(b->functions); ++i)
4023         ir_function_dump(b->functions[i], indent, oprintf);
4024     oprintf("endmodule %s\n", b->name);
4025 }
4026
4027 static const char *storenames[] = {
4028     "[global]", "[local]", "[param]", "[value]", "[return]"
4029 };
4030
4031 void ir_function_dump(ir_function *f, char *ind,
4032                       int (*oprintf)(const char*, ...))
4033 {
4034     size_t i;
4035     if (f->builtin != 0) {
4036         oprintf("%sfunction %s = builtin %i\n", ind, f->name, -f->builtin);
4037         return;
4038     }
4039     oprintf("%sfunction %s\n", ind, f->name);
4040     util_strncat(ind, "\t", IND_BUFSZ-1);
4041     if (vec_size(f->locals))
4042     {
4043         oprintf("%s%i locals:\n", ind, (int)vec_size(f->locals));
4044         for (i = 0; i < vec_size(f->locals); ++i) {
4045             oprintf("%s\t", ind);
4046             ir_value_dump(f->locals[i], oprintf);
4047             oprintf("\n");
4048         }
4049     }
4050     oprintf("%sliferanges:\n", ind);
4051     for (i = 0; i < vec_size(f->locals); ++i) {
4052         const char *attr = "";
4053         size_t l, m;
4054         ir_value *v = f->locals[i];
4055         if (v->unique_life && v->locked)
4056             attr = "unique,locked ";
4057         else if (v->unique_life)
4058             attr = "unique ";
4059         else if (v->locked)
4060             attr = "locked ";
4061         oprintf("%s\t%s: %s %s %s%s@%i ", ind, v->name, type_name[v->vtype],
4062                 storenames[v->store],
4063                 attr, (v->callparam ? "callparam " : ""),
4064                 (int)v->code.local);
4065         if (!v->life)
4066             oprintf("[null]");
4067         for (l = 0; l < vec_size(v->life); ++l) {
4068             oprintf("[%i,%i] ", v->life[l].start, v->life[l].end);
4069         }
4070         oprintf("\n");
4071         for (m = 0; m < 3; ++m) {
4072             ir_value *vm = v->members[m];
4073             if (!vm)
4074                 continue;
4075             oprintf("%s\t%s: @%i ", ind, vm->name, (int)vm->code.local);
4076             for (l = 0; l < vec_size(vm->life); ++l) {
4077                 oprintf("[%i,%i] ", vm->life[l].start, vm->life[l].end);
4078             }
4079             oprintf("\n");
4080         }
4081     }
4082     for (i = 0; i < vec_size(f->values); ++i) {
4083         const char *attr = "";
4084         size_t l, m;
4085         ir_value *v = f->values[i];
4086         if (v->unique_life && v->locked)
4087             attr = "unique,locked ";
4088         else if (v->unique_life)
4089             attr = "unique ";
4090         else if (v->locked)
4091             attr = "locked ";
4092         oprintf("%s\t%s: %s %s %s%s@%i ", ind, v->name, type_name[v->vtype],
4093                 storenames[v->store],
4094                 attr, (v->callparam ? "callparam " : ""),
4095                 (int)v->code.local);
4096         if (!v->life)
4097             oprintf("[null]");
4098         for (l = 0; l < vec_size(v->life); ++l) {
4099             oprintf("[%i,%i] ", v->life[l].start, v->life[l].end);
4100         }
4101         oprintf("\n");
4102         for (m = 0; m < 3; ++m) {
4103             ir_value *vm = v->members[m];
4104             if (!vm)
4105                 continue;
4106             if (vm->unique_life && vm->locked)
4107                 attr = "unique,locked ";
4108             else if (vm->unique_life)
4109                 attr = "unique ";
4110             else if (vm->locked)
4111                 attr = "locked ";
4112             oprintf("%s\t%s: %s@%i ", ind, vm->name, attr, (int)vm->code.local);
4113             for (l = 0; l < vec_size(vm->life); ++l) {
4114                 oprintf("[%i,%i] ", vm->life[l].start, vm->life[l].end);
4115             }
4116             oprintf("\n");
4117         }
4118     }
4119     if (vec_size(f->blocks))
4120     {
4121         oprintf("%slife passes: %i\n", ind, (int)f->run_id);
4122         for (i = 0; i < vec_size(f->blocks); ++i) {
4123             ir_block_dump(f->blocks[i], ind, oprintf);
4124         }
4125
4126     }
4127     ind[strlen(ind)-1] = 0;
4128     oprintf("%sendfunction %s\n", ind, f->name);
4129 }
4130
4131 void ir_block_dump(ir_block* b, char *ind,
4132                    int (*oprintf)(const char*, ...))
4133 {
4134     size_t i;
4135     oprintf("%s:%s\n", ind, b->label);
4136     util_strncat(ind, "\t", IND_BUFSZ-1);
4137
4138     if (b->instr && b->instr[0])
4139         oprintf("%s (%i) [entry]\n", ind, (int)(b->instr[0]->eid-1));
4140     for (i = 0; i < vec_size(b->instr); ++i)
4141         ir_instr_dump(b->instr[i], ind, oprintf);
4142     ind[strlen(ind)-1] = 0;
4143 }
4144
4145 static void dump_phi(ir_instr *in, int (*oprintf)(const char*, ...))
4146 {
4147     size_t i;
4148     oprintf("%s <- phi ", in->_ops[0]->name);
4149     for (i = 0; i < vec_size(in->phi); ++i)
4150     {
4151         oprintf("([%s] : %s) ", in->phi[i].from->label,
4152                                 in->phi[i].value->name);
4153     }
4154     oprintf("\n");
4155 }
4156
4157 void ir_instr_dump(ir_instr *in, char *ind,
4158                        int (*oprintf)(const char*, ...))
4159 {
4160     size_t i;
4161     const char *comma = NULL;
4162
4163     oprintf("%s (%i) ", ind, (int)in->eid);
4164
4165     if (in->opcode == VINSTR_PHI) {
4166         dump_phi(in, oprintf);
4167         return;
4168     }
4169
4170     util_strncat(ind, "\t", IND_BUFSZ-1);
4171
4172     if (in->_ops[0] && (in->_ops[1] || in->_ops[2])) {
4173         ir_value_dump(in->_ops[0], oprintf);
4174         if (in->_ops[1] || in->_ops[2])
4175             oprintf(" <- ");
4176     }
4177     if (in->opcode == INSTR_CALL0 || in->opcode == VINSTR_NRCALL) {
4178         oprintf("CALL%i\t", vec_size(in->params));
4179     } else
4180         oprintf("%s\t", qc_opname(in->opcode));
4181
4182     if (in->_ops[0] && !(in->_ops[1] || in->_ops[2])) {
4183         ir_value_dump(in->_ops[0], oprintf);
4184         comma = ",\t";
4185     }
4186     else
4187     {
4188         for (i = 1; i != 3; ++i) {
4189             if (in->_ops[i]) {
4190                 if (comma)
4191                     oprintf(comma);
4192                 ir_value_dump(in->_ops[i], oprintf);
4193                 comma = ",\t";
4194             }
4195         }
4196     }
4197     if (in->bops[0]) {
4198         if (comma)
4199             oprintf(comma);
4200         oprintf("[%s]", in->bops[0]->label);
4201         comma = ",\t";
4202     }
4203     if (in->bops[1])
4204         oprintf("%s[%s]", comma, in->bops[1]->label);
4205     if (vec_size(in->params)) {
4206         oprintf("\tparams: ");
4207         for (i = 0; i != vec_size(in->params); ++i) {
4208             oprintf("%s, ", in->params[i]->name);
4209         }
4210     }
4211     oprintf("\n");
4212     ind[strlen(ind)-1] = 0;
4213 }
4214
4215 static void ir_value_dump_string(const char *str, int (*oprintf)(const char*, ...))
4216 {
4217     oprintf("\"");
4218     for (; *str; ++str) {
4219         switch (*str) {
4220             case '\n': oprintf("\\n"); break;
4221             case '\r': oprintf("\\r"); break;
4222             case '\t': oprintf("\\t"); break;
4223             case '\v': oprintf("\\v"); break;
4224             case '\f': oprintf("\\f"); break;
4225             case '\b': oprintf("\\b"); break;
4226             case '\a': oprintf("\\a"); break;
4227             case '\\': oprintf("\\\\"); break;
4228             case '"': oprintf("\\\""); break;
4229             default: oprintf("%c", *str); break;
4230         }
4231     }
4232     oprintf("\"");
4233 }
4234
4235 void ir_value_dump(ir_value* v, int (*oprintf)(const char*, ...))
4236 {
4237     if (v->hasvalue) {
4238         switch (v->vtype) {
4239             default:
4240             case TYPE_VOID:
4241                 oprintf("(void)");
4242                 break;
4243             case TYPE_FUNCTION:
4244                 oprintf("fn:%s", v->name);
4245                 break;
4246             case TYPE_FLOAT:
4247                 oprintf("%g", v->constval.vfloat);
4248                 break;
4249             case TYPE_VECTOR:
4250                 oprintf("'%g %g %g'",
4251                         v->constval.vvec.x,
4252                         v->constval.vvec.y,
4253                         v->constval.vvec.z);
4254                 break;
4255             case TYPE_ENTITY:
4256                 oprintf("(entity)");
4257                 break;
4258             case TYPE_STRING:
4259                 ir_value_dump_string(v->constval.vstring, oprintf);
4260                 break;
4261 #if 0
4262             case TYPE_INTEGER:
4263                 oprintf("%i", v->constval.vint);
4264                 break;
4265 #endif
4266             case TYPE_POINTER:
4267                 oprintf("&%s",
4268                     v->constval.vpointer->name);
4269                 break;
4270         }
4271     } else {
4272         oprintf("%s", v->name);
4273     }
4274 }
4275
4276 void ir_value_dump_life(const ir_value *self, int (*oprintf)(const char*,...))
4277 {
4278     size_t i;
4279     oprintf("Life of %12s:", self->name);
4280     for (i = 0; i < vec_size(self->life); ++i)
4281     {
4282         oprintf(" + [%i, %i]\n", self->life[i].start, self->life[i].end);
4283     }
4284 }