gdb/ctfread.c

   1 /* Compact ANSI-C Type Format (CTF) support in GDB.
   2
   3    Copyright (C) 2019-2021 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 == nullptr)
 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 nullptr;
 262
 263   ids.tid = tid;
 264   ids.type = nullptr;
 265   slot = (struct ctf_tid_and_type *) htab_find (htab, &ids);
 266   if (slot)
 267     return slot->type;
 268   else
 269     return nullptr;
 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, nullptr, 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       sym->set_section_index (msym.minsym->section_index ());
 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 != nullptr)
 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 == nullptr)
 373     {
 374       t = read_type_record (ccp, tid);
 375       if (t == nullptr)
 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 (nullptr);
 409   SET_FIELD_ENUMVAL (*fp, enum_value);
 410   FIELD_BITSIZE (*fp) = 0;
 411
 412   if (name != nullptr)
 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 = nullptr;
 439
 440   gdb::unique_xmalloc_ptr<char> name (ctf_type_aname_raw (fp, tid));
 441   if (name != nullptr)
 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 != nullptr)
 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 = nullptr;
 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 nullptr;
 511     }
 512
 513   gdb::unique_xmalloc_ptr<char> copied_name (ctf_type_aname_raw (fp, tid));
 514   if (copied_name == nullptr || strlen (copied_name.get ()) == 0)
 515     {
 516       name = ctf_type_aname (fp, tid);
 517       if (name == nullptr)
 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 != nullptr && 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 != nullptr && 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, *atype;
 655   ctf_funcinfo_t cfi;
 656   uint32_t argc;
 657
 658   type = alloc_type (of);
 659
 660   gdb::unique_xmalloc_ptr<char> name (ctf_type_aname_raw (fp, tid));
 661   if (name != nullptr && strlen (name.get ()) != 0)
 662     type->set_name (obstack_strdup (&of->objfile_obstack, name.get ()));
 663
 664   type->set_code (TYPE_CODE_FUNC);
 665   ctf_func_type_info (fp, tid, &cfi);
 666   rettype = get_tid_type (of, cfi.ctc_return);
 667   TYPE_TARGET_TYPE (type) = rettype;
 668   set_type_align (type, ctf_type_align (fp, tid));
 669
 670   /* Set up function's arguments.  */
 671   argc = cfi.ctc_argc;
 672   type->set_num_fields (argc);
 673   if ((cfi.ctc_flags & CTF_FUNC_VARARG) != 0)
 674     type->set_has_varargs (true);
 675
 676   if (argc != 0)
 677     {
 678       std::vector<ctf_id_t> argv (argc);
 679       if (ctf_func_type_args (fp, tid, argc, argv.data ()) == CTF_ERR)
 680         return nullptr;
 681
 682       type->set_fields
 683         ((struct field *) TYPE_ZALLOC (type, argc * sizeof (struct field)));
 684       struct type *void_type = objfile_type (of)->builtin_void;
 685       /* If failed to find the argument type, fill it with void_type.  */
 686       for (int iparam = 0; iparam < argc; iparam++)
 687         {
 688           atype = get_tid_type (of, argv[iparam]);
 689           if (atype != nullptr)
 690             type->field (iparam).set_type (atype);
 691           else
 692             type->field (iparam).set_type (void_type);
 693         }
 694     }
 695
 696   return set_tid_type (of, tid, type);
 697 }
 698
 699 /* Given a TID of CTF_K_ENUM, process all the members of the
 700    enumeration, and create the symbol for the enumeration type.  */
 701
 702 static struct type *
 703 read_enum_type (struct ctf_context *ccp, ctf_id_t tid)
 704 {
 705   struct objfile *of = ccp->of;
 706   ctf_dict_t *fp = ccp->fp;
 707   struct type *type, *target_type;
 708   ctf_funcinfo_t fi;
 709
 710   type = alloc_type (of);
 711
 712   gdb::unique_xmalloc_ptr<char> name (ctf_type_aname_raw (fp, tid));
 713   if (name != nullptr && strlen (name.get ()) != 0)
 714     type->set_name (obstack_strdup (&of->objfile_obstack, name.get ()));
 715
 716   type->set_code (TYPE_CODE_ENUM);
 717   TYPE_LENGTH (type) = ctf_type_size (fp, tid);
 718   ctf_func_type_info (fp, tid, &fi);
 719   target_type = get_tid_type (of, fi.ctc_return);
 720   TYPE_TARGET_TYPE (type) = target_type;
 721   set_type_align (type, ctf_type_align (fp, tid));
 722
 723   return set_tid_type (of, tid, type);
 724 }
 725
 726 static void
 727 process_enum_type (struct ctf_context *ccp, ctf_id_t tid)
 728 {
 729   struct type *type;
 730   struct ctf_field_info fi;
 731
 732   type = read_enum_type (ccp, tid);
 733
 734   fi.cur_context = ccp;
 735   fi.ptype = type;
 736   if (ctf_enum_iter (ccp->fp, tid, ctf_add_enum_member_cb, &fi) == CTF_ERR)
 737     complaint (_("ctf_enum_iter process_enum_type failed - %s"),
 738                ctf_errmsg (ctf_errno (ccp->fp)));
 739
 740   /* Attach fields to the type.  */
 741   attach_fields_to_type (&fi, type);
 742
 743   new_symbol (ccp, type, tid);
 744 }
 745
 746 /* Add given cv-qualifiers CNST+VOLTL to the BASE_TYPE of array TID.  */
 747
 748 static struct type *
 749 add_array_cv_type (struct ctf_context *ccp,
 750                    ctf_id_t tid,
 751                    struct type *base_type,
 752                    int cnst,
 753                    int voltl)
 754 {
 755   struct type *el_type, *inner_array;
 756
 757   base_type = copy_type (base_type);
 758   inner_array = base_type;
 759
 760   while (TYPE_TARGET_TYPE (inner_array)->code () == TYPE_CODE_ARRAY)
 761     {
 762       TYPE_TARGET_TYPE (inner_array)
 763         = copy_type (TYPE_TARGET_TYPE (inner_array));
 764       inner_array = TYPE_TARGET_TYPE (inner_array);
 765     }
 766
 767   el_type = TYPE_TARGET_TYPE (inner_array);
 768   cnst |= TYPE_CONST (el_type);
 769   voltl |= TYPE_VOLATILE (el_type);
 770   TYPE_TARGET_TYPE (inner_array) = make_cv_type (cnst, voltl, el_type, nullptr);
 771
 772   return set_tid_type (ccp->of, tid, base_type);
 773 }
 774
 775 /* Read all information from a TID of CTF_K_ARRAY.  */
 776
 777 static struct type *
 778 read_array_type (struct ctf_context *ccp, ctf_id_t tid)
 779 {
 780   struct objfile *objfile = ccp->of;
 781   ctf_dict_t *fp = ccp->fp;
 782   struct type *element_type, *range_type, *idx_type;
 783   struct type *type;
 784   ctf_arinfo_t ar;
 785
 786   if (ctf_array_info (fp, tid, &ar) == CTF_ERR)
 787     {
 788       complaint (_("ctf_array_info read_array_type failed - %s"),
 789                  ctf_errmsg (ctf_errno (fp)));
 790       return nullptr;
 791     }
 792
 793   element_type = get_tid_type (objfile, ar.ctr_contents);
 794   if (element_type == nullptr)
 795     return nullptr;
 796
 797   idx_type = get_tid_type (objfile, ar.ctr_index);
 798   if (idx_type == nullptr)
 799     idx_type = objfile_type (objfile)->builtin_int;
 800
 801   range_type = create_static_range_type (NULL, idx_type, 0, ar.ctr_nelems - 1);
 802   type = create_array_type (NULL, element_type, range_type);
 803   if (ar.ctr_nelems <= 1)       /* Check if undefined upper bound.  */
 804     {
 805       range_type->bounds ()->high.set_undefined ();
 806       TYPE_LENGTH (type) = 0;
 807       type->set_target_is_stub (true);
 808     }
 809   else
 810     TYPE_LENGTH (type) = ctf_type_size (fp, tid);
 811
 812   set_type_align (type, ctf_type_align (fp, tid));
 813
 814   return set_tid_type (objfile, tid, type);
 815 }
 816
 817 /* Read TID of kind CTF_K_CONST with base type BTID.  */
 818
 819 static struct type *
 820 read_const_type (struct ctf_context *ccp, ctf_id_t tid, ctf_id_t btid)
 821 {
 822   struct objfile *objfile = ccp->of;
 823   struct type *base_type, *cv_type;
 824
 825   base_type = get_tid_type (objfile, btid);
 826   if (base_type == nullptr)
 827     {
 828       base_type = read_type_record (ccp, btid);
 829       if (base_type == nullptr)
 830         {
 831           complaint (_("read_const_type: NULL base type (%ld)"), btid);
 832           base_type = objfile_type (objfile)->builtin_error;
 833         }
 834     }
 835   cv_type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0);
 836
 837   return set_tid_type (objfile, tid, cv_type);
 838 }
 839
 840 /* Read TID of kind CTF_K_VOLATILE with base type BTID.  */
 841
 842 static struct type *
 843 read_volatile_type (struct ctf_context *ccp, ctf_id_t tid, ctf_id_t btid)
 844 {
 845   struct objfile *objfile = ccp->of;
 846   ctf_dict_t *fp = ccp->fp;
 847   struct type *base_type, *cv_type;
 848
 849   base_type = get_tid_type (objfile, btid);
 850   if (base_type == nullptr)
 851     {
 852       base_type = read_type_record (ccp, btid);
 853       if (base_type == nullptr)
 854         {
 855           complaint (_("read_volatile_type: NULL base type (%ld)"), btid);
 856           base_type = objfile_type (objfile)->builtin_error;
 857         }
 858     }
 859
 860   if (ctf_type_kind (fp, btid) == CTF_K_ARRAY)
 861     return add_array_cv_type (ccp, tid, base_type, 0, 1);
 862   cv_type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0);
 863
 864   return set_tid_type (objfile, tid, cv_type);
 865 }
 866
 867 /* Read TID of kind CTF_K_RESTRICT with base type BTID.  */
 868
 869 static struct type *
 870 read_restrict_type (struct ctf_context *ccp, ctf_id_t tid, ctf_id_t btid)
 871 {
 872   struct objfile *objfile = ccp->of;
 873   struct type *base_type, *cv_type;
 874
 875   base_type = get_tid_type (objfile, btid);
 876   if (base_type == nullptr)
 877     {
 878       base_type = read_type_record (ccp, btid);
 879       if (base_type == nullptr)
 880         {
 881           complaint (_("read_restrict_type: NULL base type (%ld)"), btid);
 882           base_type = objfile_type (objfile)->builtin_error;
 883         }
 884     }
 885   cv_type = make_restrict_type (base_type);
 886
 887   return set_tid_type (objfile, tid, cv_type);
 888 }
 889
 890 /* Read TID of kind CTF_K_TYPEDEF with its NAME and base type BTID.  */
 891
 892 static struct type *
 893 read_typedef_type (struct ctf_context *ccp, ctf_id_t tid,
 894                    ctf_id_t btid, const char *name)
 895 {
 896   struct objfile *objfile = ccp->of;
 897   struct type *this_type, *target_type;
 898
 899   char *aname = obstack_strdup (&objfile->objfile_obstack, name);
 900   this_type = init_type (objfile, TYPE_CODE_TYPEDEF, 0, aname);
 901   set_tid_type (objfile, tid, this_type);
 902   target_type = get_tid_type (objfile, btid);
 903   if (target_type != this_type)
 904     TYPE_TARGET_TYPE (this_type) = target_type;
 905   else
 906     TYPE_TARGET_TYPE (this_type) = nullptr;
 907
 908   this_type->set_target_is_stub (TYPE_TARGET_TYPE (this_type) != nullptr);
 909
 910   return set_tid_type (objfile, tid, this_type);
 911 }
 912
 913 /* Read TID of kind CTF_K_POINTER with base type BTID.  */
 914
 915 static struct type *
 916 read_pointer_type (struct ctf_context *ccp, ctf_id_t tid, ctf_id_t btid)
 917 {
 918   struct objfile *of = ccp->of;
 919   struct type *target_type, *type;
 920
 921   target_type = get_tid_type (of, btid);
 922   if (target_type == nullptr)
 923     {
 924       target_type = read_type_record (ccp, btid);
 925       if (target_type == nullptr)
 926         {
 927           complaint (_("read_pointer_type: NULL target type (%ld)"), btid);
 928           target_type = objfile_type (ccp->of)->builtin_error;
 929         }
 930     }
 931
 932   type = lookup_pointer_type (target_type);
 933   set_type_align (type, ctf_type_align (ccp->fp, tid));
 934
 935   return set_tid_type (of, tid, type);
 936 }
 937
 938 /* Read information associated with type TID.  */
 939
 940 static struct type *
 941 read_type_record (struct ctf_context *ccp, ctf_id_t tid)
 942 {
 943   ctf_dict_t *fp = ccp->fp;
 944   uint32_t kind;
 945   struct type *type = nullptr;
 946   ctf_id_t btid;
 947
 948   kind = ctf_type_kind (fp, tid);
 949   switch (kind)
 950     {
 951       case CTF_K_STRUCT:
 952       case CTF_K_UNION:
 953         type = read_structure_type (ccp, tid);
 954         break;
 955       case CTF_K_ENUM:
 956         type = read_enum_type (ccp, tid);
 957         break;
 958       case CTF_K_FUNCTION:
 959         type = read_func_kind_type (ccp, tid);
 960         break;
 961       case CTF_K_CONST:
 962         btid = ctf_type_reference (fp, tid);
 963         type = read_const_type (ccp, tid, btid);
 964         break;
 965       case CTF_K_TYPEDEF:
 966         {
 967           gdb::unique_xmalloc_ptr<char> name (ctf_type_aname_raw (fp, tid));
 968           btid = ctf_type_reference (fp, tid);
 969           type = read_typedef_type (ccp, tid, btid, name.get ());
 970         }
 971         break;
 972       case CTF_K_VOLATILE:
 973         btid = ctf_type_reference (fp, tid);
 974         type = read_volatile_type (ccp, tid, btid);
 975         break;
 976       case CTF_K_RESTRICT:
 977         btid = ctf_type_reference (fp, tid);
 978         type = read_restrict_type (ccp, tid, btid);
 979         break;
 980       case CTF_K_POINTER:
 981         btid = ctf_type_reference (fp, tid);
 982         type = read_pointer_type (ccp, tid, btid);
 983         break;
 984       case CTF_K_INTEGER:
 985       case CTF_K_FLOAT:
 986         type = read_base_type (ccp, tid);
 987         break;
 988       case CTF_K_ARRAY:
 989         type = read_array_type (ccp, tid);
 990         break;
 991       case CTF_K_UNKNOWN:
 992         break;
 993       default:
 994         break;
 995     }
 996
 997   return type;
 998 }
 999
1000 /* Callback to add type TID to the symbol table.  */
1001
1002 static int
1003 ctf_add_type_cb (ctf_id_t tid, void *arg)
1004 {
1005   struct ctf_context *ccp = (struct ctf_context *) arg;
1006   struct type *type;
1007   uint32_t kind;
1008
1009   /* Check if tid's type has already been defined.  */
1010   type = get_tid_type (ccp->of, tid);
1011   if (type != nullptr)
1012     return 0;
1013
1014   ctf_id_t btid = ctf_type_reference (ccp->fp, tid);
1015   kind = ctf_type_kind (ccp->fp, tid);
1016   switch (kind)
1017     {
1018       case CTF_K_STRUCT:
1019       case CTF_K_UNION:
1020         process_structure_type (ccp, tid);
1021         break;
1022       case CTF_K_ENUM:
1023         process_enum_type (ccp, tid);
1024         break;
1025       case CTF_K_FUNCTION:
1026         type = read_func_kind_type (ccp, tid);
1027         new_symbol (ccp, type, tid);
1028         break;
1029       case CTF_K_INTEGER:
1030       case CTF_K_FLOAT:
1031         process_base_type (ccp, tid);
1032         break;
1033       case CTF_K_TYPEDEF:
1034         new_symbol (ccp, read_type_record (ccp, tid), tid);
1035         break;
1036       case CTF_K_CONST:
1037         type = read_const_type (ccp, tid, btid);
1038         new_symbol (ccp, type, tid);
1039         break;
1040       case CTF_K_VOLATILE:
1041         type = read_volatile_type (ccp, tid, btid);
1042         new_symbol (ccp, type, tid);
1043         break;
1044       case CTF_K_RESTRICT:
1045         type = read_restrict_type (ccp, tid, btid);
1046         new_symbol (ccp, type, tid);
1047         break;
1048       case CTF_K_POINTER:
1049         type = read_pointer_type (ccp, tid, btid);
1050         new_symbol (ccp, type, tid);
1051         break;
1052       case CTF_K_ARRAY:
1053         type = read_array_type (ccp, tid);
1054         new_symbol (ccp, type, tid);
1055         break;
1056       case CTF_K_UNKNOWN:
1057         break;
1058       default:
1059         break;
1060     }
1061
1062   return 0;
1063 }
1064
1065 /* Callback to add variable NAME with TID to the symbol table.  */
1066
1067 static int
1068 ctf_add_var_cb (const char *name, ctf_id_t id, void *arg)
1069 {
1070   struct ctf_context *ccp = (struct ctf_context *) arg;
1071   struct symbol *sym = nullptr;
1072   struct type *type;
1073   uint32_t kind;
1074
1075   type = get_tid_type (ccp->of, id);
1076
1077   kind = ctf_type_kind (ccp->fp, id);
1078   switch (kind)
1079     {
1080       case CTF_K_FUNCTION:
1081         if (name != nullptr && strcmp (name, "main") == 0)
1082           set_objfile_main_name (ccp->of, name, language_c);
1083         break;
1084       case CTF_K_INTEGER:
1085       case CTF_K_FLOAT:
1086       case CTF_K_VOLATILE:
1087       case CTF_K_RESTRICT:
1088       case CTF_K_TYPEDEF:
1089       case CTF_K_CONST:
1090       case CTF_K_POINTER:
1091       case CTF_K_ARRAY:
1092         if (type)
1093           {
1094             sym = new_symbol (ccp, type, id);
1095             sym->compute_and_set_names (name, false, ccp->of->per_bfd);
1096           }
1097         break;
1098       case CTF_K_STRUCT:
1099       case CTF_K_UNION:
1100       case CTF_K_ENUM:
1101         if (type == nullptr)
1102         {
1103           complaint (_("ctf_add_var_cb: %s has NO type (%ld)"), name, id);
1104           type = objfile_type (ccp->of)->builtin_error;
1105         }
1106         sym = new (&ccp->of->objfile_obstack) symbol;
1107         OBJSTAT (ccp->of, n_syms++);
1108         SYMBOL_TYPE (sym) = type;
1109         SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1110         SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
1111         sym->compute_and_set_names (name, false, ccp->of->per_bfd);
1112         add_symbol_to_list (sym, ccp->builder->get_global_symbols ());
1113         break;
1114       default:
1115         complaint (_("ctf_add_var_cb: kind unsupported (%d)"), kind);
1116         break;
1117     }
1118
1119   if (sym != nullptr)
1120     set_symbol_address (ccp->of, sym, name);
1121
1122   return 0;
1123 }
1124
1125 /* Add an ELF STT_OBJ symbol with index IDX to the symbol table.  */
1126
1127 static struct symbol *
1128 add_stt_obj (struct ctf_context *ccp, unsigned long idx)
1129 {
1130   struct symbol *sym;
1131   struct type *type;
1132   ctf_id_t tid;
1133
1134   if ((tid = ctf_lookup_by_symbol (ccp->fp, idx)) == CTF_ERR)
1135     return nullptr;
1136
1137   type = get_tid_type (ccp->of, tid);
1138   if (type == nullptr)
1139     return nullptr;
1140
1141   sym = new_symbol (ccp, type, tid);
1142
1143   return sym;
1144 }
1145
1146 /* Add an ELF STT_FUNC symbol with index IDX to the symbol table.  */
1147
1148 static struct symbol *
1149 add_stt_func (struct ctf_context *ccp, unsigned long idx)
1150 {
1151   struct type *ftype, *atyp, *rettyp;
1152   struct symbol *sym;
1153   ctf_funcinfo_t finfo;
1154   ctf_id_t argv[32];
1155   uint32_t argc;
1156   ctf_id_t tid;
1157   struct type *void_type = objfile_type (ccp->of)->builtin_void;
1158
1159   if (ctf_func_info (ccp->fp, idx, &finfo) == CTF_ERR)
1160     return nullptr;
1161
1162   argc = finfo.ctc_argc;
1163   if (ctf_func_args (ccp->fp, idx, argc, argv) == CTF_ERR)
1164     return nullptr;
1165
1166   gdb::unique_xmalloc_ptr<char> name (ctf_type_aname_raw (ccp->fp, idx));
1167   if (name == nullptr)
1168     return nullptr;
1169
1170   tid = ctf_lookup_by_symbol (ccp->fp, idx);
1171   ftype = get_tid_type (ccp->of, tid);
1172   if ((finfo.ctc_flags & CTF_FUNC_VARARG) != 0)
1173     ftype->set_has_varargs (true);
1174   ftype->set_num_fields (argc);
1175
1176   /* If argc is 0, it has a "void" type.  */
1177   if (argc != 0)
1178     ftype->set_fields
1179       ((struct field *) TYPE_ZALLOC (ftype, argc * sizeof (struct field)));
1180
1181   /* TYPE_FIELD_TYPE must never be NULL.  Fill it with void_type, if failed
1182      to find the argument type.  */
1183   for (int iparam = 0; iparam < argc; iparam++)
1184     {
1185       atyp = get_tid_type (ccp->of, argv[iparam]);
1186       if (atyp)
1187         ftype->field (iparam).set_type (atyp);
1188       else
1189         ftype->field (iparam).set_type (void_type);
1190     }
1191
1192   sym = new_symbol (ccp, ftype, tid);
1193   rettyp = get_tid_type (ccp->of, finfo.ctc_return);
1194   if (rettyp != nullptr)
1195     SYMBOL_TYPE (sym) = rettyp;
1196   else
1197     SYMBOL_TYPE (sym) = void_type;
1198
1199   return sym;
1200 }
1201
1202 /* Get text segment base for OBJFILE, TSIZE contains the segment size.  */
1203
1204 static CORE_ADDR
1205 get_objfile_text_range (struct objfile *of, int *tsize)
1206 {
1207   bfd *abfd = of->obfd;
1208   const asection *codes;
1209
1210   codes = bfd_get_section_by_name (abfd, ".text");
1211   *tsize = codes ? bfd_section_size (codes) : 0;
1212   return of->text_section_offset ();
1213 }
1214
1215 /* Start a symtab for OBJFILE in CTF format.  */
1216
1217 static void
1218 ctf_start_symtab (ctf_psymtab *pst,
1219                   struct objfile *of, CORE_ADDR text_offset)
1220 {
1221   struct ctf_context *ccp;
1222
1223   ccp = pst->context;
1224   ccp->builder = new buildsym_compunit
1225                        (of, of->original_name, nullptr,
1226                        language_c, text_offset);
1227   ccp->builder->record_debugformat ("ctf");
1228 }
1229
1230 /* Finish reading symbol/type definitions in CTF format.
1231    END_ADDR is the end address of the file's text.  SECTION is
1232    the .text section number.  */
1233
1234 static struct compunit_symtab *
1235 ctf_end_symtab (ctf_psymtab *pst,
1236                 CORE_ADDR end_addr, int section)
1237 {
1238   struct ctf_context *ccp;
1239
1240   ccp = pst->context;
1241   struct compunit_symtab *result
1242     = ccp->builder->end_symtab (end_addr, section);
1243   delete ccp->builder;
1244   ccp->builder = nullptr;
1245   return result;
1246 }
1247
1248 /* Add all members of an enum with type TID to partial symbol table.  */
1249
1250 static void
1251 ctf_psymtab_add_enums (struct ctf_context *ccp, ctf_id_t tid)
1252 {
1253   int val;
1254   const char *ename;
1255   ctf_next_t *i = nullptr;
1256
1257   while ((ename = ctf_enum_next (ccp->fp, tid, &i, &val)) != nullptr)
1258     {
1259       ccp->pst->add_psymbol (ename, true,
1260                              VAR_DOMAIN, LOC_CONST, -1,
1261                              psymbol_placement::GLOBAL,
1262                              0, language_c, ccp->of);
1263     }
1264   if (ctf_errno (ccp->fp) != ECTF_NEXT_END)
1265     complaint (_("ctf_enum_next ctf_psymtab_add_enums failed - %s"),
1266                ctf_errmsg (ctf_errno (ccp->fp)));
1267 }
1268
1269 /* Read in full symbols for PST, and anything it depends on.  */
1270
1271 void
1272 ctf_psymtab::expand_psymtab (struct objfile *objfile)
1273 {
1274   struct symbol *sym;
1275   struct ctf_context *ccp;
1276
1277   gdb_assert (!readin);
1278
1279   ccp = context;
1280
1281   /* Iterate over entries in data types section.  */
1282   if (ctf_type_iter (ccp->fp, ctf_add_type_cb, ccp) == CTF_ERR)
1283     complaint (_("ctf_type_iter psymtab_to_symtab failed - %s"),
1284                ctf_errmsg (ctf_errno (ccp->fp)));
1285
1286
1287   /* Iterate over entries in variable info section.  */
1288   if (ctf_variable_iter (ccp->fp, ctf_add_var_cb, ccp) == CTF_ERR)
1289     complaint (_("ctf_variable_iter psymtab_to_symtab failed - %s"),
1290                ctf_errmsg (ctf_errno (ccp->fp)));
1291
1292   /* Add entries in data objects and function info sections.  */
1293   for (unsigned long i = 0; ; i++)
1294     {
1295       sym = add_stt_obj (ccp, i);
1296       if (sym == nullptr)
1297         {
1298           if (ctf_errno (ccp->fp) == EINVAL
1299               || ctf_errno (ccp->fp) == ECTF_NOSYMTAB)
1300             break;
1301           sym = add_stt_func (ccp, i);
1302         }
1303       if (sym == nullptr)
1304         continue;
1305
1306       set_symbol_address (ccp->of, sym, sym->linkage_name ());
1307     }
1308
1309   readin = true;
1310 }
1311
1312 /* Expand partial symbol table PST into a full symbol table.
1313    PST is not NULL.  */
1314
1315 void
1316 ctf_psymtab::read_symtab (struct objfile *objfile)
1317 {
1318   if (readin)
1319     warning (_("bug: psymtab for %s is already read in."), filename);
1320   else
1321     {
1322       if (info_verbose)
1323         {
1324           printf_filtered (_("Reading in CTF data for %s..."), filename);
1325           gdb_flush (gdb_stdout);
1326         }
1327
1328       /* Start a symtab.  */
1329       CORE_ADDR offset;        /* Start of text segment.  */
1330       int tsize;
1331
1332       offset = get_objfile_text_range (objfile, &tsize);
1333       ctf_start_symtab (this, objfile, offset);
1334       expand_psymtab (objfile);
1335
1336       set_text_low (offset);
1337       set_text_high (offset + tsize);
1338       compunit_symtab = ctf_end_symtab (this, offset + tsize,
1339                                         SECT_OFF_TEXT (objfile));
1340
1341       /* Finish up the debug error message.  */
1342       if (info_verbose)
1343         printf_filtered (_("done.\n"));
1344     }
1345 }
1346
1347 /* Allocate a new partial_symtab NAME.
1348
1349    Each source file that has not been fully read in is represented by
1350    a partial_symtab.  This contains the information on where in the
1351    executable the debugging symbols for a specific file are, and a
1352    list of names of global symbols which are located in this file.
1353    They are all chained on partial symtab lists.
1354
1355    Even after the source file has been read into a symtab, the
1356    partial_symtab remains around.  They are allocated on an obstack,
1357    objfile_obstack.  */
1358
1359 static ctf_psymtab *
1360 create_partial_symtab (const char *name,
1361                        ctf_dict_t *cfp,
1362                        struct objfile *objfile)
1363 {
1364   ctf_psymtab *pst;
1365   struct ctf_context *ccx;
1366
1367   pst = new ctf_psymtab (name, objfile, 0);
1368
1369   ccx = XOBNEW (&objfile->objfile_obstack, struct ctf_context);
1370   ccx->fp = cfp;
1371   ccx->of = objfile;
1372   ccx->pst = pst;
1373   ccx->builder = nullptr;
1374   pst->context = ccx;
1375
1376   return pst;
1377 }
1378
1379 /* Callback to add type TID to partial symbol table.  */
1380
1381 static int
1382 ctf_psymtab_type_cb (ctf_id_t tid, void *arg)
1383 {
1384   struct ctf_context *ccp;
1385   uint32_t kind;
1386   short section = -1;
1387
1388   ccp = (struct ctf_context *) arg;
1389   gdb::unique_xmalloc_ptr<char> name (ctf_type_aname_raw (ccp->fp, tid));
1390
1391   domain_enum domain = UNDEF_DOMAIN;
1392   enum address_class aclass = LOC_UNDEF;
1393   kind = ctf_type_kind (ccp->fp, tid);
1394   switch (kind)
1395     {
1396       case CTF_K_ENUM:
1397         ctf_psymtab_add_enums (ccp, tid);
1398         /* FALL THROUGH */
1399       case CTF_K_STRUCT:
1400       case CTF_K_UNION:
1401         domain = STRUCT_DOMAIN;
1402         aclass = LOC_TYPEDEF;
1403         break;
1404       case CTF_K_FUNCTION:
1405       case CTF_K_FORWARD:
1406         domain = VAR_DOMAIN;
1407         aclass = LOC_STATIC;
1408         section = SECT_OFF_TEXT (ccp->of);
1409         break;
1410       case CTF_K_CONST:
1411         domain = VAR_DOMAIN;
1412         aclass = LOC_STATIC;
1413         break;
1414       case CTF_K_TYPEDEF:
1415       case CTF_K_POINTER:
1416       case CTF_K_VOLATILE:
1417       case CTF_K_RESTRICT:
1418         domain = VAR_DOMAIN;
1419         aclass = LOC_TYPEDEF;
1420         break;
1421       case CTF_K_INTEGER:
1422       case CTF_K_FLOAT:
1423         domain = VAR_DOMAIN;
1424         aclass = LOC_TYPEDEF;
1425         break;
1426       case CTF_K_ARRAY:
1427       case CTF_K_UNKNOWN:
1428         return 0;
1429     }
1430
1431   if (name == nullptr || strlen (name.get ()) == 0)
1432     return 0;
1433
1434   ccp->pst->add_psymbol (name.get (), true,
1435                          domain, aclass, section,
1436                          psymbol_placement::GLOBAL,
1437                          0, language_c, ccp->of);
1438
1439   return 0;
1440 }
1441
1442 /* Callback to add variable NAME with ID to partial symbol table.  */
1443
1444 static int
1445 ctf_psymtab_var_cb (const char *name, ctf_id_t id, void *arg)
1446 {
1447   struct ctf_context *ccp = (struct ctf_context *) arg;
1448
1449   ccp->pst->add_psymbol (name, true,
1450                          VAR_DOMAIN, LOC_STATIC, -1,
1451                          psymbol_placement::GLOBAL,
1452                          0, language_c, ccp->of);
1453   return 0;
1454 }
1455
1456 /* Setup partial_symtab's describing each source file for which
1457    debugging information is available.  */
1458
1459 static void
1460 scan_partial_symbols (ctf_dict_t *cfp, struct objfile *of)
1461 {
1462   bfd *abfd = of->obfd;
1463   const char *name = bfd_get_filename (abfd);
1464   ctf_psymtab *pst = create_partial_symtab (name, cfp, of);
1465
1466   struct ctf_context *ccx = pst->context;
1467
1468   if (ctf_type_iter (cfp, ctf_psymtab_type_cb, ccx) == CTF_ERR)
1469     complaint (_("ctf_type_iter scan_partial_symbols failed - %s"),
1470                ctf_errmsg (ctf_errno (cfp)));
1471
1472   if (ctf_variable_iter (cfp, ctf_psymtab_var_cb, ccx) == CTF_ERR)
1473     complaint (_("ctf_variable_iter scan_partial_symbols failed - %s"),
1474                ctf_errmsg (ctf_errno (cfp)));
1475
1476   /* Scan CTF object and function sections which correspond to each
1477      STT_FUNC or STT_OBJECT entry in the symbol table,
1478      pick up what init_symtab has done.  */
1479   for (unsigned long idx = 0; ; idx++)
1480     {
1481       ctf_id_t tid;
1482       if ((tid = ctf_lookup_by_symbol (cfp, idx)) == CTF_ERR)
1483         {
1484         if (ctf_errno (cfp) == EINVAL || ctf_errno (cfp) == ECTF_NOSYMTAB)
1485           break;        // Done, reach end of the section.
1486         else
1487           continue;
1488         }
1489       gdb::unique_xmalloc_ptr<char> tname (ctf_type_aname_raw (cfp, tid));
1490       uint32_t kind = ctf_type_kind (cfp, tid);
1491       address_class aclass;
1492       domain_enum tdomain;
1493       switch (kind)
1494         {
1495           case CTF_K_STRUCT:
1496           case CTF_K_UNION:
1497           case CTF_K_ENUM:
1498             tdomain = STRUCT_DOMAIN;
1499             break;
1500           default:
1501             tdomain = VAR_DOMAIN;
1502             break;
1503         }
1504
1505       if (kind == CTF_K_FUNCTION)
1506         aclass = LOC_STATIC;
1507       else if (kind == CTF_K_CONST)
1508         aclass = LOC_CONST;
1509       else
1510         aclass = LOC_TYPEDEF;
1511
1512       pst->add_psymbol (tname.get (), true,
1513                         tdomain, aclass, -1,
1514                         psymbol_placement::STATIC,
1515                         0, language_c, of);
1516     }
1517
1518   pst->end ();
1519 }
1520
1521 /* Read CTF debugging information from a BFD section.  This is
1522    called from elfread.c.  It does a quick pass through the
1523    .ctf section to set up the partial symbol table.  */
1524
1525 void
1526 elfctf_build_psymtabs (struct objfile *of)
1527 {
1528   bfd *abfd = of->obfd;
1529   int err;
1530
1531   ctf_archive_t *arc = ctf_bfdopen (abfd, &err);
1532   if (arc == nullptr)
1533     error (_("ctf_bfdopen failed on %s - %s"),
1534            bfd_get_filename (abfd), ctf_errmsg (err));
1535
1536   ctf_dict_t *fp = ctf_dict_open (arc, NULL, &err);
1537   if (fp == nullptr)
1538     error (_("ctf_dict_open failed on %s - %s"),
1539            bfd_get_filename (abfd), ctf_errmsg (err));
1540   ctf_dict_key.emplace (of, fp);
1541
1542   scan_partial_symbols (fp, of);
1543 }
1544
1545 #else
1546
1547 void
1548 elfctf_build_psymtabs (struct objfile *of)
1549 {
1550   /* Nothing to do if CTF is disabled.  */
1551 }
1552
1553 #endif /* ENABLE_LIBCTF */