parser_compile_file vs parser_compile_string

[xonotic/gmqcc.git] / ir.c

diff --git a/ir.c b/ir.c
index 1f9a80db3d213436fce94ad993f45dd46d1ab31b..940cfbb6fb050d943fa36cf3088a1d6ccd5ddfe6 100644 (file)
--- a/ir.c
+++ b/ir.c
@@ -75,6 +75,22 @@ uint16_t type_store_instr[TYPE_COUNT] = {
     INSTR_STORE_V, /* variant, should never be accessed */
 };
 
+uint16_t field_store_instr[TYPE_COUNT] = {
+    INSTR_STORE_FLD,
+    INSTR_STORE_FLD,
+    INSTR_STORE_FLD,
+    INSTR_STORE_V,
+    INSTR_STORE_FLD,
+    INSTR_STORE_FLD,
+    INSTR_STORE_FLD,
+    INSTR_STORE_FLD,
+#if 0
+    INSTR_STORE_FLD, /* integer type */
+#endif
+
+    INSTR_STORE_V, /* variant, should never be accessed */
+};
+
 uint16_t type_storep_instr[TYPE_COUNT] = {
     INSTR_STOREP_F, /* should use I when having integer support */
     INSTR_STOREP_S,
@@ -155,6 +171,10 @@ static bool irwarning(lex_ctx ctx, int warntype, const char *fmt, ...)
  *IR Builder
  */
 
+static void ir_block_delete_quick(ir_block* self);
+static void ir_instr_delete_quick(ir_instr *self);
+static void ir_function_delete_quick(ir_function *self);
+
 ir_builder* ir_builder_new(const char *modulename)
 {
     ir_builder* self;
@@ -166,6 +186,9 @@ ir_builder* ir_builder_new(const char *modulename)
     MEM_VECTOR_INIT(self, functions);
     MEM_VECTOR_INIT(self, globals);
     MEM_VECTOR_INIT(self, fields);
+    MEM_VECTOR_INIT(self, filenames);
+    MEM_VECTOR_INIT(self, filestrings);
+    self->str_immediate = 0;
     self->name = NULL;
     if (!ir_builder_set_name(self, modulename)) {
         mem_d(self);
@@ -175,16 +198,18 @@ ir_builder* ir_builder_new(const char *modulename)
     return self;
 }
 
-MEM_VEC_FUNCTIONS(ir_builder, ir_value*, globals)
-MEM_VEC_FUNCTIONS(ir_builder, ir_value*, fields)
+MEM_VEC_FUNCTIONS(ir_builder, ir_value*,    globals)
+MEM_VEC_FUNCTIONS(ir_builder, ir_value*,    fields)
 MEM_VEC_FUNCTIONS(ir_builder, ir_function*, functions)
+MEM_VEC_FUNCTIONS(ir_builder, const char*,  filenames)
+MEM_VEC_FUNCTIONS(ir_builder, qcint,        filestrings)
 
 void ir_builder_delete(ir_builder* self)
 {
     size_t i;
     mem_d((void*)self->name);
     for (i = 0; i != self->functions_count; ++i) {
-        ir_function_delete(self->functions[i]);
+        ir_function_delete_quick(self->functions[i]);
     }
     MEM_VECTOR_CLEAR(self, functions);
     for (i = 0; i != self->globals_count; ++i) {
@@ -195,6 +220,8 @@ void ir_builder_delete(ir_builder* self)
         ir_value_delete(self->fields[i]);
     }
     MEM_VECTOR_CLEAR(self, fields);
+    MEM_VECTOR_CLEAR(self, filenames);
+    MEM_VECTOR_CLEAR(self, filestrings);
     mem_d(self);
 }
 
@@ -356,6 +383,30 @@ bool ir_function_set_name(ir_function *self, const char *name)
     return !!self->name;
 }
 
+static void ir_function_delete_quick(ir_function *self)
+{
+    size_t i;
+    mem_d((void*)self->name);
+
+    for (i = 0; i != self->blocks_count; ++i)
+        ir_block_delete_quick(self->blocks[i]);
+    MEM_VECTOR_CLEAR(self, blocks);
+
+    MEM_VECTOR_CLEAR(self, params);
+
+    for (i = 0; i != self->values_count; ++i)
+        ir_value_delete(self->values[i]);
+    MEM_VECTOR_CLEAR(self, values);
+
+    for (i = 0; i != self->locals_count; ++i)
+        ir_value_delete(self->locals[i]);
+    MEM_VECTOR_CLEAR(self, locals);
+
+    /* self->value is deleted by the builder */
+
+    mem_d(self);
+}
+
 void ir_function_delete(ir_function *self)
 {
     size_t i;
@@ -488,6 +539,19 @@ MEM_VEC_FUNCTIONS_ALL(ir_block, ir_block*, entries)
 MEM_VEC_FUNCTIONS_ALL(ir_block, ir_block*, exits)
 MEM_VEC_FUNCTIONS_ALL(ir_block, ir_value*, living)
 
+static void ir_block_delete_quick(ir_block* self)
+{
+    size_t i;
+    if (self->label) mem_d(self->label);
+    for (i = 0; i != self->instr_count; ++i)
+        ir_instr_delete_quick(self->instr[i]);
+    MEM_VECTOR_CLEAR(self, instr);
+    MEM_VECTOR_CLEAR(self, entries);
+    MEM_VECTOR_CLEAR(self, exits);
+    MEM_VECTOR_CLEAR(self, living);
+    mem_d(self);
+}
+
 void ir_block_delete(ir_block* self)
 {
     size_t i;
@@ -538,6 +602,13 @@ ir_instr* ir_instr_new(ir_block* owner, int op)
 MEM_VEC_FUNCTIONS(ir_instr, ir_phi_entry_t, phi)
 MEM_VEC_FUNCTIONS(ir_instr, ir_value*, params)
 
+static void ir_instr_delete_quick(ir_instr *self)
+{
+    MEM_VECTOR_CLEAR(self, phi);
+    MEM_VECTOR_CLEAR(self, params);
+    mem_d(self);
+}
+
 void ir_instr_delete(ir_instr *self)
 {
     size_t i;
@@ -2447,7 +2518,10 @@ tailcall:
                 stmt.opcode = INSTR_STORE_F;
                 stmt.o3.u1 = 0;
 
-                stmt.opcode = type_store_instr[param->vtype];
+                if (param->vtype == TYPE_FIELD)
+                    stmt.opcode = field_store_instr[param->fieldtype];
+                else
+                    stmt.opcode = type_store_instr[param->vtype];
                 stmt.o1.u1 = ir_value_code_addr(param);
                 stmt.o2.u1 = OFS_PARM0 + 3 * p;
                 if (code_statements_add(stmt) < 0)
@@ -2466,7 +2540,10 @@ tailcall:
             if (retvalue && retvalue->store != store_return && retvalue->life_count)
             {
                 /* not to be kept in OFS_RETURN */
-                stmt.opcode = type_store_instr[retvalue->vtype];
+                if (retvalue->vtype == TYPE_FIELD)
+                    stmt.opcode = field_store_instr[retvalue->vtype];
+                else
+                    stmt.opcode = type_store_instr[retvalue->vtype];
                 stmt.o1.u1 = OFS_RETURN;
                 stmt.o2.u1 = ir_value_code_addr(retvalue);
                 stmt.o3.u1 = 0;
@@ -2549,6 +2626,27 @@ static bool gen_function_code(ir_function *self)
     return true;
 }
 
+static qcint ir_builder_filestring(ir_builder *ir, const char *filename)
+{
+    /* NOTE: filename pointers are copied, we never strdup them,
+     * thus we can use pointer-comparison to find the string.
+     */
+    size_t i;
+    qcint  str;
+
+    for (i = 0; i < ir->filenames_count; ++i) {
+        if (ir->filenames[i] == filename)
+            return ir->filestrings[i];
+    }
+
+    str = code_genstring(filename);
+    if (!ir_builder_filenames_add(ir, filename))
+        return 0;
+    if (!ir_builder_filestrings_add(ir, str))
+        ir->filenames_count--;
+    return str;
+}
+
 static bool gen_global_function(ir_builder *ir, ir_value *global)
 {
     prog_section_function fun;
@@ -2566,7 +2664,7 @@ static bool gen_global_function(ir_builder *ir, ir_value *global)
     irfun = global->constval.vfunc;
 
     fun.name    = global->code.name;
-    fun.file    = code_cachedstring(global->context.file);
+    fun.file    = ir_builder_filestring(ir, global->context.file);
     fun.profile = 0; /* always 0 */
     fun.nargs   = irfun->params_count;
 
@@ -2652,7 +2750,18 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool isloc
 
     def.type   = global->vtype;
     def.offset = code_globals_elements;
-    def.name   = global->code.name       = code_genstring(global->name);
+
+    if (global->name) {
+        if (global->name[0] == '#') {
+            if (!self->str_immediate)
+                self->str_immediate = code_genstring("IMMEDIATE");
+            def.name = global->code.name = self->str_immediate;
+        }
+        else
+            def.name = global->code.name = code_genstring(global->name);
+    }
+    else
+        def.name   = 0;
 
     switch (global->vtype)
     {
@@ -2692,7 +2801,7 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool isloc
     case TYPE_FLOAT:
     {
         if (global->isconst) {
-            iptr = (int32_t*)&global->constval.vfloat;
+            iptr = (int32_t*)&global->constval.ivec[0];
             ir_value_code_setaddr(global, code_globals_add(*iptr));
         } else {
             ir_value_code_setaddr(global, code_globals_add(0));
@@ -2707,7 +2816,7 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool isloc
     case TYPE_STRING:
     {
         if (global->isconst)
-            ir_value_code_setaddr(global, code_globals_add(code_cachedstring(global->constval.vstring)));
+            ir_value_code_setaddr(global, code_globals_add(code_genstring(global->constval.vstring)));
         else {
             ir_value_code_setaddr(global, code_globals_add(0));
             if (!islocal)
@@ -2721,7 +2830,7 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool isloc
     {
         size_t d;
         if (global->isconst) {
-            iptr = (int32_t*)&global->constval.vvec;
+            iptr = (int32_t*)&global->constval.ivec[0];
             ir_value_code_setaddr(global, code_globals_add(iptr[0]));
             if (global->code.globaladdr < 0)
                 return false;
@@ -2899,8 +3008,6 @@ bool ir_builder_generate(ir_builder *self, const char *filename)
 
 #ifdef WIN32
 # define strncat(dst, src, sz) strncat_s(dst, sz, src, _TRUNCATE)
-#else
-# define strncat strncat
 #endif
 
 const char *qc_opname(int op)