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