ir.c

   1 #include <stdlib.h>
   2 #include <string.h>
   3 #include "ir.h"
   4
   5 /***********************************************************************
   6  *IR Builder
   7  */
   8
   9 ir_builder* ir_builder_new(const char *modulename)
  10 {
  11     ir_builder* self;
  12
  13     self = (ir_builder*)mem_a(sizeof(*self));
  14     MEM_VECTOR_INIT(self, functions);
  15     MEM_VECTOR_INIT(self, globals);
  16     self->name = NULL;
  17     ir_builder_set_name(self, modulename);
  18
  19     /* globals which always exist */
  20
  21     /* for now we give it a vector size */
  22     ir_builder_create_global(self, "OFS_RETURN", qc_variant);
  23
  24     return self;
  25 }
  26
  27 MEM_VEC_FUNCTIONS(ir_builder, ir_value*, globals)
  28 MEM_VECTOR_FUNCTIONS(ir_builder, ir_function*, functions)
  29
  30 void ir_builder_delete(ir_builder* self)
  31 {
  32     size_t i;
  33     mem_d((void*)self->name);
  34     for (i = 0; i != self->functions_count; ++i) {
  35         ir_function_delete(self->functions[i]);
  36     }
  37     MEM_VECTOR_CLEAR(self, functions);
  38     for (i = 0; i != self->globals_count; ++i) {
  39         ir_value_delete(self->globals[i]);
  40     }
  41     MEM_VECTOR_CLEAR(self, globals);
  42     mem_d(self);
  43 }
  44
  45 void ir_builder_set_name(ir_builder *self, const char *name)
  46 {
  47     if (self->name)
  48         mem_d((void*)self->name);
  49     self->name = util_strdup(name);
  50 }
  51
  52 ir_function* ir_builder_get_function(ir_builder *self, const char *name)
  53 {
  54     size_t i;
  55     for (i = 0; i < self->functions_count; ++i) {
  56         if (!strcmp(name, self->functions[i]->name))
  57             return self->functions[i];
  58     }
  59     return NULL;
  60 }
  61
  62 ir_function* ir_builder_create_function(ir_builder *self, const char *name)
  63 {
  64     ir_function *fn = ir_builder_get_function(self, name);
  65     if (fn) {
  66         return NULL;
  67     }
  68
  69     fn = ir_function_new(self);
  70     ir_function_set_name(fn, name);
  71     ir_builder_functions_add(self, fn);
  72     return fn;
  73 }
  74
  75 ir_value* ir_builder_get_global(ir_builder *self, const char *name)
  76 {
  77     size_t i;
  78     for (i = 0; i < self->globals_count; ++i) {
  79         if (!strcmp(self->globals[i]->name, name))
  80             return self->globals[i];
  81     }
  82     return NULL;
  83 }
  84
  85 ir_value* ir_builder_create_global(ir_builder *self, const char *name, ir_type_t vtype)
  86 {
  87     ir_value *ve = ir_builder_get_global(self, name);
  88     if (ve) {
  89         return NULL;
  90     }
  91
  92     ve = ir_value_var(name, qc_global, vtype);
  93     ir_builder_globals_add(self, ve);
  94     return ve;
  95 }
  96
  97 /***********************************************************************
  98  *IR Function
  99  */
 100
 101 void ir_function_naive_phi(ir_function*);
 102 void ir_function_enumerate(ir_function*);
 103 void ir_function_calculate_liferanges(ir_function*);
 104
 105 ir_function* ir_function_new(ir_builder* owner)
 106 {
 107     ir_function *self;
 108     self = (ir_function*)mem_a(sizeof(*self));
 109     self->owner = owner;
 110     self->context.file = "<@no context>";
 111     self->context.line = 0;
 112     self->retype = qc_void;
 113     MEM_VECTOR_INIT(self, params);
 114     MEM_VECTOR_INIT(self, blocks);
 115     MEM_VECTOR_INIT(self, values);
 116     MEM_VECTOR_INIT(self, locals);
 117     ir_function_set_name(self, "<@unnamed>");
 118
 119     self->run_id = 0;
 120     return self;
 121 }
 122 MEM_VECTOR_FUNCTIONS(ir_function, ir_value*, values)
 123 MEM_VECTOR_FUNCTIONS(ir_function, ir_block*, blocks)
 124 MEM_VECTOR_FUNCTIONS(ir_function, ir_value*, locals)
 125
 126 void ir_function_set_name(ir_function *self, const char *name)
 127 {
 128     if (self->name)
 129         mem_d((void*)self->name);
 130     self->name = util_strdup(name);
 131 }
 132
 133 void ir_function_delete(ir_function *self)
 134 {
 135     size_t i;
 136     mem_d((void*)self->name);
 137
 138     for (i = 0; i != self->blocks_count; ++i)
 139         ir_block_delete(self->blocks[i]);
 140     MEM_VECTOR_CLEAR(self, blocks);
 141
 142     MEM_VECTOR_CLEAR(self, params);
 143
 144     for (i = 0; i != self->values_count; ++i)
 145         ir_value_delete(self->values[i]);
 146     MEM_VECTOR_CLEAR(self, values);
 147
 148     for (i = 0; i != self->locals_count; ++i)
 149         ir_value_delete(self->locals[i]);
 150     MEM_VECTOR_CLEAR(self, locals);
 151
 152     mem_d(self);
 153 }
 154
 155 void ir_function_collect_value(ir_function *self, ir_value *v)
 156 {
 157     ir_function_values_add(self, v);
 158 }
 159
 160 ir_block* ir_function_create_block(ir_function *self, const char *label)
 161 {
 162     ir_block* bn = ir_block_new(self, label);
 163     memcpy(&bn->context, &self->context, sizeof(self->context));
 164     ir_function_blocks_add(self, bn);
 165     return bn;
 166 }
 167
 168 void ir_function_finalize(ir_function *self)
 169 {
 170     ir_function_naive_phi(self);
 171     ir_function_enumerate(self);
 172     ir_function_calculate_liferanges(self);
 173 }
 174
 175 ir_value* ir_function_get_local(ir_function *self, const char *name)
 176 {
 177     size_t i;
 178     for (i = 0; i < self->locals_count; ++i) {
 179         if (!strcmp(self->locals[i]->name, name))
 180             return self->locals[i];
 181     }
 182     return NULL;
 183 }
 184
 185 ir_value* ir_function_create_local(ir_function *self, const char *name, int vtype)
 186 {
 187     ir_value *ve = ir_function_get_local(self, name);
 188     if (ve) {
 189         return NULL;
 190     }
 191
 192     ve = ir_value_var(name, qc_localvar, vtype);
 193     ir_function_locals_add(self, ve);
 194     return ve;
 195 }