X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=scripts%2Fgen_ir.py;h=4e17588566d4e5fefce7b9610b84107310356387;hb=512040328cb40848cfa6b04e43c257812bbbcfec;hp=eab03c5a57992124d4f5d9c378f43a767dde5f97;hpb=ffbc2525c2dd6a72471461165227e2ae5fed7ae4;p=libfirm diff --git a/scripts/gen_ir.py b/scripts/gen_ir.py index eab03c5a5..4e1758856 100755 --- a/scripts/gen_ir.py +++ b/scripts/gen_ir.py @@ -6,46 +6,49 @@ from jinja2.filters import do_dictsort from spec_util import is_dynamic_pinned, verify_node, isAbstract, setdefault from ir_spec import nodes -def format_argdecls(node, first = False, voidwhenempty = False): - if len(node.arguments) == 0: - if voidwhenempty: - return "void" - else: - return "" +def format_parameterlist(parameterlist): + return "\n".join(parameterlist) - arguments = map(lambda arg: arg["type"] + " " + arg["name"], node.arguments) - res = "" - if not first: - res = ", " - res += ", ".join(arguments) - return res +def format_nodearguments(node): + arguments = map(lambda arg: arg["name"], node.arguments) + return format_parameterlist(arguments) -def format_args(node, first = False): - res = "" - if not first and node.arguments != []: - res = ", " +def format_nodeparameters(node): + parameters = map(lambda arg: arg["type"] + " " + arg["name"], node.arguments) + return format_parameterlist(parameters) - arguments = map(lambda arg: arg["name"], node.arguments) - res += ", ".join(arguments) - return res +def format_blockparameter(node): + if hasattr(node, "knownBlock"): + if hasattr(node, "knownGraph"): + return "" + return "ir_graph *irg" + else: + return "ir_node *block" -def format_blockdecl(node): +def format_blockargument(node): if hasattr(node, "knownBlock"): - return "" + if hasattr(node, "knownGraph"): + return "" + return "irg" else: - return ", ir_node *block" + return "block" + +def format_irgassign(node): + if hasattr(node, "knownGraph"): + return "ir_graph *irg = %s;\n" % node.graph -def format_block(node): if hasattr(node, "knownBlock"): return "" else: - return ", block" + return "ir_graph *irg = get_Block_irg(block);\n" def format_curblock(node): if hasattr(node, "knownBlock"): - return "" + if hasattr(node, "knownGraph"): + return "" + return "current_ir_graph" else: - return ", current_ir_graph->current_block" + return "current_ir_graph->current_block" def format_insdecl(node): arity = node.arity @@ -54,18 +57,19 @@ def format_insdecl(node): if arity == "variable": insarity = len(node.ins) - res = "int r_arity = arity + " + `insarity` + ";\n\tir_node **r_in;\n\t" \ - + "NEW_ARR_A(ir_node *, r_in, r_arity);\n\t" + res = "int r_arity = arity + " + `insarity` + ";" + res += "\n\tir_node **r_in;" + res += "\n\tNEW_ARR_A(ir_node *, r_in, r_arity);" i = 0 for input in node.ins: - res += "r_in[" + `i` + "] = irn_" + input + ";\n\t" + res += "\n\tr_in[" + `i` + "] = irn_" + input + ";" i += 1 - res += "memcpy(&r_in[" + `insarity` + "], in, sizeof(ir_node *) * arity);\n\t" + res += "\n\tmemcpy(&r_in[" + `insarity` + "], in, sizeof(ir_node *) * arity);\n\t" else: - res = "ir_node *in[" + `arity` + "];\n\t" + res = "ir_node *in[" + `arity` + "];" i = 0 for input in node.ins: - res += "in[" + `i` + "] = irn_" + input + ";\n\t" + res += "\n\tin[" + `i` + "] = irn_" + input + ";" i += 1 return res @@ -130,28 +134,51 @@ def format_opindex(node): return node.op_index return "-1" +keywords = frozenset([ "true", "false" ]) +def format_escape_keywords(word): + if word in keywords: + return word + "_" + return word + def filter_isnot(list, flag): - result = [] - for node in list: - if hasattr(node, flag): - continue - result.append(node) - return result + return filter(lambda x: not hasattr(x, flag), list) + +def filter_hasnot(list, flag): + return filter(lambda x: flag not in x, list) + +def format_arguments(string, voidwhenempty = False): + args = re.split('\s*\n\s*', string) + if args[0] == '': + args = args[1:] + if len(args) > 0 and args[-1] == '': + args = args[:-1] + if len(args) == 0 and voidwhenempty: + return "void" + return ", ".join(args) + +def format_parameters(string): + return format_arguments(string, voidwhenempty = True) env = Environment() -env.filters['argdecls'] = format_argdecls -env.filters['args'] = format_args -env.filters['blockdecl'] = format_blockdecl -env.filters['block'] = format_block -env.filters['curblock'] = format_curblock -env.filters['insdecl'] = format_insdecl -env.filters['arity_and_ins'] = format_arity_and_ins -env.filters['arity'] = format_arity -env.filters['pinned'] = format_pinned -env.filters['flags'] = format_flags -env.filters['attr_size'] = format_attr_size -env.filters['isnot'] = filter_isnot -env.filters['opindex'] = format_opindex +env.filters['parameterlist'] = format_parameterlist +env.filters['nodearguments'] = format_nodearguments +env.filters['nodeparameters'] = format_nodeparameters +env.filters['blockparameter'] = format_blockparameter +env.filters['blockargument'] = format_blockargument +env.filters['irgassign'] = format_irgassign +env.filters['curblock'] = format_curblock +env.filters['insdecl'] = format_insdecl +env.filters['arity_and_ins'] = format_arity_and_ins +env.filters['arity'] = format_arity +env.filters['pinned'] = format_pinned +env.filters['flags'] = format_flags +env.filters['attr_size'] = format_attr_size +env.filters['opindex'] = format_opindex +env.filters['isnot'] = filter_isnot +env.filters['hasnot'] = filter_hasnot +env.filters['arguments'] = format_arguments +env.filters['parameters'] = format_parameters +env.filters['escape_keywords'] = format_escape_keywords def prepare_attr(attr): if "init" in attr: @@ -250,61 +277,96 @@ def preprocess_node(node): constructor_template = env.from_string(''' -ir_node *new_rd_{{node.constrname}}(dbg_info *dbgi, ir_graph *irg{{node|blockdecl}}{{node|argdecls}}) +ir_node *new_rd_{{node.constrname}}( + {%- filter parameters %} + dbg_info *dbgi + {{node|blockparameter}} + {{node|nodeparameters}} + {% endfilter %}) { ir_node *res; - ir_graph *rem = current_ir_graph; + {{node|irgassign}} {{node|insdecl}} - current_ir_graph = irg; - res = new_ir_node(dbgi, irg, {{node.block}}, op_{{node.name}}, {{node.mode}}, {{node|arity_and_ins}}); - {% for attr in node.attrs -%} - res->attr.{{node.attrs_name}}{{attr["initname"]}} = + res = new_ir_node( + {%- filter arguments %} + dbgi + irg + {{node.block}} + op_{{node.name}} + {{node.mode}} + {{node|arity_and_ins}} + {% endfilter %}); + {%- for attr in node.attrs %} + res->attr.{{node.attrs_name}}{{attr["initname"]}} = {%- if "init" in attr %} {{ attr["init"] -}}; {%- else %} {{ attr["name"] -}}; - {% endif %} - {% endfor %} - {%- for attr in node.initattrs -%} - res->attr.{{node.attrs_name}}{{attr["initname"]}} = {{ attr["init"] -}}; + {%- endif %} + {%- endfor %} + {%- for attr in node.initattrs %} + res->attr.{{node.attrs_name}}{{attr["initname"]}} = {{ attr["init"] -}}; {%- endfor %} {{- node.init }} - {% if node.optimize != False -%} - res = optimize_node(res); - {% endif -%} - IRN_VRFY_IRG(res, irg); - current_ir_graph = rem; + {%- if node.optimize != False %} + res = optimize_node(res); + {%- endif %} + irn_verify_irg(res, irg); return res; } -ir_node *new_r_{{node.constrname}}(ir_graph *irg{{node|blockdecl}}{{node|argdecls}}) +ir_node *new_r_{{node.constrname}}( + {%- filter parameters %} + {{node|blockparameter}} + {{node|nodeparameters}} + {% endfilter %}) { - return new_rd_{{node.constrname}}(NULL, irg{{node|block}}{{node|args}}); + return new_rd_{{node.constrname}}( + {%- filter arguments %} + NULL + {{node|blockargument}} + {{node|nodearguments}} + {% endfilter %}); } -ir_node *new_d_{{node.constrname}}(dbg_info *dbgi{{node|argdecls}}) +ir_node *new_d_{{node.constrname}}( + {%- filter parameters %} + dbg_info *dbgi + {{node|nodeparameters}} + {% endfilter %}) { ir_node *res; - {{ node.d_pre }} - res = new_rd_{{node.constrname}}(dbgi, current_ir_graph{{node|curblock}}{{node|args}}); - {{ node.d_post }} + assert(get_irg_phase_state(current_ir_graph) == phase_building); + res = new_rd_{{node.constrname}}( + {%- filter parameters %} + dbgi + {{node|curblock}} + {{node|nodearguments}} + {% endfilter %}); return res; } -ir_node *new_{{node.constrname}}({{node|argdecls(True, True)}}) +ir_node *new_{{node.constrname}}( + {%- filter parameters %} + {{node|nodeparameters}} + {% endfilter %}) { - return new_d_{{node.constrname}}(NULL{{node|args}}); + return new_d_{{node.constrname}}( + {%- filter arguments %} + NULL + {{node|nodearguments}} + {% endfilter %}); } ''') irnode_h_template = env.from_string(''' /* Warning: automatically generated code */ -{% for node in nodes|isnot('custom_is') %} +{%- for node in nodes|isnot('custom_is') %} static inline int _is_{{node.name}}(const ir_node *node) { assert(node != NULL); return _get_irn_op(node) == op_{{node.name}}; } -{% endfor %} +{%- endfor -%} {% for node in nodes %} #define is_{{node.name}}(node) _is_{{node.name}}(node) @@ -320,6 +382,38 @@ int (is_{{node.name}})(const ir_node *node) return _is_{{node.name}}(node); } {% endfor %} + +{%- for node in nodes %} +{%- for attr in node.attrs|hasnot("noprop") %} +{{attr.type}} (get_{{node.name}}_{{attr.name}})(const ir_node *node) +{ + assert(is_{{node.name}}(node)); + return node->attr.{{node.attrs_name}}.{{attr.name}}; +} + +void (set_{{node.name}}_{{attr.name}})(ir_node *node, {{attr.type}} {{attr.name}}) +{ + assert(is_{{node.name}}(node)); + node->attr.{{node.attrs_name}}.{{attr.name}} = {{attr.name}}; +} +{% endfor -%} +{% endfor -%} + +{%- for node in nodes %} +{%- for in in node.ins %} +ir_node *(get_{{node.name}}_{{in}})(const ir_node *node) +{ + assert(is_{{node.name}}(node)); + return get_irn_n(node, {{node.ins.index(in)}}); +} + +void (set_{{node.name}}_{{in}})(ir_node *node, ir_node *{{in|escape_keywords}}) +{ + assert(is_{{node.name}}(node)); + set_irn_n(node, {{node.ins.index(in)}}, {{in|escape_keywords}}); +} +{% endfor %} +{% endfor %} ''') irop_template = env.from_string(''' @@ -331,7 +425,17 @@ ir_op *op_{{node.name}}; ir_op *get_op_{{node.name}}(void) { return op_{{node.na void init_op(void) { {% for node in nodes %} - op_{{node.name}} = new_ir_op(iro_{{node.name}}, "{{node.name}}", {{node|pinned}}, {{node|flags}}, {{node|arity}}, {{node|opindex}}, {{node|attr_size}}, NULL); + op_{{node.name}} = new_ir_op( + {%- filter arguments %} + iro_{{node.name}} + "{{node.name}}" + {{node|pinned}} + {{node|flags}} + {{node|arity}} + {{node|opindex}} + {{node|attr_size}} + NULL + {% endfilter %}); {%- endfor %} be_init_op(); @@ -343,30 +447,132 @@ void finish_op(void) free_ir_op(op_{{node.name}}); op_{{node.name}} = NULL; {%- endfor %} } + +''') + +nodeops_h_template = env.from_string(''' +/* Warning: automatically generated code */ +#ifndef FIRM_IR_NODEOPS_H +#define FIRM_IR_NODEOPS_H + +#include "firm_types.h" + +/** + * @addtogroup ir_node + * @{ + */ + +{% for node in nodes -%} +{% if node.outs %} +/** + * Projection numbers for result of {{node.name}} node (use for Proj nodes) + */ +typedef enum { + {% for out in node.outs -%} + pn_{{node.name}}_{{out[0]}} + {%- if out.__len__() > 2 %} = {{out[2]}}{% endif %}, /**< {{out[1]}} */ + {% endfor -%} + pn_{{node.name}}_max +} pn_{{node.name}}; +{% endif %} +{%- endfor %} + +{% for node in nodes %} +/** Return true of the node is a {{node.name}} node. */ +FIRM_API int is_{{node.name}}(const ir_node *node); +{%- endfor %} + +{% for node in nodes %} +{% for in in node.ins -%} +FIRM_API ir_node *get_{{node.name}}_{{in}}(const ir_node *node); +void set_{{node.name}}_{{in}}(ir_node *node, ir_node *{{in|escape_keywords}}); +{% endfor -%} +{% for attr in node.attrs|hasnot("noprop") -%} +FIRM_API {{attr.type}} get_{{node.name}}_{{attr.name}}(const ir_node *node); +FIRM_API void set_{{node.name}}_{{attr.name}}(ir_node *node, {{attr.type}} {{attr.name}}); +{% endfor -%} +{% endfor -%} + +/** @} */ + +#endif +''') + +opcodes_h_template = env.from_string(''' +/* Warning: automatically generated code */ +#ifndef FIRM_IR_OPCODES_H +#define FIRM_IR_OPCODES_H + +/** The opcodes of the libFirm predefined operations. */ +typedef enum ir_opcode { +{%- for node in nodes %} + iro_{{node.name}}, +{%- endfor %} + iro_First = iro_{{nodes[0].name}}, + iro_Last = iro_{{nodes[-1].name}}, + + beo_First, + /* backend specific nodes */ + beo_Spill = beo_First, + beo_Reload, + beo_Perm, + beo_MemPerm, + beo_Copy, + beo_Keep, + beo_CopyKeep, + beo_Call, + beo_Return, + beo_AddSP, + beo_SubSP, + beo_IncSP, + beo_Start, + beo_FrameAddr, + beo_Barrier, + /* last backend node number */ + beo_Last = beo_Barrier, + iro_MaxOpcode +} ir_opcode; + +{% for node in nodes %} +FIRM_API ir_op *op_{{node.name}}; +{%- endfor %} + +{% for node in nodes %} +FIRM_API ir_op *get_op_{{node.name}}(void); +{%- endfor %} + +#endif ''') ############################# +def prepare_nodes(): + real_nodes = [] + for node in nodes: + if isAbstract(node): + continue + real_nodes.append(node) + + for node in real_nodes: + preprocess_node(node) + + return real_nodes + def main(argv): if len(argv) < 3: print "usage: %s specname(ignored) destdirectory" % argv[0] sys.exit(1) gendir = argv[2] + # hardcoded path to libfirm/include/libfirm + gendir2 = argv[2] + "/../../include/libfirm" # List of TODOs niymap = [ "ASM", "Const", "Phi", "SymConst", "Sync"] - real_nodes = [] - for node in nodes: - if isAbstract(node): - continue - real_nodes.append(node) - + real_nodes = prepare_nodes() file = open(gendir + "/gen_ir_cons.c.inl", "w") for node in real_nodes: - preprocess_node(node) - if node.name in niymap: continue @@ -393,4 +599,12 @@ def main(argv): file.write(irop_template.render(nodes = real_nodes)) file.close() + file = open(gendir2 + "/opcodes.h", "w") + file.write(opcodes_h_template.render(nodes = real_nodes)) + file.close() + + file = open(gendir2 + "/nodeops.h", "w") + file.write(nodeops_h_template.render(nodes = real_nodes)) + file.close() + main(sys.argv)