The file header stores a magic number and version information, encoding
flags, and the byte offset of each of the sections relative to the end of the
header itself. If the CTF data has been uniquified against another set of
- CTF data, a reference to that data also appears in the the header. This
+ CTF data, a reference to that data also appears in the header. This
reference is the name of the label corresponding to the types uniquified
against.
struct ctf_fp_info
{
- explicit ctf_fp_info (ctf_file_t *cfp) : fp (cfp) {}
- ~ctf_fp_info ();
- ctf_file_t *fp;
+ explicit ctf_fp_info (ctf_file_t *cfp) : fp (cfp) {}
+ ~ctf_fp_info ();
+ ctf_file_t *fp;
};
/* Cleanup function for the ctf_file_key data. */
struct buildsym_compunit *builder;
};
+/* A partial symtab, specialized for this module. */
+struct ctf_psymtab : public standard_psymtab
+{
+ ctf_psymtab (const char *filename, struct objfile *objfile, CORE_ADDR addr)
+ : standard_psymtab (filename, objfile, addr)
+ {
+ }
+
+ void read_symtab (struct objfile *) override;
+ void expand_psymtab (struct objfile *) override;
+
+ struct ctf_context *context;
+};
+
/* The routines that read and process fields/members of a C struct, union,
or enumeration, pass lists of data member fields in an instance of a
ctf_field_info structure. It is derived from dwarf2read.c. */
/* Local function prototypes */
-static void psymtab_to_symtab (struct partial_symtab *);
-
static int ctf_add_type_cb (ctf_id_t tid, void *arg);
static struct type *read_array_type (struct ctf_context *cp, ctf_id_t tid);
return;
/* Record the field count, allocate space for the array of fields. */
- TYPE_NFIELDS (type) = nfields;
- TYPE_FIELDS (type)
- = (struct field *) TYPE_ZALLOC (type, sizeof (struct field) * nfields);
+ type->set_num_fields (nfields);
+ type->set_fields
+ ((struct field *) TYPE_ZALLOC (type, sizeof (struct field) * nfields));
/* Copy the saved-up fields into the field vector. */
for (int i = 0; i < nfields; ++i)
{
struct ctf_nextfield &field = fip->fields[i];
- TYPE_FIELD (type, i) = field.field;
+ type->field (i) = field.field;
}
}
const char *name,
const char *name_hint)
{
- struct gdbarch *gdbarch = get_objfile_arch (objfile);
+ struct gdbarch *gdbarch = objfile->arch ();
const struct floatformat **format;
struct type *type;
if (name != NULL)
{
- struct symbol *sym = allocate_symbol (ccp->of);
+ struct symbol *sym = new (&ccp->of->objfile_obstack) symbol;
OBJSTAT (ccp->of, n_syms++);
sym->set_language (language_c, &ccp->of->objfile_obstack);
gdb::unique_xmalloc_ptr<char> name (ctf_type_aname_raw (fp, tid));
if (name != NULL)
{
- sym = allocate_symbol (objfile);
+ sym = new (&objfile->objfile_obstack) symbol;
OBJSTAT (objfile, n_syms++);
sym->set_language (language_c, &objfile->objfile_obstack);
SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
break;
case CTF_K_CONST:
- if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_VOID)
+ if (SYMBOL_TYPE (sym)->code () == TYPE_CODE_VOID)
SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_int;
break;
case CTF_K_TYPEDEF:
if (kind == CTF_K_INTEGER)
{
uint32_t issigned, ischar, isbool;
- struct gdbarch *gdbarch = get_objfile_arch (of);
+ struct gdbarch *gdbarch = of->arch ();
issigned = cet.cte_format & CTF_INT_SIGNED;
ischar = cet.cte_format & CTF_INT_CHAR;
{
struct type *t
= ctf_init_float_type (of, cet.cte_bits / 2, NULL, name);
- type = init_complex_type (of, name, t);
+ type = init_complex_type (name, t);
}
}
else
gdb::unique_xmalloc_ptr<char> name (ctf_type_aname_raw (fp, tid));
if (name != NULL && strlen (name.get() ) != 0)
- TYPE_NAME (type) = obstack_strdup (&of->objfile_obstack, name.get ());
+ type->set_name (obstack_strdup (&of->objfile_obstack, name.get ()));
kind = ctf_type_kind (fp, tid);
if (kind == CTF_K_UNION)
- TYPE_CODE (type) = TYPE_CODE_UNION;
+ type->set_code (TYPE_CODE_UNION);
else
- TYPE_CODE (type) = TYPE_CODE_STRUCT;
+ type->set_code (TYPE_CODE_STRUCT);
TYPE_LENGTH (type) = ctf_type_size (fp, tid);
set_type_align (type, ctf_type_align (fp, tid));
gdb::unique_xmalloc_ptr<char> name (ctf_type_aname_raw (fp, tid));
if (name != NULL && strlen (name.get ()) != 0)
- TYPE_NAME (type) = obstack_strdup (&of->objfile_obstack, name.get ());
+ type->set_name (obstack_strdup (&of->objfile_obstack, name.get ()));
- TYPE_CODE (type) = TYPE_CODE_FUNC;
+ type->set_code (TYPE_CODE_FUNC);
ctf_func_type_info (fp, tid, &cfi);
rettype = get_tid_type (of, cfi.ctc_return);
TYPE_TARGET_TYPE (type) = rettype;
gdb::unique_xmalloc_ptr<char> name (ctf_type_aname_raw (fp, tid));
if (name != NULL && strlen (name.get ()) != 0)
- TYPE_NAME (type) = obstack_strdup (&of->objfile_obstack, name.get ());
+ type->set_name (obstack_strdup (&of->objfile_obstack, name.get ()));
- TYPE_CODE (type) = TYPE_CODE_ENUM;
+ type->set_code (TYPE_CODE_ENUM);
TYPE_LENGTH (type) = ctf_type_size (fp, tid);
ctf_func_type_info (fp, tid, &fi);
target_type = get_tid_type (of, fi.ctc_return);
base_type = copy_type (base_type);
inner_array = base_type;
- while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY)
+ while (TYPE_TARGET_TYPE (inner_array)->code () == TYPE_CODE_ARRAY)
{
TYPE_TARGET_TYPE (inner_array)
= copy_type (TYPE_TARGET_TYPE (inner_array));
complaint (_("ctf_add_var_cb: %s has NO type (%ld)"), name, id);
type = objfile_type (ccp->of)->builtin_error;
}
- sym = allocate_symbol (ccp->of);
+ sym = new (&ccp->of->objfile_obstack) symbol;
OBJSTAT (ccp->of, n_syms++);
SYMBOL_TYPE (sym) = type;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
ftype = get_tid_type (ccp->of, tid);
if (finfo.ctc_flags & CTF_FUNC_VARARG)
TYPE_VARARGS (ftype) = 1;
- TYPE_NFIELDS (ftype) = argc;
+ ftype->set_num_fields (argc);
/* If argc is 0, it has a "void" type. */
if (argc != 0)
- TYPE_FIELDS (ftype)
- = (struct field *) TYPE_ZALLOC (ftype, argc * sizeof (struct field));
+ ftype->set_fields
+ ((struct field *) TYPE_ZALLOC (ftype, argc * sizeof (struct field)));
/* TYPE_FIELD_TYPE must never be NULL. Fill it with void_type, if failed
to find the argument type. */
/* Start a symtab for OBJFILE in CTF format. */
static void
-ctf_start_symtab (struct partial_symtab *pst,
+ctf_start_symtab (ctf_psymtab *pst,
struct objfile *of, CORE_ADDR text_offset)
{
struct ctf_context *ccp;
- ccp = (struct ctf_context *) pst->read_symtab_private;
+ ccp = pst->context;
ccp->builder = new buildsym_compunit
(of, of->original_name, NULL,
language_c, text_offset);
the .text section number. */
static struct compunit_symtab *
-ctf_end_symtab (struct partial_symtab *pst,
+ctf_end_symtab (ctf_psymtab *pst,
CORE_ADDR end_addr, int section)
{
struct ctf_context *ccp;
- ccp = (struct ctf_context *) pst->read_symtab_private;
+ ccp = pst->context;
struct compunit_symtab *result
= ccp->builder->end_symtab (end_addr, section);
delete ccp->builder;
/* Read in full symbols for PST, and anything it depends on. */
-static void
-psymtab_to_symtab (struct partial_symtab *pst)
+void
+ctf_psymtab::expand_psymtab (struct objfile *objfile)
{
struct symbol *sym;
struct ctf_context *ccp;
- gdb_assert (!pst->readin);
+ gdb_assert (!readin);
- ccp = (struct ctf_context *) pst->read_symtab_private;
+ ccp = context;
/* Iterate over entries in data types section. */
if (ctf_type_iter (ccp->fp, ctf_add_type_cb, ccp) == CTF_ERR)
set_symbol_address (ccp->of, sym, sym->linkage_name ());
}
- pst->readin = true;
+ readin = true;
}
/* Expand partial symbol table PST into a full symbol table.
PST is not NULL. */
-static void
-ctf_read_symtab (struct partial_symtab *pst, struct objfile *objfile)
+void
+ctf_psymtab::read_symtab (struct objfile *objfile)
{
- if (pst->readin)
- warning (_("bug: psymtab for %s is already read in."), pst->filename);
+ if (readin)
+ warning (_("bug: psymtab for %s is already read in."), filename);
else
{
if (info_verbose)
{
- printf_filtered (_("Reading in CTF data for %s..."), pst->filename);
+ printf_filtered (_("Reading in CTF data for %s..."), filename);
gdb_flush (gdb_stdout);
}
/* Start a symtab. */
- CORE_ADDR text_offset; /* Start of text segment. */
+ CORE_ADDR offset; /* Start of text segment. */
int tsize;
- text_offset = get_objfile_text_range (objfile, &tsize);
- ctf_start_symtab (pst, objfile, text_offset);
- psymtab_to_symtab (pst);
+ offset = get_objfile_text_range (objfile, &tsize);
+ ctf_start_symtab (this, objfile, offset);
+ expand_psymtab (objfile);
- pst->set_text_low (text_offset);
- pst->set_text_high (text_offset + tsize);
- pst->compunit_symtab = ctf_end_symtab (pst, text_offset + tsize,
- SECT_OFF_TEXT (objfile));
+ set_text_low (offset);
+ set_text_high (offset + tsize);
+ compunit_symtab = ctf_end_symtab (this, offset + tsize,
+ SECT_OFF_TEXT (objfile));
/* Finish up the debug error message. */
if (info_verbose)
partial_symtab remains around. They are allocated on an obstack,
objfile_obstack. */
-static struct partial_symtab *
+static ctf_psymtab *
create_partial_symtab (const char *name,
ctf_file_t *cfp,
struct objfile *objfile)
{
- struct partial_symtab *pst;
+ ctf_psymtab *pst;
struct ctf_context *ccx;
- pst = start_psymtab_common (objfile, name, 0);
+ pst = new ctf_psymtab (name, objfile, 0);
ccx = XOBNEW (&objfile->objfile_obstack, struct ctf_context);
ccx->fp = cfp;
ccx->of = objfile;
- pst->read_symtab_private = (void *) ccx;
- pst->read_symtab = ctf_read_symtab;
+ pst->context = ccx;
return pst;
}
struct ctf_context ccx;
bfd *abfd = of->obfd;
const char *name = bfd_get_filename (abfd);
- struct partial_symtab *pst = create_partial_symtab (name, cfp, of);
+ ctf_psymtab *pst = create_partial_symtab (name, cfp, of);
ccx.fp = cfp;
ccx.of = of;
scan_partial_symbols (fp, of);
}
-
-void _initialize_ctfread ();
-void
-_initialize_ctfread ()
-{
-}
projects / deliverable / binutils-gdb.git / blobdiff