[V3,2/3] CTF: handle forward reference type

Message ID 1617237594-24175-3-git-send-email-weimin.pan@oracle.com
State New
Headers show
Series
  • CTF: bug fixes and new features.
Related show

Commit Message

Weimin Pan via Gdb-patches April 1, 2021, 12:39 a.m.
Added function fetch_tid_type which calls get_tid_type and will set up
the type, associated with a tid, if it is not read in yet. Also implement 
function read_forward_type which handles the CTF_K_FORWARD kind.

Expanded gdb.base/ctf-ptype.exp to add cases with forward references. 

---
 gdb/ChangeLog                        |  6 +++
 gdb/ctfread.c                        | 78 ++++++++++++++++++++++++++++++------
 gdb/testsuite/ChangeLog              |  6 +++
 gdb/testsuite/gdb.base/ctf-ptype.c   | 12 ++++++
 gdb/testsuite/gdb.base/ctf-ptype.exp |  2 +
 5 files changed, 91 insertions(+), 13 deletions(-)

-- 
1.8.3.1

Comments

Tom Tromey April 1, 2021, 4:56 p.m. | #1
>> Added function fetch_tid_type which calls get_tid_type and will set up

>> the type, associated with a tid, if it is not read in yet. Also implement 

>> function read_forward_type which handles the CTF_K_FORWARD kind.


>> Expanded gdb.base/ctf-ptype.exp to add cases with forward references. 


Thanks for the patch.

>> +  if (name != NULL && strlen (name.get() ) != 0)


A nit here -- "get() )" should be "get ())"

This is ok with this change.

Tom
Weimin Pan via Gdb-patches April 8, 2021, 1:09 a.m. | #2
On 4/1/2021 9:56 AM, Tom Tromey wrote:
>>> Added function fetch_tid_type which calls get_tid_type and will set up

>>> the type, associated with a tid, if it is not read in yet. Also implement

>>> function read_forward_type which handles the CTF_K_FORWARD kind.

>>> Expanded gdb.base/ctf-ptype.exp to add cases with forward references.

> Thanks for the patch.

>

>>> +  if (name != NULL && strlen (name.get() ) != 0)

> A nit here -- "get() )" should be "get ())"


Got rid of the space and pushed to main. Thank you.

>

> This is ok with this change.

>

> Tom

Patch

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index b555825..82602a5 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,5 +1,11 @@ 
 2021-03-19  Weimin Pan  <weimin.pan@oracle.com>
 
+	* ctfread.c (fetch_tid_type): New function, use throughout file.
+	(read_forward_type): New function.
+	(read_type_record): Call read_forward_type.
+
+2021-03-19  Weimin Pan  <weimin.pan@oracle.com>
+
 	* ctfread.c (new_symbol): Set function address.
 	(read_func_kind_type): Remove incorrect type name setting.
 	Don't copy name returned from ctf_type_aname_raw throughout file.
diff --git a/gdb/ctfread.c b/gdb/ctfread.c
index b82deee..f3374eb 100644
--- a/gdb/ctfread.c
+++ b/gdb/ctfread.c
@@ -186,6 +186,8 @@  static struct type *read_typedef_type (struct ctf_context *cp, ctf_id_t tid,
 static void process_struct_members (struct ctf_context *cp, ctf_id_t tid,
 				    struct type *type);
 
+static struct type *read_forward_type (struct ctf_context *cp, ctf_id_t tid);
+
 static struct symbol *new_symbol (struct ctf_context *cp, struct type *type,
 				  ctf_id_t tid);
 
@@ -269,6 +271,25 @@  struct ctf_tid_and_type
     return nullptr;
 }
 
+/* Fetch the type for TID in CCP OF's tid_and_type hash, add the type to
+   context CCP if hash is empty or TID does not have a saved type.  */
+
+static struct type *
+fetch_tid_type (struct ctf_context *ccp, ctf_id_t tid)
+{
+  struct objfile *of = ccp->of;
+  struct type *typ;
+
+  typ = get_tid_type (of, tid);
+  if (typ == nullptr)
+    {
+      ctf_add_type_cb (tid, ccp);
+      typ = get_tid_type (of, tid);
+    }
+
+  return typ;
+}
+
 /* Return the size of storage in bits for INTEGER, FLOAT, or ENUM.  */
 
 static int
@@ -368,7 +389,7 @@  struct ctf_tid_and_type
   FIELD_NAME (*fp) = name;
 
   kind = ctf_type_kind (ccp->fp, tid);
-  t = get_tid_type (ccp->of, tid);
+  t = fetch_tid_type (ccp, tid);
   if (t == nullptr)
     {
       t = read_type_record (ccp, tid);
@@ -658,7 +679,7 @@  struct ctf_tid_and_type
 
   type->set_code (TYPE_CODE_FUNC);
   ctf_func_type_info (fp, tid, &cfi);
-  rettype = get_tid_type (of, cfi.ctc_return);
+  rettype = fetch_tid_type (ccp, cfi.ctc_return);
   TYPE_TARGET_TYPE (type) = rettype;
   set_type_align (type, ctf_type_align (fp, tid));
 
@@ -785,11 +806,11 @@  struct ctf_tid_and_type
       return nullptr;
     }
 
-  element_type = get_tid_type (objfile, ar.ctr_contents);
+  element_type = fetch_tid_type (ccp, ar.ctr_contents);
   if (element_type == nullptr)
     return nullptr;
 
-  idx_type = get_tid_type (objfile, ar.ctr_index);
+  idx_type = fetch_tid_type (ccp, ar.ctr_index);
   if (idx_type == nullptr)
     idx_type = objfile_type (objfile)->builtin_int;
 
@@ -817,7 +838,7 @@  struct ctf_tid_and_type
   struct objfile *objfile = ccp->of;
   struct type *base_type, *cv_type;
 
-  base_type = get_tid_type (objfile, btid);
+  base_type = fetch_tid_type (ccp, btid);
   if (base_type == nullptr)
     {
       base_type = read_type_record (ccp, btid);
@@ -841,7 +862,7 @@  struct ctf_tid_and_type
   ctf_dict_t *fp = ccp->fp;
   struct type *base_type, *cv_type;
 
-  base_type = get_tid_type (objfile, btid);
+  base_type = fetch_tid_type (ccp, btid);
   if (base_type == nullptr)
     {
       base_type = read_type_record (ccp, btid);
@@ -867,7 +888,7 @@  struct ctf_tid_and_type
   struct objfile *objfile = ccp->of;
   struct type *base_type, *cv_type;
 
-  base_type = get_tid_type (objfile, btid);
+  base_type = fetch_tid_type (ccp, btid);
   if (base_type == nullptr)
     {
       base_type = read_type_record (ccp, btid);
@@ -893,7 +914,7 @@  struct ctf_tid_and_type
 
   this_type = init_type (objfile, TYPE_CODE_TYPEDEF, 0, name);
   set_tid_type (objfile, tid, this_type);
-  target_type = get_tid_type (objfile, btid);
+  target_type = fetch_tid_type (ccp, btid);
   if (target_type != this_type)
     TYPE_TARGET_TYPE (this_type) = target_type;
   else
@@ -912,7 +933,7 @@  struct ctf_tid_and_type
   struct objfile *of = ccp->of;
   struct type *target_type, *type;
 
-  target_type = get_tid_type (of, btid);
+  target_type = fetch_tid_type (ccp, btid);
   if (target_type == nullptr)
     {
       target_type = read_type_record (ccp, btid);
@@ -929,6 +950,34 @@  struct ctf_tid_and_type
   return set_tid_type (of, tid, type);
 }
 
+/* Read all information from a TID of CTF_K_FORWARD.  */
+
+static struct type *
+read_forward_type (struct ctf_context *ccp, ctf_id_t tid)
+{
+  struct objfile *of = ccp->of;
+  ctf_dict_t *fp = ccp->fp;
+  struct type *type;
+  uint32_t kind;
+
+  type = alloc_type (of);
+
+  gdb::unique_xmalloc_ptr<char> name (ctf_type_aname_raw (fp, tid));
+  if (name != NULL && strlen (name.get() ) != 0)
+    type->set_name (obstack_strdup (&of->objfile_obstack, name.get ()));
+
+  kind = ctf_type_kind_forwarded (fp, tid);
+  if (kind == CTF_K_UNION)
+    type->set_code (TYPE_CODE_UNION);
+  else
+    type->set_code (TYPE_CODE_STRUCT);
+
+  TYPE_LENGTH (type) = 0;
+  type->set_is_stub (true);
+
+  return set_tid_type (of, tid, type);
+}
+
 /* Read information associated with type TID.  */
 
 static struct type *
@@ -985,6 +1034,9 @@  struct ctf_tid_and_type
       case CTF_K_ARRAY:
 	type = read_array_type (ccp, tid);
 	break;
+      case CTF_K_FORWARD:
+	type = read_forward_type (ccp, tid);
+	break;
       case CTF_K_UNKNOWN:
 	break;
       default:
@@ -1131,7 +1183,7 @@  struct ctf_tid_and_type
   if ((tid = ctf_lookup_by_symbol (ccp->fp, idx)) == CTF_ERR)
     return nullptr;
 
-  type = get_tid_type (ccp->of, tid);
+  type = fetch_tid_type (ccp, tid);
   if (type == nullptr)
     return nullptr;
 
@@ -1165,7 +1217,7 @@  struct ctf_tid_and_type
     return nullptr;
 
   tid = ctf_lookup_by_symbol (ccp->fp, idx);
-  ftype = get_tid_type (ccp->of, tid);
+  ftype = fetch_tid_type (ccp, tid);
   if ((finfo.ctc_flags & CTF_FUNC_VARARG) != 0)
     ftype->set_has_varargs (true);
   ftype->set_num_fields (argc);
@@ -1179,7 +1231,7 @@  struct ctf_tid_and_type
      to find the argument type.  */
   for (int iparam = 0; iparam < argc; iparam++)
     {
-      atyp = get_tid_type (ccp->of, argv[iparam]);
+      atyp = fetch_tid_type (ccp, argv[iparam]);
       if (atyp)
 	ftype->field (iparam).set_type (atyp);
       else
@@ -1187,7 +1239,7 @@  struct ctf_tid_and_type
     }
 
   sym = new_symbol (ccp, ftype, tid);
-  rettyp = get_tid_type (ccp->of, finfo.ctc_return);
+  rettyp = fetch_tid_type (ccp, finfo.ctc_return);
   if (rettyp != nullptr)
     SYMBOL_TYPE (sym) = rettyp;
   else
diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog
index cf86d1b..22ee55c 100644
--- a/gdb/testsuite/ChangeLog
+++ b/gdb/testsuite/ChangeLog
@@ -1,5 +1,11 @@ 
 2021-03-19  Weimin Pan  <weimin.pan@oracle.com>
 
+	* gdb.base/ctf-ptype.c: Add struct link containing a forward
+	reference type.
+	* gdb.base/ctf-ptype.exp: Add "ptype struct link"
+
+2021-03-19  Weimin Pan  <weimin.pan@oracle.com>
+
 	* gdb.ctf/funcreturn.exp: New file.
 	* gdb.ctf/whatis.c: Copy from gdb.base.
 
diff --git a/gdb/testsuite/gdb.base/ctf-ptype.c b/gdb/testsuite/gdb.base/ctf-ptype.c
index cbc7815..51c7c68 100644
--- a/gdb/testsuite/gdb.base/ctf-ptype.c
+++ b/gdb/testsuite/gdb.base/ctf-ptype.c
@@ -124,6 +124,18 @@  struct {
    a symbol.  */
 t_struct3 v_struct3;
 
+/**** Some misc more complicated things *******/
+
+struct link {
+	struct link *next;
+#ifdef __STDC__
+	struct link *(*linkfunc) (struct link *self, int flags);
+#else
+	struct link *(*linkfunc) ();
+#endif
+	struct t_struct stuff[3];
+} *s_link;
+
 /**** unions *******/
 
 union t_union {
diff --git a/gdb/testsuite/gdb.base/ctf-ptype.exp b/gdb/testsuite/gdb.base/ctf-ptype.exp
index 056f712..7dd6d95 100644
--- a/gdb/testsuite/gdb.base/ctf-ptype.exp
+++ b/gdb/testsuite/gdb.base/ctf-ptype.exp
@@ -76,6 +76,8 @@  if [gdb_test "ptype v_t_struct_p->v_float_member"	"type = float"]<0 then {
     return -1
 }
 
+gdb_test "ptype struct link" "type = struct link \{\[\r\n\]+\[ \t\]+struct link \\*next;\[\r\n\]+\[ \t\]+struct link \\*\\(\\*linkfunc\\)\\((struct link \\*, int|void|)\\);\[\r\n\]+\[ \t\]+struct t_struct stuff.3.;\[\r\n\]+\}.*" "ptype linked list structure"
+
 #
 # test ptype command with unions
 #