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 registry<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 registry<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 = 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 = 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       sym->set_value_address (msym.value_address ());
 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->set_length (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->set_target_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->set_length (ctf_type_size (fp, tid));
 751   /* Set the underlying type based on its ctf_type_size bits.  */
 752   type->set_target_type (objfile_int_type (of, type->length (), 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 (inner_array->target_type ()->code () == TYPE_CODE_ARRAY)
 793     {
 794       inner_array->set_target_type (copy_type (inner_array->target_type ()));
 795       inner_array = inner_array->target_type ();
 796     }
 797
 798   el_type = inner_array->target_type ();
 799   cnst |= TYPE_CONST (el_type);
 800   voltl |= TYPE_VOLATILE (el_type);
 801   inner_array->set_target_type (make_cv_type (cnst, voltl, el_type, nullptr));
 802
 803   return set_tid_type (ccp->of, tid, base_type);
 804 }
 805
 806 /* Read all information from a TID of CTF_K_ARRAY.  */
 807
 808 static struct type *
 809 read_array_type (struct ctf_context *ccp, ctf_id_t tid)
 810 {
 811   struct objfile *objfile = ccp->of;
 812   ctf_dict_t *fp = ccp->fp;
 813   struct type *element_type, *range_type, *idx_type;
 814   struct type *type;
 815   ctf_arinfo_t ar;
 816
 817   if (ctf_array_info (fp, tid, &ar) == CTF_ERR)
 818     {
 819       complaint (_("ctf_array_info read_array_type failed - %s"),
 820                  ctf_errmsg (ctf_errno (fp)));
 821       return nullptr;
 822     }
 823
 824   element_type = fetch_tid_type (ccp, ar.ctr_contents);
 825   if (element_type == nullptr)
 826     return nullptr;
 827
 828   idx_type = fetch_tid_type (ccp, ar.ctr_index);
 829   if (idx_type == nullptr)
 830     idx_type = objfile_type (objfile)->builtin_int;
 831
 832   range_type = create_static_range_type (NULL, idx_type, 0, ar.ctr_nelems - 1);
 833   type = create_array_type (NULL, element_type, range_type);
 834   if (ar.ctr_nelems <= 1)       /* Check if undefined upper bound.  */
 835     {
 836       range_type->bounds ()->high.set_undefined ();
 837       type->set_length (0);
 838       type->set_target_is_stub (true);
 839     }
 840   else
 841     type->set_length (ctf_type_size (fp, tid));
 842
 843   set_type_align (type, ctf_type_align (fp, tid));
 844
 845   return set_tid_type (objfile, tid, type);
 846 }
 847
 848 /* Read TID of kind CTF_K_CONST with base type BTID.  */
 849
 850 static struct type *
 851 read_const_type (struct ctf_context *ccp, ctf_id_t tid, ctf_id_t btid)
 852 {
 853   struct objfile *objfile = ccp->of;
 854   struct type *base_type, *cv_type;
 855
 856   base_type = fetch_tid_type (ccp, btid);
 857   if (base_type == nullptr)
 858     {
 859       base_type = read_type_record (ccp, btid);
 860       if (base_type == nullptr)
 861         {
 862           complaint (_("read_const_type: NULL base type (%ld)"), btid);
 863           base_type = objfile_type (objfile)->builtin_error;
 864         }
 865     }
 866   cv_type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0);
 867
 868   return set_tid_type (objfile, tid, cv_type);
 869 }
 870
 871 /* Read TID of kind CTF_K_VOLATILE with base type BTID.  */
 872
 873 static struct type *
 874 read_volatile_type (struct ctf_context *ccp, ctf_id_t tid, ctf_id_t btid)
 875 {
 876   struct objfile *objfile = ccp->of;
 877   ctf_dict_t *fp = ccp->fp;
 878   struct type *base_type, *cv_type;
 879
 880   base_type = fetch_tid_type (ccp, btid);
 881   if (base_type == nullptr)
 882     {
 883       base_type = read_type_record (ccp, btid);
 884       if (base_type == nullptr)
 885         {
 886           complaint (_("read_volatile_type: NULL base type (%ld)"), btid);
 887           base_type = objfile_type (objfile)->builtin_error;
 888         }
 889     }
 890
 891   if (ctf_type_kind (fp, btid) == CTF_K_ARRAY)
 892     return add_array_cv_type (ccp, tid, base_type, 0, 1);
 893   cv_type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0);
 894
 895   return set_tid_type (objfile, tid, cv_type);
 896 }
 897
 898 /* Read TID of kind CTF_K_RESTRICT with base type BTID.  */
 899
 900 static struct type *
 901 read_restrict_type (struct ctf_context *ccp, ctf_id_t tid, ctf_id_t btid)
 902 {
 903   struct objfile *objfile = ccp->of;
 904   struct type *base_type, *cv_type;
 905
 906   base_type = fetch_tid_type (ccp, btid);
 907   if (base_type == nullptr)
 908     {
 909       base_type = read_type_record (ccp, btid);
 910       if (base_type == nullptr)
 911         {
 912           complaint (_("read_restrict_type: NULL base type (%ld)"), btid);
 913           base_type = objfile_type (objfile)->builtin_error;
 914         }
 915     }
 916   cv_type = make_restrict_type (base_type);
 917
 918   return set_tid_type (objfile, tid, cv_type);
 919 }
 920
 921 /* Read TID of kind CTF_K_TYPEDEF with its NAME and base type BTID.  */
 922
 923 static struct type *
 924 read_typedef_type (struct ctf_context *ccp, ctf_id_t tid,
 925                    ctf_id_t btid, const char *name)
 926 {
 927   struct objfile *objfile = ccp->of;
 928   struct type *this_type, *target_type;
 929
 930   char *aname = obstack_strdup (&objfile->objfile_obstack, name);
 931   this_type = init_type (objfile, TYPE_CODE_TYPEDEF, 0, aname);
 932   set_tid_type (objfile, tid, this_type);
 933   target_type = fetch_tid_type (ccp, btid);
 934   if (target_type != this_type)
 935     this_type->set_target_type (target_type);
 936   else
 937     this_type->set_target_type (nullptr);
 938
 939   this_type->set_target_is_stub (this_type->target_type () != nullptr);
 940
 941   return set_tid_type (objfile, tid, this_type);
 942 }
 943
 944 /* Read TID of kind CTF_K_POINTER with base type BTID.  */
 945
 946 static struct type *
 947 read_pointer_type (struct ctf_context *ccp, ctf_id_t tid, ctf_id_t btid)
 948 {
 949   struct objfile *of = ccp->of;
 950   struct type *target_type, *type;
 951
 952   target_type = fetch_tid_type (ccp, btid);
 953   if (target_type == nullptr)
 954     {
 955       target_type = read_type_record (ccp, btid);
 956       if (target_type == nullptr)
 957         {
 958           complaint (_("read_pointer_type: NULL target type (%ld)"), btid);
 959           target_type = objfile_type (ccp->of)->builtin_error;
 960         }
 961     }
 962
 963   type = lookup_pointer_type (target_type);
 964   set_type_align (type, ctf_type_align (ccp->fp, tid));
 965
 966   return set_tid_type (of, tid, type);
 967 }
 968
 969 /* Read information from a TID of CTF_K_FORWARD.  */
 970
 971 static struct type *
 972 read_forward_type (struct ctf_context *ccp, ctf_id_t tid)
 973 {
 974   struct objfile *of = ccp->of;
 975   ctf_dict_t *fp = ccp->fp;
 976   struct type *type;
 977   uint32_t kind;
 978
 979   type = alloc_type (of);
 980
 981   const char *name = ctf_type_name_raw (fp, tid);
 982   if (name != nullptr && strlen (name) != 0)
 983     type->set_name (name);
 984
 985   kind = ctf_type_kind_forwarded (fp, tid);
 986   if (kind == CTF_K_UNION)
 987     type->set_code (TYPE_CODE_UNION);
 988   else
 989     type->set_code (TYPE_CODE_STRUCT);
 990
 991   type->set_length (0);
 992   type->set_is_stub (true);
 993
 994   return set_tid_type (of, tid, type);
 995 }
 996
 997 /* Read information associated with type TID.  */
 998
 999 static struct type *
1000 read_type_record (struct ctf_context *ccp, ctf_id_t tid)
1001 {
1002   ctf_dict_t *fp = ccp->fp;
1003   uint32_t kind;
1004   struct type *type = nullptr;
1005   ctf_id_t btid;
1006
1007   kind = ctf_type_kind (fp, tid);
1008   switch (kind)
1009     {
1010       case CTF_K_STRUCT:
1011       case CTF_K_UNION:
1012         type = read_structure_type (ccp, tid);
1013         break;
1014       case CTF_K_ENUM:
1015         type = read_enum_type (ccp, tid);
1016         break;
1017       case CTF_K_FUNCTION:
1018         type = read_func_kind_type (ccp, tid);
1019         break;
1020       case CTF_K_CONST:
1021         btid = ctf_type_reference (fp, tid);
1022         type = read_const_type (ccp, tid, btid);
1023         break;
1024       case CTF_K_TYPEDEF:
1025         {
1026           const char *name = ctf_type_name_raw (fp, tid);
1027           btid = ctf_type_reference (fp, tid);
1028           type = read_typedef_type (ccp, tid, btid, name);
1029         }
1030         break;
1031       case CTF_K_VOLATILE:
1032         btid = ctf_type_reference (fp, tid);
1033         type = read_volatile_type (ccp, tid, btid);
1034         break;
1035       case CTF_K_RESTRICT:
1036         btid = ctf_type_reference (fp, tid);
1037         type = read_restrict_type (ccp, tid, btid);
1038         break;
1039       case CTF_K_POINTER:
1040         btid = ctf_type_reference (fp, tid);
1041         type = read_pointer_type (ccp, tid, btid);
1042         break;
1043       case CTF_K_INTEGER:
1044       case CTF_K_FLOAT:
1045         type = read_base_type (ccp, tid);
1046         break;
1047       case CTF_K_ARRAY:
1048         type = read_array_type (ccp, tid);
1049         break;
1050       case CTF_K_FORWARD:
1051         type = read_forward_type (ccp, tid);
1052         break;
1053       case CTF_K_UNKNOWN:
1054         break;
1055       default:
1056         break;
1057     }
1058
1059   return type;
1060 }
1061
1062 /* Callback to add type TID to the symbol table.  */
1063
1064 static int
1065 ctf_add_type_cb (ctf_id_t tid, void *arg)
1066 {
1067   struct ctf_context *ccp = (struct ctf_context *) arg;
1068   struct type *type;
1069   uint32_t kind;
1070
1071   /* Check if tid's type has already been defined.  */
1072   type = get_tid_type (ccp->of, tid);
1073   if (type != nullptr)
1074     return 0;
1075
1076   ctf_id_t btid = ctf_type_reference (ccp->fp, tid);
1077   kind = ctf_type_kind (ccp->fp, tid);
1078   switch (kind)
1079     {
1080       case CTF_K_STRUCT:
1081       case CTF_K_UNION:
1082         process_structure_type (ccp, tid);
1083         break;
1084       case CTF_K_ENUM:
1085         process_enum_type (ccp, tid);
1086         break;
1087       case CTF_K_FUNCTION:
1088         type = read_func_kind_type (ccp, tid);
1089         new_symbol (ccp, type, tid);
1090         break;
1091       case CTF_K_INTEGER:
1092       case CTF_K_FLOAT:
1093         process_base_type (ccp, tid);
1094         break;
1095       case CTF_K_TYPEDEF:
1096         new_symbol (ccp, read_type_record (ccp, tid), tid);
1097         break;
1098       case CTF_K_CONST:
1099         type = read_const_type (ccp, tid, btid);
1100         new_symbol (ccp, type, tid);
1101         break;
1102       case CTF_K_VOLATILE:
1103         type = read_volatile_type (ccp, tid, btid);
1104         new_symbol (ccp, type, tid);
1105         break;
1106       case CTF_K_RESTRICT:
1107         type = read_restrict_type (ccp, tid, btid);
1108         new_symbol (ccp, type, tid);
1109         break;
1110       case CTF_K_POINTER:
1111         type = read_pointer_type (ccp, tid, btid);
1112         new_symbol (ccp, type, tid);
1113         break;
1114       case CTF_K_ARRAY:
1115         type = read_array_type (ccp, tid);
1116         new_symbol (ccp, type, tid);
1117         break;
1118       case CTF_K_UNKNOWN:
1119         break;
1120       default:
1121         break;
1122     }
1123
1124   return 0;
1125 }
1126
1127 /* Callback to add variable NAME with TID to the symbol table.  */
1128
1129 static int
1130 ctf_add_var_cb (const char *name, ctf_id_t id, void *arg)
1131 {
1132   struct ctf_context *ccp = (struct ctf_context *) arg;
1133   struct symbol *sym = nullptr;
1134   struct type *type;
1135   uint32_t kind;
1136
1137   type = get_tid_type (ccp->of, id);
1138
1139   kind = ctf_type_kind (ccp->fp, id);
1140   switch (kind)
1141     {
1142       case CTF_K_FUNCTION:
1143         if (name != nullptr && strcmp (name, "main") == 0)
1144           set_objfile_main_name (ccp->of, name, language_c);
1145         break;
1146       case CTF_K_INTEGER:
1147       case CTF_K_FLOAT:
1148       case CTF_K_VOLATILE:
1149       case CTF_K_RESTRICT:
1150       case CTF_K_TYPEDEF:
1151       case CTF_K_CONST:
1152       case CTF_K_POINTER:
1153       case CTF_K_ARRAY:
1154         if (type != nullptr)
1155           {
1156             sym = new_symbol (ccp, type, id);
1157             if (sym != nullptr)
1158               sym->compute_and_set_names (name, false, ccp->of->per_bfd);
1159           }
1160         break;
1161       case CTF_K_STRUCT:
1162       case CTF_K_UNION:
1163       case CTF_K_ENUM:
1164         if (type == nullptr)
1165           {
1166             complaint (_("ctf_add_var_cb: %s has NO type (%ld)"), name, id);
1167             type = objfile_type (ccp->of)->builtin_error;
1168           }
1169         sym = new (&ccp->of->objfile_obstack) symbol;
1170         OBJSTAT (ccp->of, n_syms++);
1171         sym->set_type (type);
1172         sym->set_domain (VAR_DOMAIN);
1173         sym->set_aclass_index (LOC_OPTIMIZED_OUT);
1174         sym->compute_and_set_names (name, false, ccp->of->per_bfd);
1175         add_symbol_to_list (sym, ccp->builder->get_file_symbols ());
1176         break;
1177       default:
1178         complaint (_("ctf_add_var_cb: kind unsupported (%d)"), kind);
1179         break;
1180     }
1181
1182   if (sym != nullptr)
1183     set_symbol_address (ccp->of, sym, name);
1184
1185   return 0;
1186 }
1187
1188 /* Add entries in either data objects or function info section, controlled
1189    by FUNCTIONS.  */
1190
1191 static void
1192 add_stt_entries (struct ctf_context *ccp, int functions)
1193 {
1194   ctf_next_t *i = nullptr;
1195   const char *tname;
1196   ctf_id_t tid;
1197   struct symbol *sym = nullptr;
1198   struct type *type;
1199
1200   while ((tid = ctf_symbol_next (ccp->fp, &i, &tname, functions)) != CTF_ERR)
1201     {
1202       type = get_tid_type (ccp->of, tid);
1203       if (type == nullptr)
1204         continue;
1205       sym = new (&ccp->of->objfile_obstack) symbol;
1206       OBJSTAT (ccp->of, n_syms++);
1207       sym->set_type (type);
1208       sym->set_domain (VAR_DOMAIN);
1209       sym->set_aclass_index (LOC_STATIC);
1210       sym->compute_and_set_names (tname, false, ccp->of->per_bfd);
1211       add_symbol_to_list (sym, ccp->builder->get_global_symbols ());
1212       set_symbol_address (ccp->of, sym, tname);
1213     }
1214 }
1215
1216 /* Add entries in data objects section.  */
1217
1218 static void
1219 add_stt_obj (struct ctf_context *ccp)
1220 {
1221   add_stt_entries (ccp, 0);
1222 }
1223
1224 /* Add entries in function info section.  */
1225
1226 static void
1227 add_stt_func (struct ctf_context *ccp)
1228 {
1229   add_stt_entries (ccp, 1);
1230 }
1231
1232 /* Get text segment base for OBJFILE, TSIZE contains the segment size.  */
1233
1234 static CORE_ADDR
1235 get_objfile_text_range (struct objfile *of, int *tsize)
1236 {
1237   bfd *abfd = of->obfd.get ();
1238   const asection *codes;
1239
1240   codes = bfd_get_section_by_name (abfd, ".text");
1241   *tsize = codes ? bfd_section_size (codes) : 0;
1242   return of->text_section_offset ();
1243 }
1244
1245 /* Start a symtab for OBJFILE in CTF format.  */
1246
1247 static void
1248 ctf_start_compunit_symtab (ctf_psymtab *pst,
1249                            struct objfile *of, CORE_ADDR text_offset)
1250 {
1251   struct ctf_context *ccp;
1252
1253   ccp = &pst->context;
1254   ccp->builder = new buildsym_compunit
1255                        (of, pst->filename, nullptr,
1256                        language_c, text_offset);
1257   ccp->builder->record_debugformat ("ctf");
1258 }
1259
1260 /* Finish reading symbol/type definitions in CTF format.
1261    END_ADDR is the end address of the file's text.  SECTION is
1262    the .text section number.  */
1263
1264 static struct compunit_symtab *
1265 ctf_end_compunit_symtab (ctf_psymtab *pst,
1266                          CORE_ADDR end_addr, int section)
1267 {
1268   struct ctf_context *ccp;
1269
1270   ccp = &pst->context;
1271   struct compunit_symtab *result
1272     = ccp->builder->end_compunit_symtab (end_addr, section);
1273   delete ccp->builder;
1274   ccp->builder = nullptr;
1275   return result;
1276 }
1277
1278 /* Add all members of an enum with type TID to partial symbol table.  */
1279
1280 static void
1281 ctf_psymtab_add_enums (struct ctf_context *ccp, ctf_id_t tid)
1282 {
1283   int val;
1284   const char *ename;
1285   ctf_next_t *i = nullptr;
1286
1287   while ((ename = ctf_enum_next (ccp->fp, tid, &i, &val)) != nullptr)
1288     {
1289       ccp->pst->add_psymbol (ename, true,
1290                              VAR_DOMAIN, LOC_CONST, -1,
1291                              psymbol_placement::GLOBAL,
1292                              0, language_c, ccp->partial_symtabs, ccp->of);
1293     }
1294   if (ctf_errno (ccp->fp) != ECTF_NEXT_END)
1295     complaint (_("ctf_enum_next ctf_psymtab_add_enums failed - %s"),
1296                ctf_errmsg (ctf_errno (ccp->fp)));
1297 }
1298
1299 /* Add entries in either data objects or function info section, controlled
1300    by FUNCTIONS, to psymtab.  */
1301
1302 static void
1303 ctf_psymtab_add_stt_entries (ctf_dict_t *cfp, ctf_psymtab *pst,
1304                              struct objfile *of, int functions)
1305 {
1306   ctf_next_t *i = nullptr;
1307   ctf_id_t tid;
1308   const char *tname;
1309
1310   while ((tid = ctf_symbol_next (cfp, &i, &tname, functions)) != CTF_ERR)
1311     {
1312       uint32_t kind = ctf_type_kind (cfp, tid);
1313       address_class aclass;
1314       domain_enum tdomain;
1315       switch (kind)
1316         {
1317           case CTF_K_STRUCT:
1318           case CTF_K_UNION:
1319           case CTF_K_ENUM:
1320             tdomain = STRUCT_DOMAIN;
1321             break;
1322           default:
1323             tdomain = VAR_DOMAIN;
1324             break;
1325         }
1326
1327       if (kind == CTF_K_FUNCTION)
1328         aclass = LOC_STATIC;
1329       else if (kind == CTF_K_CONST)
1330         aclass = LOC_CONST;
1331       else
1332         aclass = LOC_TYPEDEF;
1333
1334       pst->add_psymbol (tname, true,
1335                         tdomain, aclass, -1,
1336                         psymbol_placement::GLOBAL,
1337                         0, language_c, pst->context.partial_symtabs, of);
1338     }
1339 }
1340
1341 /* Add entries in data objects section to psymtab.  */
1342
1343 static void
1344 ctf_psymtab_add_stt_obj (ctf_dict_t *cfp, ctf_psymtab *pst,
1345                          struct objfile *of)
1346 {
1347   ctf_psymtab_add_stt_entries (cfp, pst, of, 0);
1348 }
1349
1350 /* Add entries in function info section to psymtab.  */
1351
1352 static void
1353 ctf_psymtab_add_stt_func (ctf_dict_t *cfp, ctf_psymtab *pst,
1354                           struct objfile *of)
1355 {
1356   ctf_psymtab_add_stt_entries (cfp, pst, of, 1);
1357 }
1358
1359 /* Read in full symbols for PST, and anything it depends on.  */
1360
1361 void
1362 ctf_psymtab::expand_psymtab (struct objfile *objfile)
1363 {
1364   struct ctf_context *ccp;
1365
1366   gdb_assert (!readin);
1367
1368   ccp = &context;
1369
1370   /* Iterate over entries in data types section.  */
1371   if (ctf_type_iter (ccp->fp, ctf_add_type_cb, ccp) == CTF_ERR)
1372     complaint (_("ctf_type_iter psymtab_to_symtab failed - %s"),
1373                ctf_errmsg (ctf_errno (ccp->fp)));
1374
1375
1376   /* Iterate over entries in variable info section.  */
1377   if (ctf_variable_iter (ccp->fp, ctf_add_var_cb, ccp) == CTF_ERR)
1378     complaint (_("ctf_variable_iter psymtab_to_symtab failed - %s"),
1379                ctf_errmsg (ctf_errno (ccp->fp)));
1380
1381   /* Add entries in data objects and function info sections.  */
1382   add_stt_obj (ccp);
1383   add_stt_func (ccp);
1384
1385   readin = true;
1386 }
1387
1388 /* Expand partial symbol table PST into a full symbol table.
1389    PST is not NULL.  */
1390
1391 void
1392 ctf_psymtab::read_symtab (struct objfile *objfile)
1393 {
1394   if (readin)
1395     warning (_("bug: psymtab for %s is already read in."), filename);
1396   else
1397     {
1398       if (info_verbose)
1399         {
1400           gdb_printf (_("Reading in CTF data for %s..."), filename);
1401           gdb_flush (gdb_stdout);
1402         }
1403
1404       /* Start a symtab.  */
1405       CORE_ADDR offset;        /* Start of text segment.  */
1406       int tsize;
1407
1408       offset = get_objfile_text_range (objfile, &tsize);
1409       ctf_start_compunit_symtab (this, objfile, offset);
1410       expand_psymtab (objfile);
1411
1412       set_text_low (offset);
1413       set_text_high (offset + tsize);
1414       compunit_symtab = ctf_end_compunit_symtab (this, offset + tsize,
1415                                                  SECT_OFF_TEXT (objfile));
1416
1417       /* Finish up the debug error message.  */
1418       if (info_verbose)
1419         gdb_printf (_("done.\n"));
1420     }
1421 }
1422
1423 /* Allocate a new partial_symtab NAME.
1424
1425    Each source file that has not been fully read in is represented by
1426    a partial_symtab.  This contains the information on where in the
1427    executable the debugging symbols for a specific file are, and a
1428    list of names of global symbols which are located in this file.
1429    They are all chained on partial symtab lists.
1430
1431    Even after the source file has been read into a symtab, the
1432    partial_symtab remains around.  They are allocated on an obstack,
1433    objfile_obstack.  */
1434
1435 static ctf_psymtab *
1436 create_partial_symtab (const char *name,
1437                        ctf_archive_t *arc,
1438                        ctf_dict_t *cfp,
1439                        psymtab_storage *partial_symtabs,
1440                        struct objfile *objfile)
1441 {
1442   ctf_psymtab *pst;
1443
1444   pst = new ctf_psymtab (name, partial_symtabs, objfile->per_bfd, 0);
1445
1446   pst->context.arc = arc;
1447   pst->context.fp = cfp;
1448   pst->context.of = objfile;
1449   pst->context.partial_symtabs = partial_symtabs;
1450   pst->context.pst = pst;
1451   pst->context.builder = nullptr;
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 /* Setup partial_symtab's describing each source file for which
1534    debugging information is available.  */
1535
1536 static void
1537 scan_partial_symbols (ctf_dict_t *cfp, psymtab_storage *partial_symtabs,
1538                       struct ctf_per_tu_data *tup, const char *fname)
1539 {
1540   struct objfile *of = tup->of;
1541   bool isparent = false;
1542
1543   if (strcmp (fname, ".ctf") == 0)
1544     {
1545       fname = bfd_get_filename (of->obfd.get ());
1546       isparent = true;
1547     }
1548
1549   ctf_psymtab *pst = create_partial_symtab (fname, tup->arc, cfp,
1550                                             partial_symtabs, of);
1551
1552   struct ctf_context *ccx = &pst->context;
1553   if (isparent == false)
1554     ccx->pst = pst;
1555
1556   if (ctf_type_iter (cfp, ctf_psymtab_type_cb, ccx) == CTF_ERR)
1557     complaint (_("ctf_type_iter scan_partial_symbols failed - %s"),
1558                ctf_errmsg (ctf_errno (cfp)));
1559
1560   if (ctf_variable_iter (cfp, ctf_psymtab_var_cb, ccx) == CTF_ERR)
1561     complaint (_("ctf_variable_iter scan_partial_symbols failed - %s"),
1562                ctf_errmsg (ctf_errno (cfp)));
1563
1564   /* Scan CTF object and function sections which correspond to each
1565      STT_FUNC or STT_OBJECT entry in the symbol table,
1566      pick up what init_symtab has done.  */
1567   ctf_psymtab_add_stt_obj (cfp, pst, of);
1568   ctf_psymtab_add_stt_func (cfp, pst, of);
1569
1570   pst->end ();
1571 }
1572
1573 /* Callback to build the psymtab for archive member NAME.  */
1574
1575 static int
1576 build_ctf_archive_member (ctf_dict_t *ctf, const char *name, void *arg)
1577 {
1578   struct ctf_per_tu_data *tup = (struct ctf_per_tu_data *) arg;
1579   ctf_dict_t *parent = tup->fp;
1580
1581   if (strcmp (name, ".ctf") != 0)
1582     ctf_import (ctf, parent);
1583
1584   if (info_verbose)
1585     {
1586       gdb_printf (_("Scanning archive member %s..."), name);
1587       gdb_flush (gdb_stdout);
1588     }
1589
1590   psymtab_storage *pss = tup->psf->get_partial_symtabs ().get ();
1591   scan_partial_symbols (ctf, pss, tup, name);
1592
1593   return 0;
1594 }
1595
1596 /* Read CTF debugging information from a BFD section.  This is
1597    called from elfread.c.  It does a quick pass through the
1598    .ctf section to set up the partial symbol table.  */
1599
1600 void
1601 elfctf_build_psymtabs (struct objfile *of)
1602 {
1603   struct ctf_per_tu_data pcu;
1604   bfd *abfd = of->obfd.get ();
1605   int err;
1606
1607   ctf_archive_t *arc = ctf_bfdopen (abfd, &err);
1608   if (arc == nullptr)
1609     error (_("ctf_bfdopen failed on %s - %s"),
1610            bfd_get_filename (abfd), ctf_errmsg (err));
1611
1612   ctf_dict_t *fp = ctf_dict_open (arc, NULL, &err);
1613   if (fp == nullptr)
1614     error (_("ctf_dict_open failed on %s - %s"),
1615            bfd_get_filename (abfd), ctf_errmsg (err));
1616   ctf_dict_key.emplace (of, fp);
1617
1618   pcu.fp = fp;
1619   pcu.of = of;
1620   pcu.arc = arc;
1621
1622   psymbol_functions *psf = new psymbol_functions ();
1623   of->qf.emplace_front (psf);
1624   pcu.psf = psf;
1625
1626   if (ctf_archive_iter (arc, build_ctf_archive_member, &pcu) < 0)
1627     error (_("ctf_archive_iter failed in input file %s: - %s"),
1628            bfd_get_filename (abfd), ctf_errmsg (err));
1629 }
1630
1631 #else
1632
1633 void
1634 elfctf_build_psymtabs (struct objfile *of)
1635 {
1636   /* Nothing to do if CTF is disabled.  */
1637 }
1638
1639 #endif /* ENABLE_LIBCTF */