10823 should ignore DW_TAG_subprogram with DW_AT_declaration tags
10824 GCC7-derived CTF can double qualifiers on arrays
10825 ctfdump -c drops last type
10826 ctfdump -c goes off the rails with a missing parent
Reviewed by: Robert Mustacchi <rm@joyent.com>
Reviewed by: Jerry Jelinek <jerry.jelinek@joyent.com>
Reviewed by: Jason King <jason.king@joyent.com>
Approved by: Jerry Jelinek <jerry.jelinek@joyent.com>

@@ -8,11 +8,11 @@
  * source.  A copy of the CDDL is also available via the Internet at
  * http://www.illumos.org/license/CDDL.
  */
 
 /*
- * Copyright (c) 2019, Joyent, Inc.
+ * Copyright 2019, Joyent, Inc.
  */
 
 /*
  * Check that we properly understand reference types and can walk through them
  * as well as generate them.

@@ -129,22 +129,10 @@
         { "const char", CTF_K_CONST },
         { "char", CTF_K_INTEGER },
         { NULL }
 };
 
-static check_descent_t check_descent_cvh[] = {
-        { "const volatile foo_t *", CTF_K_POINTER },
-        { "const volatile foo_t", CTF_K_CONST },
-        { "volatile foo_t", CTF_K_VOLATILE },
-        { "foo_t", CTF_K_TYPEDEF },
-        { "int *const *", CTF_K_POINTER },
-        { "int *const", CTF_K_CONST },
-        { "int *", CTF_K_POINTER },
-        { "int", CTF_K_INTEGER },
-        { NULL }
-};
-
 static check_descent_test_t descents[] = {
         { "aa", check_descent_aa },
         { "b", check_descent_b },
         { "c", check_descent_c },
         { "d", check_descent_d },

@@ -154,14 +142,47 @@
         { "ce", check_descent_ce },
         { "ve", check_descent_ve },
         { "cve", check_descent_cve },
         { "f", check_descent_f },
         { "g", check_descent_g },
-        { "cvh", check_descent_cvh },
         { NULL }
 };
 
+static check_descent_t check_descent_cvh_gcc4[] = {
+        { "const volatile foo_t *", CTF_K_POINTER },
+        { "const volatile foo_t", CTF_K_CONST },
+        { "volatile foo_t", CTF_K_VOLATILE },
+        { "foo_t", CTF_K_TYPEDEF },
+        { "int *const *", CTF_K_POINTER },
+        { "int *const", CTF_K_CONST },
+        { "int *", CTF_K_POINTER },
+        { "int", CTF_K_INTEGER },
+        { NULL }
+};
+
+static check_descent_t check_descent_cvh_gcc7[] = {
+        { "volatile const foo_t *", CTF_K_POINTER },
+        { "volatile const foo_t", CTF_K_VOLATILE },
+        { "const foo_t", CTF_K_CONST },
+        { "foo_t", CTF_K_TYPEDEF },
+        { "int *const *", CTF_K_POINTER },
+        { "int *const", CTF_K_CONST },
+        { "int *", CTF_K_POINTER },
+        { "int", CTF_K_INTEGER },
+        { NULL }
+};
+
+/*
+ * GCC versions differ in how they order qualifiers, which is a shame for
+ * round-tripping; but as they're clearly both valid, we should cope.  We'll
+ * just insist that at least one of these checks passes.
+ */
+static check_descent_test_t alt_descents[] = {
+        { "cvh", check_descent_cvh_gcc4 },
+        { "cvh", check_descent_cvh_gcc7 },
+};
+
 int
 main(int argc, char *argv[])
 {
         int i, ret = 0;
 

@@ -169,10 +190,11 @@
                 errx(EXIT_FAILURE, "missing test files");
         }
 
         for (i = 1; i < argc; i++) {
                 ctf_file_t *fp;
+                int alt_ok = 0;
                 uint_t d;
 
                 if ((fp = ctf_open(argv[i], &ret)) == NULL) {
                         warnx("failed to open %s: %s", argv[i],
                             ctf_errmsg(ret));

@@ -184,14 +206,29 @@
                         ret = EXIT_FAILURE;
                 if (!ctftest_check_symbols(fp, check_syms))
                         ret = EXIT_FAILURE;
                 for (d = 0; descents[d].cdt_sym != NULL; d++) {
                         if (!ctftest_check_descent(descents[d].cdt_sym, fp,
-                            descents[d].cdt_tests)) {
+                            descents[d].cdt_tests, B_FALSE)) {
                                 ret = EXIT_FAILURE;
                         }
                 }
+
+                for (d = 0; alt_descents[d].cdt_sym != NULL; d++) {
+                        if (ctftest_check_descent(alt_descents[d].cdt_sym, fp,
+                            alt_descents[d].cdt_tests, B_TRUE)) {
+                                alt_ok = 1;
+                                break;
+                        }
+                }
+
+                if (!alt_ok) {
+                        warnx("all descents failed for %s",
+                            alt_descents[0].cdt_sym);
+                        ret = EXIT_FAILURE;
+                }
+
                 ctf_close(fp);
         }
 
         return (ret);
 }