ir.cpp

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