gdb/ctfread.c

   1 /* Compact ANSI-C Type Format (CTF) support in GDB.
   2
   3    Copyright (C) 2019-2020 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 /* This file format can be used to compactly represent the information needed
  21    by a debugger to interpret the ANSI-C types used by a given program.
  22    Traditionally, this kind of information is generated by the compiler when
  23    invoked with the -g flag and is stored in "stabs" strings or in the more
  24    modern DWARF format. A new -gtLEVEL option has been added in gcc to generate
  25    such information. CTF provides a representation of only the information
  26    that is relevant to debugging a complex, optimized C program such as the
  27    operating system kernel in a form that is significantly more compact than
  28    the equivalent stabs or DWARF representation.  The format is data-model
  29    independent, so consumers do not need different code depending on whether
  30    they are 32-bit or 64-bit programs.  CTF assumes that a standard ELF symbol
  31    table is available for use in the debugger, and uses the structure and data
  32    of the symbol table to avoid storing redundant information.  The CTF data
  33    may be compressed on disk or in memory, indicated by a bit in the header.
  34    CTF may be interpreted in a raw disk file, or it may be stored in an ELF
  35    section, typically named .ctf.  Data structures are aligned so that a raw
  36    CTF file or CTF ELF section may be manipulated using mmap(2).
  37
  38    The CTF file or section itself has the following structure:
  39
  40    +--------+--------+---------+----------+----------+-------+--------+
  41    |  file  |  type  |  data   | function | variable | data  | string |
  42    | header | labels | objects |   info   |   info   | types | table  |
  43    +--------+--------+---------+----------+----------+-------+--------+
  44
  45    The file header stores a magic number and version information, encoding
  46    flags, and the byte offset of each of the sections relative to the end of the
  47    header itself.  If the CTF data has been uniquified against another set of
  48    CTF data, a reference to that data also appears in the header.  This
  49    reference is the name of the label corresponding to the types uniquified
  50    against.
  51
  52    Following the header is a list of labels, used to group the types included in
  53    the data types section.  Each label is accompanied by a type ID i.  A given
  54    label refers to the group of types whose IDs are in the range [0, i].
  55
  56    Data object and function records are stored in the same order as they appear
  57    in the corresponding symbol table, except that symbols marked SHN_UNDEF are
  58    not stored and symbols that have no type data are padded out with zeroes.
  59    For each data object, the type ID (a small integer) is recorded.  For each
  60    function, the type ID of the return type and argument types is recorded.
  61
  62    Variable records (as distinct from data objects) provide a modicum of support
  63    for non-ELF systems, mapping a variable name to a CTF type ID.  The variable
  64    names are sorted into ASCIIbetical order, permitting binary searching.
  65
  66    The data types section is a list of variable size records that represent each
  67    type, in order by their ID.  The types themselves form a directed graph,
  68    where each node may contain one or more outgoing edges to other type nodes,
  69    denoted by their ID.
  70
  71    Strings are recorded as a string table ID (0 or 1) and a byte offset into the
  72    string table.  String table 0 is the internal CTF string table.  String table
  73    1 is the external string table, which is the string table associated with the
  74    ELF symbol table for this object.  CTF does not record any strings that are
  75    already in the symbol table, and the CTF string table does not contain any
  76    duplicated strings.  */
  77
  78 #include "defs.h"
  79 #include "buildsym.h"
  80 #include "complaints.h"
  81 #include "block.h"
  82 #include "ctfread.h"
  83 #include "psympriv.h"
  84
  85 #if ENABLE_LIBCTF
  86
  87 #include "ctf.h"
  88 #include "ctf-api.h"
  89
  90 static const struct objfile_key<htab, htab_deleter> ctf_tid_key;
  91
  92 struct ctf_fp_info
  93 {
  94   explicit ctf_fp_info (ctf_dict_t *cfp) : fp (cfp) {}
  95   ~ctf_fp_info ();
  96   ctf_dict_t *fp;
  97 };
  98
  99 /* Cleanup function for the ctf_dict_key data.  */
 100 ctf_fp_info::~ctf_fp_info ()
 101 {
 102   if (!fp)
 103     return;
 104
 105   ctf_archive_t *arc = ctf_get_arc (fp);
 106   ctf_dict_close (fp);
 107   ctf_close (arc);
 108 }
 109
 110 static const objfile_key<ctf_fp_info> ctf_dict_key;
 111
 112 /* A CTF context consists of a file pointer and an objfile pointer.  */
 113
 114 struct ctf_context
 115 {
 116   ctf_dict_t *fp;
 117   struct objfile *of;
 118   partial_symtab *pst;
 119   struct buildsym_compunit *builder;
 120 };
 121
 122 /* A partial symtab, specialized for this module.  */
 123 struct ctf_psymtab : public standard_psymtab
 124 {
 125   ctf_psymtab (const char *filename, struct objfile *objfile, CORE_ADDR addr)
 126     : standard_psymtab (filename, objfile, addr)
 127   {
 128   }
 129
 130   void read_symtab (struct objfile *) override;
 131   void expand_psymtab (struct objfile *) override;
 132
 133   struct ctf_context *context;
 134 };
 135
 136 /* The routines that read and process fields/members of a C struct, union,
 137    or enumeration, pass lists of data member fields in an instance of a
 138    ctf_field_info structure. It is derived from dwarf2read.c.  */
 139
 140 struct ctf_nextfield
 141 {
 142   struct field field {};
 143 };
 144
 145 struct ctf_field_info
 146 {
 147   /* List of data member fields.  */
 148   std::vector<struct ctf_nextfield> fields;
 149
 150   /* Context.  */
 151   struct ctf_context *cur_context;
 152
 153   /* Parent type.  */
 154   struct type *ptype;
 155
 156   /* typedefs defined inside this class.  TYPEDEF_FIELD_LIST contains head
 157      of a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements.  */
 158   std::vector<struct decl_field> typedef_field_list;
 159
 160   /* Nested types defined by this struct and the number of elements in
 161      this list.  */
 162   std::vector<struct decl_field> nested_types_list;
 163 };
 164
 165
 166 /* Local function prototypes */
 167
 168 static int ctf_add_type_cb (ctf_id_t tid, void *arg);
 169
 170 static struct type *read_array_type (struct ctf_context *cp, ctf_id_t tid);
 171
 172 static struct type *read_pointer_type (struct ctf_context *cp, ctf_id_t tid,
 173                                        ctf_id_t btid);
 174
 175 static struct type *read_structure_type (struct ctf_context *cp, ctf_id_t tid);
 176
 177 static struct type *read_enum_type (struct ctf_context *cp, ctf_id_t tid);
 178
 179 static struct type *read_typedef_type (struct ctf_context *cp, ctf_id_t tid,
 180                                        ctf_id_t btid, const char *name);
 181
 182 static struct type *read_type_record (struct ctf_context *cp, ctf_id_t tid);
 183
 184 static void process_structure_type (struct ctf_context *cp, ctf_id_t tid);
 185
 186 static void process_struct_members (struct ctf_context *cp, ctf_id_t tid,
 187                                     struct type *type);
 188
 189 static struct symbol *new_symbol (struct ctf_context *cp, struct type *type,
 190                                   ctf_id_t tid);
 191
 192 struct ctf_tid_and_type
 193 {
 194   ctf_id_t tid;
 195   struct type *type;
 196 };
 197
 198 /* Hash function for a ctf_tid_and_type.  */
 199
 200 static hashval_t
 201 tid_and_type_hash (const void *item)
 202 {
 203   const struct ctf_tid_and_type *ids
 204     = (const struct ctf_tid_and_type *) item;
 205
 206   return ids->tid;
 207 }
 208
 209 /* Equality function for a ctf_tid_and_type.  */
 210
 211 static int
 212 tid_and_type_eq (const void *item_lhs, const void *item_rhs)
 213 {
 214   const struct ctf_tid_and_type *ids_lhs
 215     = (const struct ctf_tid_and_type *) item_lhs;
 216   const struct ctf_tid_and_type *ids_rhs
 217     = (const struct ctf_tid_and_type *) item_rhs;
 218
 219   return ids_lhs->tid == ids_rhs->tid;
 220 }
 221
 222 /* Set the type associated with TID to TYP.  */
 223
 224 static struct type *
 225 set_tid_type (struct objfile *of, ctf_id_t tid, struct type *typ)
 226 {
 227   htab_t htab;
 228
 229   htab = (htab_t) ctf_tid_key.get (of);
 230   if (htab == NULL)
 231     {
 232       htab = htab_create_alloc (1, tid_and_type_hash,
 233                                 tid_and_type_eq,
 234                                 NULL, xcalloc, xfree);
 235       ctf_tid_key.set (of, htab);
 236     }
 237
 238   struct ctf_tid_and_type **slot, ids;
 239   ids.tid = tid;
 240   ids.type = typ;
 241   slot = (struct ctf_tid_and_type **) htab_find_slot (htab, &ids, INSERT);
 242   if (*slot)
 243     complaint (_("An internal GDB problem: ctf_ id_t %ld type already set"),
 244                (tid));
 245   *slot = XOBNEW (&of->objfile_obstack, struct ctf_tid_and_type);
 246   **slot = ids;
 247   return typ;
 248 }
 249
 250 /* Look up the type for TID in tid_and_type hash, return NULL if hash is
 251    empty or TID does not have a saved type.  */
 252
 253 static struct type *
 254 get_tid_type (struct objfile *of, ctf_id_t tid)
 255 {
 256   struct ctf_tid_and_type *slot, ids;
 257   htab_t htab;
 258
 259   htab = (htab_t) ctf_tid_key.get (of);
 260   if (htab == NULL)
 261     return NULL;
 262
 263   ids.tid = tid;
 264   ids.type = NULL;
 265   slot = (struct ctf_tid_and_type *) htab_find (htab, &ids);
 266   if (slot)
 267     return slot->type;
 268   else
 269     return NULL;
 270 }
 271
 272 /* Return the size of storage in bits for INTEGER, FLOAT, or ENUM.  */
 273
 274 static int
 275 get_bitsize (ctf_dict_t *fp, ctf_id_t tid, uint32_t kind)
 276 {
 277   ctf_encoding_t cet;
 278
 279   if ((kind == CTF_K_INTEGER || kind == CTF_K_ENUM
 280       || kind == CTF_K_FLOAT)
 281       && ctf_type_reference (fp, tid) != CTF_ERR
 282       && ctf_type_encoding (fp, tid, &cet) != CTF_ERR)
 283     return cet.cte_bits;
 284
 285   return 0;
 286 }
 287
 288 /* Set SYM's address, with NAME, from its minimal symbol entry.  */
 289
 290 static void
 291 set_symbol_address (struct objfile *of, struct symbol *sym, const char *name)
 292 {
 293   struct bound_minimal_symbol msym;
 294
 295   msym = lookup_minimal_symbol (name, NULL, of);
 296   if (msym.minsym != NULL)
 297     {
 298       SET_SYMBOL_VALUE_ADDRESS (sym, BMSYMBOL_VALUE_ADDRESS (msym));
 299       SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
 300       SYMBOL_SECTION (sym) = MSYMBOL_SECTION (msym.minsym);
 301     }
 302 }
 303
 304 /* Create the vector of fields, and attach it to TYPE.  */
 305
 306 static void
 307 attach_fields_to_type (struct ctf_field_info *fip, struct type *type)
 308 {
 309   int nfields = fip->fields.size ();
 310
 311   if (nfields == 0)
 312     return;
 313
 314   /* Record the field count, allocate space for the array of fields.  */
 315   type->set_num_fields (nfields);
 316   type->set_fields
 317     ((struct field *) TYPE_ZALLOC (type, sizeof (struct field) * nfields));
 318
 319   /* Copy the saved-up fields into the field vector.  */
 320   for (int i = 0; i < nfields; ++i)
 321     {
 322       struct ctf_nextfield &field = fip->fields[i];
 323       type->field (i) = field.field;
 324     }
 325 }
 326
 327 /* Allocate a floating-point type of size BITS and name NAME.  Pass NAME_HINT
 328    (which may be different from NAME) to the architecture back-end to allow
 329    it to guess the correct format if necessary.  */
 330
 331 static struct type *
 332 ctf_init_float_type (struct objfile *objfile,
 333                      int bits,
 334                      const char *name,
 335                      const char *name_hint)
 336 {
 337   struct gdbarch *gdbarch = objfile->arch ();
 338   const struct floatformat **format;
 339   struct type *type;
 340
 341   format = gdbarch_floatformat_for_type (gdbarch, name_hint, bits);
 342   if (format != NULL)
 343     type = init_float_type (objfile, bits, name, format);
 344   else
 345     type = init_type (objfile, TYPE_CODE_ERROR, bits, name);
 346
 347   return type;
 348 }
 349
 350 /* Callback to add member NAME to a struct/union type. TID is the type
 351    of struct/union member, OFFSET is the offset of member in bits,
 352    and ARG contains the ctf_field_info.  */
 353
 354 static int
 355 ctf_add_member_cb (const char *name,
 356                    ctf_id_t tid,
 357                    unsigned long offset,
 358                    void *arg)
 359 {
 360   struct ctf_field_info *fip = (struct ctf_field_info *) arg;
 361   struct ctf_context *ccp = fip->cur_context;
 362   struct ctf_nextfield new_field;
 363   struct field *fp;
 364   struct type *t;
 365   uint32_t kind;
 366
 367   fp = &new_field.field;
 368   FIELD_NAME (*fp) = name;
 369
 370   kind = ctf_type_kind (ccp->fp, tid);
 371   t = get_tid_type (ccp->of, tid);
 372   if (t == NULL)
 373     {
 374       t = read_type_record (ccp, tid);
 375       if (t == NULL)
 376         {
 377           complaint (_("ctf_add_member_cb: %s has NO type (%ld)"), name, tid);
 378           t = objfile_type (ccp->of)->builtin_error;
 379           set_tid_type (ccp->of, tid, t);
 380         }
 381     }
 382
 383   if (kind == CTF_K_STRUCT || kind == CTF_K_UNION)
 384     process_struct_members (ccp, tid, t);
 385
 386   fp->set_type (t);
 387   SET_FIELD_BITPOS (*fp, offset / TARGET_CHAR_BIT);
 388   FIELD_BITSIZE (*fp) = get_bitsize (ccp->fp, tid, kind);
 389
 390   fip->fields.emplace_back (new_field);
 391
 392   return 0;
 393 }
 394
 395 /* Callback to add member NAME of EVAL to an enumeration type.
 396    ARG contains the ctf_field_info.  */
 397
 398 static int
 399 ctf_add_enum_member_cb (const char *name, int enum_value, void *arg)
 400 {
 401   struct ctf_field_info *fip = (struct ctf_field_info *) arg;
 402   struct ctf_nextfield new_field;
 403   struct field *fp;
 404   struct ctf_context *ccp = fip->cur_context;
 405
 406   fp = &new_field.field;
 407   FIELD_NAME (*fp) = name;
 408   fp->set_type (NULL);
 409   SET_FIELD_ENUMVAL (*fp, enum_value);
 410   FIELD_BITSIZE (*fp) = 0;
 411
 412   if (name != NULL)
 413     {
 414       struct symbol *sym = new (&ccp->of->objfile_obstack) symbol;
 415       OBJSTAT (ccp->of, n_syms++);
 416
 417       sym->set_language (language_c, &ccp->of->objfile_obstack);
 418       sym->compute_and_set_names (name, false, ccp->of->per_bfd);
 419       SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
 420       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
 421       SYMBOL_TYPE (sym) = fip->ptype;
 422       add_symbol_to_list (sym, ccp->builder->get_global_symbols ());
 423     }
 424
 425   fip->fields.emplace_back (new_field);
 426
 427   return 0;
 428 }
 429
 430 /* Add a new symbol entry, with its name from TID, its access index and
 431    domain from TID's kind, and its type from TYPE.  */
 432
 433 static struct symbol *
 434 new_symbol (struct ctf_context *ccp, struct type *type, ctf_id_t tid)
 435 {
 436   struct objfile *objfile = ccp->of;
 437   ctf_dict_t *fp = ccp->fp;
 438   struct symbol *sym = NULL;
 439
 440   gdb::unique_xmalloc_ptr<char> name (ctf_type_aname_raw (fp, tid));
 441   if (name != NULL)
 442     {
 443       sym = new (&objfile->objfile_obstack) symbol;
 444       OBJSTAT (objfile, n_syms++);
 445
 446       sym->set_language (language_c, &objfile->objfile_obstack);
 447       sym->compute_and_set_names (name.get (), true, objfile->per_bfd);
 448       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
 449       SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
 450
 451       if (type != NULL)
 452         SYMBOL_TYPE (sym) = type;
 453
 454       uint32_t kind = ctf_type_kind (fp, tid);
 455       switch (kind)
 456         {
 457           case CTF_K_STRUCT:
 458           case CTF_K_UNION:
 459           case CTF_K_ENUM:
 460             SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
 461             SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
 462             break;
 463           case CTF_K_FUNCTION:
 464             SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
 465             break;
 466           case CTF_K_CONST:
 467             if (SYMBOL_TYPE (sym)->code () == TYPE_CODE_VOID)
 468               SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_int;
 469             break;
 470           case CTF_K_TYPEDEF:
 471           case CTF_K_INTEGER:
 472           case CTF_K_FLOAT:
 473             SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
 474             SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
 475             break;
 476           case CTF_K_POINTER:
 477             break;
 478           case CTF_K_VOLATILE:
 479           case CTF_K_RESTRICT:
 480             break;
 481           case CTF_K_SLICE:
 482           case CTF_K_ARRAY:
 483           case CTF_K_UNKNOWN:
 484             break;
 485         }
 486
 487       add_symbol_to_list (sym, ccp->builder->get_global_symbols ());
 488     }
 489
 490   return sym;
 491 }
 492
 493 /* Given a TID of kind CTF_K_INTEGER or CTF_K_FLOAT, find a representation
 494    and create the symbol for it.  */
 495
 496 static struct type *
 497 read_base_type (struct ctf_context *ccp, ctf_id_t tid)
 498 {
 499   struct objfile *of = ccp->of;
 500   ctf_dict_t *fp = ccp->fp;
 501   ctf_encoding_t cet;
 502   struct type *type = NULL;
 503   char *name;
 504   uint32_t kind;
 505
 506   if (ctf_type_encoding (fp, tid, &cet))
 507     {
 508       complaint (_("ctf_type_encoding read_base_type failed - %s"),
 509                  ctf_errmsg (ctf_errno (fp)));
 510       return NULL;
 511     }
 512
 513   gdb::unique_xmalloc_ptr<char> copied_name (ctf_type_aname_raw (fp, tid));
 514   if (copied_name == NULL || strlen (copied_name.get ()) == 0)
 515     {
 516       name = ctf_type_aname (fp, tid);
 517       if (name == NULL)
 518         complaint (_("ctf_type_aname read_base_type failed - %s"),
 519                    ctf_errmsg (ctf_errno (fp)));
 520     }
 521   else
 522     name = obstack_strdup (&of->objfile_obstack, copied_name.get ());
 523
 524   kind = ctf_type_kind (fp, tid);
 525   if (kind == CTF_K_INTEGER)
 526     {
 527       uint32_t issigned, ischar, isbool;
 528       struct gdbarch *gdbarch = of->arch ();
 529
 530       issigned = cet.cte_format & CTF_INT_SIGNED;
 531       ischar = cet.cte_format & CTF_INT_CHAR;
 532       isbool = cet.cte_format & CTF_INT_BOOL;
 533       if (ischar)
 534         type = init_character_type (of, TARGET_CHAR_BIT, !issigned, name);
 535       else if (isbool)
 536         type = init_boolean_type (of, gdbarch_int_bit (gdbarch),
 537                                   !issigned, name);
 538       else
 539         {
 540           int bits;
 541           if (cet.cte_bits && ((cet.cte_bits % TARGET_CHAR_BIT) == 0))
 542             bits = cet.cte_bits;
 543           else
 544             bits = gdbarch_int_bit (gdbarch);
 545           type = init_integer_type (of, bits, !issigned, name);
 546         }
 547     }
 548   else if (kind == CTF_K_FLOAT)
 549     {
 550       uint32_t isflt;
 551       isflt = !((cet.cte_format & CTF_FP_IMAGRY) == CTF_FP_IMAGRY
 552                  || (cet.cte_format & CTF_FP_DIMAGRY) == CTF_FP_DIMAGRY
 553                  || (cet.cte_format & CTF_FP_LDIMAGRY) == CTF_FP_LDIMAGRY);
 554       if (isflt)
 555         type = ctf_init_float_type (of, cet.cte_bits, name, name);
 556       else
 557         {
 558           struct type *t
 559             = ctf_init_float_type (of, cet.cte_bits / 2, NULL, name);
 560           type = init_complex_type (name, t);
 561         }
 562     }
 563   else
 564     {
 565       complaint (_("read_base_type: unsupported base kind (%d)"), kind);
 566       type = init_type (of, TYPE_CODE_ERROR, cet.cte_bits, name);
 567     }
 568
 569   if (name != NULL && strcmp (name, "char") == 0)
 570     type->set_has_no_signedness (true);
 571
 572   return set_tid_type (of, tid, type);
 573 }
 574
 575 static void
 576 process_base_type (struct ctf_context *ccp, ctf_id_t tid)
 577 {
 578   struct type *type;
 579
 580   type = read_base_type (ccp, tid);
 581   new_symbol (ccp, type, tid);
 582 }
 583
 584 /* Start a structure or union scope (definition) with TID to create a type
 585    for the structure or union.
 586
 587    Fill in the type's name and general properties. The members will not be
 588    processed, nor a symbol table entry be done until process_structure_type
 589    (assuming the type has a name).  */
 590
 591 static struct type *
 592 read_structure_type (struct ctf_context *ccp, ctf_id_t tid)
 593 {
 594   struct objfile *of = ccp->of;
 595   ctf_dict_t *fp = ccp->fp;
 596   struct type *type;
 597   uint32_t kind;
 598
 599   type = alloc_type (of);
 600
 601   gdb::unique_xmalloc_ptr<char> name (ctf_type_aname_raw (fp, tid));
 602   if (name != NULL && strlen (name.get() ) != 0)
 603     type->set_name (obstack_strdup (&of->objfile_obstack, name.get ()));
 604
 605   kind = ctf_type_kind (fp, tid);
 606   if (kind == CTF_K_UNION)
 607     type->set_code (TYPE_CODE_UNION);
 608   else
 609     type->set_code (TYPE_CODE_STRUCT);
 610
 611   TYPE_LENGTH (type) = ctf_type_size (fp, tid);
 612   set_type_align (type, ctf_type_align (fp, tid));
 613
 614   return set_tid_type (ccp->of, tid, type);
 615 }
 616
 617 /* Given a tid of CTF_K_STRUCT or CTF_K_UNION, process all its members
 618    and create the symbol for it.  */
 619
 620 static void
 621 process_struct_members (struct ctf_context *ccp,
 622                         ctf_id_t tid,
 623                         struct type *type)
 624 {
 625   struct ctf_field_info fi;
 626
 627   fi.cur_context = ccp;
 628   if (ctf_member_iter (ccp->fp, tid, ctf_add_member_cb, &fi) == CTF_ERR)
 629     complaint (_("ctf_member_iter process_struct_members failed - %s"),
 630                ctf_errmsg (ctf_errno (ccp->fp)));
 631
 632   /* Attach fields to the type.  */
 633   attach_fields_to_type (&fi, type);
 634
 635   new_symbol (ccp, type, tid);
 636 }
 637
 638 static void
 639 process_structure_type (struct ctf_context *ccp, ctf_id_t tid)
 640 {
 641   struct type *type;
 642
 643   type = read_structure_type (ccp, tid);
 644   process_struct_members (ccp, tid, type);
 645 }
 646
 647 /* Create a function type for TID and set its return type.  */
 648
 649 static struct type *
 650 read_func_kind_type (struct ctf_context *ccp, ctf_id_t tid)
 651 {
 652   struct objfile *of = ccp->of;
 653   ctf_dict_t *fp = ccp->fp;
 654   struct type *type, *rettype;
 655   ctf_funcinfo_t cfi;
 656
 657   type = alloc_type (of);
 658
 659   gdb::unique_xmalloc_ptr<char> name (ctf_type_aname_raw (fp, tid));
 660   if (name != NULL && strlen (name.get ()) != 0)
 661     type->set_name (obstack_strdup (&of->objfile_obstack, name.get ()));
 662
 663   type->set_code (TYPE_CODE_FUNC);
 664   ctf_func_type_info (fp, tid, &cfi);
 665   rettype = get_tid_type (of, cfi.ctc_return);
 666   TYPE_TARGET_TYPE (type) = rettype;
 667   set_type_align (type, ctf_type_align (fp, tid));
 668
 669   return set_tid_type (of, tid, type);
 670 }
 671
 672 /* Given a TID of CTF_K_ENUM, process all the members of the
 673    enumeration, and create the symbol for the enumeration type.  */
 674
 675 static struct type *
 676 read_enum_type (struct ctf_context *ccp, ctf_id_t tid)
 677 {
 678   struct objfile *of = ccp->of;
 679   ctf_dict_t *fp = ccp->fp;
 680   struct type *type, *target_type;
 681   ctf_funcinfo_t fi;
 682
 683   type = alloc_type (of);
 684
 685   gdb::unique_xmalloc_ptr<char> name (ctf_type_aname_raw (fp, tid));
 686   if (name != NULL && strlen (name.get ()) != 0)
 687     type->set_name (obstack_strdup (&of->objfile_obstack, name.get ()));
 688
 689   type->set_code (TYPE_CODE_ENUM);
 690   TYPE_LENGTH (type) = ctf_type_size (fp, tid);
 691   ctf_func_type_info (fp, tid, &fi);
 692   target_type = get_tid_type (of, fi.ctc_return);
 693   TYPE_TARGET_TYPE (type) = target_type;
 694   set_type_align (type, ctf_type_align (fp, tid));
 695
 696   return set_tid_type (of, tid, type);
 697 }
 698
 699 static void
 700 process_enum_type (struct ctf_context *ccp, ctf_id_t tid)
 701 {
 702   struct type *type;
 703   struct ctf_field_info fi;
 704
 705   type = read_enum_type (ccp, tid);
 706
 707   fi.cur_context = ccp;
 708   fi.ptype = type;
 709   if (ctf_enum_iter (ccp->fp, tid, ctf_add_enum_member_cb, &fi) == CTF_ERR)
 710     complaint (_("ctf_enum_iter process_enum_type failed - %s"),
 711                ctf_errmsg (ctf_errno (ccp->fp)));
 712
 713   /* Attach fields to the type.  */
 714   attach_fields_to_type (&fi, type);
 715
 716   new_symbol (ccp, type, tid);
 717 }
 718
 719 /* Add given cv-qualifiers CNST+VOLTL to the BASE_TYPE of array TID.  */
 720
 721 static struct type *
 722 add_array_cv_type (struct ctf_context *ccp,
 723                    ctf_id_t tid,
 724                    struct type *base_type,
 725                    int cnst,
 726                    int voltl)
 727 {
 728   struct type *el_type, *inner_array;
 729
 730   base_type = copy_type (base_type);
 731   inner_array = base_type;
 732
 733   while (TYPE_TARGET_TYPE (inner_array)->code () == TYPE_CODE_ARRAY)
 734     {
 735       TYPE_TARGET_TYPE (inner_array)
 736         = copy_type (TYPE_TARGET_TYPE (inner_array));
 737       inner_array = TYPE_TARGET_TYPE (inner_array);
 738     }
 739
 740   el_type = TYPE_TARGET_TYPE (inner_array);
 741   cnst |= TYPE_CONST (el_type);
 742   voltl |= TYPE_VOLATILE (el_type);
 743   TYPE_TARGET_TYPE (inner_array) = make_cv_type (cnst, voltl, el_type, NULL);
 744
 745   return set_tid_type (ccp->of, tid, base_type);
 746 }
 747
 748 /* Read all information from a TID of CTF_K_ARRAY.  */
 749
 750 static struct type *
 751 read_array_type (struct ctf_context *ccp, ctf_id_t tid)
 752 {
 753   struct objfile *objfile = ccp->of;
 754   ctf_dict_t *fp = ccp->fp;
 755   struct type *element_type, *range_type, *idx_type;
 756   struct type *type;
 757   ctf_arinfo_t ar;
 758
 759   if (ctf_array_info (fp, tid, &ar) == CTF_ERR)
 760     {
 761       complaint (_("ctf_array_info read_array_type failed - %s"),
 762                  ctf_errmsg (ctf_errno (fp)));
 763       return NULL;
 764     }
 765
 766   element_type = get_tid_type (objfile, ar.ctr_contents);
 767   if (element_type == NULL)
 768     return NULL;
 769
 770   idx_type = get_tid_type (objfile, ar.ctr_index);
 771   if (idx_type == NULL)
 772     idx_type = objfile_type (objfile)->builtin_int;
 773
 774   range_type = create_static_range_type (NULL, idx_type, 0, ar.ctr_nelems - 1);
 775   type = create_array_type (NULL, element_type, range_type);
 776   if (ar.ctr_nelems <= 1)       /* Check if undefined upper bound.  */
 777     {
 778       range_type->bounds ()->high.set_undefined ();
 779       TYPE_LENGTH (type) = 0;
 780       type->set_target_is_stub (true);
 781     }
 782   else
 783     TYPE_LENGTH (type) = ctf_type_size (fp, tid);
 784
 785   set_type_align (type, ctf_type_align (fp, tid));
 786
 787   return set_tid_type (objfile, tid, type);
 788 }
 789
 790 /* Read TID of kind CTF_K_CONST with base type BTID.  */
 791
 792 static struct type *
 793 read_const_type (struct ctf_context *ccp, ctf_id_t tid, ctf_id_t btid)
 794 {
 795   struct objfile *objfile = ccp->of;
 796   struct type *base_type, *cv_type;
 797
 798   base_type = get_tid_type (objfile, btid);
 799   if (base_type == NULL)
 800     {
 801       base_type = read_type_record (ccp, btid);
 802       if (base_type == NULL)
 803         {
 804           complaint (_("read_const_type: NULL base type (%ld)"), btid);
 805           base_type = objfile_type (objfile)->builtin_error;
 806         }
 807     }
 808   cv_type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0);
 809
 810   return set_tid_type (objfile, tid, cv_type);
 811 }
 812
 813 /* Read TID of kind CTF_K_VOLATILE with base type BTID.  */
 814
 815 static struct type *
 816 read_volatile_type (struct ctf_context *ccp, ctf_id_t tid, ctf_id_t btid)
 817 {
 818   struct objfile *objfile = ccp->of;
 819   ctf_dict_t *fp = ccp->fp;
 820   struct type *base_type, *cv_type;
 821
 822   base_type = get_tid_type (objfile, btid);
 823   if (base_type == NULL)
 824     {
 825       base_type = read_type_record (ccp, btid);
 826       if (base_type == NULL)
 827         {
 828           complaint (_("read_volatile_type: NULL base type (%ld)"), btid);
 829           base_type = objfile_type (objfile)->builtin_error;
 830         }
 831     }
 832
 833   if (ctf_type_kind (fp, btid) == CTF_K_ARRAY)
 834     return add_array_cv_type (ccp, tid, base_type, 0, 1);
 835   cv_type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0);
 836
 837   return set_tid_type (objfile, tid, cv_type);
 838 }
 839
 840 /* Read TID of kind CTF_K_RESTRICT with base type BTID.  */
 841
 842 static struct type *
 843 read_restrict_type (struct ctf_context *ccp, ctf_id_t tid, ctf_id_t btid)
 844 {
 845   struct objfile *objfile = ccp->of;
 846   struct type *base_type, *cv_type;
 847
 848   base_type = get_tid_type (objfile, btid);
 849   if (base_type == NULL)
 850     {
 851       base_type = read_type_record (ccp, btid);
 852       if (base_type == NULL)
 853         {
 854           complaint (_("read_restrict_type: NULL base type (%ld)"), btid);
 855           base_type = objfile_type (objfile)->builtin_error;
 856         }
 857     }
 858   cv_type = make_restrict_type (base_type);
 859
 860   return set_tid_type (objfile, tid, cv_type);
 861 }
 862
 863 /* Read TID of kind CTF_K_TYPEDEF with its NAME and base type BTID.  */
 864
 865 static struct type *
 866 read_typedef_type (struct ctf_context *ccp, ctf_id_t tid,
 867                    ctf_id_t btid, const char *name)
 868 {
 869   struct objfile *objfile = ccp->of;
 870   struct type *this_type, *target_type;
 871
 872   char *aname = obstack_strdup (&objfile->objfile_obstack, name);
 873   this_type = init_type (objfile, TYPE_CODE_TYPEDEF, 0, aname);
 874   set_tid_type (objfile, tid, this_type);
 875   target_type = get_tid_type (objfile, btid);
 876   if (target_type != this_type)
 877     TYPE_TARGET_TYPE (this_type) = target_type;
 878   else
 879     TYPE_TARGET_TYPE (this_type) = NULL;
 880
 881   this_type->set_target_is_stub (TYPE_TARGET_TYPE (this_type) != nullptr);
 882
 883   return set_tid_type (objfile, tid, this_type);
 884 }
 885
 886 /* Read TID of kind CTF_K_POINTER with base type BTID.  */
 887
 888 static struct type *
 889 read_pointer_type (struct ctf_context *ccp, ctf_id_t tid, ctf_id_t btid)
 890 {
 891   struct objfile *of = ccp->of;
 892   struct type *target_type, *type;
 893
 894   target_type = get_tid_type (of, btid);
 895   if (target_type == NULL)
 896     {
 897       target_type = read_type_record (ccp, btid);
 898       if (target_type == NULL)
 899         {
 900           complaint (_("read_pointer_type: NULL target type (%ld)"), btid);
 901           target_type = objfile_type (ccp->of)->builtin_error;
 902         }
 903     }
 904
 905   type = lookup_pointer_type (target_type);
 906   set_type_align (type, ctf_type_align (ccp->fp, tid));
 907
 908   return set_tid_type (of, tid, type);
 909 }
 910
 911 /* Read information associated with type TID.  */
 912
 913 static struct type *
 914 read_type_record (struct ctf_context *ccp, ctf_id_t tid)
 915 {
 916   ctf_dict_t *fp = ccp->fp;
 917   uint32_t kind;
 918   struct type *type = NULL;
 919   ctf_id_t btid;
 920
 921   kind = ctf_type_kind (fp, tid);
 922   switch (kind)
 923     {
 924       case CTF_K_STRUCT:
 925       case CTF_K_UNION:
 926         type = read_structure_type (ccp, tid);
 927         break;
 928       case CTF_K_ENUM:
 929         type = read_enum_type (ccp, tid);
 930         break;
 931       case CTF_K_FUNCTION:
 932         type = read_func_kind_type (ccp, tid);
 933         break;
 934       case CTF_K_CONST:
 935         btid = ctf_type_reference (fp, tid);
 936         type = read_const_type (ccp, tid, btid);
 937         break;
 938       case CTF_K_TYPEDEF:
 939         {
 940           gdb::unique_xmalloc_ptr<char> name (ctf_type_aname_raw (fp, tid));
 941           btid = ctf_type_reference (fp, tid);
 942           type = read_typedef_type (ccp, tid, btid, name.get ());
 943         }
 944         break;
 945       case CTF_K_VOLATILE:
 946         btid = ctf_type_reference (fp, tid);
 947         type = read_volatile_type (ccp, tid, btid);
 948         break;
 949       case CTF_K_RESTRICT:
 950         btid = ctf_type_reference (fp, tid);
 951         type = read_restrict_type (ccp, tid, btid);
 952         break;
 953       case CTF_K_POINTER:
 954         btid = ctf_type_reference (fp, tid);
 955         type = read_pointer_type (ccp, tid, btid);
 956         break;
 957       case CTF_K_INTEGER:
 958       case CTF_K_FLOAT:
 959         type = read_base_type (ccp, tid);
 960         break;
 961       case CTF_K_ARRAY:
 962         type = read_array_type (ccp, tid);
 963         break;
 964       case CTF_K_UNKNOWN:
 965         break;
 966       default:
 967         break;
 968     }
 969
 970   return type;
 971 }
 972
 973 /* Callback to add type TID to the symbol table.  */
 974
 975 static int
 976 ctf_add_type_cb (ctf_id_t tid, void *arg)
 977 {
 978   struct ctf_context *ccp = (struct ctf_context *) arg;
 979   struct type *type;
 980   uint32_t kind;
 981
 982   /* Check if tid's type has already been defined.  */
 983   type = get_tid_type (ccp->of, tid);
 984   if (type != NULL)
 985     return 0;
 986
 987   ctf_id_t btid = ctf_type_reference (ccp->fp, tid);
 988   kind = ctf_type_kind (ccp->fp, tid);
 989   switch (kind)
 990     {
 991       case CTF_K_STRUCT:
 992       case CTF_K_UNION:
 993         process_structure_type (ccp, tid);
 994         break;
 995       case CTF_K_ENUM:
 996         process_enum_type (ccp, tid);
 997         break;
 998       case CTF_K_FUNCTION:
 999         type = read_func_kind_type (ccp, tid);
1000         new_symbol (ccp, type, tid);
1001         break;
1002       case CTF_K_INTEGER:
1003       case CTF_K_FLOAT:
1004         process_base_type (ccp, tid);
1005         break;
1006       case CTF_K_TYPEDEF:
1007         new_symbol (ccp, read_type_record (ccp, tid), tid);
1008         break;
1009       case CTF_K_CONST:
1010         type = read_const_type (ccp, tid, btid);
1011         new_symbol (ccp, type, tid);
1012         break;
1013       case CTF_K_VOLATILE:
1014         type = read_volatile_type (ccp, tid, btid);
1015         new_symbol (ccp, type, tid);
1016         break;
1017       case CTF_K_RESTRICT:
1018         type = read_restrict_type (ccp, tid, btid);
1019         new_symbol (ccp, type, tid);
1020         break;
1021       case CTF_K_POINTER:
1022         type = read_pointer_type (ccp, tid, btid);
1023         new_symbol (ccp, type, tid);
1024         break;
1025       case CTF_K_ARRAY:
1026         type = read_array_type (ccp, tid);
1027         new_symbol (ccp, type, tid);
1028         break;
1029       case CTF_K_UNKNOWN:
1030         break;
1031       default:
1032         break;
1033     }
1034
1035   return 0;
1036 }
1037
1038 /* Callback to add variable NAME with TID to the symbol table.  */
1039
1040 static int
1041 ctf_add_var_cb (const char *name, ctf_id_t id, void *arg)
1042 {
1043   struct ctf_context *ccp = (struct ctf_context *) arg;
1044   struct symbol *sym = NULL;
1045   struct type *type;
1046   uint32_t kind;
1047
1048   type = get_tid_type (ccp->of, id);
1049
1050   kind = ctf_type_kind (ccp->fp, id);
1051   switch (kind)
1052     {
1053       case CTF_K_FUNCTION:
1054         if (name && !strcmp(name, "main"))
1055           set_objfile_main_name (ccp->of, name, language_c);
1056         break;
1057       case CTF_K_INTEGER:
1058       case CTF_K_FLOAT:
1059       case CTF_K_VOLATILE:
1060       case CTF_K_RESTRICT:
1061       case CTF_K_TYPEDEF:
1062       case CTF_K_CONST:
1063       case CTF_K_POINTER:
1064       case CTF_K_ARRAY:
1065         if (type)
1066           {
1067             sym = new_symbol (ccp, type, id);
1068             sym->compute_and_set_names (name, false, ccp->of->per_bfd);
1069           }
1070         break;
1071       case CTF_K_STRUCT:
1072       case CTF_K_UNION:
1073       case CTF_K_ENUM:
1074         if (type == NULL)
1075         {
1076           complaint (_("ctf_add_var_cb: %s has NO type (%ld)"), name, id);
1077           type = objfile_type (ccp->of)->builtin_error;
1078         }
1079         sym = new (&ccp->of->objfile_obstack) symbol;
1080         OBJSTAT (ccp->of, n_syms++);
1081         SYMBOL_TYPE (sym) = type;
1082         SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1083         SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
1084         sym->compute_and_set_names (name, false, ccp->of->per_bfd);
1085         add_symbol_to_list (sym, ccp->builder->get_global_symbols ());
1086         break;
1087       default:
1088         complaint (_("ctf_add_var_cb: kind unsupported (%d)"), kind);
1089         break;
1090     }
1091
1092   if (sym)
1093     set_symbol_address (ccp->of, sym, name);
1094
1095   return 0;
1096 }
1097
1098 /* Add an ELF STT_OBJ symbol with index IDX to the symbol table.  */
1099
1100 static struct symbol *
1101 add_stt_obj (struct ctf_context *ccp, unsigned long idx)
1102 {
1103   struct symbol *sym;
1104   struct type *type;
1105   ctf_id_t tid;
1106
1107   if ((tid = ctf_lookup_by_symbol (ccp->fp, idx)) == CTF_ERR)
1108     return NULL;
1109
1110   type = get_tid_type (ccp->of, tid);
1111   if (type == NULL)
1112     return NULL;
1113
1114   sym = new_symbol (ccp, type, tid);
1115
1116   return sym;
1117 }
1118
1119 /* Add an ELF STT_FUNC symbol with index IDX to the symbol table.  */
1120
1121 static struct symbol *
1122 add_stt_func (struct ctf_context *ccp, unsigned long idx)
1123 {
1124   struct type *ftype, *atyp, *rettyp;
1125   struct symbol *sym;
1126   ctf_funcinfo_t finfo;
1127   ctf_id_t argv[32];
1128   uint32_t argc;
1129   ctf_id_t tid;
1130   struct type *void_type = objfile_type (ccp->of)->builtin_void;
1131
1132   if (ctf_func_info (ccp->fp, idx, &finfo) == CTF_ERR)
1133     return NULL;
1134
1135   argc = finfo.ctc_argc;
1136   if (ctf_func_args (ccp->fp, idx, argc, argv) == CTF_ERR)
1137     return NULL;
1138
1139   gdb::unique_xmalloc_ptr<char> name (ctf_type_aname_raw (ccp->fp, idx));
1140   if (name == NULL)
1141     return NULL;
1142
1143   tid = ctf_lookup_by_symbol (ccp->fp, idx);
1144   ftype = get_tid_type (ccp->of, tid);
1145   if (finfo.ctc_flags & CTF_FUNC_VARARG)
1146     ftype->set_has_varargs (true);
1147   ftype->set_num_fields (argc);
1148
1149   /* If argc is 0, it has a "void" type.  */
1150   if (argc != 0)
1151     ftype->set_fields
1152       ((struct field *) TYPE_ZALLOC (ftype, argc * sizeof (struct field)));
1153
1154   /* TYPE_FIELD_TYPE must never be NULL.  Fill it with void_type, if failed
1155      to find the argument type.  */
1156   for (int iparam = 0; iparam < argc; iparam++)
1157     {
1158       atyp = get_tid_type (ccp->of, argv[iparam]);
1159       if (atyp)
1160         ftype->field (iparam).set_type (atyp);
1161       else
1162         ftype->field (iparam).set_type (void_type);
1163     }
1164
1165   sym = new_symbol (ccp, ftype, tid);
1166   rettyp = get_tid_type (ccp->of, finfo.ctc_return);
1167   if (rettyp != NULL)
1168     SYMBOL_TYPE (sym) = rettyp;
1169   else
1170     SYMBOL_TYPE (sym) = void_type;
1171
1172   return sym;
1173 }
1174
1175 /* Get text segment base for OBJFILE, TSIZE contains the segment size.  */
1176
1177 static CORE_ADDR
1178 get_objfile_text_range (struct objfile *of, int *tsize)
1179 {
1180   bfd *abfd = of->obfd;
1181   const asection *codes;
1182
1183   codes = bfd_get_section_by_name (abfd, ".text");
1184   *tsize = codes ? bfd_section_size (codes) : 0;
1185   return of->text_section_offset ();
1186 }
1187
1188 /* Start a symtab for OBJFILE in CTF format.  */
1189
1190 static void
1191 ctf_start_symtab (ctf_psymtab *pst,
1192                   struct objfile *of, CORE_ADDR text_offset)
1193 {
1194   struct ctf_context *ccp;
1195
1196   ccp = pst->context;
1197   ccp->builder = new buildsym_compunit
1198                        (of, of->original_name, NULL,
1199                        language_c, text_offset);
1200   ccp->builder->record_debugformat ("ctf");
1201 }
1202
1203 /* Finish reading symbol/type definitions in CTF format.
1204    END_ADDR is the end address of the file's text.  SECTION is
1205    the .text section number.  */
1206
1207 static struct compunit_symtab *
1208 ctf_end_symtab (ctf_psymtab *pst,
1209                 CORE_ADDR end_addr, int section)
1210 {
1211   struct ctf_context *ccp;
1212
1213   ccp = pst->context;
1214   struct compunit_symtab *result
1215     = ccp->builder->end_symtab (end_addr, section);
1216   delete ccp->builder;
1217   ccp->builder = NULL;
1218   return result;
1219 }
1220
1221 /* Read in full symbols for PST, and anything it depends on.  */
1222
1223 void
1224 ctf_psymtab::expand_psymtab (struct objfile *objfile)
1225 {
1226   struct symbol *sym;
1227   struct ctf_context *ccp;
1228
1229   gdb_assert (!readin);
1230
1231   ccp = context;
1232
1233   /* Iterate over entries in data types section.  */
1234   if (ctf_type_iter (ccp->fp, ctf_add_type_cb, ccp) == CTF_ERR)
1235     complaint (_("ctf_type_iter psymtab_to_symtab failed - %s"),
1236                ctf_errmsg (ctf_errno (ccp->fp)));
1237
1238
1239   /* Iterate over entries in variable info section.  */
1240   if (ctf_variable_iter (ccp->fp, ctf_add_var_cb, ccp) == CTF_ERR)
1241     complaint (_("ctf_variable_iter psymtab_to_symtab failed - %s"),
1242                ctf_errmsg (ctf_errno (ccp->fp)));
1243
1244   /* Add entries in data objects and function info sections.  */
1245   for (unsigned long i = 0; ; i++)
1246     {
1247       sym = add_stt_obj (ccp, i);
1248       if (sym == NULL)
1249         {
1250           if (ctf_errno (ccp->fp) == EINVAL
1251               || ctf_errno (ccp->fp) == ECTF_NOSYMTAB)
1252             break;
1253           sym = add_stt_func (ccp, i);
1254         }
1255       if (sym == NULL)
1256         continue;
1257
1258       set_symbol_address (ccp->of, sym, sym->linkage_name ());
1259     }
1260
1261   readin = true;
1262 }
1263
1264 /* Expand partial symbol table PST into a full symbol table.
1265    PST is not NULL.  */
1266
1267 void
1268 ctf_psymtab::read_symtab (struct objfile *objfile)
1269 {
1270   if (readin)
1271     warning (_("bug: psymtab for %s is already read in."), filename);
1272   else
1273     {
1274       if (info_verbose)
1275         {
1276           printf_filtered (_("Reading in CTF data for %s..."), filename);
1277           gdb_flush (gdb_stdout);
1278         }
1279
1280       /* Start a symtab.  */
1281       CORE_ADDR offset;        /* Start of text segment.  */
1282       int tsize;
1283
1284       offset = get_objfile_text_range (objfile, &tsize);
1285       ctf_start_symtab (this, objfile, offset);
1286       expand_psymtab (objfile);
1287
1288       set_text_low (offset);
1289       set_text_high (offset + tsize);
1290       compunit_symtab = ctf_end_symtab (this, offset + tsize,
1291                                         SECT_OFF_TEXT (objfile));
1292
1293       /* Finish up the debug error message.  */
1294       if (info_verbose)
1295         printf_filtered (_("done.\n"));
1296     }
1297 }
1298
1299 /* Allocate a new partial_symtab NAME.
1300
1301    Each source file that has not been fully read in is represented by
1302    a partial_symtab.  This contains the information on where in the
1303    executable the debugging symbols for a specific file are, and a
1304    list of names of global symbols which are located in this file.
1305    They are all chained on partial symtab lists.
1306
1307    Even after the source file has been read into a symtab, the
1308    partial_symtab remains around.  They are allocated on an obstack,
1309    objfile_obstack.  */
1310
1311 static ctf_psymtab *
1312 create_partial_symtab (const char *name,
1313                        ctf_dict_t *cfp,
1314                        struct objfile *objfile)
1315 {
1316   ctf_psymtab *pst;
1317   struct ctf_context *ccx;
1318
1319   pst = new ctf_psymtab (name, objfile, 0);
1320
1321   ccx = XOBNEW (&objfile->objfile_obstack, struct ctf_context);
1322   ccx->fp = cfp;
1323   ccx->of = objfile;
1324   ccx->pst = pst;
1325   ccx->builder = nullptr;
1326   pst->context = ccx;
1327
1328   return pst;
1329 }
1330
1331 /* Callback to add type TID to partial symbol table.  */
1332
1333 static int
1334 ctf_psymtab_type_cb (ctf_id_t tid, void *arg)
1335 {
1336   struct ctf_context *ccp;
1337   uint32_t kind;
1338   short section = -1;
1339
1340   ccp = (struct ctf_context *) arg;
1341   gdb::unique_xmalloc_ptr<char> name (ctf_type_aname_raw (ccp->fp, tid));
1342   if (name == NULL || strlen (name.get ()) == 0)
1343     return 0;
1344
1345   domain_enum domain = UNDEF_DOMAIN;
1346   enum address_class aclass = LOC_UNDEF;
1347   kind = ctf_type_kind (ccp->fp, tid);
1348   switch (kind)
1349     {
1350       case CTF_K_STRUCT:
1351       case CTF_K_UNION:
1352       case CTF_K_ENUM:
1353         domain = STRUCT_DOMAIN;
1354         aclass = LOC_TYPEDEF;
1355         break;
1356       case CTF_K_FUNCTION:
1357       case CTF_K_FORWARD:
1358         domain = VAR_DOMAIN;
1359         aclass = LOC_STATIC;
1360         section = SECT_OFF_TEXT (ccp->of);
1361         break;
1362       case CTF_K_CONST:
1363         domain = VAR_DOMAIN;
1364         aclass = LOC_STATIC;
1365         break;
1366       case CTF_K_TYPEDEF:
1367       case CTF_K_POINTER:
1368       case CTF_K_VOLATILE:
1369       case CTF_K_RESTRICT:
1370         domain = VAR_DOMAIN;
1371         aclass = LOC_TYPEDEF;
1372         break;
1373       case CTF_K_INTEGER:
1374       case CTF_K_FLOAT:
1375         domain = VAR_DOMAIN;
1376         aclass = LOC_TYPEDEF;
1377         break;
1378       case CTF_K_ARRAY:
1379       case CTF_K_UNKNOWN:
1380         return 0;
1381     }
1382
1383   ccp->pst->add_psymbol (name.get (), true,
1384                          domain, aclass, section,
1385                          psymbol_placement::GLOBAL,
1386                          0, language_c, ccp->of);
1387
1388   return 0;
1389 }
1390
1391 /* Callback to add variable NAME with ID to partial symbol table.  */
1392
1393 static int
1394 ctf_psymtab_var_cb (const char *name, ctf_id_t id, void *arg)
1395 {
1396   struct ctf_context *ccp = (struct ctf_context *) arg;
1397
1398   ccp->pst->add_psymbol (name, true,
1399                          VAR_DOMAIN, LOC_STATIC, -1,
1400                          psymbol_placement::GLOBAL,
1401                          0, language_c, ccp->of);
1402   return 0;
1403 }
1404
1405 /* Setup partial_symtab's describing each source file for which
1406    debugging information is available.  */
1407
1408 static void
1409 scan_partial_symbols (ctf_dict_t *cfp, struct objfile *of)
1410 {
1411   bfd *abfd = of->obfd;
1412   const char *name = bfd_get_filename (abfd);
1413   ctf_psymtab *pst = create_partial_symtab (name, cfp, of);
1414
1415   struct ctf_context *ccx = pst->context;
1416
1417   if (ctf_type_iter (cfp, ctf_psymtab_type_cb, ccx) == CTF_ERR)
1418     complaint (_("ctf_type_iter scan_partial_symbols failed - %s"),
1419                ctf_errmsg (ctf_errno (cfp)));
1420
1421   if (ctf_variable_iter (cfp, ctf_psymtab_var_cb, ccx) == CTF_ERR)
1422     complaint (_("ctf_variable_iter scan_partial_symbols failed - %s"),
1423                ctf_errmsg (ctf_errno (cfp)));
1424
1425   /* Scan CTF object and function sections which correspond to each
1426      STT_FUNC or STT_OBJECT entry in the symbol table,
1427      pick up what init_symtab has done.  */
1428   for (unsigned long idx = 0; ; idx++)
1429     {
1430       ctf_id_t tid;
1431       if ((tid = ctf_lookup_by_symbol (cfp, idx)) == CTF_ERR)
1432         {
1433         if (ctf_errno (cfp) == EINVAL || ctf_errno (cfp) == ECTF_NOSYMTAB)
1434           break;        // Done, reach end of the section.
1435         else
1436           continue;
1437         }
1438       gdb::unique_xmalloc_ptr<char> tname (ctf_type_aname_raw (cfp, tid));
1439       uint32_t kind = ctf_type_kind (cfp, tid);
1440       address_class aclass;
1441       domain_enum tdomain;
1442       switch (kind)
1443         {
1444           case CTF_K_STRUCT:
1445           case CTF_K_UNION:
1446           case CTF_K_ENUM:
1447             tdomain = STRUCT_DOMAIN;
1448             break;
1449           default:
1450             tdomain = VAR_DOMAIN;
1451             break;
1452         }
1453
1454       if (kind == CTF_K_FUNCTION)
1455         aclass = LOC_STATIC;
1456       else if (kind == CTF_K_CONST)
1457         aclass = LOC_CONST;
1458       else
1459         aclass = LOC_TYPEDEF;
1460
1461       pst->add_psymbol (tname.get (), true,
1462                         tdomain, aclass, -1,
1463                         psymbol_placement::STATIC,
1464                         0, language_c, of);
1465     }
1466
1467   pst->end ();
1468 }
1469
1470 /* Read CTF debugging information from a BFD section.  This is
1471    called from elfread.c.  It does a quick pass through the
1472    .ctf section to set up the partial symbol table.  */
1473
1474 void
1475 elfctf_build_psymtabs (struct objfile *of)
1476 {
1477   bfd *abfd = of->obfd;
1478   int err;
1479
1480   ctf_archive_t *arc = ctf_bfdopen (abfd, &err);
1481   if (arc == NULL)
1482     error (_("ctf_bfdopen failed on %s - %s"),
1483            bfd_get_filename (abfd), ctf_errmsg (err));
1484
1485   ctf_dict_t *fp = ctf_dict_open (arc, NULL, &err);
1486   if (fp == NULL)
1487     error (_("ctf_dict_open failed on %s - %s"),
1488            bfd_get_filename (abfd), ctf_errmsg (err));
1489   ctf_dict_key.emplace (of, fp);
1490
1491   scan_partial_symbols (fp, of);
1492 }
1493
1494 #else
1495
1496 void
1497 elfctf_build_psymtabs (struct objfile *of)
1498 {
1499   /* Nothing to do if CTF is disabled.  */
1500 }
1501
1502 #endif /* ENABLE_LIBCTF */