[PATCH 2/5] CTF: set up debug info for function arguments

[Weimin Pan <weimin.pan@oracle.com>]

Added this support in read_func_kind_type after gcc started generating
CTF for function arguments.

Expanded gdb.base/ctf-ptype.exp to test function arguments. Also fixed
some typos.

---
 gdb/ctfread.c                        | 34 +++++++++++++++++++++++++++++++++-
 gdb/testsuite/gdb.base/ctf-ptype.exp | 19 ++++++++++++++++---
 2 files changed, 49 insertions(+), 4 deletions(-)

diff --git a/gdb/ctfread.c b/gdb/ctfread.c
index 5a68d9c..c75fe25 100644
--- a/gdb/ctfread.c
+++ b/gdb/ctfread.c
@@ -652,8 +652,10 @@ struct ctf_tid_and_type
 {
   struct objfile *of = ccp->of;
   ctf_dict_t *fp = ccp->fp;
-  struct type *type, *rettype;
+  struct type *type, *rettype, *atype;
   ctf_funcinfo_t cfi;
+  ctf_id_t *argv;
+  uint32_t argc;
 
   type = alloc_type (of);
 
@@ -663,6 +665,36 @@ struct ctf_tid_and_type
   TYPE_TARGET_TYPE (type) = rettype;
   set_type_align (type, ctf_type_align (fp, tid));
 
+  /* Set up function's arguments.  */
+  argc = cfi.ctc_argc;
+  type->set_num_fields (argc);
+  if (cfi.ctc_flags & CTF_FUNC_VARARG)
+    type->set_has_varargs (1);
+
+  if (argc != 0)
+    {
+      argv = XNEWVEC (ctf_id_t, argc);
+      if (ctf_func_type_args (fp, tid, argc, argv) == CTF_ERR)
+	{
+	  xfree (argv);
+	  return NULL;
+	}
+
+      type->set_fields
+	((struct field *) TYPE_ZALLOC (type, argc * sizeof (struct field)));
+      struct type *void_type = objfile_type (of)->builtin_void;
+      /* If failed to find the argument type, fill it with void_type.  */
+      for (int iparam = 0; iparam < argc; iparam++)
+	{
+	  atype = get_tid_type (of, argv[iparam]);
+	  if (atype)
+	    type->field (iparam).set_type (atype);
+	  else
+	    type->field (iparam).set_type (void_type);
+	}
+      xfree (argv);
+    }
+
   return set_tid_type (of, tid, type);
 }
 
diff --git a/gdb/testsuite/gdb.base/ctf-ptype.exp b/gdb/testsuite/gdb.base/ctf-ptype.exp
index ffe40f1..056f712 100644
--- a/gdb/testsuite/gdb.base/ctf-ptype.exp
+++ b/gdb/testsuite/gdb.base/ctf-ptype.exp
@@ -63,10 +63,10 @@ gdb_test "ptype struct t_struct" "type = struct t_struct \{.*\[\r\n\]    (unsign
 
 # Test the equivalence between '.' and '->' for struct member references.
 
-if [gdb_test "ptype v_t_struct_p.v_float_member"	"type = float"]<0 then {
+if [gdb_test "ptype v_struct1.v_float_member"	"type = float"]<0 then {
     return -1
 }
-if [gdb_test "ptype v_t_struct_p->v_float_member"	"type = float"]<0 then {
+if [gdb_test "ptype v_struct1->v_float_member"	"type = float"]<0 then {
     return -1
 }
 if [gdb_test "ptype v_t_struct_p.v_float_member"	"type = float"]<0 then {
@@ -211,7 +211,7 @@ gdb_test "ptype the_highest" \
 
 gdb_test "ptype the_highest.anonymous_level_1" \
          "type = struct \{.*\[\r\n\] *int b;.*\[\r\n\] *struct \{.*\[\r\n\] *int c;.*\[\r\n\] *\} anonymous_level_2;.*\[\r\n\]}.*" \
-         "ptype the_highest"
+         "ptype the_highest.anonymous_level_1"
 
 # Print the type of the identifier ID, and check the response:
 # - Expect to see PROTOTYPED as the type.  PROTOTYPED is not a regular
@@ -255,8 +255,21 @@ proc ptype_maybe_prototyped { id prototyped plain { overprototyped "NO-MATCH" }
     }
 }
 
+ptype_maybe_prototyped "func_type" "int (*)(int (*)(int, float), float)" \
+                                   "int (*)()"
 ptype_maybe_prototyped "old_fptr" "double (*)()" "double (*)()" \
                                   "double (*)(void)"
+ptype_maybe_prototyped "new_fptr" "double (*)()" "double (*)()"
+ptype_maybe_prototyped "fptr" "int (*)(int, float)" "int (*)()"
+ptype_maybe_prototyped "fptr2" "int *(*)(int (*)(int, float), float)" \
+                               "int *(*)()"
+ptype_maybe_prototyped "xptr" "int (*)(int (*)(), int (*)(), int)" \
+                              "int (*)()" \
+                              "int (*)(int (*)(void), int (*)(void), int)"
+ptype_maybe_prototyped "ffptr" "int (*(*)(char))(short int)" \
+                               "int (*(*)())()"
+ptype_maybe_prototyped "fffptr" "int (*(*(*)(char))(short int))(long int)" \
+                                "int (*(*(*)())())()"
 
 # Test printing type of string constants and array constants, but
 # requires a running process.  These call malloc, and can take a long
-- 
1.8.3.1