Merge pull request #116 from davidmalcolm/fixing-gcc-8

Fixing gcc 8

Author: davidmalcolm

.travis.yml

@@ -1,7 +1,66 @@
+matrix:
+  include:
+    - os: linux
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-4.8 gcc-4.8-plugin-dev
+      env:
+         - MATRIX_EVAL="CC=gcc-4.8 && CXX=g++-4.8"
+
+    # works on Precise and Trusty
+    - os: linux
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-4.9 gcc-4.9-plugin-dev
+      env:
+         - MATRIX_EVAL="CC=gcc-4.9 && CXX=g++-4.9"
+
+    # works on Precise and Trusty
+    - os: linux
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-5 gcc-5-plugin-dev
+      env:
+         - MATRIX_EVAL="CC=gcc-5 && CXX=g++-5"
+
+    # works on Precise and Trusty
+    - os: linux
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-6 gcc-6-plugin-dev
+      env:
+        - MATRIX_EVAL="CC=gcc-6 && CXX=g++-6"
+
+    # works on Precise and Trusty
+    - os: linux
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-7 gcc-7-plugin-dev
+      env:
+        - MATRIX_EVAL="CC=gcc-7 && CXX=g++-7"
+
 language: c
 compiler:
   - gcc
-script: make
+
 before_install:
- - sudo apt-get update -qq
- - sudo apt-get install -qq gcc-4.6-plugin-dev python-six python-pygments graphviz python-lxml
+  - eval "${MATRIX_EVAL}"
+  - sudo apt-get update -qq
+  - sudo apt-get install -qq python-six python-pygments graphviz python-lxml
+
+script: make

gcc-c-api/gcc-callgraph.c

@@ -24,7 +24,11 @@
 #include "tree-ssa-alias.h"
 #include "basic-block.h"
 #if (GCC_VERSION >= 4009)
-#include "gimple-expr.h"
+#include "tree-ssa-alias.h" /* needed by gimple.h in 4.9 */
+#include "internal-fn.h" /* needed by gimple.h in 4.9 */
+#include "is-a.h" /* needed by gimple.h in 4.9 */
+#include "predict.h" /* needed by gimple.h in 4.9 */
+#include "gimple-expr.h" /* needed by gimple.h in 4.9 */
 #endif
 #include "gimple.h"
 

gcc-python-compat.h

@@ -43,12 +43,20 @@ dump_gimple_stmt (pretty_printer *buffer, gimple gs, int spc, int flags);
 
 
 /*
-   This is declared in gcc/tree-pretty-print.c (around line 580); it doesn't
-   seem to be declared in any of the plugin headers:
+   This is declared in gcc/tree-pretty-print.c (around line 580); it was only
+   exposed to plugin headers (in tree-pretty-print.h) in GCC commit r203113
+   (aka 0d9585ca35b919263b973afb371f0eda04857159, 2013-10-02), as part of
+   GCC 4.9
+
+   The signature was changed by GCC 8 commit r248140 (aka
+   3f6e5ced7eb1cf5b3212b2391c5b70ec3dcaf136, 2017-05-17), which introduced
+   dump_flags_t.
  */
+#if GCC_VERSION < 4009
 extern int
 dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 		   bool is_stmt);
+#endif
 
 /* Within gcc/gcc-internal.h, not exposed by plugin API */
 extern bool ggc_force_collect;

gcc-python-diagnostics.c

@@ -164,7 +164,11 @@ PyGcc_inform(PyObject *self, PyObject *args, PyObject *kwargs)
         Py_RETURN_NONE;
     } else if (Py_TYPE (obj) == (PyTypeObject *)&PyGccRichLocation_TypeObj) {
         PyGccRichLocation *richloc_obj = (PyGccRichLocation *)obj;
-        inform_at_rich_loc (&richloc_obj->richloc, msg);
+#if (GCC_VERSION >= 8000)
+        inform (&richloc_obj->richloc, "%s", msg);
+#else
+        inform_at_rich_loc (&richloc_obj->richloc, "%s", msg);
+#endif
         Py_RETURN_NONE;
     } else {
         return PyErr_Format(PyExc_TypeError,

gcc-python-tree.c

@@ -60,8 +60,16 @@ __typeof__ (lang_check_failed) lang_check_failed __attribute__ ((weak));
 
 __typeof__ (decl_as_string) decl_as_string __attribute__ ((weak));
 
-/* Similar for namespace_binding: */
+/* Similar for namespace_binding, though gcc 8's r247654 (aka
+   f906dcc33dd818b71e16c88cef38f33c161070db) replaced it with
+   get_namespace_value and reversed the order of the params
+   and r247745 (aka 9d79db401edbb9665cde47ddea2702671c89e548)
+   renamed it from get_namespace_value to get_namespace_binding.  */
+#if (GCC_VERSION >= 8000)
+__typeof__ (get_namespace_binding) get_namespace_binding __attribute__ ((weak));
+#else
 __typeof__ (namespace_binding) namespace_binding __attribute__ ((weak));
+#endif
 
 /* And for cp_namespace_decls: */
 __typeof__ (cp_namespace_decls) cp_namespace_decls __attribute__ ((weak));
@@ -678,13 +686,32 @@ PyGccConstructor_get_elements(PyObject *self, void *closure)
     return NULL;
 }
 
+#if (GCC_VERSION >= 5000)
+
+static void
+print_integer_cst_to_buf(tree int_cst, char *buf, tree type)
+{
+    /*
+      GCC 8 commit r253595 (aka e3d0f65c14ffd7a63455dc1aa9d0405d25b327e4,
+      2017-10-10) introduces and requires the use of wi::to_wide on
+      INTEGER_CST.
+    */
+#if (GCC_VERSION >= 8000)
+    print_dec(wi::to_wide(int_cst), buf, TYPE_SIGN (type));
+#else
+    print_dec(int_cst, buf, TYPE_SIGN (type));
+#endif
+}
+
+#endif /* #if (GCC_VERSION >= 5000) */
+
 PyObject *
 PyGcc_int_from_int_cst(tree int_cst)
 {
     tree type = TREE_TYPE(int_cst);
 #if (GCC_VERSION >= 5000)
     char buf[WIDE_INT_PRINT_BUFFER_SIZE];
-    print_dec(int_cst, buf, TYPE_SIGN (type));
+    print_integer_cst_to_buf (int_cst, buf, type);
     return PyGcc_int_from_decimal_string_buffer(buf);
 #else
     return PyGcc_int_from_double_int(TREE_INT_CST(int_cst),
@@ -704,7 +731,7 @@ PyGccIntegerConstant_repr(struct PyGccTree * self)
     tree type = TREE_TYPE(self->t.inner);
 #if (GCC_VERSION >= 5000)
     char buf[WIDE_INT_PRINT_BUFFER_SIZE];
-    print_dec(self->t.inner, buf, TYPE_SIGN (type));
+    print_integer_cst_to_buf (self->t.inner, buf, type);
 #else
     char buf[512];
     PyGcc_DoubleIntAsText(TREE_INT_CST(self->t.inner),
@@ -931,13 +958,22 @@ PyGccNamespaceDecl_lookup(struct PyGccTree * self, PyObject *args, PyObject *kwa
         return NULL;
     }
 
+#if (GCC_VERSION >= 8000)
+    if (NULL == get_namespace_binding) {
+#else
     if (NULL == namespace_binding) {
+#endif
         return raise_cplusplus_only("gcc.NamespaceDecl.lookup");
     }
 
     t_name = get_identifier(name);
 
+#if (GCC_VERSION >= 8000)
+    t_result = get_namespace_binding(self->t.inner, t_name);
+#else
     t_result = namespace_binding(t_name, self->t.inner);
+#endif
+
     return PyGccTree_New(gcc_private_make_tree(t_result));
 }
 
@@ -980,6 +1016,16 @@ PyGccNamespaceDecl_declarations(tree t)
   return PyGcc_TreeListFromChain(cp_namespace_decls(t));
 }
 
+#if (GCC_VERSION >= 8000)
+
+static int is_namespace (tree decl, void *)
+{
+    return (TREE_CODE (decl) == NAMESPACE_DECL
+            && !DECL_NAMESPACE_ALIAS (decl));
+}
+
+#endif /* #if (GCC_VERSION >= 8000) */
+
 PyObject *
 PyGccNamespaceDecl_namespaces(tree t)
 {
@@ -993,7 +1039,57 @@ PyGccNamespaceDecl_namespaces(tree t)
   if (DECL_NAMESPACE_ALIAS(t))
     return raise_namespace_alias("gcc.NamespaceDecl.namespaces");
 
+  /* GCC 8's r248821 (aka f7564df45462679c3b0b82f2942f5fb50b640113)
+     eliminated the "namespaces" field from cp_binding_level.  */
+
+#if (GCC_VERSION >= 8000)
+  return PyGcc_TreeListFromChainWithFilter(NAMESPACE_LEVEL(t)->names,
+                                           is_namespace, NULL);
+#else
   return PyGcc_TreeListFromChain(NAMESPACE_LEVEL(t)->namespaces);
+#endif
+}
+
+/* Accessing the fields and methods of compound types.
+   GCC 8's r250413 (aka ab87ee8f509c0b600102195704105d4d98ec59d9)
+   eliminated TYPE_METHODS, instead putting both fields and methods
+   on the TYPE_FIELDS chain, using DECL_DECLARES_FUNCTION_P to
+   distinguish them.  */
+
+#if (GCC_VERSION >= 8000)
+
+static int is_field (tree t, void *)
+{
+    return !DECL_DECLARES_FUNCTION_P (t);
+}
+
+static int is_method (tree t, void *)
+{
+    return DECL_DECLARES_FUNCTION_P (t);
+}
+
+#endif /* #if (GCC_VERSION >= 8000) */
+
+PyObject *
+PyGcc_GetFields(struct PyGccTree *self)
+{
+#if (GCC_VERSION >= 8000)
+    return PyGcc_TreeListFromChainWithFilter(TYPE_FIELDS(self->t.inner),
+                                             is_field, NULL);
+#else
+    return PyGcc_TreeListFromChain(TYPE_FIELDS(self->t.inner));
+#endif
+}
+
+PyObject *
+PyGcc_GetMethods(struct PyGccTree *self)
+{
+#if (GCC_VERSION >= 8000)
+    return PyGcc_TreeListFromChainWithFilter(TYPE_FIELDS(self->t.inner),
+                                             is_method, NULL);
+#else
+    return PyGcc_TreeListFromChain(TYPE_METHODS(self->t.inner));
+#endif
 }
 
 /* 
@@ -1104,6 +1200,44 @@ PyGcc_TreeListFromChain(tree t)
     return NULL;
 }
 
+/* As above, but only add nodes for which "filter" returns true.  */
+PyObject *
+PyGcc_TreeListFromChainWithFilter(tree t,
+                                  int (*filter) (tree, void *),
+                                  void *user_data)
+{
+    PyObject *result = NULL;
+
+    result = PyList_New(0);
+    if (!result) {
+	goto error;
+    }
+
+    while (t) {
+        if (filter (t, user_data)) {
+            PyObject *item;
+
+            item = PyGccTree_New(gcc_private_make_tree(t));
+            if (!item) {
+                goto error;
+            }
+            if (-1 == PyList_Append(result, item)) {
+                Py_DECREF(item);
+                goto error;
+            }
+            Py_DECREF(item);
+        }
+
+        t = TREE_CHAIN(t);
+    }
+
+    return result;
+
+ error:
+    Py_XDECREF(result);
+    return NULL;
+}
+
 /*
   As above, but expect nodes of the form:
      tree_list  ---> value

gcc-python-wrappers.h

@@ -346,6 +346,11 @@ PyGccNamespaceDecl_declarations(tree t);
 PyObject *
 PyGccNamespaceDecl_namespaces(tree t);
 
+PyObject *
+PyGcc_GetFields(struct PyGccTree *self);
+
+PyObject *
+PyGcc_GetMethods(struct PyGccTree *self);
 
 /* gcc-python-gimple.c: */
 extern gcc_gimple_asm
@@ -499,6 +504,11 @@ PyGccRtl_str(struct PyGccRtl * self);
 PyObject *
 PyGcc_TreeListFromChain(tree t);
 
+PyObject *
+PyGcc_TreeListFromChainWithFilter(tree t,
+                                  int (*filter) (tree, void *),
+                                  void *user_data);
+
 PyObject *
 PyGcc_TreeMakeListFromTreeList(tree t);
 

gcc-python.c

@@ -301,8 +301,22 @@ PyGcc_get_translation_units(PyObject *self, PyObject *args)
                            add_translation_unit_decl_to_list)
 }
 
-/* Weakly import global_namespace; it will be non-NULL for the C++ frontend: */
+
+/* Weakly import global_namespace; it will be non-NULL for the C++ frontend.
+
+   GCC 8's r247599 (aka c99e91fe8d1191b348cbc1659fbfbac2fc07e154)
+   converted it from:
+      extern GTY(()) tree global_namespace;
+   to:
+      #define global_namespace               cp_global_trees[CPTI_GLOBAL]
+   so we have to access cp_global_trees instead.  */
+
+#if (GCC_VERSION >= 8000)
+__typeof__ (cp_global_trees) cp_global_trees __attribute__ ((weak));
+#else
 __typeof__ (global_namespace) global_namespace __attribute__ ((weak));
+#endif /* #if (GCC_VERSION >= 8000) */
+
 
 static PyObject *
 PyGcc_get_global_namespace(PyObject *self, PyObject *args)

generate-tree-c.py

@@ -479,10 +479,10 @@ def add_complex_getter(name, doc):
 
         if tree_type.SYM in ('RECORD_TYPE', 'UNION_TYPE', 'QUAL_UNION_TYPE'):
             add_simple_getter('fields',
-                              'PyGcc_TreeListFromChain(TYPE_FIELDS(self->t.inner))',
+                              'PyGcc_GetFields(self)',
                               "The fields of this type")
             add_simple_getter('methods',
-                              'PyGcc_TreeListFromChain(TYPE_METHODS(self->t.inner))',
+                              'PyGcc_GetMethods(self)',
                               "The methods of this type")
 
         if tree_type.SYM == 'ENUMERAL_TYPE':