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

   1 #!/usr/bin/env python
   2 import sys
   3 from jinja2 import Environment, Template
   4 from jinja2.filters import do_dictsort
   5 import ir_spec
   6
   7 def format_argdecls(node, first = False, voidwhenempty = False):
   8         if not node.has_key("args") or len(node["args"]) == 0:
   9                 if voidwhenempty:
  10                         return "void"
  11                 else:
  12                         return ""
  13
  14         res = ""
  15         if not first:
  16                 comma = ", "
  17         else:
  18                 comma = ""
  19         for arg in node["args"]:
  20                 res = res + (comma + arg["type"] + " " + arg["name"])
  21                 comma = ", "
  22         return res
  23
  24 def format_args(node, first = False):
  25         if not node.has_key("args"):
  26                 return ""
  27
  28         res = ""
  29         if not first:
  30                 comma = ", "
  31         else:
  32                 comma = ""
  33         for arg in node["args"]:
  34                 res = res + (comma + arg["name"])
  35                 comma = ", "
  36         return res
  37
  38 def format_blockdecl(node):
  39         if node.get("knownBlock"):
  40                 return ""
  41         else:
  42                 return ", ir_node *block"
  43
  44 def format_block(node):
  45         if node.get("knownBlock"):
  46                 return ""
  47         else:
  48                 return ", block"
  49
  50 def format_curblock(node):
  51         if node.get("knownBlock"):
  52                 return ""
  53         else:
  54                 return ", current_ir_graph->current_block"
  55
  56 def format_insdecl(node):
  57         arity = node["arity"]
  58         if arity == "variable" and len(node["ins"]) == 0 or arity == "dynamic" or arity == 0:
  59                 return ""
  60
  61         if arity == "variable":
  62                 insarity = len(node["ins"])
  63                 res = "int r_arity = arity + " + `insarity` + ";\n\tir_node **r_in;\n\t" \
  64                         + "NEW_ARR_A(ir_node *, r_in, r_arity);\n\t"
  65                 i = 0
  66                 for input in node["ins"]:
  67                         res += "r_in[" + `i` + "] = irn_" + input + ";\n\t"
  68                         i += 1
  69                 res += "memcpy(&r_in[" + `insarity` + "], in, sizeof(ir_node *) * arity);\n\t"
  70         else:
  71                 res = "ir_node *in[" + `arity` + "];\n\t"
  72                 i = 0
  73                 for input in node["ins"]:
  74                         res += "in[" + `i` + "] = irn_" + input + ";\n\t"
  75                         i += 1
  76         return res
  77
  78 def format_arity_and_ins(node):
  79         arity = node["arity"]
  80         if arity == "dynamic":
  81                 return "-1, NULL"
  82         elif arity == "variable":
  83                 if len(node["ins"]) == 0:
  84                         return "arity, in"
  85                 else:
  86                         return "r_arity, r_in"
  87         elif arity == 0:
  88                 return "0, NULL"
  89         else:
  90                 return `arity` + ", in"
  91
  92 env = Environment()
  93 env.filters['argdecls']  = format_argdecls
  94 env.filters['args']      = format_args
  95 env.filters['blockdecl'] = format_blockdecl
  96 env.filters['block']     = format_block
  97 env.filters['curblock']  = format_curblock
  98 env.filters['insdecl']       = format_insdecl
  99 env.filters['arity_and_ins'] = format_arity_and_ins
 100
 101 def add_attr(list, type, name, init = None, initname = None):
 102         if initname == None:
 103                 initname = "." + name
 104         if init != None:
 105                 list.append(dict(type = type, name = name, init = init, initname = initname))
 106         else:
 107                 list.append(dict(type = type, name = name, initname = initname))
 108
 109 def prepare_attr(attr):
 110         if "init" in attr:
 111                 return dict(type = attr["type"], name = attr["name"], init = attr["init"])
 112         else:
 113                 return dict(type = attr["type"], name = attr["name"])
 114
 115 def preprocess_node(nodename, node):
 116         if "is_a" in node:
 117                 parent = ir_spec.nodes[node["is_a"]]
 118                 node["ins"] = parent["ins"]
 119                 if "outs" in parent:
 120                         node["outs"] = parent["outs"]
 121         if "ins" not in node:
 122                 node["ins"] = []
 123         if "outs" in node:
 124                 node["mode"] = "mode_T"
 125         if "arity" not in node:
 126                 node["arity"] = len(node["ins"])
 127         if "attrs" not in node:
 128                 node["attrs"] = []
 129         if "constructor_args" not in node:
 130                 node["constructor_args"] = []
 131         if "attrs_name" not in node:
 132                 node["attrs_name"] = nodename.lower()
 133         if "block" not in node:
 134                 node["block"] = "block"
 135         if "nodbginfo" in node:
 136                 node["db"] = "NULL"
 137                 node["dbdecl"] = ""
 138                 node["dbdeclnocomma"] = ""
 139         else:
 140                 node["db"] = "db"
 141                 node["dbdecl"] = "dbg_info *db, "
 142                 node["dbdeclnocomma"] = "dbg_info *db"
 143
 144         # construct node arguments
 145         arguments = [ ]
 146         initargs = [ ]
 147         initattrs = [ ]
 148         specialconstrs = [ ]
 149         i = 0
 150         for input in node["ins"]:
 151                 arguments.append(dict(type = "ir_node *", name = "irn_" + input))
 152                 i += 1
 153
 154         # Special case for Builtin...
 155         if nodename == "Builtin":
 156                 for attr in node["attrs"]:
 157                         if attr["name"] == "kind":
 158                                 arguments.append(prepare_attr(attr))
 159
 160         if node["arity"] == "variable":
 161                 arguments.append(dict(type = "int", name = "arity"))
 162                 arguments.append(dict(type = "ir_node **", name = "in"))
 163
 164         if "mode" not in node:
 165                 arguments.append(dict(type = "ir_mode *", name = "mode"))
 166                 node["mode"] = "mode"
 167
 168         attrs_with_special = 0
 169         for attr in node["attrs"]:
 170                 if nodename == "Builtin" and attr["name"] == "kind":
 171                         continue
 172
 173                 if "initname" not in attr:
 174                         attr["initname"] = "." + attr["name"]
 175
 176                 # "special" stuff does not work at all, yet
 177                 if "special" in attr:
 178                         if not "init" in attr:
 179                                 print "Node type %s has an attribute with a \"special\" entry but without \"init\"" % nodename
 180                                 sys.exit(1)
 181
 182                         if attrs_with_special != 0:
 183                                 print "Node type %s has more than one attribute with a \"special\" entry" % nodename
 184                                 sys.exit(1)
 185
 186                         attrs_with_special += 1
 187
 188                         if "prefix" in attr["special"]:
 189                                 specialname = attr["special"]["prefix"] + nodename
 190                         elif "suffix" in attr["special"]:
 191                                 specialname = nodename + attr["special"]["suffix"]
 192                         else:
 193                                 print "Unknown special constructor type for node type %s" %nodename
 194                                 sys.exit(1)
 195
 196                         specialconstrs.append(
 197                                 dict(
 198                                         constrname = specialname,
 199                                         attrname = attr["name"],
 200                                         value = attr["special"]["init"]
 201                                 )
 202                         )
 203                 elif "init" in attr:
 204                         initargs.append(attr["name"])
 205                 else:
 206                         arguments.append(prepare_attr(attr))
 207
 208         for arg in node["constructor_args"]:
 209                 arguments.append(prepare_attr(arg))
 210                 if arg["type"] == "ir_cons_flags":
 211                         name = arg["name"]
 212                         initattrs.append(dict(initname = ".exc.pin_state",
 213                                 init = name + " & cons_floats ? op_pin_state_floats : op_pin_state_pinned"))
 214                         initattrs.append(dict(initname = ".volatility",
 215                                 init = name + " & cons_volatile ? volatility_is_volatile : volatility_non_volatile"))
 216                         initattrs.append(dict(initname = ".aligned",
 217                                 init = name + " & cons_unaligned ? align_non_aligned : align_is_aligned"))
 218
 219         node["args"] = arguments
 220         node["initargs"] = initargs
 221         node["initattrs"] = initattrs
 222         node["special_constructors"] = specialconstrs
 223
 224 #############################
 225
 226 node_template = env.from_string('''
 227 ir_node *new_rd_{{nodename}}({{node["dbdecl"]}}ir_graph *irg{{node|blockdecl}}{{node|argdecls}})
 228 {
 229         ir_node *res;
 230         ir_graph *rem = current_ir_graph;
 231         {{node|insdecl}}
 232         current_ir_graph = irg;
 233         res = new_ir_node({{node["db"]}}, irg, {{node["block"]}}, op_{{nodename}}, {{node["mode"]}}, {{node|arity_and_ins}});
 234         {% for attr in node["attrs"] -%}
 235                 res->attr.{{node["attrs_name"]}}{{attr["initname"]}} =
 236                 {%- if "init" in attr %} {{ attr["init"] -}};
 237                 {%- else              %} {{ attr["name"] -}};
 238                 {% endif %}
 239         {% endfor %}
 240         {%- for attr in node["initattrs"] -%}
 241                 res->attr.{{node["attrs_name"]}}{{attr["initname"]}} = {{ attr["init"] -}};
 242         {% endfor %}
 243         {{- node["init"] }}
 244         {% if node["optimize"] != False -%}
 245                 res = optimize_node(res);
 246         {% endif -%}
 247         IRN_VRFY_IRG(res, irg);
 248         current_ir_graph = rem;
 249         return res;
 250 }
 251
 252 ir_node *new_r_{{nodename}}(ir_graph *irg{{node|blockdecl}}{{node|argdecls}})
 253 {
 254         {% if node["nodbginfo"] -%}
 255                 return new_rd_{{nodename}}(irg{{node|block}}{{node|args}});
 256         {%- else -%}
 257                 return new_rd_{{nodename}}(NULL, irg{{node|block}}{{node|args}});
 258         {%- endif %}
 259 }
 260
 261 ir_node *new_d_{{nodename}}({{node["dbdeclnocomma"]}}{{node|argdecls(node["nodbginfo"])}})
 262 {
 263         ir_node *res;
 264         {{ node["d_pre"] }}
 265         {% if node["nodbginfo"] -%}
 266                 res = new_rd_{{nodename}}(current_ir_graph{{node|curblock}}{{node|args}});
 267         {%- else -%}
 268                 res = new_rd_{{nodename}}(db, current_ir_graph{{node|curblock}}{{node|args}});
 269         {%- endif %}
 270         {{ node["d_post"] }}
 271         return res;
 272 }
 273
 274 ir_node *new_{{nodename}}({{node|argdecls(True, True)}})
 275 {
 276         {% if node["nodbginfo"] -%}
 277                 return new_d_{{nodename}}({{node|args(True)}});
 278         {%- else -%}
 279                 return new_d_{{nodename}}(NULL{{node|args}});
 280         {%- endif %}
 281 }
 282
 283 ''')
 284
 285 #############################
 286
 287 def main(argv):
 288         """the main function"""
 289
 290         if len(argv) < 3:
 291                 print "usage: %s specname(ignored) destdirectory" % argv[0]
 292                 sys.exit(1)
 293
 294         gendir = argv[2]
 295
 296         # List of TODOs
 297         niymap = ["Alloc", "Anchor", "ASM", "Bad", "Bound", "Break", "Builtin",
 298                 "Call", "CallBegin", "Cast", "Const", "Const_type", "Const_long", "CopyB",
 299                 "defaultProj", "Div", "DivRL", "DivMod", "Dummy", "EndReg", "EndExcept",
 300                 "Filter", "InstOf", "Mod", "NoMem", "Phi", "Quot", "Raise",
 301                 "simpleSel", "strictConv", "SymConst", "SymConst_type", "Sync"]
 302
 303         file = open(gendir + "/gen_ir_cons.c.inl", "w")
 304         for nodename, node in do_dictsort(ir_spec.nodes):
 305                 if nodename in niymap:
 306                         continue
 307                 preprocess_node(nodename, node)
 308                 if not "abstract" in node:
 309                         file.write(node_template.render(vars()))
 310         file.write("\n")
 311         file.close()
 312
 313 if __name__ == "__main__":
 314         main(sys.argv)