/* Convert symbols from GDB to GCC
- Copyright (C) 2014-2015 Free Software Foundation, Inc.
+ Copyright (C) 2014-2018 Free Software Foundation, Inc.
This file is part of GDB.
static hashval_t
hash_symbol_error (const void *a)
{
- const struct symbol_error *se = a;
+ const struct symbol_error *se = (const struct symbol_error *) a;
return htab_hash_pointer (se->sym);
}
static int
eq_symbol_error (const void *a, const void *b)
{
- const struct symbol_error *sea = a;
- const struct symbol_error *seb = b;
+ const struct symbol_error *sea = (const struct symbol_error *) a;
+ const struct symbol_error *seb = (const struct symbol_error *) b;
return sea->sym == seb->sym;
}
static void
del_symbol_error (void *a)
{
- struct symbol_error *se = a;
+ struct symbol_error *se = (struct symbol_error *) a;
xfree (se->message);
xfree (se);
{
struct symbol_error search;
struct symbol_error *err;
- char *message;
if (context->symbol_err_map == NULL)
return;
search.sym = sym;
- err = htab_find (context->symbol_err_map, &search);
+ err = (struct symbol_error *) htab_find (context->symbol_err_map, &search);
if (err == NULL || err->message == NULL)
return;
- message = err->message;
+ gdb::unique_xmalloc_ptr<char> message (err->message);
err->message = NULL;
- make_cleanup (xfree, message);
- error (_("%s"), message);
+ error (_("%s"), message.get ());
}
\f
/* Compute the name of the pointer representing a local symbol's
address. */
-static char *
+static gdb::unique_xmalloc_ptr<char>
symbol_substitution_name (struct symbol *sym)
{
- return concat ("__", SYMBOL_NATURAL_NAME (sym), "_ptr", (char *) NULL);
+ return gdb::unique_xmalloc_ptr<char>
+ (concat ("__", SYMBOL_NATURAL_NAME (sym), "_ptr", (char *) NULL));
}
/* Convert a given symbol, SYM, to the compiler's representation.
static void
convert_one_symbol (struct compile_c_instance *context,
- struct symbol *sym,
+ struct block_symbol sym,
int is_global,
int is_local)
{
gcc_type sym_type;
- const char *filename = symbol_symtab (sym)->filename;
- unsigned short line = SYMBOL_LINE (sym);
+ const char *filename = symbol_symtab (sym.symbol)->filename;
+ unsigned short line = SYMBOL_LINE (sym.symbol);
- error_symbol_once (context, sym);
+ error_symbol_once (context, sym.symbol);
- if (SYMBOL_CLASS (sym) == LOC_LABEL)
+ if (SYMBOL_CLASS (sym.symbol) == LOC_LABEL)
sym_type = 0;
else
- sym_type = convert_type (context, SYMBOL_TYPE (sym));
+ sym_type = convert_type (context, SYMBOL_TYPE (sym.symbol));
- if (SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN)
+ if (SYMBOL_DOMAIN (sym.symbol) == STRUCT_DOMAIN)
{
/* Binding a tag, so we don't need to build a decl. */
C_CTX (context)->c_ops->tagbind (C_CTX (context),
- SYMBOL_NATURAL_NAME (sym),
+ SYMBOL_NATURAL_NAME (sym.symbol),
sym_type, filename, line);
}
else
gcc_decl decl;
enum gcc_c_symbol_kind kind;
CORE_ADDR addr = 0;
- char *symbol_name = NULL;
+ gdb::unique_xmalloc_ptr<char> symbol_name;
- switch (SYMBOL_CLASS (sym))
+ switch (SYMBOL_CLASS (sym.symbol))
{
case LOC_TYPEDEF:
kind = GCC_C_SYMBOL_TYPEDEF;
case LOC_LABEL:
kind = GCC_C_SYMBOL_LABEL;
- addr = SYMBOL_VALUE_ADDRESS (sym);
+ addr = SYMBOL_VALUE_ADDRESS (sym.symbol);
break;
case LOC_BLOCK:
kind = GCC_C_SYMBOL_FUNCTION;
- addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
- if (is_global && TYPE_GNU_IFUNC (SYMBOL_TYPE (sym)))
+ addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym.symbol));
+ if (is_global && TYPE_GNU_IFUNC (SYMBOL_TYPE (sym.symbol)))
addr = gnu_ifunc_resolve_addr (target_gdbarch (), addr);
break;
case LOC_CONST:
- if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_ENUM)
+ if (TYPE_CODE (SYMBOL_TYPE (sym.symbol)) == TYPE_CODE_ENUM)
{
/* Already handled by convert_enum. */
return;
}
- C_CTX (context)->c_ops->build_constant (C_CTX (context), sym_type,
- SYMBOL_NATURAL_NAME (sym),
- SYMBOL_VALUE (sym),
- filename, line);
+ C_CTX (context)->c_ops->build_constant
+ (C_CTX (context),
+ sym_type, SYMBOL_NATURAL_NAME (sym.symbol),
+ SYMBOL_VALUE (sym.symbol),
+ filename, line);
return;
case LOC_CONST_BYTES:
error (_("Unsupported LOC_CONST_BYTES for symbol \"%s\"."),
- SYMBOL_PRINT_NAME (sym));
+ SYMBOL_PRINT_NAME (sym.symbol));
case LOC_UNDEF:
internal_error (__FILE__, __LINE__, _("LOC_UNDEF found for \"%s\"."),
- SYMBOL_PRINT_NAME (sym));
+ SYMBOL_PRINT_NAME (sym.symbol));
case LOC_COMMON_BLOCK:
error (_("Fortran common block is unsupported for compilation "
"evaluaton of symbol \"%s\"."),
- SYMBOL_PRINT_NAME (sym));
+ SYMBOL_PRINT_NAME (sym.symbol));
case LOC_OPTIMIZED_OUT:
error (_("Symbol \"%s\" cannot be used for compilation evaluation "
"as it is optimized out."),
- SYMBOL_PRINT_NAME (sym));
+ SYMBOL_PRINT_NAME (sym.symbol));
case LOC_COMPUTED:
if (is_local)
warning (_("Symbol \"%s\" is thread-local and currently can only "
"be referenced from the current thread in "
"compiled code."),
- SYMBOL_PRINT_NAME (sym));
+ SYMBOL_PRINT_NAME (sym.symbol));
/* FALLTHROUGH */
case LOC_UNRESOLVED:
/* 'symbol_name' cannot be used here as that one is used only for
struct value *val;
struct frame_info *frame = NULL;
- if (symbol_read_needs_frame (sym))
+ if (symbol_read_needs_frame (sym.symbol))
{
frame = get_selected_frame (NULL);
if (frame == NULL)
error (_("Symbol \"%s\" cannot be used because "
"there is no selected frame"),
- SYMBOL_PRINT_NAME (sym));
+ SYMBOL_PRINT_NAME (sym.symbol));
}
- val = read_var_value (sym, frame);
+ val = read_var_value (sym.symbol, sym.block, frame);
if (VALUE_LVAL (val) != lval_memory)
error (_("Symbol \"%s\" cannot be used for compilation "
"evaluation as its address has not been found."),
- SYMBOL_PRINT_NAME (sym));
+ SYMBOL_PRINT_NAME (sym.symbol));
kind = GCC_C_SYMBOL_VARIABLE;
addr = value_address (val);
case LOC_LOCAL:
substitution:
kind = GCC_C_SYMBOL_VARIABLE;
- symbol_name = symbol_substitution_name (sym);
+ symbol_name = symbol_substitution_name (sym.symbol);
break;
case LOC_STATIC:
kind = GCC_C_SYMBOL_VARIABLE;
- addr = SYMBOL_VALUE_ADDRESS (sym);
+ addr = SYMBOL_VALUE_ADDRESS (sym.symbol);
break;
case LOC_FINAL_VALUE:
if (context->base.scope != COMPILE_I_RAW_SCOPE
|| symbol_name == NULL)
{
- decl = C_CTX (context)->c_ops->build_decl (C_CTX (context),
- SYMBOL_NATURAL_NAME (sym),
- kind,
- sym_type,
- symbol_name, addr,
- filename, line);
+ decl = C_CTX (context)->c_ops->build_decl
+ (C_CTX (context),
+ SYMBOL_NATURAL_NAME (sym.symbol),
+ kind,
+ sym_type,
+ symbol_name.get (), addr,
+ filename, line);
C_CTX (context)->c_ops->bind (C_CTX (context), decl, is_global);
}
-
- xfree (symbol_name);
}
}
fprintf_unfiltered (gdb_stdlog,
"gcc_convert_symbol \"%s\": global symbol\n",
identifier);
- convert_one_symbol (context, global_sym.symbol, 1, 0);
+ convert_one_symbol (context, global_sym, 1, 0);
}
}
fprintf_unfiltered (gdb_stdlog,
"gcc_convert_symbol \"%s\": local symbol\n",
identifier);
- convert_one_symbol (context, sym.symbol, 0, is_local_symbol);
+ convert_one_symbol (context, sym, 0, is_local_symbol);
}
/* Convert a minimal symbol to its gcc form. CONTEXT is the compiler
break;
case mst_text_gnu_ifunc:
- /* nodebug_text_gnu_ifunc_symbol would cause:
- function return type cannot be function */
- type = objfile_type (objfile)->nodebug_text_symbol;
+ type = objfile_type (objfile)->nodebug_text_gnu_ifunc_symbol;
kind = GCC_C_SYMBOL_FUNCTION;
addr = gnu_ifunc_resolve_addr (target_gdbarch (), addr);
break;
enum gcc_c_oracle_request request,
const char *identifier)
{
- struct compile_c_instance *context = datum;
+ struct compile_c_instance *context = (struct compile_c_instance *) datum;
domain_enum domain;
int found = 0;
gcc_symbol_address (void *datum, struct gcc_c_context *gcc_context,
const char *identifier)
{
- struct compile_c_instance *context = datum;
+ struct compile_c_instance *context = (struct compile_c_instance *) datum;
gcc_address result = 0;
int found = 0;
static hashval_t
hash_symname (const void *a)
{
- const struct symbol *sym = a;
+ const struct symbol *sym = (const struct symbol *) a;
return htab_hash_string (SYMBOL_NATURAL_NAME (sym));
}
static int
eq_symname (const void *a, const void *b)
{
- const struct symbol *syma = a;
- const struct symbol *symb = b;
+ const struct symbol *syma = (const struct symbol *) a;
+ const struct symbol *symb = (const struct symbol *) b;
return strcmp (SYMBOL_NATURAL_NAME (syma), SYMBOL_NATURAL_NAME (symb)) == 0;
}
static void
generate_vla_size (struct compile_c_instance *compiler,
- struct ui_file *stream,
+ string_file &stream,
struct gdbarch *gdbarch,
unsigned char *registers_used,
CORE_ADDR pc,
{
type = check_typedef (type);
- if (TYPE_CODE (type) == TYPE_CODE_REF)
+ if (TYPE_IS_REFERENCE (type))
type = check_typedef (TYPE_TARGET_TYPE (type));
switch (TYPE_CODE (type))
|| TYPE_HIGH_BOUND_KIND (type) == PROP_LOCLIST)
{
const struct dynamic_prop *prop = &TYPE_RANGE_DATA (type)->high;
- char *name = c_get_range_decl_name (prop);
- struct cleanup *cleanup = make_cleanup (xfree, name);
+ std::string name = c_get_range_decl_name (prop);
- dwarf2_compile_property_to_c (stream, name,
+ dwarf2_compile_property_to_c (stream, name.c_str (),
gdbarch, registers_used,
prop, pc, sym);
- do_cleanups (cleanup);
}
}
break;
static void
generate_c_for_for_one_variable (struct compile_c_instance *compiler,
- struct ui_file *stream,
+ string_file &stream,
struct gdbarch *gdbarch,
unsigned char *registers_used,
CORE_ADDR pc,
{
if (is_dynamic_type (SYMBOL_TYPE (sym)))
{
- struct ui_file *size_file = mem_fileopen ();
- struct cleanup *cleanup = make_cleanup_ui_file_delete (size_file);
+ /* We need to emit to a temporary buffer in case an error
+ occurs in the middle. */
+ string_file local_file;
- generate_vla_size (compiler, size_file, gdbarch, registers_used, pc,
+ generate_vla_size (compiler, local_file, gdbarch, registers_used, pc,
SYMBOL_TYPE (sym), sym);
- ui_file_put (size_file, ui_file_write_for_put, stream);
- do_cleanups (cleanup);
+ stream.write (local_file.c_str (), local_file.size ());
}
if (SYMBOL_COMPUTED_OPS (sym) != NULL)
{
- char *generated_name = symbol_substitution_name (sym);
- struct cleanup *cleanup = make_cleanup (xfree, generated_name);
+ gdb::unique_xmalloc_ptr<char> generated_name
+ = symbol_substitution_name (sym);
/* We need to emit to a temporary buffer in case an error
occurs in the middle. */
- struct ui_file *local_file = mem_fileopen ();
+ string_file local_file;
- make_cleanup_ui_file_delete (local_file);
SYMBOL_COMPUTED_OPS (sym)->generate_c_location (sym, local_file,
gdbarch,
registers_used,
- pc, generated_name);
- ui_file_put (local_file, ui_file_write_for_put, stream);
-
- do_cleanups (cleanup);
+ pc,
+ generated_name.get ());
+ stream.write (local_file.c_str (), local_file.size ());
}
else
{
unsigned char *
generate_c_for_variable_locations (struct compile_c_instance *compiler,
- struct ui_file *stream,
+ string_file &stream,
struct gdbarch *gdbarch,
const struct block *block,
CORE_ADDR pc)
{
- struct cleanup *cleanup, *outer;
- htab_t symhash;
+ struct cleanup *outer;
const struct block *static_block = block_static_block (block);
unsigned char *registers_used;
/* Ensure that a given name is only entered once. This reflects the
reality of shadowing. */
- symhash = htab_create_alloc (1, hash_symname, eq_symname, NULL,
- xcalloc, xfree);
- cleanup = make_cleanup_htab_delete (symhash);
+ htab_up symhash (htab_create_alloc (1, hash_symname, eq_symname, NULL,
+ xcalloc, xfree));
while (1)
{
sym != NULL;
sym = block_iterator_next (&iter))
{
- if (!symbol_seen (symhash, sym))
+ if (!symbol_seen (symhash.get (), sym))
generate_c_for_for_one_variable (compiler, stream, gdbarch,
registers_used, pc, sym);
}
block = BLOCK_SUPERBLOCK (block);
}
- do_cleanups (cleanup);
discard_cleanups (outer);
return registers_used;
}
projects / thirdparty / binutils-gdb.git / blobdiff