X-Git-Url: https://git.xonotic.org/?p=xonotic%2Fgmqcc.git;a=blobdiff_plain;f=ir.h;h=73dd447c0df8c946189809557f6dc60caf4ff676;hp=cd382957f022c34d82a0bdd2f1603bf1aa1ef7d9;hb=a7c1f6f021f3c924c11b338e289b8ed636b8f7f6;hpb=9f2b9e1b46c583d12796df8741bd9b448397b8cb

diff --git a/ir.h b/ir.h
index cd38295..73dd447 100644
--- a/ir.h
+++ b/ir.h
@@ -36,7 +36,7 @@ typedef struct ir_value_s {
     char      *name;
     int       vtype;
     int       store;
-    lex_ctx   context;
+    lex_ctx_t   context;
     /* even the IR knows the subtype of a field */
     int       fieldtype;
     /* and the output type of a function */
@@ -53,7 +53,7 @@ typedef struct ir_value_s {
     union {
         float    vfloat;
         int      vint;
-        vector   vvec;
+        vec3_t   vvec;
         int32_t  ivec[3];
         char    *vstring;
         struct ir_value_s *vpointer;
@@ -94,7 +94,7 @@ ir_value*       ir_value_vector_member(ir_value*, unsigned int member);
 bool GMQCC_WARN ir_value_set_float(ir_value*, float f);
 bool GMQCC_WARN ir_value_set_func(ir_value*, int f);
 bool GMQCC_WARN ir_value_set_string(ir_value*, const char *s);
-bool GMQCC_WARN ir_value_set_vector(ir_value*, vector v);
+bool GMQCC_WARN ir_value_set_vector(ir_value*, vec3_t v);
 bool GMQCC_WARN ir_value_set_field(ir_value*, ir_value *fld);
 bool            ir_value_lives(ir_value*, size_t);
 void            ir_value_dump_life(const ir_value *self, int (*oprintf)(const char*,...));
@@ -110,7 +110,7 @@ typedef struct ir_phi_entry_s
 typedef struct ir_instr_s
 {
     int       opcode;
-    lex_ctx   context;
+    lex_ctx_t   context;
     ir_value* (_ops[3]);
     struct ir_block_s* (bops[2]);
 
@@ -130,7 +130,7 @@ typedef struct ir_instr_s
 typedef struct ir_block_s
 {
     char      *label;
-    lex_ctx    context;
+    lex_ctx_t    context;
     bool       final; /* once a jump is added we're done */
 
     ir_instr          **instr;
@@ -149,26 +149,26 @@ typedef struct ir_block_s
     size_t code_start;
 } ir_block;
 
-ir_value*       ir_block_create_binop(ir_block*, lex_ctx, const char *label, int op, ir_value *left, ir_value *right);
-ir_value*       ir_block_create_unary(ir_block*, lex_ctx, const char *label, int op, ir_value *operand);
-bool GMQCC_WARN ir_block_create_store_op(ir_block*, lex_ctx, int op, ir_value *target, ir_value *what);
-bool GMQCC_WARN ir_block_create_storep(ir_block*, lex_ctx, ir_value *target, ir_value *what);
-ir_value*       ir_block_create_load_from_ent(ir_block*, lex_ctx, const char *label, ir_value *ent, ir_value *field, int outype);
-ir_value*       ir_block_create_fieldaddress(ir_block*, lex_ctx, const char *label, ir_value *entity, ir_value *field);
+ir_value*       ir_block_create_binop(ir_block*, lex_ctx_t, const char *label, int op, ir_value *left, ir_value *right);
+ir_value*       ir_block_create_unary(ir_block*, lex_ctx_t, const char *label, int op, ir_value *operand);
+bool GMQCC_WARN ir_block_create_store_op(ir_block*, lex_ctx_t, int op, ir_value *target, ir_value *what);
+bool GMQCC_WARN ir_block_create_storep(ir_block*, lex_ctx_t, ir_value *target, ir_value *what);
+ir_value*       ir_block_create_load_from_ent(ir_block*, lex_ctx_t, const char *label, ir_value *ent, ir_value *field, int outype);
+ir_value*       ir_block_create_fieldaddress(ir_block*, lex_ctx_t, const char *label, ir_value *entity, ir_value *field);
 
 /* This is to create an instruction of the form
  * <outtype>%label := opcode a, b
  */
-ir_instr* ir_block_create_phi(ir_block*, lex_ctx, const char *label, int vtype);
+ir_instr* ir_block_create_phi(ir_block*, lex_ctx_t, const char *label, int vtype);
 ir_value* ir_phi_value(ir_instr*);
 void ir_phi_add(ir_instr*, ir_block *b, ir_value *v);
-ir_instr* ir_block_create_call(ir_block*, lex_ctx, const char *label, ir_value *func, bool noreturn);
+ir_instr* ir_block_create_call(ir_block*, lex_ctx_t, const char *label, ir_value *func, bool noreturn);
 ir_value* ir_call_value(ir_instr*);
 void ir_call_param(ir_instr*, ir_value*);
 
-bool GMQCC_WARN ir_block_create_return(ir_block*, lex_ctx, ir_value *opt_value);
+bool GMQCC_WARN ir_block_create_return(ir_block*, lex_ctx_t, ir_value *opt_value);
 
-bool GMQCC_WARN ir_block_create_if(ir_block*, lex_ctx, ir_value *cond,
+bool GMQCC_WARN ir_block_create_if(ir_block*, lex_ctx_t, ir_value *cond,
                                    ir_block *ontrue, ir_block *onfalse);
 /* A 'goto' is an actual 'goto' coded in QC, whereas
  * a 'jump' is a virtual construct which simply names the
@@ -176,8 +176,8 @@ bool GMQCC_WARN ir_block_create_if(ir_block*, lex_ctx, ir_value *cond,
  * A goto usually becomes an OP_GOTO in the resulting code,
  * whereas a 'jump' usually doesn't add any actual instruction.
  */
-bool GMQCC_WARN ir_block_create_jump(ir_block*, lex_ctx, ir_block *to);
-bool GMQCC_WARN ir_block_create_goto(ir_block*, lex_ctx, ir_block *to);
+bool GMQCC_WARN ir_block_create_jump(ir_block*, lex_ctx_t, ir_block *to);
+bool GMQCC_WARN ir_block_create_goto(ir_block*, lex_ctx_t, ir_block *to);
 
 /* function */
 typedef struct ir_function_s
@@ -208,7 +208,7 @@ typedef struct ir_function_s
     ir_block*     first;
     ir_block*     last;
 
-    lex_ctx       context;
+    lex_ctx_t       context;
 
     /* for prototypes - first we generate all the
      * globals, and we remember teh function-defs
@@ -216,7 +216,7 @@ typedef struct ir_function_s
      *
      * remember the ID:
      */
-    qcint code_function_def;
+    qcint_t code_function_def;
 
     /* for temp allocation */
     size_t run_id;
@@ -231,15 +231,17 @@ typedef struct ir_function_s
 #define IR_FLAG_HAS_UNINITIALIZED (1<<2)
 #define IR_FLAG_HAS_GOTO          (1<<3)
 #define IR_FLAG_INCLUDE_DEF       (1<<4)
+#define IR_FLAG_ERASEABLE         (1<<5)
 #define IR_FLAG_MASK_NO_OVERLAP     (IR_FLAG_HAS_ARRAYS | IR_FLAG_HAS_UNINITIALIZED)
 #define IR_FLAG_MASK_NO_LOCAL_TEMPS (IR_FLAG_HAS_ARRAYS | IR_FLAG_HAS_UNINITIALIZED)
 
 ir_value*       ir_function_create_local(ir_function *self, const char *name, int vtype, bool param);
 bool GMQCC_WARN ir_function_finalize(ir_function*);
-ir_block*       ir_function_create_block(lex_ctx ctx, ir_function*, const char *label);
+ir_block*       ir_function_create_block(lex_ctx_t ctx, ir_function*, const char *label);
 
 /* builder */
 #define IR_HT_SIZE 1024
+#define IR_MAX_VINSTR_TEMPS 1
 typedef struct ir_builder_s
 {
     char *name;
@@ -261,12 +263,19 @@ typedef struct ir_builder_s
     uint32_t      first_common_globaltemp;
 
     const char **filenames;
-    qcint       *filestrings;
+    qcint_t     *filestrings;
     /* we cache the #IMMEDIATE string here */
-    qcint        str_immediate;
+    qcint_t      str_immediate;
     /* there should just be this one nil */
     ir_value    *nil;
     ir_value    *reserved_va_count;
+    /* some virtual instructions require temps, and their code is isolated
+     * so that we don't need to keep track of their liveness.
+     */
+    ir_value    *vinstr_temp[IR_MAX_VINSTR_TEMPS];
+
+    /* code generator */
+    code_t      *code;
 } ir_builder;
 
 ir_builder*  ir_builder_new(const char *modulename);
@@ -275,15 +284,15 @@ ir_function* ir_builder_create_function(ir_builder*, const char *name, int outty
 ir_value*    ir_builder_create_global(ir_builder*, const char *name, int vtype);
 ir_value*    ir_builder_create_field(ir_builder*, const char *name, int vtype);
 ir_value*    ir_builder_get_va_count(ir_builder*);
-bool         ir_builder_generate(code_t *, ir_builder *self, const char *filename);
+bool         ir_builder_generate(ir_builder *self, const char *filename);
 void         ir_builder_dump(ir_builder*, int (*oprintf)(const char*, ...));
 
 /*
  * This code assumes 32 bit floats while generating binary
  * Blub: don't use extern here, it's annoying and shows up in nm
- * for some reason :P  
+ * for some reason :P
  */
 typedef int static_assert_is_32bit_float  [(sizeof(int32_t) == 4)?1:-1];
-typedef int static_assert_is_32bit_integer[(sizeof(qcfloat) == 4)?1:-1];
+typedef int static_assert_is_32bit_integer[(sizeof(qcfloat_t) == 4)?1:-1];
 
 #endif