conversion warnings and sanity check

[xonotic/gmqcc.git] / ir.c

diff --git a/ir.c b/ir.c
index cab06582870363241c99c782266647a05db784d0..a8d54f07437601a5559c0c2ece87d1d144a733b7 100644 (file)
--- a/ir.c
+++ b/ir.c
@@ -171,6 +171,28 @@ uint16_t type_ne_instr[TYPE_COUNT] = {
     AINSTR_END, /* array  */
 };
 
+uint16_t type_not_instr[TYPE_COUNT] = {
+    INSTR_NOT_F, /* should use I when having integer support */
+    INSTR_NOT_S,
+    INSTR_NOT_F,
+    INSTR_NOT_V,
+    INSTR_NOT_ENT,
+    INSTR_NOT_ENT,
+    INSTR_NOT_FNC,
+    INSTR_NOT_ENT, /* should use I */
+#if 0
+    INSTR_NOT_I, /* integer type */
+#else
+    INSTR_NOT_F,
+#endif
+
+    INSTR_NOT_V, /* variant, should never be accessed */
+
+    AINSTR_END, /* struct */
+    AINSTR_END, /* union  */
+    AINSTR_END, /* array  */
+};
+
 static void irerror(lex_ctx ctx, const char *msg, ...)
 {
     va_list ap;
@@ -520,7 +542,6 @@ bool ir_function_finalize(ir_function *self)
 
     if (!ir_function_calculate_liferanges(self))
         return false;
-
     if (!ir_function_allocate_locals(self))
         return false;
     return true;
@@ -654,6 +675,8 @@ ir_instr* ir_instr_new(ir_block* owner, int op)
     self->params = NULL;
 
     self->eid = 0;
+
+    self->likely = true;
     return self;
 }
 
@@ -1768,6 +1791,7 @@ bool ir_function_naive_phi(ir_function *self)
     return true;
 }
 
+#if 0
 static bool ir_naive_phi_emit_store(ir_block *block, size_t iid, ir_value *old, ir_value *what)
 {
     ir_instr *instr;
@@ -1785,10 +1809,11 @@ static bool ir_naive_phi_emit_store(ir_block *block, size_t iid, ir_value *old,
 
     return true;
 }
+#endif
 
 static bool ir_block_naive_phi(ir_block *self)
 {
-    size_t i, p, w;
+    size_t i, p; /*, w;*/
     /* 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"
@@ -1812,7 +1837,8 @@ static bool ir_block_naive_phi(ir_block *self)
                 vec_size(v->writes) == 1)
             {
                 /* replace the value */
-                ir_instr_op(v->writes[0], 0, instr->_ops[0], true);
+                if (!ir_instr_op(v->writes[0], 0, instr->_ops[0], true))
+                    return false;
             }
             else
             {
@@ -2498,6 +2524,13 @@ tailcall:
             }
             /* neither ontrue nor onfalse exist */
             stmt.opcode = INSTR_IFNOT;
+            if (!instr->likely) {
+                /* Honor the likelyhood hint */
+                ir_block *tmp = onfalse;
+                stmt.opcode = INSTR_IF;
+                onfalse = ontrue;
+                ontrue = tmp;
+            }
             stidx = vec_size(code_statements);
             vec_push(code_statements, stmt);
             /* on false we jump, so add ontrue-path */
@@ -2509,6 +2542,16 @@ tailcall:
             if (onfalse->generated) {
                 /* fixup the jump address */
                 code_statements[stidx].o2.s1 = (onfalse->code_start) - (stidx);
+                stmt.opcode = vec_last(code_statements).opcode;
+                if (stmt.opcode == INSTR_GOTO ||
+                    stmt.opcode == INSTR_IF ||
+                    stmt.opcode == INSTR_IFNOT ||
+                    stmt.opcode == INSTR_RETURN ||
+                    stmt.opcode == INSTR_DONE)
+                {
+                    /* no use jumping from here */
+                    return true;
+                }
                 /* may have been generated in the previous recursive call */
                 stmt.opcode = INSTR_GOTO;
                 stmt.o1.s1 = (onfalse->code_start) - vec_size(code_statements);
@@ -2557,20 +2600,20 @@ tailcall:
                 stmt.o2.u1 = OFS_PARM0 + 3 * p;
                 vec_push(code_statements, stmt);
             }
-            /* No whandle extparams */
+            /* Now handle extparams */
             first = vec_size(instr->params);
             for (; p < first; ++p)
             {
                 ir_builder *ir = func->owner;
                 ir_value *param = instr->params[p];
-                ir_value *target;
+                ir_value *targetparam;
 
                 if (p-8 >= vec_size(ir->extparams)) {
                     irerror(instr->context, "Not enough extparam-globals have been created");
                     return false;
                 }
 
-                target = ir->extparams[p-8];
+                targetparam = ir->extparams[p-8];
 
                 stmt.opcode = INSTR_STORE_F;
                 stmt.o3.u1 = 0;
@@ -2580,7 +2623,7 @@ tailcall:
                 else
                     stmt.opcode = type_store_instr[param->vtype];
                 stmt.o1.u1 = ir_value_code_addr(param);
-                stmt.o2.u1 = ir_value_code_addr(target);
+                stmt.o2.u1 = ir_value_code_addr(targetparam);
                 vec_push(code_statements, stmt);
             }
 
@@ -3002,8 +3045,8 @@ static bool ir_builder_gen_field(ir_builder *self, ir_value *field)
     prog_section_def def;
     prog_section_field fld;
 
-    def.type   = field->vtype;
-    def.offset = vec_size(code_globals);
+    def.type   = (uint16_t)field->vtype;
+    def.offset = (uint16_t)vec_size(code_globals);
 
     /* create a global named the same as the field */
     if (opts_standard == COMPILER_GMQCC) {
@@ -3091,6 +3134,11 @@ bool ir_builder_generate(ir_builder *self, const char *filename)
         }
     }
 
+    if (vec_size(code_globals) >= 65536) {
+        irerror(vec_last(self->globals)->context, "This progs file would require more globals than the metadata can handle. Bailing out.");
+        return false;
+    }
+
     /* DP errors if the last instruction is not an INSTR_DONE
      * and for debugging purposes we add an additional AINSTR_END
      * to the end of functions, so here it goes:
@@ -3286,6 +3334,26 @@ void ir_instr_dump(ir_instr *in, char *ind,
     ind[strlen(ind)-1] = 0;
 }
 
+void ir_value_dump_string(const char *str, int (*oprintf)(const char*, ...))
+{
+    oprintf("\"");
+    for (; *str; ++str) {
+        switch (*str) {
+            case '\n': oprintf("\\n"); break;
+            case '\r': oprintf("\\r"); break;
+            case '\t': oprintf("\\t"); break;
+            case '\v': oprintf("\\v"); break;
+            case '\f': oprintf("\\f"); break;
+            case '\b': oprintf("\\b"); break;
+            case '\a': oprintf("\\a"); break;
+            case '\\': oprintf("\\\\"); break;
+            case '"': oprintf("\\\""); break;
+            default: oprintf("%c", *str); break;
+        }
+    }
+    oprintf("\"");
+}
+
 void ir_value_dump(ir_value* v, int (*oprintf)(const char*, ...))
 {
     if (v->isconst) {
@@ -3310,7 +3378,7 @@ void ir_value_dump(ir_value* v, int (*oprintf)(const char*, ...))
                 oprintf("(entity)");
                 break;
             case TYPE_STRING:
-                oprintf("\"%s\"", v->constval.vstring);
+                ir_value_dump_string(v->constval.vstring, oprintf);
                 break;
 #if 0
             case TYPE_INTEGER: