4e17588566d4e5fefce7b9610b84107310356387
[libfirm] / scripts / gen_ir.py
1 #!/usr/bin/env python
2 import sys
3 import re
4 from jinja2 import Environment, Template
5 from jinja2.filters import do_dictsort
6 from spec_util import is_dynamic_pinned, verify_node, isAbstract, setdefault
7 from ir_spec import nodes
8
9 def format_parameterlist(parameterlist):
10         return "\n".join(parameterlist)
11
12 def format_nodearguments(node):
13         arguments = map(lambda arg: arg["name"], node.arguments)
14         return format_parameterlist(arguments)
15
16 def format_nodeparameters(node):
17         parameters = map(lambda arg: arg["type"] + " " + arg["name"], node.arguments)
18         return format_parameterlist(parameters)
19
20 def format_blockparameter(node):
21         if hasattr(node, "knownBlock"):
22                 if hasattr(node, "knownGraph"):
23                         return ""
24                 return "ir_graph *irg"
25         else:
26                 return "ir_node *block"
27
28 def format_blockargument(node):
29         if hasattr(node, "knownBlock"):
30                 if hasattr(node, "knownGraph"):
31                         return ""
32                 return "irg"
33         else:
34                 return "block"
35
36 def format_irgassign(node):
37         if hasattr(node, "knownGraph"):
38                 return "ir_graph *irg = %s;\n" % node.graph
39
40         if hasattr(node, "knownBlock"):
41                 return ""
42         else:
43                 return "ir_graph *irg = get_Block_irg(block);\n"
44
45 def format_curblock(node):
46         if hasattr(node, "knownBlock"):
47                 if hasattr(node, "knownGraph"):
48                         return ""
49                 return "current_ir_graph"
50         else:
51                 return "current_ir_graph->current_block"
52
53 def format_insdecl(node):
54         arity = node.arity
55         if arity == "variable" and len(node.ins) == 0 or arity == "dynamic" or arity == 0:
56                 return ""
57
58         if arity == "variable":
59                 insarity = len(node.ins)
60                 res  = "int r_arity = arity + " + `insarity` + ";"
61                 res += "\n\tir_node **r_in;"
62                 res += "\n\tNEW_ARR_A(ir_node *, r_in, r_arity);"
63                 i = 0
64                 for input in node.ins:
65                         res += "\n\tr_in[" + `i` + "] = irn_" + input + ";"
66                         i += 1
67                 res += "\n\tmemcpy(&r_in[" + `insarity` + "], in, sizeof(ir_node *) * arity);\n\t"
68         else:
69                 res = "ir_node *in[" + `arity` + "];"
70                 i = 0
71                 for input in node.ins:
72                         res += "\n\tin[" + `i` + "] = irn_" + input + ";"
73                         i += 1
74         return res
75
76 def format_arity_and_ins(node):
77         arity = node.arity
78         if arity == "dynamic":
79                 return "-1, NULL"
80         elif arity == "variable":
81                 if len(node.ins) == 0:
82                         return "arity, in"
83                 else:
84                         return "r_arity, r_in"
85         elif arity == 0:
86                 return "0, NULL"
87         else:
88                 return `arity` + ", in"
89
90 def format_arity(node):
91         if hasattr(node, "arity_override"):
92                 return node.arity_override
93         arity = node.arity
94         if arity == "dynamic":
95                 return "oparity_dynamic"
96         if arity == "variable":
97                 return "oparity_variable"
98         if arity == 0:
99                 return "oparity_zero"
100         if arity == 1:
101                 return "oparity_unary"
102         if arity == 2:
103                 return "oparity_binary"
104         if arity == 3:
105                 return "oparity_trinary"
106         return "oparity_any"
107
108 def format_pinned(node):
109         pinned = node.pinned
110         if pinned == "yes":
111                 return "op_pin_state_pinned"
112         if pinned == "no":
113                 return "op_pin_state_floats"
114         if pinned == "exception":
115                 return "op_pin_state_exc_pinned"
116         if pinned == "memory":
117                 return "op_pin_state_mem_pinned"
118         print "WARNING: Unknown pinned state %s in format pined" % pinned
119         return ""
120
121 def format_flags(node):
122         flags = map(lambda x : "irop_flag_" + x, node.flags)
123         if flags == []:
124                 flags = [ "irop_flag_none" ]
125         return " | ".join(flags)
126
127 def format_attr_size(node):
128         if not hasattr(node, "attr_struct"):
129                 return "0"
130         return "sizeof(%s)" % node.attr_struct
131
132 def format_opindex(node):
133         if hasattr(node, "op_index"):
134                 return node.op_index
135         return "-1"
136
137 keywords = frozenset([ "true", "false" ])
138 def format_escape_keywords(word):
139         if word in keywords:
140                 return word + "_"
141         return word
142
143 def filter_isnot(list, flag):
144         return filter(lambda x: not hasattr(x, flag), list)
145
146 def filter_hasnot(list, flag):
147         return filter(lambda x: flag not in x, list)
148
149 def format_arguments(string, voidwhenempty = False):
150         args = re.split('\s*\n\s*', string)
151         if args[0] == '':
152                 args = args[1:]
153         if len(args) > 0 and args[-1] == '':
154                 args = args[:-1]
155         if len(args) == 0 and voidwhenempty:
156                 return "void"
157         return ", ".join(args)
158
159 def format_parameters(string):
160         return format_arguments(string, voidwhenempty = True)
161
162 env = Environment()
163 env.filters['parameterlist']   = format_parameterlist
164 env.filters['nodearguments']   = format_nodearguments
165 env.filters['nodeparameters']  = format_nodeparameters
166 env.filters['blockparameter']  = format_blockparameter
167 env.filters['blockargument']   = format_blockargument
168 env.filters['irgassign']       = format_irgassign
169 env.filters['curblock']        = format_curblock
170 env.filters['insdecl']         = format_insdecl
171 env.filters['arity_and_ins']   = format_arity_and_ins
172 env.filters['arity']           = format_arity
173 env.filters['pinned']          = format_pinned
174 env.filters['flags']           = format_flags
175 env.filters['attr_size']       = format_attr_size
176 env.filters['opindex']         = format_opindex
177 env.filters['isnot']           = filter_isnot
178 env.filters['hasnot']          = filter_hasnot
179 env.filters['arguments']       = format_arguments
180 env.filters['parameters']      = format_parameters
181 env.filters['escape_keywords'] = format_escape_keywords
182
183 def prepare_attr(attr):
184         if "init" in attr:
185                 return dict(type = attr["type"], name = attr["name"], init = attr["init"])
186         else:
187                 return dict(type = attr["type"], name = attr["name"])
188
189 def preprocess_node(node):
190         verify_node(node)
191
192         setdefault(node, "attrs_name", node.name.lower())
193         setdefault(node, "block", "block")
194
195         # construct node arguments
196         arguments = [ ]
197         initattrs = [ ]
198         specialconstrs = [ ]
199         for input in node.ins:
200                 arguments.append(dict(type = "ir_node *", name = "irn_" + input))
201
202         if node.arity == "variable" or node.arity == "dynamic":
203                 arguments.append(dict(type = "int", name = "arity"))
204                 arguments.append(dict(type = "ir_node **", name = "in"))
205
206         if not hasattr(node, "mode"):
207                 arguments.append(dict(type = "ir_mode *", name = "mode"))
208                 node.mode = "mode"
209
210         attrs_with_special = 0
211         for attr in node.attrs:
212                 attr.setdefault("initname", "." + attr["name"])
213
214                 if "special" in attr:
215                         if not "init" in attr:
216                                 print "Node type %s has an attribute with a \"special\" entry but without \"init\"" % node.name
217                                 sys.exit(1)
218
219                         if attrs_with_special != 0:
220                                 print "Node type %s has more than one attribute with a \"special\" entry" % node.name
221                                 sys.exit(1)
222
223                         attrs_with_special += 1
224
225                         if "prefix" in attr["special"]:
226                                 specialname = attr["special"]["prefix"] + node.name
227                         elif "suffix" in attr["special"]:
228                                 specialname = node.name + attr["special"]["suffix"]
229                         else:
230                                 print "Unknown special constructor type for node type %s" % node.name
231                                 sys.exit(1)
232
233                         specialconstrs.append(
234                                 dict(
235                                         constrname = specialname,
236                                         attr = attr
237                                 )
238                         )
239                 elif not "init" in attr:
240                         arguments.append(prepare_attr(attr))
241
242         # dynamic pin state means more constructor arguments
243         if is_dynamic_pinned(node):
244                 if hasattr(node, "pinned_init"):
245                         initattrs.append(dict(
246                                 initname = ".exc.pin_state",
247                                 init     = node.pinned_init
248                         ))
249                 else:
250                         node.constructor_args.append(
251                                 dict(
252                                         name = "pin_state",
253                                         type = "op_pin_state"
254                                 )
255                         )
256                         initattrs.append(dict(
257                                 initname = ".exc.pin_state",
258                                 init     = "pin_state"
259                         ))
260
261         for arg in node.constructor_args:
262                 arguments.append(prepare_attr(arg))
263                 if arg["type"] == "ir_cons_flags":
264                         name = arg["name"]
265                         initattrs.append(dict(initname = ".exc.pin_state",
266                                 init = name + " & cons_floats ? op_pin_state_floats : op_pin_state_pinned"))
267                         initattrs.append(dict(initname = ".volatility",
268                                 init = name + " & cons_volatile ? volatility_is_volatile : volatility_non_volatile"))
269                         initattrs.append(dict(initname = ".aligned",
270                                 init = name + " & cons_unaligned ? align_non_aligned : align_is_aligned"))
271
272         node.arguments = arguments
273         node.initattrs = initattrs
274         node.special_constructors = specialconstrs
275
276 #############################
277
278 constructor_template = env.from_string('''
279
280 ir_node *new_rd_{{node.constrname}}(
281         {%- filter parameters %}
282                 dbg_info *dbgi
283                 {{node|blockparameter}}
284                 {{node|nodeparameters}}
285         {% endfilter %})
286 {
287         ir_node *res;
288         {{node|irgassign}}
289         {{node|insdecl}}
290         res = new_ir_node(
291                 {%- filter arguments %}
292                         dbgi
293                         irg
294                         {{node.block}}
295                         op_{{node.name}}
296                         {{node.mode}}
297                         {{node|arity_and_ins}}
298                 {% endfilter %});
299         {%- for attr in node.attrs %}
300         res->attr.{{node.attrs_name}}{{attr["initname"]}} =
301                 {%- if "init" in attr %} {{ attr["init"] -}};
302                 {%- else              %} {{ attr["name"] -}};
303                 {%- endif %}
304         {%- endfor %}
305         {%- for attr in node.initattrs %}
306         res->attr.{{node.attrs_name}}{{attr["initname"]}} = {{ attr["init"] -}};
307         {%- endfor %}
308         {{- node.init }}
309         {%- if node.optimize != False %}
310         res = optimize_node(res);
311         {%- endif %}
312         irn_verify_irg(res, irg);
313         return res;
314 }
315
316 ir_node *new_r_{{node.constrname}}(
317                 {%- filter parameters %}
318                         {{node|blockparameter}}
319                         {{node|nodeparameters}}
320                 {% endfilter %})
321 {
322         return new_rd_{{node.constrname}}(
323                 {%- filter arguments %}
324                         NULL
325                         {{node|blockargument}}
326                         {{node|nodearguments}}
327                 {% endfilter %});
328 }
329
330 ir_node *new_d_{{node.constrname}}(
331                 {%- filter parameters %}
332                         dbg_info *dbgi
333                         {{node|nodeparameters}}
334                 {% endfilter %})
335 {
336         ir_node *res;
337         assert(get_irg_phase_state(current_ir_graph) == phase_building);
338         res = new_rd_{{node.constrname}}(
339                 {%- filter parameters %}
340                         dbgi
341                         {{node|curblock}}
342                         {{node|nodearguments}}
343                 {% endfilter %});
344         return res;
345 }
346
347 ir_node *new_{{node.constrname}}(
348                 {%- filter parameters %}
349                         {{node|nodeparameters}}
350                 {% endfilter %})
351 {
352         return new_d_{{node.constrname}}(
353                 {%- filter arguments %}
354                         NULL
355                         {{node|nodearguments}}
356                 {% endfilter %});
357 }
358 ''')
359
360 irnode_h_template = env.from_string('''
361 /* Warning: automatically generated code */
362
363 {%- for node in nodes|isnot('custom_is') %}
364 static inline int _is_{{node.name}}(const ir_node *node)
365 {
366         assert(node != NULL);
367         return _get_irn_op(node) == op_{{node.name}};
368 }
369 {%- endfor -%}
370
371 {% for node in nodes %}
372 #define is_{{node.name}}(node)    _is_{{node.name}}(node)
373 {%- endfor %}
374
375 ''')
376
377 irnode_template = env.from_string('''
378 /* Warning: automatically generated code */
379 {% for node in nodes %}
380 int (is_{{node.name}})(const ir_node *node)
381 {
382         return _is_{{node.name}}(node);
383 }
384 {% endfor %}
385
386 {%- for node in nodes %}
387 {%- for attr in node.attrs|hasnot("noprop") %}
388 {{attr.type}} (get_{{node.name}}_{{attr.name}})(const ir_node *node)
389 {
390         assert(is_{{node.name}}(node));
391         return node->attr.{{node.attrs_name}}.{{attr.name}};
392 }
393
394 void (set_{{node.name}}_{{attr.name}})(ir_node *node, {{attr.type}} {{attr.name}})
395 {
396         assert(is_{{node.name}}(node));
397         node->attr.{{node.attrs_name}}.{{attr.name}} = {{attr.name}};
398 }
399 {% endfor -%}
400 {% endfor -%}
401
402 {%- for node in nodes %}
403 {%- for in in node.ins %}
404 ir_node *(get_{{node.name}}_{{in}})(const ir_node *node)
405 {
406         assert(is_{{node.name}}(node));
407         return get_irn_n(node, {{node.ins.index(in)}});
408 }
409
410 void (set_{{node.name}}_{{in}})(ir_node *node, ir_node *{{in|escape_keywords}})
411 {
412         assert(is_{{node.name}}(node));
413         set_irn_n(node, {{node.ins.index(in)}}, {{in|escape_keywords}});
414 }
415 {% endfor %}
416 {% endfor %}
417 ''')
418
419 irop_template = env.from_string('''
420 /* Warning: automatically generated code */
421 {% for node in nodes %}
422 ir_op *op_{{node.name}}; ir_op *get_op_{{node.name}}(void) { return op_{{node.name}}; }
423 {%- endfor %}
424
425 void init_op(void)
426 {
427         {% for node in nodes %}
428         op_{{node.name}} = new_ir_op(
429                 {%- filter arguments %}
430                         iro_{{node.name}}
431                         "{{node.name}}"
432                         {{node|pinned}}
433                         {{node|flags}}
434                         {{node|arity}}
435                         {{node|opindex}}
436                         {{node|attr_size}}
437                         NULL
438                 {% endfilter %});
439         {%- endfor %}
440
441         be_init_op();
442 }
443
444 void finish_op(void)
445 {
446         {% for node in nodes %}
447         free_ir_op(op_{{node.name}}); op_{{node.name}} = NULL;
448         {%- endfor %}
449 }
450
451 ''')
452
453 nodeops_h_template = env.from_string('''
454 /* Warning: automatically generated code */
455 #ifndef FIRM_IR_NODEOPS_H
456 #define FIRM_IR_NODEOPS_H
457
458 #include "firm_types.h"
459
460 /**
461  * @addtogroup ir_node
462  * @{
463  */
464
465 {% for node in nodes -%}
466 {% if node.outs %}
467 /**
468  * Projection numbers for result of {{node.name}} node (use for Proj nodes)
469  */
470 typedef enum {
471         {% for out in node.outs -%}
472         pn_{{node.name}}_{{out[0]}}
473         {%- if out.__len__() > 2 %} = {{out[2]}}{% endif %}, /**< {{out[1]}} */
474         {% endfor -%}
475         pn_{{node.name}}_max
476 } pn_{{node.name}};
477 {% endif %}
478 {%- endfor %}
479
480 {% for node in nodes %}
481 /** Return true of the node is a {{node.name}} node. */
482 FIRM_API int is_{{node.name}}(const ir_node *node);
483 {%- endfor %}
484
485 {% for node in nodes %}
486 {% for in in node.ins -%}
487 FIRM_API ir_node *get_{{node.name}}_{{in}}(const ir_node *node);
488 void set_{{node.name}}_{{in}}(ir_node *node, ir_node *{{in|escape_keywords}});
489 {% endfor -%}
490 {% for attr in node.attrs|hasnot("noprop") -%}
491 FIRM_API {{attr.type}} get_{{node.name}}_{{attr.name}}(const ir_node *node);
492 FIRM_API void set_{{node.name}}_{{attr.name}}(ir_node *node, {{attr.type}} {{attr.name}});
493 {% endfor -%}
494 {% endfor -%}
495
496 /** @} */
497
498 #endif
499 ''')
500
501 opcodes_h_template = env.from_string('''
502 /* Warning: automatically generated code */
503 #ifndef FIRM_IR_OPCODES_H
504 #define FIRM_IR_OPCODES_H
505
506 /** The opcodes of the libFirm predefined operations. */
507 typedef enum ir_opcode {
508 {%- for node in nodes %}
509         iro_{{node.name}},
510 {%- endfor %}
511         iro_First = iro_{{nodes[0].name}},
512         iro_Last = iro_{{nodes[-1].name}},
513
514         beo_First,
515         /* backend specific nodes */
516         beo_Spill = beo_First,
517         beo_Reload,
518         beo_Perm,
519         beo_MemPerm,
520         beo_Copy,
521         beo_Keep,
522         beo_CopyKeep,
523         beo_Call,
524         beo_Return,
525         beo_AddSP,
526         beo_SubSP,
527         beo_IncSP,
528         beo_Start,
529         beo_FrameAddr,
530         beo_Barrier,
531         /* last backend node number */
532         beo_Last = beo_Barrier,
533         iro_MaxOpcode
534 } ir_opcode;
535
536 {% for node in nodes %}
537 FIRM_API ir_op *op_{{node.name}};
538 {%- endfor %}
539
540 {% for node in nodes %}
541 FIRM_API ir_op *get_op_{{node.name}}(void);
542 {%- endfor %}
543
544 #endif
545 ''')
546
547 #############################
548
549 def prepare_nodes():
550         real_nodes = []
551         for node in nodes:
552                 if isAbstract(node):
553                         continue
554                 real_nodes.append(node)
555
556         for node in real_nodes:
557                 preprocess_node(node)
558
559         return real_nodes
560
561 def main(argv):
562         if len(argv) < 3:
563                 print "usage: %s specname(ignored) destdirectory" % argv[0]
564                 sys.exit(1)
565
566         gendir = argv[2]
567         # hardcoded path to libfirm/include/libfirm
568         gendir2 = argv[2] + "/../../include/libfirm"
569
570         # List of TODOs
571         niymap = [ "ASM", "Const", "Phi", "SymConst", "Sync"]
572
573         real_nodes = prepare_nodes()
574         file = open(gendir + "/gen_ir_cons.c.inl", "w")
575         for node in real_nodes:
576                 if node.name in niymap:
577                         continue
578
579                 if not isAbstract(node) and not hasattr(node, "singleton"):
580                         file.write(constructor_template.render(vars()))
581
582                         if hasattr(node, "special_constructors"):
583                                 for special in node.special_constructors:
584                                         node.constrname = special["constrname"]
585                                         special["attr"]["init"] = special["attr"]["special"]["init"]
586                                         file.write(constructor_template.render(vars()))
587         file.write("\n")
588         file.close()
589
590         file = open(gendir + "/gen_irnode.h", "w")
591         file.write(irnode_h_template.render(nodes = real_nodes))
592         file.close()
593
594         file = open(gendir + "/gen_irnode.c.inl", "w")
595         file.write(irnode_template.render(nodes = real_nodes))
596         file.close()
597
598         file = open(gendir + "/gen_irop.c.inl", "w")
599         file.write(irop_template.render(nodes = real_nodes))
600         file.close()
601
602         file = open(gendir2 + "/opcodes.h", "w")
603         file.write(opcodes_h_template.render(nodes = real_nodes))
604         file.close()
605
606         file = open(gendir2 + "/nodeops.h", "w")
607         file.write(nodeops_h_template.render(nodes = real_nodes))
608         file.close()
609
610 main(sys.argv)