/* Convert symbols from GDB to GCC
- Copyright (C) 2014-2018 Free Software Foundation, Inc.
+ Copyright (C) 2014-2019 Free Software Foundation, Inc.
This file is part of GDB.
#include "defs.h"
#include "compile-internal.h"
+#include "compile-c.h"
#include "symtab.h"
#include "parser-defs.h"
#include "block.h"
\f
-/* Object of this type are stored in the compiler's symbol_err_map. */
-
-struct symbol_error
-{
- /* The symbol. */
-
- const struct symbol *sym;
-
- /* The error message to emit. This is malloc'd and owned by the
- hash table. */
-
- char *message;
-};
-
-/* Hash function for struct symbol_error. */
-
-static hashval_t
-hash_symbol_error (const void *a)
-{
- const struct symbol_error *se = (const struct symbol_error *) a;
-
- return htab_hash_pointer (se->sym);
-}
-
-/* Equality function for struct symbol_error. */
-
-static int
-eq_symbol_error (const void *a, const void *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;
-}
-
-/* Deletion function for struct symbol_error. */
-
-static void
-del_symbol_error (void *a)
-{
- struct symbol_error *se = (struct symbol_error *) a;
-
- xfree (se->message);
- xfree (se);
-}
-
-/* Associate SYMBOL with some error text. */
-
-static void
-insert_symbol_error (htab_t hash, const struct symbol *sym, const char *text)
-{
- struct symbol_error e;
- void **slot;
-
- e.sym = sym;
- slot = htab_find_slot (hash, &e, INSERT);
- if (*slot == NULL)
- {
- struct symbol_error *e = XNEW (struct symbol_error);
-
- e->sym = sym;
- e->message = xstrdup (text);
- *slot = e;
- }
-}
-
-/* Emit the error message corresponding to SYM, if one exists, and
- arrange for it not to be emitted again. */
-
-static void
-error_symbol_once (struct compile_c_instance *context,
- const struct symbol *sym)
-{
- struct symbol_error search;
- struct symbol_error *err;
-
- if (context->symbol_err_map == NULL)
- return;
-
- search.sym = sym;
- err = (struct symbol_error *) htab_find (context->symbol_err_map, &search);
- if (err == NULL || err->message == NULL)
- return;
-
- gdb::unique_xmalloc_ptr<char> message (err->message);
- err->message = NULL;
- error (_("%s"), message.get ());
-}
-
-\f
-
/* Compute the name of the pointer representing a local symbol's
address. */
-static gdb::unique_xmalloc_ptr<char>
-symbol_substitution_name (struct symbol *sym)
+gdb::unique_xmalloc_ptr<char>
+c_symbol_substitution_name (struct symbol *sym)
{
return gdb::unique_xmalloc_ptr<char>
- (concat ("__", SYMBOL_NATURAL_NAME (sym), "_ptr", (char *) NULL));
+ (concat ("__", sym->natural_name (), "_ptr", (char *) NULL));
}
/* Convert a given symbol, SYM, to the compiler's representation.
scope.) */
static void
-convert_one_symbol (struct compile_c_instance *context,
+convert_one_symbol (compile_c_instance *context,
struct block_symbol sym,
int is_global,
int is_local)
const char *filename = symbol_symtab (sym.symbol)->filename;
unsigned short line = SYMBOL_LINE (sym.symbol);
- error_symbol_once (context, sym.symbol);
+ context->error_symbol_once (sym.symbol);
if (SYMBOL_CLASS (sym.symbol) == LOC_LABEL)
sym_type = 0;
else
- sym_type = convert_type (context, SYMBOL_TYPE (sym.symbol));
+ sym_type = context->convert_type (SYMBOL_TYPE (sym.symbol));
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),
- sym_type, filename, line);
+ context->plugin ().tagbind (sym.symbol->natural_name (),
+ sym_type, filename, line);
}
else
{
case LOC_BLOCK:
kind = GCC_C_SYMBOL_FUNCTION;
- addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym.symbol));
+ addr = BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym.symbol));
if (is_global && TYPE_GNU_IFUNC (SYMBOL_TYPE (sym.symbol)))
addr = gnu_ifunc_resolve_addr (target_gdbarch (), addr);
break;
/* Already handled by convert_enum. */
return;
}
- C_CTX (context)->c_ops->build_constant
- (C_CTX (context),
- sym_type, SYMBOL_NATURAL_NAME (sym.symbol),
+ context->plugin ().build_constant
+ (sym_type, sym.symbol->natural_name (),
SYMBOL_VALUE (sym.symbol),
filename, line);
return;
case LOC_CONST_BYTES:
error (_("Unsupported LOC_CONST_BYTES for symbol \"%s\"."),
- SYMBOL_PRINT_NAME (sym.symbol));
+ sym.symbol->print_name ());
case LOC_UNDEF:
internal_error (__FILE__, __LINE__, _("LOC_UNDEF found for \"%s\"."),
- SYMBOL_PRINT_NAME (sym.symbol));
+ sym.symbol->print_name ());
case LOC_COMMON_BLOCK:
error (_("Fortran common block is unsupported for compilation "
"evaluaton of symbol \"%s\"."),
- SYMBOL_PRINT_NAME (sym.symbol));
+ sym.symbol->print_name ());
case LOC_OPTIMIZED_OUT:
error (_("Symbol \"%s\" cannot be used for compilation evaluation "
"as it is optimized out."),
- SYMBOL_PRINT_NAME (sym.symbol));
+ sym.symbol->print_name ());
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));
+ sym.symbol->print_name ());
/* FALLTHROUGH */
case LOC_UNRESOLVED:
/* 'symbol_name' cannot be used here as that one is used only for
if (frame == NULL)
error (_("Symbol \"%s\" cannot be used because "
"there is no selected frame"),
- SYMBOL_PRINT_NAME (sym.symbol));
+ sym.symbol->print_name ());
}
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));
+ sym.symbol->print_name ());
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);
+ symbol_name = c_symbol_substitution_name (sym.symbol);
break;
case LOC_STATIC:
}
/* Don't emit local variable decls for a raw expression. */
- if (context->base.scope != COMPILE_I_RAW_SCOPE
+ if (context->scope () != COMPILE_I_RAW_SCOPE
|| symbol_name == NULL)
{
- decl = C_CTX (context)->c_ops->build_decl
- (C_CTX (context),
- SYMBOL_NATURAL_NAME (sym.symbol),
+ decl = context->plugin ().build_decl
+ (sym.symbol->natural_name (),
kind,
sym_type,
symbol_name.get (), addr,
filename, line);
- C_CTX (context)->c_ops->bind (C_CTX (context), decl, is_global);
+ context->plugin ().bind (decl, is_global);
}
}
}
itself, and DOMAIN is the domain which was searched. */
static void
-convert_symbol_sym (struct compile_c_instance *context, const char *identifier,
+convert_symbol_sym (compile_c_instance *context, const char *identifier,
struct block_symbol sym, domain_enum domain)
{
const struct block *static_block;
to use and BMSYM is the minimal symbol to convert. */
static void
-convert_symbol_bmsym (struct compile_c_instance *context,
+convert_symbol_bmsym (compile_c_instance *context,
struct bound_minimal_symbol bmsym)
{
struct minimal_symbol *msym = bmsym.minsym;
break;
}
- sym_type = convert_type (context, type);
- decl = C_CTX (context)->c_ops->build_decl (C_CTX (context),
- MSYMBOL_NATURAL_NAME (msym),
- kind, sym_type, NULL, addr,
- NULL, 0);
- C_CTX (context)->c_ops->bind (C_CTX (context), decl, 1 /* is_global */);
+ sym_type = context->convert_type (type);
+ decl = context->plugin ().build_decl (msym->natural_name (),
+ kind, sym_type, NULL, addr,
+ NULL, 0);
+ context->plugin ().bind (decl, 1 /* is_global */);
}
/* See compile-internal.h. */
enum gcc_c_oracle_request request,
const char *identifier)
{
- struct compile_c_instance *context = (struct compile_c_instance *) datum;
+ compile_c_instance *context
+ = static_cast<compile_c_instance *> (datum);
domain_enum domain;
int found = 0;
/* We can't allow exceptions to escape out of this callback. Safest
is to simply emit a gcc error. */
- TRY
+ try
{
struct block_symbol sym;
- sym = lookup_symbol (identifier, context->base.block, domain, NULL);
+ sym = lookup_symbol (identifier, context->block (), domain, NULL);
if (sym.symbol != NULL)
{
convert_symbol_sym (context, identifier, sym, domain);
}
}
- CATCH (e, RETURN_MASK_ALL)
+ catch (const gdb_exception &e)
{
- C_CTX (context)->c_ops->error (C_CTX (context), e.message);
+ context->plugin ().error (e.what ());
}
- END_CATCH
if (compile_debug && !found)
fprintf_unfiltered (gdb_stdlog,
gcc_symbol_address (void *datum, struct gcc_c_context *gcc_context,
const char *identifier)
{
- struct compile_c_instance *context = (struct compile_c_instance *) datum;
+ compile_c_instance *context
+ = static_cast<compile_c_instance *> (datum);
gcc_address result = 0;
int found = 0;
/* We can't allow exceptions to escape out of this callback. Safest
is to simply emit a gcc error. */
- TRY
+ try
{
struct symbol *sym;
fprintf_unfiltered (gdb_stdlog,
"gcc_symbol_address \"%s\": full symbol\n",
identifier);
- result = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
+ result = BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym));
if (TYPE_GNU_IFUNC (SYMBOL_TYPE (sym)))
result = gnu_ifunc_resolve_addr (target_gdbarch (), result);
found = 1;
}
}
- CATCH (e, RETURN_MASK_ERROR)
+ catch (const gdb_exception_error &e)
{
- C_CTX (context)->c_ops->error (C_CTX (context), e.message);
+ context->plugin ().error (e.what ());
}
- END_CATCH
if (compile_debug && !found)
fprintf_unfiltered (gdb_stdlog,
{
const struct symbol *sym = (const struct symbol *) a;
- return htab_hash_string (SYMBOL_NATURAL_NAME (sym));
+ return htab_hash_string (sym->natural_name ());
}
/* A comparison function for hash tables that just looks at symbol
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;
+ return strcmp (syma->natural_name (), symb->natural_name ()) == 0;
}
/* If a symbol with the same name as SYM is already in HASHTAB, return
/* Generate C code to compute the length of a VLA. */
static void
-generate_vla_size (struct compile_c_instance *compiler,
- string_file &stream,
+generate_vla_size (compile_instance *compiler,
+ string_file *stream,
struct gdbarch *gdbarch,
unsigned char *registers_used,
CORE_ADDR pc,
/* Generate C code to compute the address of SYM. */
static void
-generate_c_for_for_one_variable (struct compile_c_instance *compiler,
- string_file &stream,
+generate_c_for_for_one_variable (compile_instance *compiler,
+ string_file *stream,
struct gdbarch *gdbarch,
unsigned char *registers_used,
CORE_ADDR pc,
struct symbol *sym)
{
- TRY
+ try
{
if (is_dynamic_type (SYMBOL_TYPE (sym)))
{
occurs in the middle. */
string_file local_file;
- generate_vla_size (compiler, local_file, gdbarch, registers_used, pc,
+ generate_vla_size (compiler, &local_file, gdbarch, registers_used, pc,
SYMBOL_TYPE (sym), sym);
- stream.write (local_file.c_str (), local_file.size ());
+ stream->write (local_file.c_str (), local_file.size ());
}
if (SYMBOL_COMPUTED_OPS (sym) != NULL)
{
gdb::unique_xmalloc_ptr<char> generated_name
- = symbol_substitution_name (sym);
+ = c_symbol_substitution_name (sym);
/* We need to emit to a temporary buffer in case an error
occurs in the middle. */
string_file local_file;
- SYMBOL_COMPUTED_OPS (sym)->generate_c_location (sym, local_file,
+ SYMBOL_COMPUTED_OPS (sym)->generate_c_location (sym, &local_file,
gdbarch,
registers_used,
pc,
generated_name.get ());
- stream.write (local_file.c_str (), local_file.size ());
+ stream->write (local_file.c_str (), local_file.size ());
}
else
{
}
}
- CATCH (e, RETURN_MASK_ERROR)
+ catch (const gdb_exception_error &e)
{
- if (compiler->symbol_err_map == NULL)
- compiler->symbol_err_map = htab_create_alloc (10,
- hash_symbol_error,
- eq_symbol_error,
- del_symbol_error,
- xcalloc,
- xfree);
- insert_symbol_error (compiler->symbol_err_map, sym, e.message);
+ compiler->insert_symbol_error (sym, e.what ());
}
- END_CATCH
}
-/* See compile-internal.h. */
+/* See compile-c.h. */
gdb::unique_xmalloc_ptr<unsigned char>
-generate_c_for_variable_locations (struct compile_c_instance *compiler,
- string_file &stream,
+generate_c_for_variable_locations (compile_instance *compiler,
+ string_file *stream,
struct gdbarch *gdbarch,
const struct block *block,
CORE_ADDR pc)
projects / deliverable / binutils-gdb.git / blobdiff