Generate appropriate gcc.Gimple subclasses for each statement; add some experiments on also wrapping the underlying layouts

davidmalcolm · davidmalcolm · commit b64cff135685 · 2011-04-25T14:36:10.000-04:00
diff --git a/Makefile b/Makefile
@@ -36,10 +36,10 @@ autogenerated-gimple-types.txt: gimple-types.txt.in
 autogenerated-tree-types.txt: tree-types.txt.in
 	cpp $(CFLAGS) $^ -o $@
 
-autogenerated-tree.c: cpybuilder.py generate-tree-c.py autogenerated-tree-types.txt
+autogenerated-tree.c: cpybuilder.py generate-tree-c.py autogenerated-tree-types.txt maketreetypes.py
 	python generate-tree-c.py > $@
 
-autogenerated-gimple.c: cpybuilder.py generate-gimple-c.py autogenerated-gimple-types.txt
+autogenerated-gimple.c: cpybuilder.py generate-gimple-c.py autogenerated-gimple-types.txt maketreetypes.py
 	python generate-gimple-c.py > $@
 
 # Hint for debugging: add -v to the gcc options 
diff --git a/gcc-python-tree.c b/gcc-python-tree.c
@@ -54,8 +54,13 @@ PyObject*
 gcc_python_make_wrapper_gimple(gimple stmt)
 {
     struct PyGccGimple *gimple_obj = NULL;
+    PyTypeObject* tp;
+  
+    tp = gcc_python_autogenerated_gimple_type_for_stmt(stmt);
+    assert(tp);
+    //printf("tp:%p\n", tp);
   
-    gimple_obj = PyObject_New(struct PyGccGimple, &gcc_GimpleType);
+    gimple_obj = PyObject_New(struct PyGccGimple, tp);
     if (!gimple_obj) {
         goto error;
     }
diff --git a/gcc-python.h b/gcc-python.h
@@ -57,6 +57,8 @@ DECLARE_SIMPLE_WRAPPER(PyGccTree,
 /* autogenerated-gimple.c */
 int autogenerated_gimple_init_types(void);
 void autogenerated_gimple_add_types(PyObject *m);
+PyTypeObject* gcc_python_autogenerated_gimple_type_for_stmt(gimple g);
+
 
 int
 gcc_python_autogenerated_tree_init_types(void);
diff --git a/generate-gimple-c.py b/generate-gimple-c.py
@@ -1,4 +1,4 @@
-from maketreetypes import iter_gimple_types
+from maketreetypes import iter_gimple_types, iter_gimple_struct_types
 
 from cpybuilder import *
 
@@ -11,8 +11,155 @@
 modinit_preinit = ''
 modinit_postinit = ''
 
+gimple_struct_types = list(iter_gimple_struct_types())
 gimple_types = list(iter_gimple_types())
 
+# gimple.h declares a family of struct gimple_statement_* which internally express an inheritance hierarchy, via enum enum gimple_statement_structure_enum (see gsstruct.def).
+# FIXME there's also enum gimple_code, which is used to look up into this hierarchy
+#
+# From reading gimple.h, the struct hierarchy is:
+#
+# gimple_statement_base (GSS_BASE)
+#   gimple_statement_with_ops_base
+#      gimple_statement_with_ops (GSS_WITH_OPS)
+#      gimple_statement_with_memory_ops_base (GSS_WITH_MEM_OPS_BASE)
+#         gimple_statement_with_memory_ops (GSS_WITH_MEM_OPS)
+#         gimple_statement_call (GSS_CALL)
+#         gimple_statement_asm (GSS_ASM)
+#   gimple_statement_omp (GSS_OMP)
+#     gimple_statement_omp_critical (GSS_OMP_CRITICAL)
+#     gimple_statement_omp_for (GSS_OMP_FOR)
+#     gimple_statement_omp_parallel (GSS_OMP_PARALLEL)
+#       gimple_statement_omp_task (GSS_OMP_TASK)
+#     gimple_statement_omp_sections (GSS_OMP_SECTIONS)
+#     gimple_statement_omp_single (GSS_OMP_SINGLE)
+#   gimple_statement_bind (GSS_BIND)
+#   gimple_statement_catch (GSS_CATCH)
+#   gimple_statement_eh_filter (GSS_EH_FILTER)
+#   gimple_statement_eh_mnt (GSS_EH_MNT)
+#   gimple_statement_phi (GSS_PHI)
+#   gimple_statement_eh_ctrl (GSS_EH_CTRL)
+#   gimple_statement_try (GSS_TRY)
+#   gimple_statement_wce (GSS_WCE)
+#   gimple_statement_omp_continue (GSS_OMP_CONTINUE)   (does not inherit from gimple_statement_omp)
+#   gimple_statement_omp_atomic_load (GSS_OMP_ATOMIC_LOAD  (likewise)
+#   gimple_statement_omp_atomic_store (GSS_OMP_ATOMIC_STORE)  (ditto)
+
+# The inheritance hierarchy of struct gimple_statement_*,
+#  expressed as (structname, parentstructname) pairs:
+struct_hier = (('gimple_statement_base', None),
+               ('gimple_statement_with_ops_base', 'simple_statement_base'),
+               ('gimple_statement_with_ops', 'gimple_statement_with_ops_base'),
+               ('gimple_statement_with_memory_ops_base', 'gimple_statement_with_ops_base opbase'),
+               ('gimple_statement_with_memory_ops', 'gimple_statement_with_memory_ops_base membase'),
+               ('gimple_statement_call', 'gimple_statement_with_memory_ops_base membase'),
+               ('gimple_statement_omp', 'gimple_statement_base'),
+               ('gimple_statement_bind', 'gimple_statement_base'),
+               ('gimple_statement_catch', 'gimple_statement_base'),
+               ('gimple_statement_eh_filter', 'gimple_statement_base'),
+               ('gimple_statement_eh_mnt', 'gimple_statement_base'),
+               ('gimple_statement_phi', 'gimple_statement_base'),
+               ('gimple_statement_eh_ct', 'gimple_statement_base'),
+               ('gimple_statement_try', 'gimple_statement_base'),
+               ('gimple_statement_wce', 'gimple_statement_base'),
+               ('gimple_statement_asm', 'gimple_statement_with_memory_ops_base'),
+               ('gimple_statement_omp_critical', 'gimple_statement_omp'),
+               ('gimple_statement_omp_for', 'gimple_statement_omp'),
+               ('gimple_statement_omp_parallel', 'gimple_statement_omp'),
+               ('gimple_statement_omp_task', 'gimple_statement_omp_parallel'),
+               ('gimple_statement_omp_sections', 'gimple_statement_omp'),
+               ('gimple_statement_omp_continue', 'gimple_statement_base'),
+               ('gimple_statement_omp_single', 'gimple_statement_omp'),
+               ('gimple_statement_omp_atomic_load', 'gimple_statement_base'),
+               ('gimple_statement_omp_atomic_store', 'gimple_statement_base'))
+
+# Interleaving with the material from gimple.def:
+# gimple_statement_base (GSS_BASE)
+#   GIMPLE_ERROR_MARK, "gimple_error_mark", GSS_BASE
+#   GIMPLE_NOP, "gimple_nop", GSS_BASE
+#   GIMPLE_OMP_RETURN, "gimple_omp_return", GSS_BASE
+#   GIMPLE_OMP_SECTIONS_SWITCH, "gimple_omp_sections_switch", GSS_BASE
+#   GIMPLE_PREDICT, "gimple_predict", GSS_BASE
+#   gimple_statement_with_ops_base
+#      gimple_statement_with_ops (GSS_WITH_OPS)
+#        GIMPLE_COND, "gimple_cond", GSS_WITH_OPS
+#        GIMPLE_DEBUG, "gimple_debug", GSS_WITH_OPS
+#        GIMPLE_GOTO, "gimple_goto", GSS_WITH_OPS
+#        GIMPLE_LABEL, "gimple_label", GSS_WITH_OPS
+#        GIMPLE_SWITCH, "gimple_switch", GSS_WITH_OPS
+#      gimple_statement_with_memory_ops_base (GSS_WITH_MEM_OPS_BASE)
+#         gimple_statement_with_memory_ops (GSS_WITH_MEM_OPS)
+#           GIMPLE_ASSIGN, "gimple_assign", GSS_WITH_MEM_OPS
+#           GIMPLE_RETURN, "gimple_return", GSS_WITH_MEM_OPS
+#         gimple_statement_call (GSS_CALL)
+#           GIMPLE_CALL, "gimple_call", GSS_CALL
+#         gimple_statement_asm (GSS_ASM)
+#            GIMPLE_ASM, "gimple_asm", GSS_ASM
+#   gimple_statement_omp (GSS_OMP)
+#     GIMPLE_OMP_MASTER, "gimple_omp_master", GSS_OMP
+#     GIMPLE_OMP_ORDERED, "gimple_omp_ordered", GSS_OMP
+#     GIMPLE_OMP_SECTION, "gimple_omp_section", GSS_OMP
+#     gimple_statement_omp_critical (GSS_OMP_CRITICAL)
+#       GIMPLE_OMP_CRITICAL, "gimple_omp_critical", GSS_OMP_CRITICAL
+#     gimple_statement_omp_for (GSS_OMP_FOR)
+#        GIMPLE_OMP_FOR, "gimple_omp_for", GSS_OMP_FOR
+#     gimple_statement_omp_parallel (GSS_OMP_PARALLEL)
+#       GIMPLE_OMP_PARALLEL, "gimple_omp_parallel", GSS_OMP_PARALLEL
+#       gimple_statement_omp_task (GSS_OMP_TASK)
+#       GIMPLE_OMP_TASK, "gimple_omp_task", GSS_OMP_TASK
+#     gimple_statement_omp_sections (GSS_OMP_SECTIONS)
+#       GIMPLE_OMP_SECTIONS, "gimple_omp_sections", GSS_OMP_SECTIONS
+#     gimple_statement_omp_single (GSS_OMP_SINGLE)
+#       GIMPLE_OMP_SINGLE, "gimple_omp_single", GSS_OMP_SINGLE
+#   gimple_statement_bind (GSS_BIND)
+#     GIMPLE_BIND, "gimple_bind", GSS_BIND
+#   gimple_statement_catch (GSS_CATCH)
+#     GIMPLE_CATCH, "gimple_catch", GSS_CATCH
+#   gimple_statement_eh_filter (GSS_EH_FILTER)
+#      GIMPLE_EH_FILTER, "gimple_eh_filter", GSS_EH_FILTER
+#   gimple_statement_eh_mnt (GSS_EH_MNT)
+#      GIMPLE_EH_MUST_NOT_THROW, "gimple_eh_must_not_throw", GSS_EH_MNT
+#   gimple_statement_phi (GSS_PHI)
+#      GIMPLE_PHI, "gimple_phi", GSS_PHI
+#   gimple_statement_eh_ctrl (GSS_EH_CTRL)
+#      GIMPLE_RESX, "gimple_resx", GSS_EH_CTRL
+#      GIMPLE_EH_DISPATCH, "gimple_eh_dispatch", GSS_EH_CTRL
+#   gimple_statement_try (GSS_TRY)
+#     GIMPLE_TRY, "gimple_try", GSS_TRY
+#   gimple_statement_wce (GSS_WCE)
+#     GIMPLE_WITH_CLEANUP_EXPR, "gimple_with_cleanup_expr", GSS_WCE
+#   gimple_statement_omp_continue (GSS_OMP_CONTINUE)   (does not inherit from gimple_statement_omp)
+#     GIMPLE_OMP_CONTINUE, "gimple_omp_continue", GSS_OMP_CONTINUE
+#   gimple_statement_omp_atomic_load (GSS_OMP_ATOMIC_LOAD  (likewise)
+#     GIMPLE_OMP_ATOMIC_LOAD, "gimple_omp_atomic_load", GSS_OMP_ATOMIC_LOAD
+#   gimple_statement_omp_atomic_store (GSS_OMP_ATOMIC_STORE)  (ditto)
+#     GIMPLE_OMP_ATOMIC_STORE, "gimple_omp_atomic_store", GSS_OMP_ATOMIC_STORE
+
+
+def generate_gimple_struct_subclasses():
+    global modinit_preinit
+    global modinit_postinit
+    
+    for gt in gimple_struct_types:
+    #print gimple_types
+        cc = gt.camel_cased_string()
+        pytype = PyTypeObject(identifier = 'gcc_GimpleStructType%sType' % cc,
+                              localname = 'GimpleStructType' + cc,
+                              tp_name = 'gcc.GimpleStructType%s' % cc,
+                              struct_name = 'struct PyGccGimple',
+                              tp_new = 'PyType_GenericNew',
+                              tp_base = '&gcc_GimpleType',
+                              #tp_getset = getsettable.identifier,
+                              #tp_repr = '(reprfunc)gcc_Gimple_repr',
+                              #tp_str = '(reprfunc)gcc_Gimple_str',
+                              )
+        cu.add_defn(pytype.c_defn())
+        modinit_preinit += pytype.c_invoke_type_ready()
+        modinit_postinit += pytype.c_invoke_add_to_module()
+
+#generate_gimple_struct_subclasses()
+
+
 def generate_gimple_subclasses():
     global modinit_preinit
     global modinit_postinit
@@ -36,6 +183,30 @@ def generate_gimple_subclasses():
 
 generate_gimple_subclasses()
 
+def generate_gimple_code_map():
+    cu.add_defn('\n/* Map from GCC gimple codes to PyTypeObject* */\n')
+    cu.add_defn('PyTypeObject *pytype_for_gimple_code[] = {\n')
+    for gt in gimple_types:
+        cc = gt.camel_cased_string()
+        cu.add_defn('    &gcc_%sType, /* %s */\n' % (cc, gt.gimple_symbol))
+    cu.add_defn('};\n\n')
+
+    cu.add_defn("""
+PyTypeObject*
+gcc_python_autogenerated_gimple_type_for_stmt(gimple g)
+{
+    enum gimple_code code = gimple_code(g);
+
+    /* printf("code:%i\\n", code); */
+    assert(code >= 0);
+    assert(code < LAST_AND_UNUSED_GIMPLE_CODE);
+    return pytype_for_gimple_code[code];
+}
+""")
+
+generate_gimple_code_map()
+
+
 cu.add_defn("""
 int autogenerated_gimple_init_types(void)
 {
diff --git a/gimple-types.txt.in b/gimple-types.txt.in
@@ -2,3 +2,10 @@
    GIMPLE_symbol, printable_name, GSS_symbol
 #include "gimple.def"
 #undef DEFGSCODE
+
+#define DEFGSSTRUCT(GSS_enumeration_value, structure_name, has_tree_operands) \
+   GSS_enumeration_value, structure_name, has_tree_operands
+#include "gsstruct.def"
+#undef DEFGSSTRUCT
+
+
diff --git a/maketreetypes.py b/maketreetypes.py
@@ -37,12 +37,34 @@ def iter_gimple_types():
     for line in f:
         # e.g.
         #   GIMPLE_ERROR_MARK, "gimple_error_mark", GSS_BASE
-        m = re.match('(.+), (.+), (.+)', line)
+        m = re.match('(GIMPLE_.+), (.+), (.+)', line)
         if m:
             yield GimpleType(gimple_symbol=m.group(1),
                              printable_name=m.group(2)[1:-1],
                              gss_symbol=m.group(3))
         else:
             #    print 'UNMATCHED: ', line
-            assert(line.startswith('#') or line.strip() == '')
+            assert(line.startswith('#') or line.strip() == '' or line.startswith('GSS_'))
+    f.close()
+
+
+# Corresponds to a DEFGSTRUCT macro from gsstruct.def
+class GimpleStructType(namedtuple('GimpleStructType', 'enum_value struct_name has_tree_operands')):
+    def camel_cased_string(self):
+        return camel_case(self.struct_name)
+
+def iter_gimple_struct_types():
+    import re
+    f = open('autogenerated-gimple-types.txt')
+    for line in f:
+        # e.g.
+        #   GSS_BASE, gimple_statement_base, false
+        m = re.match('(GSS_.+), (.+), (.+)', line)
+        if m:
+            yield GimpleStructType(enum_value=m.group(1),
+                                   struct_name=m.group(2),
+                                   has_tree_operands=m.group(3))
+        else:
+            #    print 'UNMATCHED: ', line
+            assert(line.startswith('#') or line.strip() == '' or line.startswith('GIMPLE_'))
     f.close()

Original file line number	Diff line number	Diff line change
`@@ -54,8 +54,13 @@ PyObject*`
`54`	`54`	`gcc_python_make_wrapper_gimple(gimple stmt)`
`55`	`55`	`{`
`56`	`56`	`struct PyGccGimple *gimple_obj = NULL;`
	`57`	`+ PyTypeObject* tp;`
	`58`	`+`
	`59`	`+ tp = gcc_python_autogenerated_gimple_type_for_stmt(stmt);`
	`60`	`+ assert(tp);`
	`61`	`+ //printf("tp:%p\n", tp);`
`57`	`62`
`58`		`- gimple_obj = PyObject_New(struct PyGccGimple, &gcc_GimpleType);`
	`63`	`+ gimple_obj = PyObject_New(struct PyGccGimple, tp);`
`59`	`64`	`if (!gimple_obj) {`
`60`	`65`	`goto error;`
`61`	`66`	`}`