nsz Git - libfirm/blob - scripts/gen_ir_io.py

   1 #!/usr/bin/env python
   2 import sys
   3 from jinja2 import Environment, Template
   4 from spec_util import is_dynamic_pinned, isAbstract, load_spec
   5 from filters import format_arguments, filter_isnot, filter_hasnot, filter_notset
   6
   7 def error(msg):
   8         """writes an error message to stderr"""
   9         sys.stderr.write("Error: " + msg + "\n");
  10
  11 def warning(msg):
  12         """writes a warning message to stderr"""
  13         sys.stderr.write("Warning: " + msg + "\n");
  14
  15 def format_args(arglist):
  16         return "\n".join(arglist)
  17
  18 def format_block(node):
  19         if hasattr(node, "knownBlock"):
  20                 if hasattr(node, "knownGraph"):
  21                         return ""
  22                 return "env->irg"
  23         else:
  24                 return "block"
  25
  26 env = Environment()
  27 env.filters['args']      = format_args
  28 env.filters['block']     = format_block
  29 env.filters['arguments'] = format_arguments
  30 env.filters['isnot']     = filter_isnot
  31 env.filters['notset']    = filter_notset
  32 env.filters['hasnot']    = filter_hasnot
  33
  34 def get_io_type(type, attrname, node):
  35         if type == "ir_tarval*":
  36                 importcmd = "read_tarval(env)"
  37                 exportcmd = "write_tarval(env, %(val)s);"
  38         elif type == "ir_mode*":
  39                 importcmd = "read_mode_ref(env)"
  40                 exportcmd = "write_mode_ref(env, %(val)s);"
  41         elif type == "ir_entity*":
  42                 importcmd = "read_entity_ref(env)"
  43                 exportcmd = "write_entity_ref(env, %(val)s);"
  44         elif type == "ir_type*":
  45                 importcmd = "read_type_ref(env)"
  46                 exportcmd = "write_type_ref(env, %(val)s);"
  47         elif type == "long":
  48                 importcmd = "read_long(env)"
  49                 exportcmd = "write_long(env, %(val)s);"
  50         elif type == "ir_relation":
  51                 importcmd = "read_relation(env)"
  52                 exportcmd = "write_relation(env, %(val)s);"
  53         elif type == "ir_where_alloc":
  54                 importcmd = "read_where_alloc(env)"
  55                 exportcmd = "write_where_alloc(env, %(val)s);"
  56         elif type == "ir_align":
  57                 importcmd = "read_align(env)"
  58                 exportcmd = "write_align(env, %(val)s);"
  59         elif type == "ir_volatility":
  60                 importcmd = "read_volatility(env)"
  61                 exportcmd = "write_volatility(env, %(val)s);"
  62         elif type == "ir_cons_flags":
  63                 importcmd = "cons_none"
  64                 exportcmd = "" # can't really export cons_flags
  65         elif type == "op_pin_state":
  66                 importcmd = "read_pin_state(env)"
  67                 exportcmd = "write_pin_state(env, node);"
  68         elif type == "ir_builtin_kind":
  69                 importcmd = "read_builtin_kind(env)"
  70                 exportcmd = "write_builtin_kind(env, node);"
  71         elif type == "cond_kind":
  72                 importcmd = "read_cond_kind(env)"
  73                 exportcmd = "write_cond_kind(env, node);"
  74         elif type == "cond_jmp_predicate":
  75                 importcmd = "read_cond_jmp_predicate(env)"
  76                 exportcmd = "write_cond_jmp_predicate(env, node);"
  77         elif type == "int":
  78                 importcmd = "read_int(env)"
  79                 exportcmd = "write_int(env, %(val)s);"
  80         elif type == "unsigned":
  81                 importcmd = "read_unsigned(env)"
  82                 exportcmd = "write_unsigned(env, %(val)s);"
  83         elif type == "long":
  84                 importcmd = "read_long(env)"
  85                 exportcmd = "write_long(env, %(val)s);"
  86         elif type == "ir_switch_table*":
  87                 importcmd = "read_switch_table(env)"
  88                 exportcmd = "write_switch_table(env, %(val)s);"
  89         else:
  90                 warning("cannot generate import/export for node %s: unsupported attribute type: %s" % (node.name, type))
  91                 importcmd = "/* BAD: %s %s */ (%s)0" % (type, attrname, type)
  92                 exportcmd = "// BAD: %s" % type
  93         return (importcmd, exportcmd)
  94
  95 def prepare_attr(node, attr):
  96         (importcmd,exportcmd) = get_io_type(attr["type"], attr["name"], node)
  97         attr["importcmd"] = importcmd
  98         attr["exportcmd"] = exportcmd % {"val": "get_%s_%s(node)" % (node.name, attr["name"])}
  99
 100
 101 def preprocess_node(node):
 102         if node.customSerializer:
 103                 return
 104
 105         # construct node arguments
 106         arguments = [ ]
 107         extraattrs = [ ]
 108         for input in node.ins:
 109                 arguments.append("in_%s" % input[0])
 110
 111         if node.arity == "variable" or node.arity == "dynamic":
 112                 arguments.append("n_preds")
 113                 arguments.append("preds")
 114
 115         if not hasattr(node, "mode"):
 116                 arguments.append("mode")
 117
 118         for attr in node.attrs:
 119                 prepare_attr(node, attr)
 120                 if "to_flags" in attr:
 121                         node.constructorFlags = True
 122                         attr['to_flags'] = attr['to_flags'] % (attr["name"])
 123                 elif "init" in attr:
 124                         extraattrs.append(attr)
 125                 else:
 126                         arguments.append(attr["name"])
 127
 128         for arg in node.constructor_args:
 129                 if arg['type'] != "ir_cons_flags" and arg['name'] != "flags":
 130                         error("only ir_cons_flags constructor arg supported in irio")
 131                         continue
 132                 node.constructorFlags = True
 133                 arguments.append("flags")
 134
 135         node.arguments  = arguments
 136         node.extraattrs = extraattrs
 137         node.dynamic_pinned = is_dynamic_pinned(node)
 138
 139 io_template = env.from_string('''/* Warning: automatically generated code */
 140 {%- for node in nodes|notset('customSerializer') %}
 141 static ir_node *read_{{node.name}}(read_env_t *env)
 142 {
 143         {%- if not node.knownBlock %}
 144         ir_node *block = read_node_ref(env);
 145         {%- endif %}
 146         {%- for input in node.ins %}
 147         ir_node *in_{{input[0]}} = read_node_ref(env);
 148         {%- endfor %}
 149         {%- if not hasattr(node, "mode") %}
 150         ir_mode *mode = read_mode_ref(env);
 151         {%- endif %}
 152         {%- for attr in node.attrs %}
 153         {{attr.type}} {{attr.name}} = {{attr.importcmd}};
 154         {%- endfor %}
 155         {%- if node.dynamic_pinned %}
 156         op_pin_state pin_state = read_pin_state(env);
 157         {%- endif %}
 158         {%- if "fragile" in node.flags %}
 159         bool throws = read_throws(env);
 160         {%- endif %}
 161         {%- if node.arity == "dynamic" or node.arity == "variable" %}
 162         int       n_preds = read_preds(env);
 163         ir_node **preds   = (ir_node**)obstack_finish(&env->preds_obst);
 164         {%- endif %}
 165         {%- if node.constructorFlags %}
 166         ir_cons_flags flags = cons_none;
 167         {%- endif %}
 168         ir_node *res;
 169         {%- if node.constructorFlags %}
 170                 {%- for attr in node.attrs %}
 171                         {%- if "to_flags" in attr %}
 172         flags |= {{attr.to_flags}};
 173                         {%- endif %}
 174                 {%- endfor %}
 175                 {%- if node.dynamic_pinned %}
 176         flags |= pin_state == op_pin_state_floats ? cons_floats : cons_none;
 177                 {%- endif %}
 178                 {%- if "fragile" in node.flags %}
 179         flags |= throws ? cons_throws_exception : cons_none;
 180                 {%- endif %}
 181         {%- endif %}
 182         res = new_r_{{node.name}}(
 183                 {%- filter arguments %}
 184 {{node|block}}
 185 {{node.arguments|args}}
 186                 {%- if node.dynamic_pinned and not hasattr(node, "pinned_init") %}
 187 pin_state
 188                 {%- endif %}
 189 {% endfilter %});
 190
 191         {%- if node.arity == "dynamic" or node.arity == "variable" %}
 192         obstack_free(&env->preds_obst, preds);
 193         {%- endif %}
 194         {%- for attr in node.extraattrs %}
 195         set_{{node.name}}_{{attr.name}}(res, {{attr.name}});
 196         {%- endfor %}
 197         {%- if not node.constructorFlags %}
 198                 {%- if node.dynamic_pinned and hasattr(node, "pinned_init") %}
 199         set_irn_pinned(res, pin_state);
 200                 {%- endif %}
 201                 {%- if "fragile" in node.flags and hasattr(node, "throws_init") %}
 202         ir_set_throws_exception(res, throws);
 203                 {%- endif %}
 204         {%- endif %}
 205         return res;
 206 }
 207 {% endfor %}
 208
 209 {%- for node in nodes|notset('customSerializer') %}
 210 static void write_{{node.name}}(write_env_t *env, const ir_node *node)
 211 {
 212         write_symbol(env, "{{node.name}}");
 213         write_node_nr(env, node);
 214         {%- if not node.knownBlock %}
 215         write_node_ref(env, get_nodes_block(node));
 216         {%- endif %}
 217         {%- for input in node.ins %}
 218         write_node_ref(env, get_{{node.name}}_{{input[0]}}(node));
 219         {%- endfor %}
 220         {%- if not hasattr(node, "mode") %}
 221         write_mode_ref(env, get_irn_mode(node));
 222         {%- endif %}
 223         {%- for attr in node.attrs %}
 224         {{attr.exportcmd}}
 225         {%- endfor %}
 226         {%- if node.dynamic_pinned %}
 227         write_pin_state(env, get_irn_pinned(node));
 228         {%- endif %}
 229         {%- if "fragile" in node.flags %}
 230         write_throws(env, ir_throws_exception(node));
 231         {%- endif %}
 232         {%- if node.arity == "dynamic" or node.arity == "variable" %}
 233         write_pred_refs(env, node, {% if node.ins %}n_{{node.name}}_max+1{% else %}0{%endif%});
 234         {%- endif %}
 235 }
 236 {% endfor %}
 237
 238 static void register_generated_node_readers(void)
 239 {
 240         {%- for node in nodes|notset('customSerializer') %}
 241         register_node_reader(new_id_from_str("{{node.name}}"), read_{{node.name}});
 242         {%- endfor %}
 243 }
 244
 245 static void register_generated_node_writers(void)
 246 {
 247         {%- for node in nodes|notset('customSerializer') %}
 248         register_node_writer(op_{{node.name}}, write_{{node.name}});
 249         {%- endfor %}
 250 }
 251
 252 ''')
 253
 254 def main(argv):
 255         if len(argv) < 3:
 256                 print "usage: %s specname(ignored) destdirectory" % argv[0]
 257                 sys.exit(1)
 258
 259         specfile = argv[1]
 260         gendir = argv[2]
 261
 262         spec = load_spec(specfile)
 263         nodes = spec.nodes
 264         real_nodes = []
 265         for node in nodes:
 266                 if isAbstract(node):
 267                         continue
 268                 preprocess_node(node)
 269                 real_nodes.append(node)
 270
 271         file = open(gendir + "/gen_irio.inl", "w");
 272         file.write(io_template.render(nodes = real_nodes, hasattr=hasattr))
 273         file.close()
 274
 275 main(sys.argv)