gdb/ctfread.c

   1 /* Compact ANSI-C Type Format (CTF) support in GDB.
   2
   3    Copyright (C) 2019-2022 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   psymtab_storage *partial_symtabs;
 119   partial_symtab *pst;
 120   ctf_archive_t *arc;
 121   struct buildsym_compunit *builder;
 122 };
 123
 124 /* A partial symtab, specialized for this module.  */
 125 struct ctf_psymtab : public standard_psymtab
 126 {
 127   ctf_psymtab (const char *filename,
 128                psymtab_storage *partial_symtabs,
 129                objfile_per_bfd_storage *objfile_per_bfd,
 130                CORE_ADDR addr)
 131     : standard_psymtab (filename, partial_symtabs, objfile_per_bfd, addr)
 132   {
 133   }
 134
 135   void read_symtab (struct objfile *) override;
 136   void expand_psymtab (struct objfile *) override;
 137
 138   struct ctf_context context;
 139 };
 140
 141 /* The routines that read and process fields/members of a C struct, union,
 142    or enumeration, pass lists of data member fields in an instance of a
 143    ctf_field_info structure. It is derived from dwarf2read.c.  */
 144
 145 struct ctf_nextfield
 146 {
 147   struct field field {};
 148 };
 149
 150 struct ctf_field_info
 151 {
 152   /* List of data member fields.  */
 153   std::vector<struct ctf_nextfield> fields;
 154
 155   /* Context.  */
 156   struct ctf_context *cur_context;
 157
 158   /* Parent type.  */
 159   struct type *ptype;
 160
 161   /* typedefs defined inside this class.  TYPEDEF_FIELD_LIST contains head
 162      of a NULL terminated list of TYPEDEF_FIELD_LIST_COUNT elements.  */
 163   std::vector<struct decl_field> typedef_field_list;
 164
 165   /* Nested types defined by this struct and the number of elements in
 166      this list.  */
 167   std::vector<struct decl_field> nested_types_list;
 168 };
 169
 170 /* Data held for a translation unit.  */
 171
 172 struct ctf_per_tu_data
 173 {
 174   ctf_dict_t *fp;
 175   struct objfile *of;
 176   ctf_archive_t *arc;
 177   psymtab_storage *pss;
 178   psymbol_functions *psf;
 179 };
 180
 181 /* Local function prototypes */
 182
 183 static int ctf_add_type_cb (ctf_id_t tid, void *arg);
 184
 185 static struct type *read_array_type (struct ctf_context *cp, ctf_id_t tid);
 186
 187 static struct type *read_pointer_type (struct ctf_context *cp, ctf_id_t tid,
 188                                        ctf_id_t btid);
 189
 190 static struct type *read_structure_type (struct ctf_context *cp, ctf_id_t tid);
 191
 192 static struct type *read_enum_type (struct ctf_context *cp, ctf_id_t tid);
 193
 194 static struct type *read_typedef_type (struct ctf_context *cp, ctf_id_t tid,
 195                                        ctf_id_t btid, const char *name);
 196
 197 static struct type *read_type_record (struct ctf_context *cp, ctf_id_t tid);
 198
 199 static void process_structure_type (struct ctf_context *cp, ctf_id_t tid);
 200
 201 static void process_struct_members (struct ctf_context *cp, ctf_id_t tid,
 202                                     struct type *type);
 203
 204 static struct type *read_forward_type (struct ctf_context *cp, ctf_id_t tid);
 205
 206 static struct symbol *new_symbol (struct ctf_context *cp, struct type *type,
 207                                   ctf_id_t tid);
 208
 209 struct ctf_tid_and_type
 210 {
 211   ctf_id_t tid;
 212   struct type *type;
 213 };
 214
 215 /* Hash function for a ctf_tid_and_type.  */
 216
 217 static hashval_t
 218 tid_and_type_hash (const void *item)
 219 {
 220   const struct ctf_tid_and_type *ids
 221     = (const struct ctf_tid_and_type *) item;
 222
 223   return ids->tid;
 224 }
 225
 226 /* Equality function for a ctf_tid_and_type.  */
 227
 228 static int
 229 tid_and_type_eq (const void *item_lhs, const void *item_rhs)
 230 {
 231   const struct ctf_tid_and_type *ids_lhs
 232     = (const struct ctf_tid_and_type *) item_lhs;
 233   const struct ctf_tid_and_type *ids_rhs
 234     = (const struct ctf_tid_and_type *) item_rhs;
 235
 236   return ids_lhs->tid == ids_rhs->tid;
 237 }
 238
 239 /* Set the type associated with TID to TYP.  */
 240
 241 static struct type *
 242 set_tid_type (struct objfile *of, ctf_id_t tid, struct type *typ)
 243 {
 244   htab_t htab;
 245
 246   htab = (htab_t) ctf_tid_key.get (of);
 247   if (htab == NULL)
 248     {
 249       htab = htab_create_alloc (1, tid_and_type_hash,
 250                                 tid_and_type_eq,
 251                                 NULL, xcalloc, xfree);
 252       ctf_tid_key.set (of, htab);
 253     }
 254
 255   struct ctf_tid_and_type **slot, ids;
 256   ids.tid = tid;
 257   ids.type = typ;
 258   slot = (struct ctf_tid_and_type **) htab_find_slot (htab, &ids, INSERT);
 259   if (*slot == nullptr)
 260     *slot = XOBNEW (&of->objfile_obstack, struct ctf_tid_and_type);
 261   **slot = ids;
 262   return typ;
 263 }
 264
 265 /* Look up the type for TID in tid_and_type hash, return NULL if hash is
 266    empty or TID does not have a saved type.  */
 267
 268 static struct type *
 269 get_tid_type (struct objfile *of, ctf_id_t tid)
 270 {
 271   struct ctf_tid_and_type *slot, ids;
 272   htab_t htab;
 273
 274   htab = (htab_t) ctf_tid_key.get (of);
 275   if (htab == NULL)
 276     return nullptr;
 277
 278   ids.tid = tid;
 279   ids.type = nullptr;
 280   slot = (struct ctf_tid_and_type *) htab_find (htab, &ids);
 281   if (slot)
 282     return slot->type;
 283   else
 284     return nullptr;
 285 }
 286
 287 /* Fetch the type for TID in CCP OF's tid_and_type hash, add the type to
 288  *    context CCP if hash is empty or TID does not have a saved type.  */
 289
 290 static struct type *
 291 fetch_tid_type (struct ctf_context *ccp, ctf_id_t tid)
 292 {
 293   struct objfile *of = ccp->of;
 294   struct type *typ;
 295
 296   typ = get_tid_type (of, tid);
 297   if (typ == nullptr)
 298     {
 299       ctf_add_type_cb (tid, ccp);
 300       typ = get_tid_type (of, tid);
 301     }
 302
 303   return typ;
 304 }
 305
 306 /* Return the size of storage in bits for INTEGER, FLOAT, or ENUM.  */
 307
 308 static int
 309 get_bitsize (ctf_dict_t *fp, ctf_id_t tid, uint32_t kind)
 310 {
 311   ctf_encoding_t cet;
 312
 313   if ((kind == CTF_K_INTEGER || kind == CTF_K_ENUM
 314       || kind == CTF_K_FLOAT)
 315       && ctf_type_reference (fp, tid) != CTF_ERR
 316       && ctf_type_encoding (fp, tid, &cet) != CTF_ERR)
 317     return cet.cte_bits;
 318
 319   return 0;
 320 }
 321
 322 /* Set SYM's address, with NAME, from its minimal symbol entry.  */
 323
 324 static void
 325 set_symbol_address (struct objfile *of, struct symbol *sym, const char *name)
 326 {
 327   struct bound_minimal_symbol msym;
 328
 329   msym = lookup_minimal_symbol (name, nullptr, of);
 330   if (msym.minsym != NULL)
 331     {
 332       SET_SYMBOL_VALUE_ADDRESS (sym, BMSYMBOL_VALUE_ADDRESS (msym));
 333       sym->set_aclass_index (LOC_STATIC);
 334       sym->set_section_index (msym.minsym->section_index ());
 335     }
 336 }
 337
 338 /* Create the vector of fields, and attach it to TYPE.  */
 339
 340 static void
 341 attach_fields_to_type (struct ctf_field_info *fip, struct type *type)
 342 {
 343   int nfields = fip->fields.size ();
 344
 345   if (nfields == 0)
 346     return;
 347
 348   /* Record the field count, allocate space for the array of fields.  */
 349   type->set_num_fields (nfields);
 350   type->set_fields
 351     ((struct field *) TYPE_ZALLOC (type, sizeof (struct field) * nfields));
 352
 353   /* Copy the saved-up fields into the field vector.  */
 354   for (int i = 0; i < nfields; ++i)
 355     {
 356       struct ctf_nextfield &field = fip->fields[i];
 357       type->field (i) = field.field;
 358     }
 359 }
 360
 361 /* Allocate a floating-point type of size BITS and name NAME.  Pass NAME_HINT
 362    (which may be different from NAME) to the architecture back-end to allow
 363    it to guess the correct format if necessary.  */
 364
 365 static struct type *
 366 ctf_init_float_type (struct objfile *objfile,
 367                      int bits,
 368                      const char *name,
 369                      const char *name_hint)
 370 {
 371   struct gdbarch *gdbarch = objfile->arch ();
 372   const struct floatformat **format;
 373   struct type *type;
 374
 375   format = gdbarch_floatformat_for_type (gdbarch, name_hint, bits);
 376   if (format != nullptr)
 377     type = init_float_type (objfile, bits, name, format);
 378   else
 379     type = init_type (objfile, TYPE_CODE_ERROR, bits, name);
 380
 381   return type;
 382 }
 383
 384 /* Callback to add member NAME to a struct/union type. TID is the type
 385    of struct/union member, OFFSET is the offset of member in bits,
 386    and ARG contains the ctf_field_info.  */
 387
 388 static int
 389 ctf_add_member_cb (const char *name,
 390                    ctf_id_t tid,
 391                    unsigned long offset,
 392                    void *arg)
 393 {
 394   struct ctf_field_info *fip = (struct ctf_field_info *) arg;
 395   struct ctf_context *ccp = fip->cur_context;
 396   struct ctf_nextfield new_field;
 397   struct field *fp;
 398   struct type *t;
 399   uint32_t kind;
 400
 401   fp = &new_field.field;
 402   fp->set_name (name);
 403
 404   kind = ctf_type_kind (ccp->fp, tid);
 405   t = fetch_tid_type (ccp, tid);
 406   if (t == nullptr)
 407     {
 408       t = read_type_record (ccp, tid);
 409       if (t == nullptr)
 410         {
 411           complaint (_("ctf_add_member_cb: %s has NO type (%ld)"), name, tid);
 412           t = objfile_type (ccp->of)->builtin_error;
 413           set_tid_type (ccp->of, tid, t);
 414         }
 415     }
 416
 417   if (kind == CTF_K_STRUCT || kind == CTF_K_UNION)
 418     process_struct_members (ccp, tid, t);
 419
 420   fp->set_type (t);
 421   fp->set_loc_bitpos (offset / TARGET_CHAR_BIT);
 422   FIELD_BITSIZE (*fp) = get_bitsize (ccp->fp, tid, kind);
 423
 424   fip->fields.emplace_back (new_field);
 425
 426   return 0;
 427 }
 428
 429 /* Callback to add member NAME of EVAL to an enumeration type.
 430    ARG contains the ctf_field_info.  */
 431
 432 static int
 433 ctf_add_enum_member_cb (const char *name, int enum_value, void *arg)
 434 {
 435   struct ctf_field_info *fip = (struct ctf_field_info *) arg;
 436   struct ctf_nextfield new_field;
 437   struct field *fp;
 438   struct ctf_context *ccp = fip->cur_context;
 439
 440   fp = &new_field.field;
 441   fp->set_name (name);
 442   fp->set_type (nullptr);
 443   fp->set_loc_enumval (enum_value);
 444   FIELD_BITSIZE (*fp) = 0;
 445
 446   if (name != nullptr)
 447     {
 448       struct symbol *sym = new (&ccp->of->objfile_obstack) symbol;
 449       OBJSTAT (ccp->of, n_syms++);
 450
 451       sym->set_language (language_c, &ccp->of->objfile_obstack);
 452       sym->compute_and_set_names (name, false, ccp->of->per_bfd);
 453       sym->set_aclass_index (LOC_CONST);
 454       sym->set_domain (VAR_DOMAIN);
 455       sym->set_type (fip->ptype);
 456       add_symbol_to_list (sym, ccp->builder->get_global_symbols ());
 457     }
 458
 459   fip->fields.emplace_back (new_field);
 460
 461   return 0;
 462 }
 463
 464 /* Add a new symbol entry, with its name from TID, its access index and
 465    domain from TID's kind, and its type from TYPE.  */
 466
 467 static struct symbol *
 468 new_symbol (struct ctf_context *ccp, struct type *type, ctf_id_t tid)
 469 {
 470   struct objfile *objfile = ccp->of;
 471   ctf_dict_t *fp = ccp->fp;
 472   struct symbol *sym = nullptr;
 473
 474   const char *name = ctf_type_name_raw (fp, tid);
 475   if (name != nullptr)
 476     {
 477       sym = new (&objfile->objfile_obstack) symbol;
 478       OBJSTAT (objfile, n_syms++);
 479
 480       sym->set_language (language_c, &objfile->objfile_obstack);
 481       sym->compute_and_set_names (name, false, objfile->per_bfd);
 482       sym->set_domain (VAR_DOMAIN);
 483       sym->set_aclass_index (LOC_OPTIMIZED_OUT);
 484
 485       if (type != nullptr)
 486         sym->set_type (type);
 487
 488       uint32_t kind = ctf_type_kind (fp, tid);
 489       switch (kind)
 490         {
 491           case CTF_K_STRUCT:
 492           case CTF_K_UNION:
 493           case CTF_K_ENUM:
 494             sym->set_aclass_index (LOC_TYPEDEF);
 495             sym->set_domain (STRUCT_DOMAIN);
 496             break;
 497           case CTF_K_FUNCTION:
 498             sym->set_aclass_index (LOC_STATIC);
 499             set_symbol_address (objfile, sym, sym->linkage_name ());
 500             break;
 501           case CTF_K_CONST:
 502             if (sym->type ()->code () == TYPE_CODE_VOID)
 503               sym->set_type (objfile_type (objfile)->builtin_int);
 504             break;
 505           case CTF_K_TYPEDEF:
 506           case CTF_K_INTEGER:
 507           case CTF_K_FLOAT:
 508             sym->set_aclass_index (LOC_TYPEDEF);
 509             sym->set_domain (VAR_DOMAIN);
 510             break;
 511           case CTF_K_POINTER:
 512             break;
 513           case CTF_K_VOLATILE:
 514           case CTF_K_RESTRICT:
 515             break;
 516           case CTF_K_SLICE:
 517           case CTF_K_ARRAY:
 518           case CTF_K_UNKNOWN:
 519             break;
 520         }
 521
 522       add_symbol_to_list (sym, ccp->builder->get_file_symbols ());
 523     }
 524
 525   return sym;
 526 }
 527
 528 /* Given a TID of kind CTF_K_INTEGER or CTF_K_FLOAT, find a representation
 529    and create the symbol for it.  */
 530
 531 static struct type *
 532 read_base_type (struct ctf_context *ccp, ctf_id_t tid)
 533 {
 534   struct objfile *of = ccp->of;
 535   ctf_dict_t *fp = ccp->fp;
 536   ctf_encoding_t cet;
 537   struct type *type = nullptr;
 538   const char *name;
 539   uint32_t kind;
 540
 541   if (ctf_type_encoding (fp, tid, &cet))
 542     {
 543       complaint (_("ctf_type_encoding read_base_type failed - %s"),
 544                  ctf_errmsg (ctf_errno (fp)));
 545       return nullptr;
 546     }
 547
 548   name = ctf_type_name_raw (fp, tid);
 549   if (name == nullptr || strlen (name) == 0)
 550     {
 551       name = ctf_type_aname (fp, tid);
 552       if (name == nullptr)
 553         complaint (_("ctf_type_aname read_base_type failed - %s"),
 554                    ctf_errmsg (ctf_errno (fp)));
 555     }
 556
 557   kind = ctf_type_kind (fp, tid);
 558   if (kind == CTF_K_INTEGER)
 559     {
 560       uint32_t issigned, ischar, isbool;
 561       struct gdbarch *gdbarch = of->arch ();
 562
 563       issigned = cet.cte_format & CTF_INT_SIGNED;
 564       ischar = cet.cte_format & CTF_INT_CHAR;
 565       isbool = cet.cte_format & CTF_INT_BOOL;
 566       if (ischar)
 567         type = init_character_type (of, TARGET_CHAR_BIT, !issigned, name);
 568       else if (isbool)
 569         type = init_boolean_type (of, gdbarch_int_bit (gdbarch),
 570                                   !issigned, name);
 571       else
 572         {
 573           int bits;
 574           if (cet.cte_bits && ((cet.cte_bits % TARGET_CHAR_BIT) == 0))
 575             bits = cet.cte_bits;
 576           else
 577             bits = gdbarch_int_bit (gdbarch);
 578           type = init_integer_type (of, bits, !issigned, name);
 579         }
 580     }
 581   else if (kind == CTF_K_FLOAT)
 582     {
 583       uint32_t isflt;
 584       isflt = !((cet.cte_format & CTF_FP_IMAGRY) == CTF_FP_IMAGRY
 585                  || (cet.cte_format & CTF_FP_DIMAGRY) == CTF_FP_DIMAGRY
 586                  || (cet.cte_format & CTF_FP_LDIMAGRY) == CTF_FP_LDIMAGRY);
 587       if (isflt)
 588         type = ctf_init_float_type (of, cet.cte_bits, name, name);
 589       else
 590         {
 591           struct type *t
 592             = ctf_init_float_type (of, cet.cte_bits / 2, NULL, name);
 593           type = init_complex_type (name, t);
 594         }
 595     }
 596   else
 597     {
 598       complaint (_("read_base_type: unsupported base kind (%d)"), kind);
 599       type = init_type (of, TYPE_CODE_ERROR, cet.cte_bits, name);
 600     }
 601
 602   if (name != nullptr && strcmp (name, "char") == 0)
 603     type->set_has_no_signedness (true);
 604
 605   return set_tid_type (of, tid, type);
 606 }
 607
 608 static void
 609 process_base_type (struct ctf_context *ccp, ctf_id_t tid)
 610 {
 611   struct type *type;
 612
 613   type = read_base_type (ccp, tid);
 614   new_symbol (ccp, type, tid);
 615 }
 616
 617 /* Start a structure or union scope (definition) with TID to create a type
 618    for the structure or union.
 619
 620    Fill in the type's name and general properties. The members will not be
 621    processed, nor a symbol table entry be done until process_structure_type
 622    (assuming the type has a name).  */
 623
 624 static struct type *
 625 read_structure_type (struct ctf_context *ccp, ctf_id_t tid)
 626 {
 627   struct objfile *of = ccp->of;
 628   ctf_dict_t *fp = ccp->fp;
 629   struct type *type;
 630   uint32_t kind;
 631
 632   type = alloc_type (of);
 633
 634   const char *name = ctf_type_name_raw (fp, tid);
 635   if (name != nullptr && strlen (name) != 0)
 636     type->set_name (name);
 637
 638   kind = ctf_type_kind (fp, tid);
 639   if (kind == CTF_K_UNION)
 640     type->set_code (TYPE_CODE_UNION);
 641   else
 642     type->set_code (TYPE_CODE_STRUCT);
 643
 644   TYPE_LENGTH (type) = ctf_type_size (fp, tid);
 645   set_type_align (type, ctf_type_align (fp, tid));
 646
 647   return set_tid_type (ccp->of, tid, type);
 648 }
 649
 650 /* Given a tid of CTF_K_STRUCT or CTF_K_UNION, process all its members
 651    and create the symbol for it.  */
 652
 653 static void
 654 process_struct_members (struct ctf_context *ccp,
 655                         ctf_id_t tid,
 656                         struct type *type)
 657 {
 658   struct ctf_field_info fi;
 659
 660   fi.cur_context = ccp;
 661   if (ctf_member_iter (ccp->fp, tid, ctf_add_member_cb, &fi) == CTF_ERR)
 662     complaint (_("ctf_member_iter process_struct_members failed - %s"),
 663                ctf_errmsg (ctf_errno (ccp->fp)));
 664
 665   /* Attach fields to the type.  */
 666   attach_fields_to_type (&fi, type);
 667
 668   new_symbol (ccp, type, tid);
 669 }
 670
 671 static void
 672 process_structure_type (struct ctf_context *ccp, ctf_id_t tid)
 673 {
 674   struct type *type;
 675
 676   type = read_structure_type (ccp, tid);
 677   process_struct_members (ccp, tid, type);
 678 }
 679
 680 /* Create a function type for TID and set its return type.  */
 681
 682 static struct type *
 683 read_func_kind_type (struct ctf_context *ccp, ctf_id_t tid)
 684 {
 685   struct objfile *of = ccp->of;
 686   ctf_dict_t *fp = ccp->fp;
 687   struct type *type, *rettype, *atype;
 688   ctf_funcinfo_t cfi;
 689   uint32_t argc;
 690
 691   type = alloc_type (of);
 692
 693   type->set_code (TYPE_CODE_FUNC);
 694   if (ctf_func_type_info (fp, tid, &cfi) < 0)
 695     {
 696       const char *fname = ctf_type_name_raw (fp, tid);
 697       error (_("Error getting function type info: %s"),
 698              fname == nullptr ? "noname" : fname);
 699     }
 700   rettype = fetch_tid_type (ccp, cfi.ctc_return);
 701   TYPE_TARGET_TYPE (type) = rettype;
 702   set_type_align (type, ctf_type_align (fp, tid));
 703
 704   /* Set up function's arguments.  */
 705   argc = cfi.ctc_argc;
 706   type->set_num_fields (argc);
 707   if ((cfi.ctc_flags & CTF_FUNC_VARARG) != 0)
 708     type->set_has_varargs (true);
 709
 710   if (argc != 0)
 711     {
 712       std::vector<ctf_id_t> argv (argc);
 713       if (ctf_func_type_args (fp, tid, argc, argv.data ()) == CTF_ERR)
 714         return nullptr;
 715
 716       type->set_fields
 717         ((struct field *) TYPE_ZALLOC (type, argc * sizeof (struct field)));
 718       struct type *void_type = objfile_type (of)->builtin_void;
 719       /* If failed to find the argument type, fill it with void_type.  */
 720       for (int iparam = 0; iparam < argc; iparam++)
 721         {
 722           atype = fetch_tid_type (ccp, argv[iparam]);
 723           if (atype != nullptr)
 724             type->field (iparam).set_type (atype);
 725           else
 726             type->field (iparam).set_type (void_type);
 727         }
 728     }
 729
 730   return set_tid_type (of, tid, type);
 731 }
 732
 733 /* Given a TID of CTF_K_ENUM, process all the members of the
 734    enumeration, and create the symbol for the enumeration type.  */
 735
 736 static struct type *
 737 read_enum_type (struct ctf_context *ccp, ctf_id_t tid)
 738 {
 739   struct objfile *of = ccp->of;
 740   ctf_dict_t *fp = ccp->fp;
 741   struct type *type;
 742
 743   type = alloc_type (of);
 744
 745   const char *name = ctf_type_name_raw (fp, tid);
 746   if (name != nullptr && strlen (name) != 0)
 747     type->set_name (name);
 748
 749   type->set_code (TYPE_CODE_ENUM);
 750   TYPE_LENGTH (type) = ctf_type_size (fp, tid);
 751   /* Set the underlying type based on its ctf_type_size bits.  */
 752   TYPE_TARGET_TYPE (type) = objfile_int_type (of, TYPE_LENGTH (type), false);
 753   set_type_align (type, ctf_type_align (fp, tid));
 754
 755   return set_tid_type (of, tid, type);
 756 }
 757
 758 static void
 759 process_enum_type (struct ctf_context *ccp, ctf_id_t tid)
 760 {
 761   struct type *type;
 762   struct ctf_field_info fi;
 763
 764   type = read_enum_type (ccp, tid);
 765
 766   fi.cur_context = ccp;
 767   fi.ptype = type;
 768   if (ctf_enum_iter (ccp->fp, tid, ctf_add_enum_member_cb, &fi) == CTF_ERR)
 769     complaint (_("ctf_enum_iter process_enum_type failed - %s"),
 770                ctf_errmsg (ctf_errno (ccp->fp)));
 771
 772   /* Attach fields to the type.  */
 773   attach_fields_to_type (&fi, type);
 774
 775   new_symbol (ccp, type, tid);
 776 }
 777
 778 /* Add given cv-qualifiers CNST+VOLTL to the BASE_TYPE of array TID.  */
 779
 780 static struct type *
 781 add_array_cv_type (struct ctf_context *ccp,
 782                    ctf_id_t tid,
 783                    struct type *base_type,
 784                    int cnst,
 785                    int voltl)
 786 {
 787   struct type *el_type, *inner_array;
 788
 789   base_type = copy_type (base_type);
 790   inner_array = base_type;
 791
 792   while (TYPE_TARGET_TYPE (inner_array)->code () == TYPE_CODE_ARRAY)
 793     {
 794       TYPE_TARGET_TYPE (inner_array)
 795         = copy_type (TYPE_TARGET_TYPE (inner_array));
 796       inner_array = TYPE_TARGET_TYPE (inner_array);
 797     }
 798
 799   el_type = TYPE_TARGET_TYPE (inner_array);
 800   cnst |= TYPE_CONST (el_type);
 801   voltl |= TYPE_VOLATILE (el_type);
 802   TYPE_TARGET_TYPE (inner_array) = make_cv_type (cnst, voltl, el_type, nullptr);
 803
 804   return set_tid_type (ccp->of, tid, base_type);
 805 }
 806
 807 /* Read all information from a TID of CTF_K_ARRAY.  */
 808
 809 static struct type *
 810 read_array_type (struct ctf_context *ccp, ctf_id_t tid)
 811 {
 812   struct objfile *objfile = ccp->of;
 813   ctf_dict_t *fp = ccp->fp;
 814   struct type *element_type, *range_type, *idx_type;
 815   struct type *type;
 816   ctf_arinfo_t ar;
 817
 818   if (ctf_array_info (fp, tid, &ar) == CTF_ERR)
 819     {
 820       complaint (_("ctf_array_info read_array_type failed - %s"),
 821                  ctf_errmsg (ctf_errno (fp)));
 822       return nullptr;
 823     }
 824
 825   element_type = fetch_tid_type (ccp, ar.ctr_contents);
 826   if (element_type == nullptr)
 827     return nullptr;
 828
 829   idx_type = fetch_tid_type (ccp, ar.ctr_index);
 830   if (idx_type == nullptr)
 831     idx_type = objfile_type (objfile)->builtin_int;
 832
 833   range_type = create_static_range_type (NULL, idx_type, 0, ar.ctr_nelems - 1);
 834   type = create_array_type (NULL, element_type, range_type);
 835   if (ar.ctr_nelems <= 1)       /* Check if undefined upper bound.  */
 836     {
 837       range_type->bounds ()->high.set_undefined ();
 838       TYPE_LENGTH (type) = 0;
 839       type->set_target_is_stub (true);
 840     }
 841   else
 842     TYPE_LENGTH (type) = ctf_type_size (fp, tid);
 843
 844   set_type_align (type, ctf_type_align (fp, tid));
 845
 846   return set_tid_type (objfile, tid, type);
 847 }
 848
 849 /* Read TID of kind CTF_K_CONST with base type BTID.  */
 850
 851 static struct type *
 852 read_const_type (struct ctf_context *ccp, ctf_id_t tid, ctf_id_t btid)
 853 {
 854   struct objfile *objfile = ccp->of;
 855   struct type *base_type, *cv_type;
 856
 857   base_type = fetch_tid_type (ccp, btid);
 858   if (base_type == nullptr)
 859     {
 860       base_type = read_type_record (ccp, btid);
 861       if (base_type == nullptr)
 862         {
 863           complaint (_("read_const_type: NULL base type (%ld)"), btid);
 864           base_type = objfile_type (objfile)->builtin_error;
 865         }
 866     }
 867   cv_type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0);
 868
 869   return set_tid_type (objfile, tid, cv_type);
 870 }
 871
 872 /* Read TID of kind CTF_K_VOLATILE with base type BTID.  */
 873
 874 static struct type *
 875 read_volatile_type (struct ctf_context *ccp, ctf_id_t tid, ctf_id_t btid)
 876 {
 877   struct objfile *objfile = ccp->of;
 878   ctf_dict_t *fp = ccp->fp;
 879   struct type *base_type, *cv_type;
 880
 881   base_type = fetch_tid_type (ccp, btid);
 882   if (base_type == nullptr)
 883     {
 884       base_type = read_type_record (ccp, btid);
 885       if (base_type == nullptr)
 886         {
 887           complaint (_("read_volatile_type: NULL base type (%ld)"), btid);
 888           base_type = objfile_type (objfile)->builtin_error;
 889         }
 890     }
 891
 892   if (ctf_type_kind (fp, btid) == CTF_K_ARRAY)
 893     return add_array_cv_type (ccp, tid, base_type, 0, 1);
 894   cv_type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0);
 895
 896   return set_tid_type (objfile, tid, cv_type);
 897 }
 898
 899 /* Read TID of kind CTF_K_RESTRICT with base type BTID.  */
 900
 901 static struct type *
 902 read_restrict_type (struct ctf_context *ccp, ctf_id_t tid, ctf_id_t btid)
 903 {
 904   struct objfile *objfile = ccp->of;
 905   struct type *base_type, *cv_type;
 906
 907   base_type = fetch_tid_type (ccp, btid);
 908   if (base_type == nullptr)
 909     {
 910       base_type = read_type_record (ccp, btid);
 911       if (base_type == nullptr)
 912         {
 913           complaint (_("read_restrict_type: NULL base type (%ld)"), btid);
 914           base_type = objfile_type (objfile)->builtin_error;
 915         }
 916     }
 917   cv_type = make_restrict_type (base_type);
 918
 919   return set_tid_type (objfile, tid, cv_type);
 920 }
 921
 922 /* Read TID of kind CTF_K_TYPEDEF with its NAME and base type BTID.  */
 923
 924 static struct type *
 925 read_typedef_type (struct ctf_context *ccp, ctf_id_t tid,
 926                    ctf_id_t btid, const char *name)
 927 {
 928   struct objfile *objfile = ccp->of;
 929   struct type *this_type, *target_type;
 930
 931   char *aname = obstack_strdup (&objfile->objfile_obstack, name);
 932   this_type = init_type (objfile, TYPE_CODE_TYPEDEF, 0, aname);
 933   set_tid_type (objfile, tid, this_type);
 934   target_type = fetch_tid_type (ccp, btid);
 935   if (target_type != this_type)
 936     TYPE_TARGET_TYPE (this_type) = target_type;
 937   else
 938     TYPE_TARGET_TYPE (this_type) = nullptr;
 939
 940   this_type->set_target_is_stub (TYPE_TARGET_TYPE (this_type) != nullptr);
 941
 942   return set_tid_type (objfile, tid, this_type);
 943 }
 944
 945 /* Read TID of kind CTF_K_POINTER with base type BTID.  */
 946
 947 static struct type *
 948 read_pointer_type (struct ctf_context *ccp, ctf_id_t tid, ctf_id_t btid)
 949 {
 950   struct objfile *of = ccp->of;
 951   struct type *target_type, *type;
 952
 953   target_type = fetch_tid_type (ccp, btid);
 954   if (target_type == nullptr)
 955     {
 956       target_type = read_type_record (ccp, btid);
 957       if (target_type == nullptr)
 958         {
 959           complaint (_("read_pointer_type: NULL target type (%ld)"), btid);
 960           target_type = objfile_type (ccp->of)->builtin_error;
 961         }
 962     }
 963
 964   type = lookup_pointer_type (target_type);
 965   set_type_align (type, ctf_type_align (ccp->fp, tid));
 966
 967   return set_tid_type (of, tid, type);
 968 }
 969
 970 /* Read information from a TID of CTF_K_FORWARD.  */
 971
 972 static struct type *
 973 read_forward_type (struct ctf_context *ccp, ctf_id_t tid)
 974 {
 975   struct objfile *of = ccp->of;
 976   ctf_dict_t *fp = ccp->fp;
 977   struct type *type;
 978   uint32_t kind;
 979
 980   type = alloc_type (of);
 981
 982   const char *name = ctf_type_name_raw (fp, tid);
 983   if (name != nullptr && strlen (name) != 0)
 984     type->set_name (name);
 985
 986   kind = ctf_type_kind_forwarded (fp, tid);
 987   if (kind == CTF_K_UNION)
 988     type->set_code (TYPE_CODE_UNION);
 989   else
 990     type->set_code (TYPE_CODE_STRUCT);
 991
 992   TYPE_LENGTH (type) = 0;
 993   type->set_is_stub (true);
 994
 995   return set_tid_type (of, tid, type);
 996 }
 997
 998 /* Read information associated with type TID.  */
 999
1000 static struct type *
1001 read_type_record (struct ctf_context *ccp, ctf_id_t tid)
1002 {
1003   ctf_dict_t *fp = ccp->fp;
1004   uint32_t kind;
1005   struct type *type = nullptr;
1006   ctf_id_t btid;
1007
1008   kind = ctf_type_kind (fp, tid);
1009   switch (kind)
1010     {
1011       case CTF_K_STRUCT:
1012       case CTF_K_UNION:
1013         type = read_structure_type (ccp, tid);
1014         break;
1015       case CTF_K_ENUM:
1016         type = read_enum_type (ccp, tid);
1017         break;
1018       case CTF_K_FUNCTION:
1019         type = read_func_kind_type (ccp, tid);
1020         break;
1021       case CTF_K_CONST:
1022         btid = ctf_type_reference (fp, tid);
1023         type = read_const_type (ccp, tid, btid);
1024         break;
1025       case CTF_K_TYPEDEF:
1026         {
1027           const char *name = ctf_type_name_raw (fp, tid);
1028           btid = ctf_type_reference (fp, tid);
1029           type = read_typedef_type (ccp, tid, btid, name);
1030         }
1031         break;
1032       case CTF_K_VOLATILE:
1033         btid = ctf_type_reference (fp, tid);
1034         type = read_volatile_type (ccp, tid, btid);
1035         break;
1036       case CTF_K_RESTRICT:
1037         btid = ctf_type_reference (fp, tid);
1038         type = read_restrict_type (ccp, tid, btid);
1039         break;
1040       case CTF_K_POINTER:
1041         btid = ctf_type_reference (fp, tid);
1042         type = read_pointer_type (ccp, tid, btid);
1043         break;
1044       case CTF_K_INTEGER:
1045       case CTF_K_FLOAT:
1046         type = read_base_type (ccp, tid);
1047         break;
1048       case CTF_K_ARRAY:
1049         type = read_array_type (ccp, tid);
1050         break;
1051       case CTF_K_FORWARD:
1052         type = read_forward_type (ccp, tid);
1053         break;
1054       case CTF_K_UNKNOWN:
1055         break;
1056       default:
1057         break;
1058     }
1059
1060   return type;
1061 }
1062
1063 /* Callback to add type TID to the symbol table.  */
1064
1065 static int
1066 ctf_add_type_cb (ctf_id_t tid, void *arg)
1067 {
1068   struct ctf_context *ccp = (struct ctf_context *) arg;
1069   struct type *type;
1070   uint32_t kind;
1071
1072   /* Check if tid's type has already been defined.  */
1073   type = get_tid_type (ccp->of, tid);
1074   if (type != nullptr)
1075     return 0;
1076
1077   ctf_id_t btid = ctf_type_reference (ccp->fp, tid);
1078   kind = ctf_type_kind (ccp->fp, tid);
1079   switch (kind)
1080     {
1081       case CTF_K_STRUCT:
1082       case CTF_K_UNION:
1083         process_structure_type (ccp, tid);
1084         break;
1085       case CTF_K_ENUM:
1086         process_enum_type (ccp, tid);
1087         break;
1088       case CTF_K_FUNCTION:
1089         type = read_func_kind_type (ccp, tid);
1090         new_symbol (ccp, type, tid);
1091         break;
1092       case CTF_K_INTEGER:
1093       case CTF_K_FLOAT:
1094         process_base_type (ccp, tid);
1095         break;
1096       case CTF_K_TYPEDEF:
1097         new_symbol (ccp, read_type_record (ccp, tid), tid);
1098         break;
1099       case CTF_K_CONST:
1100         type = read_const_type (ccp, tid, btid);
1101         new_symbol (ccp, type, tid);
1102         break;
1103       case CTF_K_VOLATILE:
1104         type = read_volatile_type (ccp, tid, btid);
1105         new_symbol (ccp, type, tid);
1106         break;
1107       case CTF_K_RESTRICT:
1108         type = read_restrict_type (ccp, tid, btid);
1109         new_symbol (ccp, type, tid);
1110         break;
1111       case CTF_K_POINTER:
1112         type = read_pointer_type (ccp, tid, btid);
1113         new_symbol (ccp, type, tid);
1114         break;
1115       case CTF_K_ARRAY:
1116         type = read_array_type (ccp, tid);
1117         new_symbol (ccp, type, tid);
1118         break;
1119       case CTF_K_UNKNOWN:
1120         break;
1121       default:
1122         break;
1123     }
1124
1125   return 0;
1126 }
1127
1128 /* Callback to add variable NAME with TID to the symbol table.  */
1129
1130 static int
1131 ctf_add_var_cb (const char *name, ctf_id_t id, void *arg)
1132 {
1133   struct ctf_context *ccp = (struct ctf_context *) arg;
1134   struct symbol *sym = nullptr;
1135   struct type *type;
1136   uint32_t kind;
1137
1138   type = get_tid_type (ccp->of, id);
1139
1140   kind = ctf_type_kind (ccp->fp, id);
1141   switch (kind)
1142     {
1143       case CTF_K_FUNCTION:
1144         if (name != nullptr && strcmp (name, "main") == 0)
1145           set_objfile_main_name (ccp->of, name, language_c);
1146         break;
1147       case CTF_K_INTEGER:
1148       case CTF_K_FLOAT:
1149       case CTF_K_VOLATILE:
1150       case CTF_K_RESTRICT:
1151       case CTF_K_TYPEDEF:
1152       case CTF_K_CONST:
1153       case CTF_K_POINTER:
1154       case CTF_K_ARRAY:
1155         if (type != nullptr)
1156           {
1157             sym = new_symbol (ccp, type, id);
1158             if (sym != nullptr)
1159               sym->compute_and_set_names (name, false, ccp->of->per_bfd);
1160           }
1161         break;
1162       case CTF_K_STRUCT:
1163       case CTF_K_UNION:
1164       case CTF_K_ENUM:
1165         if (type == nullptr)
1166           {
1167             complaint (_("ctf_add_var_cb: %s has NO type (%ld)"), name, id);
1168             type = objfile_type (ccp->of)->builtin_error;
1169           }
1170         sym = new (&ccp->of->objfile_obstack) symbol;
1171         OBJSTAT (ccp->of, n_syms++);
1172         sym->set_type (type);
1173         sym->set_domain (VAR_DOMAIN);
1174         sym->set_aclass_index (LOC_OPTIMIZED_OUT);
1175         sym->compute_and_set_names (name, false, ccp->of->per_bfd);
1176         add_symbol_to_list (sym, ccp->builder->get_file_symbols ());
1177         break;
1178       default:
1179         complaint (_("ctf_add_var_cb: kind unsupported (%d)"), kind);
1180         break;
1181     }
1182
1183   if (sym != nullptr)
1184     set_symbol_address (ccp->of, sym, name);
1185
1186   return 0;
1187 }
1188
1189 /* Add entries in either data objects or function info section, controlled
1190    by FUNCTIONS.  */
1191
1192 static void
1193 add_stt_entries (struct ctf_context *ccp, int functions)
1194 {
1195   ctf_next_t *i = nullptr;
1196   const char *tname;
1197   ctf_id_t tid;
1198   struct symbol *sym = nullptr;
1199   struct type *type;
1200
1201   while ((tid = ctf_symbol_next (ccp->fp, &i, &tname, functions)) != CTF_ERR)
1202     {
1203       type = get_tid_type (ccp->of, tid);
1204       if (type == nullptr)
1205         continue;
1206       sym = new (&ccp->of->objfile_obstack) symbol;
1207       OBJSTAT (ccp->of, n_syms++);
1208       sym->set_type (type);
1209       sym->set_domain (VAR_DOMAIN);
1210       sym->set_aclass_index (LOC_STATIC);
1211       sym->compute_and_set_names (tname, false, ccp->of->per_bfd);
1212       add_symbol_to_list (sym, ccp->builder->get_global_symbols ());
1213       set_symbol_address (ccp->of, sym, tname);
1214     }
1215 }
1216
1217 /* Add entries in data objects section.  */
1218
1219 static void
1220 add_stt_obj (struct ctf_context *ccp)
1221 {
1222   add_stt_entries (ccp, 0);
1223 }
1224
1225 /* Add entries in function info section.  */
1226
1227 static void
1228 add_stt_func (struct ctf_context *ccp)
1229 {
1230   add_stt_entries (ccp, 1);
1231 }
1232
1233 /* Get text segment base for OBJFILE, TSIZE contains the segment size.  */
1234
1235 static CORE_ADDR
1236 get_objfile_text_range (struct objfile *of, int *tsize)
1237 {
1238   bfd *abfd = of->obfd;
1239   const asection *codes;
1240
1241   codes = bfd_get_section_by_name (abfd, ".text");
1242   *tsize = codes ? bfd_section_size (codes) : 0;
1243   return of->text_section_offset ();
1244 }
1245
1246 /* Start a symtab for OBJFILE in CTF format.  */
1247
1248 static void
1249 ctf_start_symtab (ctf_psymtab *pst,
1250                   struct objfile *of, CORE_ADDR text_offset)
1251 {
1252   struct ctf_context *ccp;
1253
1254   ccp = &pst->context;
1255   ccp->builder = new buildsym_compunit
1256                        (of, of->original_name, nullptr,
1257                        language_c, text_offset);
1258   ccp->builder->record_debugformat ("ctf");
1259 }
1260
1261 /* Finish reading symbol/type definitions in CTF format.
1262    END_ADDR is the end address of the file's text.  SECTION is
1263    the .text section number.  */
1264
1265 static struct compunit_symtab *
1266 ctf_end_symtab (ctf_psymtab *pst,
1267                 CORE_ADDR end_addr, int section)
1268 {
1269   struct ctf_context *ccp;
1270
1271   ccp = &pst->context;
1272   struct compunit_symtab *result
1273     = ccp->builder->end_symtab (end_addr, section);
1274   delete ccp->builder;
1275   ccp->builder = nullptr;
1276   return result;
1277 }
1278
1279 /* Add all members of an enum with type TID to partial symbol table.  */
1280
1281 static void
1282 ctf_psymtab_add_enums (struct ctf_context *ccp, ctf_id_t tid)
1283 {
1284   int val;
1285   const char *ename;
1286   ctf_next_t *i = nullptr;
1287
1288   while ((ename = ctf_enum_next (ccp->fp, tid, &i, &val)) != nullptr)
1289     {
1290       ccp->pst->add_psymbol (ename, true,
1291                              VAR_DOMAIN, LOC_CONST, -1,
1292                              psymbol_placement::GLOBAL,
1293                              0, language_c, ccp->partial_symtabs, ccp->of);
1294     }
1295   if (ctf_errno (ccp->fp) != ECTF_NEXT_END)
1296     complaint (_("ctf_enum_next ctf_psymtab_add_enums failed - %s"),
1297                ctf_errmsg (ctf_errno (ccp->fp)));
1298 }
1299
1300 /* Add entries in either data objects or function info section, controlled
1301    by FUNCTIONS, to psymtab.  */
1302
1303 static void
1304 ctf_psymtab_add_stt_entries (ctf_dict_t *cfp, ctf_psymtab *pst,
1305                              struct objfile *of, int functions)
1306 {
1307   ctf_next_t *i = nullptr;
1308   ctf_id_t tid;
1309   const char *tname;
1310
1311   while ((tid = ctf_symbol_next (cfp, &i, &tname, functions)) != CTF_ERR)
1312     {
1313       uint32_t kind = ctf_type_kind (cfp, tid);
1314       address_class aclass;
1315       domain_enum tdomain;
1316       switch (kind)
1317         {
1318           case CTF_K_STRUCT:
1319           case CTF_K_UNION:
1320           case CTF_K_ENUM:
1321             tdomain = STRUCT_DOMAIN;
1322             break;
1323           default:
1324             tdomain = VAR_DOMAIN;
1325             break;
1326         }
1327
1328       if (kind == CTF_K_FUNCTION)
1329         aclass = LOC_STATIC;
1330       else if (kind == CTF_K_CONST)
1331         aclass = LOC_CONST;
1332       else
1333         aclass = LOC_TYPEDEF;
1334
1335       pst->add_psymbol (tname, true,
1336                         tdomain, aclass, -1,
1337                         psymbol_placement::GLOBAL,
1338                         0, language_c, pst->context.partial_symtabs, of);
1339     }
1340 }
1341
1342 /* Add entries in data objects section to psymtab.  */
1343
1344 static void
1345 ctf_psymtab_add_stt_obj (ctf_dict_t *cfp, ctf_psymtab *pst,
1346                          struct objfile *of)
1347 {
1348   ctf_psymtab_add_stt_entries (cfp, pst, of, 0);
1349 }
1350
1351 /* Add entries in function info section to psymtab.  */
1352
1353 static void
1354 ctf_psymtab_add_stt_func (ctf_dict_t *cfp, ctf_psymtab *pst,
1355                           struct objfile *of)
1356 {
1357   ctf_psymtab_add_stt_entries (cfp, pst, of, 1);
1358 }
1359
1360 /* Read in full symbols for PST, and anything it depends on.  */
1361
1362 void
1363 ctf_psymtab::expand_psymtab (struct objfile *objfile)
1364 {
1365   struct ctf_context *ccp;
1366
1367   gdb_assert (!readin);
1368
1369   ccp = &context;
1370
1371   /* Iterate over entries in data types section.  */
1372   if (ctf_type_iter (ccp->fp, ctf_add_type_cb, ccp) == CTF_ERR)
1373     complaint (_("ctf_type_iter psymtab_to_symtab failed - %s"),
1374                ctf_errmsg (ctf_errno (ccp->fp)));
1375
1376
1377   /* Iterate over entries in variable info section.  */
1378   if (ctf_variable_iter (ccp->fp, ctf_add_var_cb, ccp) == CTF_ERR)
1379     complaint (_("ctf_variable_iter psymtab_to_symtab failed - %s"),
1380                ctf_errmsg (ctf_errno (ccp->fp)));
1381
1382   /* Add entries in data objects and function info sections.  */
1383   add_stt_obj (ccp);
1384   add_stt_func (ccp);
1385
1386   readin = true;
1387 }
1388
1389 /* Expand partial symbol table PST into a full symbol table.
1390    PST is not NULL.  */
1391
1392 void
1393 ctf_psymtab::read_symtab (struct objfile *objfile)
1394 {
1395   if (readin)
1396     warning (_("bug: psymtab for %s is already read in."), filename);
1397   else
1398     {
1399       if (info_verbose)
1400         {
1401           gdb_printf (_("Reading in CTF data for %s..."), filename);
1402           gdb_flush (gdb_stdout);
1403         }
1404
1405       /* Start a symtab.  */
1406       CORE_ADDR offset;        /* Start of text segment.  */
1407       int tsize;
1408
1409       offset = get_objfile_text_range (objfile, &tsize);
1410       ctf_start_symtab (this, objfile, offset);
1411       expand_psymtab (objfile);
1412
1413       set_text_low (offset);
1414       set_text_high (offset + tsize);
1415       compunit_symtab = ctf_end_symtab (this, offset + tsize,
1416                                         SECT_OFF_TEXT (objfile));
1417
1418       /* Finish up the debug error message.  */
1419       if (info_verbose)
1420         gdb_printf (_("done.\n"));
1421     }
1422 }
1423
1424 /* Allocate a new partial_symtab NAME.
1425
1426    Each source file that has not been fully read in is represented by
1427    a partial_symtab.  This contains the information on where in the
1428    executable the debugging symbols for a specific file are, and a
1429    list of names of global symbols which are located in this file.
1430    They are all chained on partial symtab lists.
1431
1432    Even after the source file has been read into a symtab, the
1433    partial_symtab remains around.  They are allocated on an obstack,
1434    objfile_obstack.  */
1435
1436 static ctf_psymtab *
1437 create_partial_symtab (const char *name,
1438                        ctf_archive_t *arc,
1439                        ctf_dict_t *cfp,
1440                        psymtab_storage *partial_symtabs,
1441                        struct objfile *objfile)
1442 {
1443   ctf_psymtab *pst;
1444
1445   pst = new ctf_psymtab (name, partial_symtabs, objfile->per_bfd, 0);
1446
1447   pst->context.arc = arc;
1448   pst->context.fp = cfp;
1449   pst->context.of = objfile;
1450   pst->context.partial_symtabs = partial_symtabs;
1451   pst->context.pst = pst;
1452
1453   return pst;
1454 }
1455
1456 /* Callback to add type TID to partial symbol table.  */
1457
1458 static int
1459 ctf_psymtab_type_cb (ctf_id_t tid, void *arg)
1460 {
1461   struct ctf_context *ccp;
1462   uint32_t kind;
1463   short section = -1;
1464
1465   ccp = (struct ctf_context *) arg;
1466
1467   domain_enum domain = UNDEF_DOMAIN;
1468   enum address_class aclass = LOC_UNDEF;
1469   kind = ctf_type_kind (ccp->fp, tid);
1470   switch (kind)
1471     {
1472       case CTF_K_ENUM:
1473         ctf_psymtab_add_enums (ccp, tid);
1474         /* FALL THROUGH */
1475       case CTF_K_STRUCT:
1476       case CTF_K_UNION:
1477         domain = STRUCT_DOMAIN;
1478         aclass = LOC_TYPEDEF;
1479         break;
1480       case CTF_K_FUNCTION:
1481       case CTF_K_FORWARD:
1482         domain = VAR_DOMAIN;
1483         aclass = LOC_STATIC;
1484         section = SECT_OFF_TEXT (ccp->of);
1485         break;
1486       case CTF_K_CONST:
1487         domain = VAR_DOMAIN;
1488         aclass = LOC_STATIC;
1489         break;
1490       case CTF_K_TYPEDEF:
1491       case CTF_K_POINTER:
1492       case CTF_K_VOLATILE:
1493       case CTF_K_RESTRICT:
1494         domain = VAR_DOMAIN;
1495         aclass = LOC_TYPEDEF;
1496         break;
1497       case CTF_K_INTEGER:
1498       case CTF_K_FLOAT:
1499         domain = VAR_DOMAIN;
1500         aclass = LOC_TYPEDEF;
1501         break;
1502       case CTF_K_ARRAY:
1503       case CTF_K_UNKNOWN:
1504         return 0;
1505     }
1506
1507   const char *name = ctf_type_name_raw (ccp->fp, tid);
1508   if (name == nullptr || strlen (name) == 0)
1509     return 0;
1510
1511   ccp->pst->add_psymbol (name, false,
1512                          domain, aclass, section,
1513                          psymbol_placement::STATIC,
1514                          0, language_c, ccp->partial_symtabs, ccp->of);
1515
1516   return 0;
1517 }
1518
1519 /* Callback to add variable NAME with ID to partial symbol table.  */
1520
1521 static int
1522 ctf_psymtab_var_cb (const char *name, ctf_id_t id, void *arg)
1523 {
1524   struct ctf_context *ccp = (struct ctf_context *) arg;
1525
1526   ccp->pst->add_psymbol (name, true,
1527                          VAR_DOMAIN, LOC_STATIC, -1,
1528                          psymbol_placement::GLOBAL,
1529                          0, language_c, ccp->partial_symtabs, ccp->of);
1530   return 0;
1531 }
1532
1533 /* Start a subfile for CTF. FNAME is the name of the archive.  */
1534
1535 static void
1536 ctf_start_archive (struct ctf_context *ccx, struct objfile *of,
1537                    const char *fname)
1538 {
1539   if (ccx->builder == nullptr)
1540     {
1541       ccx->builder = new buildsym_compunit (of,
1542                       of->original_name, nullptr, language_c, 0);
1543       ccx->builder->record_debugformat ("ctf");
1544     }
1545   ccx->builder->start_subfile (fname);
1546 }
1547
1548 /* Setup partial_symtab's describing each source file for which
1549    debugging information is available.  */
1550
1551 static void
1552 scan_partial_symbols (ctf_dict_t *cfp, psymtab_storage *partial_symtabs,
1553                       struct ctf_per_tu_data *tup, const char *fname)
1554 {
1555   struct objfile *of = tup->of;
1556   bool isparent = false;
1557
1558   if (strcmp (fname, ".ctf") == 0)
1559     {
1560       fname = bfd_get_filename (of->obfd);
1561       isparent = true;
1562     }
1563
1564   ctf_psymtab *pst = create_partial_symtab (fname, tup->arc, cfp,
1565                                             partial_symtabs, of);
1566
1567   struct ctf_context *ccx = &pst->context;
1568   if (isparent == false)
1569     {
1570       ctf_start_archive (ccx, of, fname);
1571       ccx->pst = pst;
1572     }
1573
1574   if (ctf_type_iter (cfp, ctf_psymtab_type_cb, ccx) == CTF_ERR)
1575     complaint (_("ctf_type_iter scan_partial_symbols failed - %s"),
1576                ctf_errmsg (ctf_errno (cfp)));
1577
1578   if (ctf_variable_iter (cfp, ctf_psymtab_var_cb, ccx) == CTF_ERR)
1579     complaint (_("ctf_variable_iter scan_partial_symbols failed - %s"),
1580                ctf_errmsg (ctf_errno (cfp)));
1581
1582   /* Scan CTF object and function sections which correspond to each
1583      STT_FUNC or STT_OBJECT entry in the symbol table,
1584      pick up what init_symtab has done.  */
1585   ctf_psymtab_add_stt_obj (cfp, pst, of);
1586   ctf_psymtab_add_stt_func (cfp, pst, of);
1587
1588   pst->end ();
1589 }
1590
1591 /* Callback to build the psymtab for archive member NAME.  */
1592
1593 static int
1594 build_ctf_archive_member (ctf_dict_t *ctf, const char *name, void *arg)
1595 {
1596   struct ctf_per_tu_data *tup = (struct ctf_per_tu_data *) arg;
1597   ctf_dict_t *parent = tup->fp;
1598
1599   if (strcmp (name, ".ctf") != 0)
1600     ctf_import (ctf, parent);
1601
1602   if (info_verbose)
1603     {
1604       gdb_printf (_("Scanning archive member %s..."), name);
1605       gdb_flush (gdb_stdout);
1606     }
1607
1608   psymtab_storage *pss = tup->psf->get_partial_symtabs ().get ();
1609   scan_partial_symbols (ctf, pss, tup, name);
1610
1611   return 0;
1612 }
1613
1614 /* Read CTF debugging information from a BFD section.  This is
1615    called from elfread.c.  It does a quick pass through the
1616    .ctf section to set up the partial symbol table.  */
1617
1618 void
1619 elfctf_build_psymtabs (struct objfile *of)
1620 {
1621   struct ctf_per_tu_data pcu;
1622   bfd *abfd = of->obfd;
1623   int err;
1624
1625   ctf_archive_t *arc = ctf_bfdopen (abfd, &err);
1626   if (arc == nullptr)
1627     error (_("ctf_bfdopen failed on %s - %s"),
1628            bfd_get_filename (abfd), ctf_errmsg (err));
1629
1630   ctf_dict_t *fp = ctf_dict_open (arc, NULL, &err);
1631   if (fp == nullptr)
1632     error (_("ctf_dict_open failed on %s - %s"),
1633            bfd_get_filename (abfd), ctf_errmsg (err));
1634   ctf_dict_key.emplace (of, fp);
1635
1636   pcu.fp = fp;
1637   pcu.of = of;
1638   pcu.arc = arc;
1639
1640   psymbol_functions *psf = new psymbol_functions ();
1641   of->qf.emplace_front (psf);
1642   pcu.psf = psf;
1643
1644   if (ctf_archive_iter (arc, build_ctf_archive_member, &pcu) < 0)
1645     error (_("ctf_archive_iter failed in input file %s: - %s"),
1646            bfd_get_filename (abfd), ctf_errmsg (err));
1647 }
1648
1649 #else
1650
1651 void
1652 elfctf_build_psymtabs (struct objfile *of)
1653 {
1654   /* Nothing to do if CTF is disabled.  */
1655 }
1656
1657 #endif /* ENABLE_LIBCTF */