renaming some ast_node members before making ast_expression an ast_node to use the...
[xonotic/gmqcc.git] / ir.cpp
diff --git a/ir.cpp b/ir.cpp
index 509fc3b501690327a2be40c5bf91c8cbfa7df116..92cd11d41f318fd0ead169de7e6edc00cc9f5649 100644 (file)
--- a/ir.cpp
+++ b/ir.cpp
@@ -239,15 +239,14 @@ static bool GMQCC_WARN irwarning(lex_ctx_t ctx, int warntype, const char *fmt, .
  * Vector utility functions
  */
 
-static bool GMQCC_WARN vec_ir_value_find(ir_value **vec, const ir_value *what, size_t *idx)
+static bool GMQCC_WARN vec_ir_value_find(std::vector<ir_value *> &vec, const ir_value *what, size_t *idx)
 {
-    size_t i;
-    size_t len = vec_size(vec);
-    for (i = 0; i < len; ++i) {
-        if (vec[i] == what) {
-            if (idx) *idx = i;
-            return true;
-        }
+    for (auto &it : vec) {
+        if (it != what)
+            continue;
+        if (idx)
+            *idx = &it - &vec[0];
+        return true;
     }
     return false;
 }
@@ -265,15 +264,14 @@ static bool GMQCC_WARN vec_ir_block_find(ir_block **vec, ir_block *what, size_t
     return false;
 }
 
-static bool GMQCC_WARN vec_ir_instr_find(ir_instr **vec, ir_instr *what, size_t *idx)
+static bool GMQCC_WARN vec_ir_instr_find(std::vector<ir_instr *> &vec, ir_instr *what, size_t *idx)
 {
-    size_t i;
-    size_t len = vec_size(vec);
-    for (i = 0; i < len; ++i) {
-        if (vec[i] == what) {
-            if (idx) *idx = i;
-            return true;
-        }
+    for (auto &it : vec) {
+        if (it != what)
+            continue;
+        if (idx)
+            *idx = &it - &vec[0];
+        return true;
     }
     return false;
 }
@@ -293,19 +291,19 @@ ir_builder* ir_builder_new(const char *modulename)
 
     self = (ir_builder*)mem_a(sizeof(*self));
     if (!self)
-        return NULL;
+        return nullptr;
 
-    self->functions   = NULL;
-    self->globals     = NULL;
-    self->fields      = NULL;
-    self->filenames   = NULL;
-    self->filestrings = NULL;
+    self->functions   = nullptr;
+    self->globals     = nullptr;
+    self->fields      = nullptr;
+    self->filenames   = nullptr;
+    self->filestrings = nullptr;
     self->htglobals   = util_htnew(IR_HT_SIZE);
     self->htfields    = util_htnew(IR_HT_SIZE);
     self->htfunctions = util_htnew(IR_HT_SIZE);
 
-    self->extparams       = NULL;
-    self->extparam_protos = NULL;
+    self->extparams       = nullptr;
+    self->extparam_protos = nullptr;
 
     self->first_common_globaltemp = 0;
     self->max_globaltemps         = 0;
@@ -313,10 +311,10 @@ ir_builder* ir_builder_new(const char *modulename)
     self->max_locals              = 0;
 
     self->str_immediate = 0;
-    self->name = NULL;
+    self->name = nullptr;
     if (!ir_builder_set_name(self, modulename)) {
         mem_d(self);
-        return NULL;
+        return nullptr;
     }
 
     self->nil = ir_value_var("nil", store_value, TYPE_NIL);
@@ -331,8 +329,8 @@ ir_builder* ir_builder_new(const char *modulename)
         self->vinstr_temp[i]->cvq = CV_CONST;
     }
 
-    self->reserved_va_count = NULL;
-    self->coverage_func     = NULL;
+    self->reserved_va_count = nullptr;
+    self->coverage_func     = nullptr;
 
     self->code              = code_init();
 
@@ -391,14 +389,14 @@ ir_function* ir_builder_create_function(ir_builder *self, const char *name, int
 {
     ir_function *fn = ir_builder_get_function(self, name);
     if (fn) {
-        return NULL;
+        return nullptr;
     }
 
     fn = ir_function_new(self, outtype);
     if (!ir_function_set_name(fn, name))
     {
         ir_function_delete(fn);
-        return NULL;
+        return nullptr;
     }
     vec_push(self->functions, fn);
     util_htset(self->htfunctions, name, fn);
@@ -406,7 +404,7 @@ ir_function* ir_builder_create_function(ir_builder *self, const char *name, int
     fn->value = ir_builder_create_global(self, fn->name, TYPE_FUNCTION);
     if (!fn->value) {
         ir_function_delete(fn);
-        return NULL;
+        return nullptr;
     }
 
     fn->value->hasvalue = true;
@@ -430,7 +428,7 @@ ir_value* ir_builder_create_global(ir_builder *self, const char *name, int vtype
     {
         ve = ir_builder_get_global(self, name);
         if (ve) {
-            return NULL;
+            return nullptr;
         }
     }
 
@@ -457,7 +455,7 @@ ir_value* ir_builder_create_field(ir_builder *self, const char *name, int vtype)
 {
     ir_value *ve = ir_builder_get_field(self, name);
     if (ve) {
-        return NULL;
+        return nullptr;
     }
 
     ve = ir_value_var(name, store_global, TYPE_FIELD);
@@ -482,14 +480,14 @@ ir_function* ir_function_new(ir_builder* owner, int outtype)
     self = (ir_function*)mem_a(sizeof(*self));
 
     if (!self)
-        return NULL;
+        return nullptr;
 
     memset(self, 0, sizeof(*self));
 
-    self->name = NULL;
+    self->name = nullptr;
     if (!ir_function_set_name(self, "<@unnamed>")) {
         mem_d(self);
-        return NULL;
+        return nullptr;
     }
     self->flags = 0;
 
@@ -497,13 +495,13 @@ ir_function* ir_function_new(ir_builder* owner, int outtype)
     self->context.file = "<@no context>";
     self->context.line = 0;
     self->outtype = outtype;
-    self->value = NULL;
+    self->value = nullptr;
     self->builtin = 0;
 
-    self->params = NULL;
-    self->blocks = NULL;
-    self->values = NULL;
-    self->locals = NULL;
+    self->params = nullptr;
+    self->blocks = nullptr;
+    self->values = nullptr;
+    self->locals = nullptr;
 
     self->max_varargs = 0;
 
@@ -583,7 +581,7 @@ ir_block* ir_function_create_block(lex_ctx_t ctx, ir_function *self, const char
     vec_push(self->blocks, bn);
 
     if ((self->flags & IR_FLAG_BLOCK_COVERAGE) && self->owner->coverage_func)
-        (void)ir_block_create_call(bn, ctx, NULL, self->owner->coverage_func, false);
+        (void)ir_block_create_call(bn, ctx, nullptr, self->owner->coverage_func, false);
 
     return bn;
 }
@@ -640,7 +638,7 @@ static bool ir_function_pass_peephole(ir_function *self)
                     continue;
 
                 /* don't optimize out the temp if it's used later again */
-                if (vec_size(value->reads) != 1)
+                if (value->reads.size() != 1)
                     continue;
 
                 /* The very next store must use this value */
@@ -670,12 +668,8 @@ static bool ir_function_pass_peephole(ir_function *self)
                     ir_value *value;
                     value = inst->_ops[0];
 
-                    if (value->store != store_value ||
-                        vec_size(value->reads) != 1 ||
-                        value->reads[0] != inst)
-                    {
+                    if (value->store != store_value || value->reads.size() != 1 || value->reads[0] != inst)
                         break;
-                    }
 
                     inot = value->writes[0];
                     if (inot->_ops[0] != value ||
@@ -722,7 +716,7 @@ static bool ir_function_pass_tailrecursion(ir_function *self)
 
     for (b = 0; b < vec_size(self->blocks); ++b) {
         ir_value *funcval;
-        ir_instr *ret, *call, *store = NULL;
+        ir_instr *ret, *call, *store = nullptr;
         ir_block *block = self->blocks[b];
 
         if (!block->final || vec_size(block->instr) < 2)
@@ -784,7 +778,7 @@ static bool ir_function_pass_tailrecursion(ir_function *self)
         block->final = false; /* open it back up */
 
         /* emite parameter-stores */
-        for (p = 0; p < vec_size(call->params); ++p) {
+        for (p = 0; p < call->params.size(); ++p) {
             /* assert(call->params_count <= self->locals_count); */
             if (!ir_block_create_store(block, call->context, self->locals[p], call->params[p])) {
                 irerror(call->context, "failed to create tailcall store instruction for parameter %i", (int)p);
@@ -867,7 +861,7 @@ ir_value* ir_function_create_local(ir_function *self, const char *name, int vtyp
         vec_size(self->locals) &&
         self->locals[vec_size(self->locals)-1]->store != store_param) {
         irerror(self->context, "cannot add parameters after adding locals");
-        return NULL;
+        return nullptr;
     }
 
     ve = ir_value_var(name, (param ? store_param : store_local), vtype);
@@ -883,32 +877,25 @@ ir_value* ir_function_create_local(ir_function *self, const char *name, int vtyp
 
 ir_block* ir_block_new(ir_function* owner, const char *name)
 {
-    ir_block *self;
-    self = (ir_block*)mem_a(sizeof(*self));
-    if (!self)
-        return NULL;
-
+    ir_block *self = new ir_block;
     memset(self, 0, sizeof(*self));
 
-    self->label = NULL;
+    self->label = nullptr;
     if (name && !ir_block_set_label(self, name)) {
         mem_d(self);
-        return NULL;
+        return nullptr;
     }
     self->owner = owner;
     self->context.file = "<@no context>";
     self->context.line = 0;
     self->final = false;
 
-    self->instr   = NULL;
-    self->entries = NULL;
-    self->exits   = NULL;
+    self->instr = nullptr;
+    self->entries = nullptr;
+    self->exits = nullptr;
 
     self->eid = 0;
     self->is_return = false;
-
-    self->living = NULL;
-
     self->generated = false;
 
     return self;
@@ -923,8 +910,7 @@ static void ir_block_delete_quick(ir_block* self)
     vec_free(self->instr);
     vec_free(self->entries);
     vec_free(self->exits);
-    vec_free(self->living);
-    mem_d(self);
+    delete self;
 }
 
 void ir_block_delete(ir_block* self)
@@ -936,8 +922,7 @@ void ir_block_delete(ir_block* self)
     vec_free(self->instr);
     vec_free(self->entries);
     vec_free(self->exits);
-    vec_free(self->living);
-    mem_d(self);
+    delete self;
 }
 
 bool ir_block_set_label(ir_block *self, const char *name)
@@ -954,64 +939,50 @@ bool ir_block_set_label(ir_block *self, const char *name)
 
 static ir_instr* ir_instr_new(lex_ctx_t ctx, ir_block* owner, int op)
 {
-    ir_instr *self;
-    self = (ir_instr*)mem_a(sizeof(*self));
-    if (!self)
-        return NULL;
-
+    ir_instr *self = new ir_instr;
     self->owner = owner;
     self->context = ctx;
     self->opcode = op;
-    self->_ops[0] = NULL;
-    self->_ops[1] = NULL;
-    self->_ops[2] = NULL;
-    self->bops[0] = NULL;
-    self->bops[1] = NULL;
-
-    self->phi    = NULL;
-    self->params = NULL;
-
+    self->_ops[0] = nullptr;
+    self->_ops[1] = nullptr;
+    self->_ops[2] = nullptr;
+    self->bops[0] = nullptr;
+    self->bops[1] = nullptr;
     self->eid = 0;
-
     self->likely = true;
     return self;
 }
 
 static void ir_instr_delete_quick(ir_instr *self)
 {
-    vec_free(self->phi);
-    vec_free(self->params);
-    mem_d(self);
+    delete self;
 }
 
 static void ir_instr_delete(ir_instr *self)
 {
-    size_t i;
     /* The following calls can only delete from
      * vectors, we still want to delete this instruction
      * so ignore the return value. Since with the warn_unused_result attribute
      * gcc doesn't care about an explicit: (void)foo(); to ignore the result,
      * I have to improvise here and use if(foo());
      */
-    for (i = 0; i < vec_size(self->phi); ++i) {
+    for (auto &it : self->phi) {
         size_t idx;
-        if (vec_ir_instr_find(self->phi[i].value->writes, self, &idx))
-            vec_remove(self->phi[i].value->writes, idx, 1);
-        if (vec_ir_instr_find(self->phi[i].value->reads, self, &idx))
-            vec_remove(self->phi[i].value->reads, idx, 1);
+        if (vec_ir_instr_find(it.value->writes, self, &idx))
+            it.value->writes.erase(it.value->writes.begin() + idx);
+        if (vec_ir_instr_find(it.value->reads, self, &idx))
+            it.value->reads.erase(it.value->reads.begin() + idx);
     }
-    vec_free(self->phi);
-    for (i = 0; i < vec_size(self->params); ++i) {
+    for (auto &it : self->params) {
         size_t idx;
-        if (vec_ir_instr_find(self->params[i]->writes, self, &idx))
-            vec_remove(self->params[i]->writes, idx, 1);
-        if (vec_ir_instr_find(self->params[i]->reads, self, &idx))
-            vec_remove(self->params[i]->reads, idx, 1);
-    }
-    vec_free(self->params);
-    (void)!ir_instr_op(self, 0, NULL, false);
-    (void)!ir_instr_op(self, 1, NULL, false);
-    (void)!ir_instr_op(self, 2, NULL, false);
+        if (vec_ir_instr_find(it->writes, self, &idx))
+            it->writes.erase(it->writes.begin() + idx);
+        if (vec_ir_instr_find(it->reads, self, &idx))
+            it->reads.erase(it->reads.begin() + idx);
+    }
+    (void)!ir_instr_op(self, 0, nullptr, false);
+    (void)!ir_instr_op(self, 1, nullptr, false);
+    (void)!ir_instr_op(self, 2, nullptr, false);
     mem_d(self);
 }
 
@@ -1025,15 +996,15 @@ static bool ir_instr_op(ir_instr *self, int op, ir_value *v, bool writing)
     if (self->_ops[op]) {
         size_t idx;
         if (writing && vec_ir_instr_find(self->_ops[op]->writes, self, &idx))
-            vec_remove(self->_ops[op]->writes, idx, 1);
+            self->_ops[op]->writes.erase(self->_ops[op]->writes.begin() + idx);
         else if (vec_ir_instr_find(self->_ops[op]->reads, self, &idx))
-            vec_remove(self->_ops[op]->reads, idx, 1);
+            self->_ops[op]->reads.erase(self->_ops[op]->reads.begin() + idx);
     }
     if (v) {
         if (writing)
-            vec_push(v->writes, self);
+            v->writes.push_back(self);
         else
-            vec_push(v->reads, self);
+            v->reads.push_back(self);
     }
     self->_ops[op] = v;
     return true;
@@ -1062,39 +1033,37 @@ ir_value* ir_value_var(const char *name, int storetype, int vtype)
 {
     ir_value *self;
     self = (ir_value*)mem_a(sizeof(*self));
+    new (self) ir_value();
     self->vtype = vtype;
     self->fieldtype = TYPE_VOID;
     self->outtype = TYPE_VOID;
     self->store = storetype;
     self->flags = 0;
 
-    self->reads  = NULL;
-    self->writes = NULL;
-
-    self->cvq          = CV_NONE;
-    self->hasvalue     = false;
+    self->cvq = CV_NONE;
+    self->hasvalue = false;
     self->context.file = "<@no context>";
     self->context.line = 0;
-    self->name = NULL;
+    self->name = nullptr;
     if (name && !ir_value_set_name(self, name)) {
         irerror(self->context, "out of memory");
         mem_d(self);
-        return NULL;
+        return nullptr;
     }
 
     memset(&self->constval, 0, sizeof(self->constval));
     memset(&self->code,     0, sizeof(self->code));
 
-    self->members[0] = NULL;
-    self->members[1] = NULL;
-    self->members[2] = NULL;
-    self->memberof = NULL;
+    self->members[0] = nullptr;
+    self->members[1] = nullptr;
+    self->members[2] = nullptr;
+    self->memberof = nullptr;
 
     self->unique_life = false;
-    self->locked      = false;
-    self->callparam   = false;
+    self->locked = false;
+    self->callparam  = false;
 
-    self->life = NULL;
+    self->life = nullptr;
     return self;
 }
 
@@ -1114,11 +1083,11 @@ static ir_value* ir_builder_imm_float(ir_builder *self, float value, bool add_to
 
 ir_value* ir_value_vector_member(ir_value *self, unsigned int member)
 {
-    char     *name;
-    size_t    len;
+    char *name;
+    size_t len;
     ir_value *m;
     if (member >= 3)
-        return NULL;
+        return nullptr;
 
     if (self->members[member])
         return self->members[member];
@@ -1132,7 +1101,7 @@ ir_value* ir_value_vector_member(ir_value *self, unsigned int member)
         name[len+2] = '\0';
     }
     else
-        name = NULL;
+        name = nullptr;
 
     if (self->vtype == TYPE_VECTOR)
     {
@@ -1140,7 +1109,7 @@ ir_value* ir_value_vector_member(ir_value *self, unsigned int member)
         if (name)
             mem_d(name);
         if (!m)
-            return NULL;
+            return nullptr;
         m->context = self->context;
 
         self->members[member] = m;
@@ -1149,12 +1118,12 @@ ir_value* ir_value_vector_member(ir_value *self, unsigned int member)
     else if (self->vtype == TYPE_FIELD)
     {
         if (self->fieldtype != TYPE_VECTOR)
-            return NULL;
+            return nullptr;
         m = ir_value_var(name, self->store, TYPE_FIELD);
         if (name)
             mem_d(name);
         if (!m)
-            return NULL;
+            return nullptr;
         m->fieldtype = TYPE_FLOAT;
         m->context = self->context;
 
@@ -1164,7 +1133,7 @@ ir_value* ir_value_vector_member(ir_value *self, unsigned int member)
     else
     {
         irerror(self->context, "invalid member access on %s", self->name);
-        return NULL;
+        return nullptr;
     }
 
     m->memberof = self;
@@ -1182,7 +1151,7 @@ static ir_value* ir_value_out(ir_function *owner, const char *name, int storetyp
 {
     ir_value *v = ir_value_var(name, storetype, vtype);
     if (!v)
-        return NULL;
+        return nullptr;
     ir_function_collect_value(owner, v);
     return v;
 }
@@ -1203,8 +1172,6 @@ void ir_value_delete(ir_value* self)
                 ir_value_delete(self->members[i]);
         }
     }
-    vec_free(self->reads);
-    vec_free(self->writes);
     vec_free(self->life);
     mem_d(self);
 }
@@ -1301,8 +1268,8 @@ static bool ir_value_life_merge(ir_value *self, size_t s)
 {
     size_t i;
     const size_t vs = vec_size(self->life);
-    ir_life_entry_t *life = NULL;
-    ir_life_entry_t *before = NULL;
+    ir_life_entry_t *life = nullptr;
+    ir_life_entry_t *before = nullptr;
     ir_life_entry_t new_entry;
 
     /* Find the first range >= s */
@@ -1677,19 +1644,19 @@ ir_instr* ir_block_create_phi(ir_block *self, lex_ctx_t ctx, const char *label,
     ir_value *out;
     ir_instr *in;
     if (!ir_check_unreachable(self))
-        return NULL;
+        return nullptr;
     in = ir_instr_new(ctx, self, VINSTR_PHI);
     if (!in)
-        return NULL;
+        return nullptr;
     out = ir_value_out(self->owner, label, store_value, ot);
     if (!out) {
         ir_instr_delete(in);
-        return NULL;
+        return nullptr;
     }
     if (!ir_instr_op(in, 0, out, true)) {
         ir_instr_delete(in);
         ir_value_delete(out);
-        return NULL;
+        return nullptr;
     }
     vec_push(self->instr, in);
     return in;
@@ -1704,7 +1671,7 @@ void ir_phi_add(ir_instr* self, ir_block *b, ir_value *v)
 {
     ir_phi_entry_t pe;
 
-    if (!vec_ir_block_find(self->owner->entries, b, NULL)) {
+    if (!vec_ir_block_find(self->owner->entries, b, nullptr)) {
         /* Must not be possible to cause this, otherwise the AST
          * is doing something wrong.
          */
@@ -1714,8 +1681,8 @@ void ir_phi_add(ir_instr* self, ir_block *b, ir_value *v)
 
     pe.value = v;
     pe.from = b;
-    vec_push(v->reads, self);
-    vec_push(self->phi, pe);
+    v->reads.push_back(self);
+    self->phi.push_back(pe);
 }
 
 /* call related code */
@@ -1724,10 +1691,10 @@ ir_instr* ir_block_create_call(ir_block *self, lex_ctx_t ctx, const char *label,
     ir_value *out;
     ir_instr *in;
     if (!ir_check_unreachable(self))
-        return NULL;
+        return nullptr;
     in = ir_instr_new(ctx, self, (noreturn ? VINSTR_NRCALL : INSTR_CALL0));
     if (!in)
-        return NULL;
+        return nullptr;
     if (noreturn) {
         self->final = true;
         self->is_return = true;
@@ -1735,22 +1702,22 @@ ir_instr* ir_block_create_call(ir_block *self, lex_ctx_t ctx, const char *label,
     out = ir_value_out(self->owner, label, (func->outtype == TYPE_VOID) ? store_return : store_value, func->outtype);
     if (!out) {
         ir_instr_delete(in);
-        return NULL;
+        return nullptr;
     }
     if (!ir_instr_op(in, 0, out, true) ||
         !ir_instr_op(in, 1, func, false))
     {
         ir_instr_delete(in);
         ir_value_delete(out);
-        return NULL;
+        return nullptr;
     }
     vec_push(self->instr, in);
     /*
     if (noreturn) {
-        if (!ir_block_create_return(self, ctx, NULL)) {
+        if (!ir_block_create_return(self, ctx, nullptr)) {
             compile_error(ctx, "internal error: failed to generate dummy-return instruction");
             ir_instr_delete(in);
-            return NULL;
+            return nullptr;
         }
     }
     */
@@ -1764,8 +1731,8 @@ ir_value* ir_call_value(ir_instr *self)
 
 void ir_call_param(ir_instr* self, ir_value *v)
 {
-    vec_push(self->params, v);
-    vec_push(v->reads, self);
+    self->params.push_back(v);
+    v->reads.push_back(self);
 }
 
 /* binary op related code */
@@ -1883,7 +1850,7 @@ ir_value* ir_block_create_binop(ir_block *self, lex_ctx_t ctx,
     };
     if (ot == TYPE_VOID) {
         /* The AST or parser were supposed to check this! */
-        return NULL;
+        return nullptr;
     }
 
     return ir_block_create_general_instr(self, ctx, label, opcode, left, right, ot);
@@ -1909,9 +1876,9 @@ ir_value* ir_block_create_unary(ir_block *self, lex_ctx_t ctx,
          * the operand for 0 already exists so we just source it from here.
          */
         case VINSTR_NEG_F:
-            return ir_block_create_general_instr(self, ctx, label, INSTR_SUB_F, NULL, operand, ot);
+            return ir_block_create_general_instr(self, ctx, label, INSTR_SUB_F, nullptr, operand, ot);
         case VINSTR_NEG_V:
-            return ir_block_create_general_instr(self, ctx, label, INSTR_SUB_V, NULL, operand, TYPE_VECTOR);
+            return ir_block_create_general_instr(self, ctx, label, INSTR_SUB_V, nullptr, operand, TYPE_VECTOR);
 
         default:
             ot = operand->vtype;
@@ -1919,11 +1886,11 @@ ir_value* ir_block_create_unary(ir_block *self, lex_ctx_t ctx,
     };
     if (ot == TYPE_VOID) {
         /* The AST or parser were supposed to check this! */
-        return NULL;
+        return nullptr;
     }
 
-    /* let's use the general instruction creator and pass NULL for OPB */
-    return ir_block_create_general_instr(self, ctx, label, opcode, operand, NULL, ot);
+    /* let's use the general instruction creator and pass nullptr for OPB */
+    return ir_block_create_general_instr(self, ctx, label, opcode, operand, nullptr, ot);
 }
 
 static ir_value* ir_block_create_general_instr(ir_block *self, lex_ctx_t ctx, const char *label,
@@ -1934,12 +1901,12 @@ static ir_value* ir_block_create_general_instr(ir_block *self, lex_ctx_t ctx, co
 
     out = ir_value_out(self->owner, label, store_value, outype);
     if (!out)
-        return NULL;
+        return nullptr;
 
     instr = ir_instr_new(ctx, self, op);
     if (!instr) {
         ir_value_delete(out);
-        return NULL;
+        return nullptr;
     }
 
     if (!ir_instr_op(instr, 0, out, true) ||
@@ -1955,7 +1922,7 @@ static ir_value* ir_block_create_general_instr(ir_block *self, lex_ctx_t ctx, co
 on_error:
     ir_instr_delete(instr);
     ir_value_delete(out);
-    return NULL;
+    return nullptr;
 }
 
 ir_value* ir_block_create_fieldaddress(ir_block *self, lex_ctx_t ctx, const char *label, ir_value *ent, ir_value *field)
@@ -1964,10 +1931,10 @@ ir_value* ir_block_create_fieldaddress(ir_block *self, lex_ctx_t ctx, const char
 
     /* Support for various pointer types todo if so desired */
     if (ent->vtype != TYPE_ENTITY)
-        return NULL;
+        return nullptr;
 
     if (field->vtype != TYPE_FIELD)
-        return NULL;
+        return nullptr;
 
     v = ir_block_create_general_instr(self, ctx, label, INSTR_ADDRESS, ent, field, TYPE_POINTER);
     v->fieldtype = field->fieldtype;
@@ -1978,11 +1945,11 @@ ir_value* ir_block_create_load_from_ent(ir_block *self, lex_ctx_t ctx, const cha
 {
     int op;
     if (ent->vtype != TYPE_ENTITY)
-        return NULL;
+        return nullptr;
 
     /* at some point we could redirect for TYPE_POINTER... but that could lead to carelessness */
     if (field->vtype != TYPE_FIELD)
-        return NULL;
+        return nullptr;
 
     switch (outype)
     {
@@ -1998,7 +1965,7 @@ ir_value* ir_block_create_load_from_ent(ir_block *self, lex_ctx_t ctx, const cha
 #endif
         default:
             irerror(self->context, "invalid type for ir_block_create_load_from_ent: %s", type_name[outype]);
-            return NULL;
+            return nullptr;
     }
 
     return ir_block_create_general_instr(self, ctx, label, op, ent, field, outype);
@@ -2023,7 +1990,7 @@ bool ir_function_naive_phi(ir_function *self)
 
 static bool ir_block_naive_phi(ir_block *self)
 {
-    size_t i, p; /*, w;*/
+    size_t i;
     /* FIXME: optionally, create_phi can add the phis
      * to a list so we don't need to loop through blocks
      * - anyway: "don't optimize YET"
@@ -2037,21 +2004,14 @@ static bool ir_block_naive_phi(ir_block *self)
         vec_remove(self->instr, i, 1);
         --i; /* NOTE: i+1 below */
 
-        for (p = 0; p < vec_size(instr->phi); ++p)
-        {
-            ir_value *v = instr->phi[p].value;
-            ir_block *b = instr->phi[p].from;
-
-            if (v->store == store_value &&
-                vec_size(v->reads) == 1 &&
-                vec_size(v->writes) == 1)
-            {
+        for (auto &it : instr->phi) {
+            ir_value *v = it.value;
+            ir_block *b = it.from;
+            if (v->store == store_value && v->reads.size() == 1 && v->writes.size() == 1) {
                 /* replace the value */
                 if (!ir_instr_op(v->writes[0], 0, instr->_ops[0], true))
                     return false;
-            }
-            else
-            {
+            } else {
                 /* force a move instruction */
                 ir_instr *prevjump = vec_last(b->instr);
                 vec_pop(b->instr);
@@ -2209,14 +2169,14 @@ bool ir_function_allocate_locals(ir_function *self)
     if (!vec_size(self->locals) && !vec_size(self->values))
         return true;
 
-    globalloc.locals    = NULL;
-    globalloc.sizes     = NULL;
-    globalloc.positions = NULL;
-    globalloc.unique    = NULL;
-    lockalloc.locals    = NULL;
-    lockalloc.sizes     = NULL;
-    lockalloc.positions = NULL;
-    lockalloc.unique    = NULL;
+    globalloc.locals    = nullptr;
+    globalloc.sizes     = nullptr;
+    globalloc.positions = nullptr;
+    globalloc.unique    = nullptr;
+    lockalloc.locals    = nullptr;
+    lockalloc.sizes     = nullptr;
+    lockalloc.positions = nullptr;
+    lockalloc.unique    = nullptr;
 
     for (i = 0; i < vec_size(self->locals); ++i)
     {
@@ -2254,13 +2214,13 @@ bool ir_function_allocate_locals(ir_function *self)
          * and it's not "locked", write it to the OFS_PARM directly.
          */
         if (OPTS_OPTIMIZATION(OPTIM_CALL_STORES) && !v->locked && !v->unique_life) {
-            if (vec_size(v->reads) == 1 && vec_size(v->writes) == 1 &&
+            if (v->reads.size() == 1 && v->writes.size() == 1 &&
                 (v->reads[0]->opcode == VINSTR_NRCALL ||
                  (v->reads[0]->opcode >= INSTR_CALL0 && v->reads[0]->opcode <= INSTR_CALL8)
                 )
                )
             {
-                size_t    param;
+                size_t param;
                 ir_instr *call = v->reads[0];
                 if (!vec_ir_value_find(call->params, v, &param)) {
                     irerror(call->context, "internal error: unlocked parameter %s not found", v->name);
@@ -2287,8 +2247,7 @@ bool ir_function_allocate_locals(ir_function *self)
                 }
                 continue;
             }
-            if (vec_size(v->writes) == 1 && v->writes[0]->opcode == INSTR_CALL0)
-            {
+            if (v->writes.size() == 1 && v->writes[0]->opcode == INSTR_CALL0) {
                 v->store = store_return;
                 if (v->members[0]) v->members[0]->store = store_return;
                 if (v->members[1]) v->members[1]->store = store_return;
@@ -2404,29 +2363,21 @@ static void ir_op_read_write(int op, size_t *read, size_t *write)
     };
 }
 
-static bool ir_block_living_add_instr(ir_block *self, size_t eid)
-{
-    size_t       i;
-    const size_t vs = vec_size(self->living);
-    bool         changed = false;
-    for (i = 0; i != vs; ++i)
-    {
-        if (ir_value_life_merge(self->living[i], eid))
+static bool ir_block_living_add_instr(ir_block *self, size_t eid) {
+    bool changed = false;
+    for (auto &it : self->living)
+        if (ir_value_life_merge(it, eid))
             changed = true;
-    }
     return changed;
 }
 
-static bool ir_block_living_lock(ir_block *self)
-{
-    size_t i;
+static bool ir_block_living_lock(ir_block *self) {
     bool changed = false;
-    for (i = 0; i != vec_size(self->living); ++i)
-    {
-        if (!self->living[i]->locked) {
-            self->living[i]->locked = true;
-            changed = true;
-        }
+    for (auto &it : self->living) {
+        if (it->locked)
+            continue;
+        it->locked = true;
+        changed = true;
     }
     return changed;
 }
@@ -2435,7 +2386,7 @@ static bool ir_block_life_propagate(ir_block *self, bool *changed)
 {
     ir_instr *instr;
     ir_value *value;
-    size_t i, o, p, mem, cnt;
+    size_t i, o, p, mem;
     /* bitmasks which operands are read from or written to */
     size_t read, write;
     char dbg_ind[16];
@@ -2443,16 +2394,14 @@ static bool ir_block_life_propagate(ir_block *self, bool *changed)
     dbg_ind[1] = '0';
     (void)dbg_ind;
 
-    vec_free(self->living);
+    self->living.clear();
 
     p = vec_size(self->exits);
     for (i = 0; i < p; ++i) {
         ir_block *prev = self->exits[i];
-        cnt = vec_size(prev->living);
-        for (o = 0; o < cnt; ++o) {
-            if (!vec_ir_value_find(self->living, prev->living[o], NULL))
-                vec_push(self->living, prev->living[o]);
-        }
+        for (auto &it : prev->living)
+            if (!vec_ir_value_find(self->living, it, nullptr))
+                self->living.push_back(it);
     }
 
     i = vec_size(self->instr);
@@ -2509,28 +2458,28 @@ static bool ir_block_life_propagate(ir_block *self, bool *changed)
                      */
                     if (ir_value_life_merge(value, instr->eid))
                         *changed = true;
-                    /* Then remove */
-                    vec_remove(self->living, idx, 1);
+                    // Then remove
+                    self->living.erase(self->living.begin() + idx);
                 }
                 /* Removing a vector removes all members */
                 for (mem = 0; mem < 3; ++mem) {
                     if (value->members[mem] && vec_ir_value_find(self->living, value->members[mem], &idx)) {
                         if (ir_value_life_merge(value->members[mem], instr->eid))
                             *changed = true;
-                        vec_remove(self->living, idx, 1);
+                        self->living.erase(self->living.begin() + idx);
                     }
                 }
                 /* Removing the last member removes the vector */
                 if (value->memberof) {
                     value = value->memberof;
                     for (mem = 0; mem < 3; ++mem) {
-                        if (value->members[mem] && vec_ir_value_find(self->living, value->members[mem], NULL))
+                        if (value->members[mem] && vec_ir_value_find(self->living, value->members[mem], nullptr))
                             break;
                     }
                     if (mem == 3 && vec_ir_value_find(self->living, value, &idx)) {
                         if (ir_value_life_merge(value, instr->eid))
                             *changed = true;
-                        vec_remove(self->living, idx, 1);
+                        self->living.erase(self->living.begin() + idx);
                     }
                 }
             }
@@ -2588,29 +2537,28 @@ static bool ir_block_life_propagate(ir_block *self, bool *changed)
             /* read operands */
             if (read & (1<<o))
             {
-                if (!vec_ir_value_find(self->living, value, NULL))
-                    vec_push(self->living, value);
+                if (!vec_ir_value_find(self->living, value, nullptr))
+                    self->living.push_back(value);
                 /* reading adds the full vector */
-                if (value->memberof && !vec_ir_value_find(self->living, value->memberof, NULL))
-                    vec_push(self->living, value->memberof);
+                if (value->memberof && !vec_ir_value_find(self->living, value->memberof, nullptr))
+                    self->living.push_back(value->memberof);
                 for (mem = 0; mem < 3; ++mem) {
-                    if (value->members[mem] && !vec_ir_value_find(self->living, value->members[mem], NULL))
-                        vec_push(self->living, value->members[mem]);
+                    if (value->members[mem] && !vec_ir_value_find(self->living, value->members[mem], nullptr))
+                        self->living.push_back(value->members[mem]);
                 }
             }
         }
         /* PHI operands are always read operands */
-        for (p = 0; p < vec_size(instr->phi); ++p)
-        {
-            value = instr->phi[p].value;
-            if (!vec_ir_value_find(self->living, value, NULL))
-                vec_push(self->living, value);
+        for (auto &it : instr->phi) {
+            value = it.value;
+            if (!vec_ir_value_find(self->living, value, nullptr))
+                self->living.push_back(value);
             /* reading adds the full vector */
-            if (value->memberof && !vec_ir_value_find(self->living, value->memberof, NULL))
-                vec_push(self->living, value->memberof);
+            if (value->memberof && !vec_ir_value_find(self->living, value->memberof, nullptr))
+                self->living.push_back(value->memberof);
             for (mem = 0; mem < 3; ++mem) {
-                if (value->members[mem] && !vec_ir_value_find(self->living, value->members[mem], NULL))
-                    vec_push(self->living, value->members[mem]);
+                if (value->members[mem] && !vec_ir_value_find(self->living, value->members[mem], nullptr))
+                    self->living.push_back(value->members[mem]);
             }
         }
 
@@ -2620,17 +2568,16 @@ static bool ir_block_life_propagate(ir_block *self, bool *changed)
                 *changed = true;
         }
         /* call params are read operands too */
-        for (p = 0; p < vec_size(instr->params); ++p)
-        {
-            value = instr->params[p];
-            if (!vec_ir_value_find(self->living, value, NULL))
-                vec_push(self->living, value);
+        for (auto &it : instr->params) {
+            value = it;
+            if (!vec_ir_value_find(self->living, value, nullptr))
+                self->living.push_back(value);
             /* reading adds the full vector */
-            if (value->memberof && !vec_ir_value_find(self->living, value->memberof, NULL))
-                vec_push(self->living, value->memberof);
+            if (value->memberof && !vec_ir_value_find(self->living, value->memberof, nullptr))
+                self->living.push_back(value->memberof);
             for (mem = 0; mem < 3; ++mem) {
-                if (value->members[mem] && !vec_ir_value_find(self->living, value->members[mem], NULL))
-                    vec_push(self->living, value->members[mem]);
+                if (value->members[mem] && !vec_ir_value_find(self->living, value->members[mem], nullptr))
+                    self->living.push_back(value->members[mem]);
             }
         }
 
@@ -2666,19 +2613,19 @@ bool ir_function_calculate_liferanges(ir_function *self)
 
     if (vec_size(self->blocks)) {
         ir_block *block = self->blocks[0];
-        for (i = 0; i < vec_size(block->living); ++i) {
-            ir_value *v = block->living[i];
+        for (auto &it : block->living) {
+            ir_value *v = it;
             if (v->store != store_local)
                 continue;
             if (v->vtype == TYPE_VECTOR)
                 continue;
             self->flags |= IR_FLAG_HAS_UNINITIALIZED;
             /* find the instruction reading from it */
-            for (s = 0; s < vec_size(v->reads); ++s) {
+            for (s = 0; s < v->reads.size(); ++s) {
                 if (v->reads[s]->eid == v->life[0].end)
                     break;
             }
-            if (s < vec_size(v->reads)) {
+            if (s < v->reads.size()) {
                 if (irwarning(v->context, WARN_USED_UNINITIALIZED,
                               "variable `%s` may be used uninitialized in this function\n"
                               " -> %s:%i",
@@ -2692,11 +2639,11 @@ bool ir_function_calculate_liferanges(ir_function *self)
             }
             if (v->memberof) {
                 ir_value *vec = v->memberof;
-                for (s = 0; s < vec_size(vec->reads); ++s) {
+                for (s = 0; s < vec->reads.size(); ++s) {
                     if (vec->reads[s]->eid == v->life[0].end)
                         break;
                 }
-                if (s < vec_size(vec->reads)) {
+                if (s < vec->reads.size()) {
                     if (irwarning(v->context, WARN_USED_UNINITIALIZED,
                                   "variable `%s` may be used uninitialized in this function\n"
                                   " -> %s:%i",
@@ -2775,7 +2722,7 @@ static bool gen_global_pointer(code_t *code, ir_value *global)
         ir_value *target = global->constval.vpointer;
         if (!target) {
             irerror(global->context, "Invalid pointer constant: %s", global->name);
-            /* NULL pointers are pointing to the NULL constant, which also
+            /* nullptr pointers are pointing to the nullptr constant, which also
              * sits at address 0, but still has an ir_value for itself.
              */
             return false;
@@ -3102,7 +3049,7 @@ static bool gen_blocks_recursive(code_t *code, ir_function *func, ir_block *bloc
             size_t p, first;
             ir_value *retvalue;
 
-            first = vec_size(instr->params);
+            first = instr->params.size();
             if (first > 8)
                 first = 8;
             for (p = 0; p < first; ++p)
@@ -3139,7 +3086,7 @@ static bool gen_blocks_recursive(code_t *code, ir_function *func, ir_block *bloc
                     code_push_statement(code, &stmt, instr->context);
             }
             /* Now handle extparams */
-            first = vec_size(instr->params);
+            first = instr->params.size();
             for (; p < first; ++p)
             {
                 ir_builder *ir = func->owner;
@@ -3181,7 +3128,7 @@ static bool gen_blocks_recursive(code_t *code, ir_function *func, ir_block *bloc
                     code_push_statement(code, &stmt, instr->context);
             }
 
-            stmt.opcode = INSTR_CALL0 + vec_size(instr->params);
+            stmt.opcode = INSTR_CALL0 + instr->params.size();
             if (stmt.opcode > INSTR_CALL8)
                 stmt.opcode = INSTR_CALL8;
             stmt.o1.u1 = ir_value_code_addr(instr->_ops[1]);
@@ -3668,7 +3615,7 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool isloc
          * if we're eraseable and the function isn't referenced ignore outputting
          * the function.
          */
-        if (global->flags & IR_FLAG_ERASABLE && vec_size(global->reads) == 0) {
+        if (global->flags & IR_FLAG_ERASABLE && global->reads.empty()) {
             return true;
         }
 
@@ -3909,7 +3856,7 @@ static bool ir_builder_gen_field(ir_builder *self, ir_value *field)
 
 static void ir_builder_collect_reusables(ir_builder *builder) {
     size_t i;
-    ir_value **reusables = NULL;
+    ir_value **reusables = nullptr;
     for (i = 0; i < vec_size(builder->globals); ++i) {
         ir_value *value = builder->globals[i];
         if (value->vtype != TYPE_FLOAT || !value->hasvalue)
@@ -3923,16 +3870,16 @@ static void ir_builder_collect_reusables(ir_builder *builder) {
 
 static void ir_builder_split_vector(ir_builder *self, ir_value *vec) {
     size_t i, count;
-    ir_value* found[3] = { NULL, NULL, NULL };
+    ir_value* found[3] = { nullptr, nullptr, nullptr };
 
     /* must not be written to */
-    if (vec_size(vec->writes))
+    if (vec->writes.size())
         return;
     /* must not be trying to access individual members */
     if (vec->members[0] || vec->members[1] || vec->members[2])
         return;
     /* should be actually used otherwise it won't be generated anyway */
-    count = vec_size(vec->reads);
+    count = vec->reads.size();
     if (!count)
         return;
 
@@ -3984,11 +3931,11 @@ static void ir_builder_split_vector(ir_builder *self, ir_value *vec) {
     vec->members[2] = found[2];
 
     /* register the readers for these floats */
-    count = vec_size(vec->reads);
+    count = vec->reads.size();
     for (i = 0; i != count; ++i) {
-        vec_push(found[0]->reads, vec->reads[i]);
-        vec_push(found[1]->reads, vec->reads[i]);
-        vec_push(found[2]->reads, vec->reads[i]);
+        found[0]->reads.push_back(vec->reads[i]);
+        found[1]->reads.push_back(vec->reads[i]);
+        found[2]->reads.push_back(vec->reads[i]);
     }
 }
 
@@ -4006,7 +3953,7 @@ bool ir_builder_generate(ir_builder *self, const char *filename)
 {
     prog_section_statement_t stmt;
     size_t i;
-    char  *lnofile = NULL;
+    char  *lnofile = nullptr;
 
     if (OPTS_FLAG(SPLIT_VECTOR_PARAMETERS)) {
         ir_builder_collect_reusables(self);
@@ -4301,12 +4248,10 @@ void ir_block_dump(ir_block* b, char *ind,
 
 static void dump_phi(ir_instr *in, int (*oprintf)(const char*, ...))
 {
-    size_t i;
     oprintf("%s <- phi ", in->_ops[0]->name);
-    for (i = 0; i < vec_size(in->phi); ++i)
-    {
-        oprintf("([%s] : %s) ", in->phi[i].from->label,
-                                in->phi[i].value->name);
+    for (auto &it : in->phi) {
+        oprintf("([%s] : %s) ", it.from->label,
+                                it.value->name);
     }
     oprintf("\n");
 }
@@ -4315,7 +4260,7 @@ void ir_instr_dump(ir_instr *in, char *ind,
                        int (*oprintf)(const char*, ...))
 {
     size_t i;
-    const char *comma = NULL;
+    const char *comma = nullptr;
 
     oprintf("%s (%i) ", ind, (int)in->eid);
 
@@ -4332,7 +4277,7 @@ void ir_instr_dump(ir_instr *in, char *ind,
             oprintf(" <- ");
     }
     if (in->opcode == INSTR_CALL0 || in->opcode == VINSTR_NRCALL) {
-        oprintf("CALL%i\t", vec_size(in->params));
+        oprintf("CALL%i\t", in->params.size());
     } else
         oprintf("%s\t", qc_opname(in->opcode));
 
@@ -4359,11 +4304,10 @@ void ir_instr_dump(ir_instr *in, char *ind,
     }
     if (in->bops[1])
         oprintf("%s[%s]", comma, in->bops[1]->label);
-    if (vec_size(in->params)) {
+    if (in->params.size()) {
         oprintf("\tparams: ");
-        for (i = 0; i != vec_size(in->params); ++i) {
-            oprintf("%s, ", in->params[i]->name);
-        }
+        for (auto &it : in->params)
+            oprintf("%s, ", it->name);
     }
     oprintf("\n");
     ind[strlen(ind)-1] = 0;