static struct type *
find_function_return_type (CORE_ADDR pc)
{
struct symbol *sym = find_pc_function (pc);
if (sym != NULL && BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) == pc
&& SYMBOL_TYPE (sym) != NULL)
return TYPE_TARGET_TYPE (SYMBOL_TYPE (sym));
return NULL;
}
static SCM
gdbscm_symbol_type (SCM self)
{
symbol_smob *s_smob
= syscm_get_valid_symbol_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
const struct symbol *symbol = s_smob->symbol;
if (SYMBOL_TYPE (symbol) == NULL)
return SCM_BOOL_F;
return tyscm_scm_from_type (SYMBOL_TYPE (symbol));
}
void
c_print_typedef (struct type *type, struct symbol *new_symbol,
struct ui_file *stream)
{
CHECK_TYPEDEF (type);
fprintf_filtered (stream, "typedef ");
type_print (type, "", stream, 0);
if (TYPE_NAME ((SYMBOL_TYPE (new_symbol))) == 0
|| strcmp (TYPE_NAME ((SYMBOL_TYPE (new_symbol))),
SYMBOL_LINKAGE_NAME (new_symbol)) != 0)
fprintf_filtered (stream, " %s", SYMBOL_PRINT_NAME (new_symbol));
fprintf_filtered (stream, ";\n");
}
/* Evaluate a location description, starting at DATA and with length
SIZE, to find the current location of variable VAR in the context
of FRAME. */
static struct value *
dwarf2_evaluate_loc_desc (struct symbol *var, struct frame_info *frame,
unsigned char *data, unsigned short size,
struct objfile *objfile)
{
CORE_ADDR result;
struct value *retval;
struct dwarf_expr_baton baton;
struct dwarf_expr_context *ctx;
if (size == 0)
{
retval = allocate_value (SYMBOL_TYPE (var));
VALUE_LVAL (retval) = not_lval;
VALUE_OPTIMIZED_OUT (retval) = 1;
}
baton.frame = frame;
baton.objfile = objfile;
ctx = new_dwarf_expr_context ();
ctx->baton = &baton;
ctx->read_reg = dwarf_expr_read_reg;
ctx->read_mem = dwarf_expr_read_mem;
ctx->get_frame_base = dwarf_expr_frame_base;
ctx->get_tls_address = dwarf_expr_tls_address;
dwarf_expr_eval (ctx, data, size);
result = dwarf_expr_fetch (ctx, 0);
if (ctx->in_reg)
{
int regnum = DWARF2_REG_TO_REGNUM (result);
retval = value_from_register (SYMBOL_TYPE (var), regnum, frame);
}
else
{
retval = allocate_value (SYMBOL_TYPE (var));
VALUE_BFD_SECTION (retval) = SYMBOL_BFD_SECTION (var);
VALUE_LVAL (retval) = lval_memory;
VALUE_LAZY (retval) = 1;
VALUE_ADDRESS (retval) = result;
}
free_dwarf_expr_context (ctx);
return retval;
}
void
m2_print_typedef (struct type *type, struct symbol *new_symbol,
struct ui_file *stream)
{
CHECK_TYPEDEF (type);
fprintf_filtered (stream, "TYPE ");
if (!TYPE_NAME (SYMBOL_TYPE (new_symbol))
|| strcmp (TYPE_NAME ((SYMBOL_TYPE (new_symbol))),
SYMBOL_LINKAGE_NAME (new_symbol)) != 0)
fprintf_filtered (stream, "%s = ", SYMBOL_PRINT_NAME (new_symbol));
else
fprintf_filtered (stream, "<builtin> = ");
type_print (type, "", stream, 0);
fprintf_filtered (stream, ";\n");
}
static PyObject *
sympy_get_type (PyObject *self, void *closure)
{
struct symbol *symbol = NULL;
SYMPY_REQUIRE_VALID (self, symbol);
if (SYMBOL_TYPE (symbol) == NULL)
{
Py_INCREF (Py_None);
return Py_None;
}
return type_to_type_object (SYMBOL_TYPE (symbol));
}
/*
* typeletter()
* return a description letter for the given basic type code of an
* symbol table entry. The return value will be upper case for
* external, lower case for internal symbols.
*/
char
typeletter(struct nlist *np, int aout)
{
int ext = IS_EXTERNAL(np->n_type);
if (!aout && !IS_DEBUGGER_SYMBOL(np->n_type) && np->n_other)
return np->n_other;
switch(SYMBOL_TYPE(np->n_type)) {
case N_ABS:
return(ext? 'A' : 'a');
case N_BSS:
return(ext? 'B' : 'b');
case N_COMM:
return(ext? 'C' : 'c');
case N_DATA:
return(ext? 'D' : 'd');
case N_FN:
/* NOTE: N_FN == N_WARNING,
* in this case, the N_EXT bit is to considered as
* part of the symbol's type itself.
*/
return(ext? 'F' : 'W');
case N_TEXT:
return(ext? 'T' : 't');
case N_INDR:
return(ext? 'I' : 'i');
case N_SIZE:
return(ext? 'S' : 's');
case N_UNDF:
return(ext? 'U' : 'u');
}
return('?');
}
static struct type *
get_regs_type (struct symbol *func_sym, struct objfile *objfile)
{
struct type *func_type = SYMBOL_TYPE (func_sym);
struct type *regsp_type, *regs_type;
/* No register parameter present. */
if (TYPE_NFIELDS (func_type) == 0)
return NULL;
regsp_type = check_typedef (TYPE_FIELD_TYPE (func_type, 0));
if (TYPE_CODE (regsp_type) != TYPE_CODE_PTR)
error (_("Invalid type code %d of first parameter of function \"%s\" "
"in compiled module \"%s\"."),
TYPE_CODE (regsp_type), GCC_FE_WRAPPER_FUNCTION,
objfile_name (objfile));
regs_type = check_typedef (TYPE_TARGET_TYPE (regsp_type));
if (TYPE_CODE (regs_type) != TYPE_CODE_STRUCT)
error (_("Invalid type code %d of dereferenced first parameter "
"of function \"%s\" in compiled module \"%s\"."),
TYPE_CODE (regs_type), GCC_FE_WRAPPER_FUNCTION,
objfile_name (objfile));
return regs_type;
}
//set info_type to var type
node *CTvar(node *arg_node, info *arg_info){
DBUG_ENTER("CTvar");
INFO_TYPE(arg_info) = SYMBOL_TYPE(VAR_DECL(arg_node));
DBUG_RETURN(arg_node);
}
struct sparc_frame_cache *
sparc32_frame_cache (struct frame_info *next_frame, void **this_cache)
{
struct sparc_frame_cache *cache;
struct symbol *sym;
if (*this_cache)
return *this_cache;
cache = sparc_frame_cache (next_frame, this_cache);
sym = find_pc_function (cache->pc);
if (sym)
{
struct type *type = check_typedef (SYMBOL_TYPE (sym));
enum type_code code = TYPE_CODE (type);
if (code == TYPE_CODE_FUNC || code == TYPE_CODE_METHOD)
{
type = check_typedef (TYPE_TARGET_TYPE (type));
if (sparc_structure_or_union_p (type)
|| (sparc_floating_p (type) && TYPE_LENGTH (type) == 16))
cache->struct_return_p = 1;
}
}
return cache;
}
struct type *
lang_bool_type (void)
{
struct symbol *sym;
struct type *type;
switch (current_language->la_language)
{
case language_fortran:
sym = lookup_symbol ("logical", NULL, VAR_DOMAIN, NULL, NULL);
if (sym)
{
type = SYMBOL_TYPE (sym);
if (type && TYPE_CODE (type) == TYPE_CODE_BOOL)
return type;
}
return builtin_type_f_logical_s2;
case language_cplus:
case language_pascal:
if (current_language->la_language==language_cplus)
{
sym = lookup_symbol ("bool", NULL, VAR_DOMAIN, NULL, NULL);
}
else
{
sym = lookup_symbol ("boolean", NULL, VAR_DOMAIN, NULL, NULL);
}
if (sym)
{
type = SYMBOL_TYPE (sym);
if (type && TYPE_CODE (type) == TYPE_CODE_BOOL)
return type;
}
return builtin_type_bool;
case language_java:
sym = lookup_symbol ("boolean", NULL, VAR_DOMAIN, NULL, NULL);
if (sym)
{
type = SYMBOL_TYPE (sym);
if (type && TYPE_CODE (type) == TYPE_CODE_BOOL)
return type;
}
return java_boolean_type;
default:
return builtin_type_int;
}
}
static void
expand_token (struct obstack *obs, token_type t, token_data *td, int line)
{
symbol *sym;
switch (t)
{ /* TOKSW */
case TOKEN_EOF:
case TOKEN_MACDEF:
break;
case TOKEN_OPEN:
case TOKEN_COMMA:
case TOKEN_CLOSE:
case TOKEN_SIMPLE:
case TOKEN_STRING:
shipout_text (obs, TOKEN_DATA_TEXT (td), strlen (TOKEN_DATA_TEXT (td)),
line);
break;
case TOKEN_WORD:
sym = lookup_symbol (TOKEN_DATA_TEXT (td), SYMBOL_LOOKUP);
if (sym == NULL || SYMBOL_TYPE (sym) == TOKEN_VOID
|| (SYMBOL_TYPE (sym) == TOKEN_FUNC
&& SYMBOL_BLIND_NO_ARGS (sym)
&& peek_token () != TOKEN_OPEN))
{
#ifdef ENABLE_CHANGEWORD
shipout_text (obs, TOKEN_DATA_ORIG_TEXT (td),
strlen (TOKEN_DATA_ORIG_TEXT (td)), line);
#else
shipout_text (obs, TOKEN_DATA_TEXT (td),
strlen (TOKEN_DATA_TEXT (td)), line);
#endif
}
else
expand_macro (sym);
break;
default:
M4ERROR ((warning_status, 0,
"INTERNAL ERROR: bad token type in expand_token ()"));
abort ();
}
}
void
typedef_print(struct type *type, struct symbol *newsym,
struct ui_file *stream)
{
CHECK_TYPEDEF(type);
switch (current_language->la_language)
{
#ifdef _LANG_c
case language_c:
case language_cplus:
case language_objc:
case language_objcplus:
fprintf_filtered(stream, "typedef ");
type_print(type, "", stream, 0);
if ((TYPE_NAME((SYMBOL_TYPE(newsym))) == 0)
|| (strcmp(TYPE_NAME((SYMBOL_TYPE(newsym))),
DEPRECATED_SYMBOL_NAME(newsym)) != 0))
fprintf_filtered(stream, " %s", SYMBOL_PRINT_NAME(newsym));
break;
#endif /* _LANG_c */
#ifdef _LANG_m2
case language_m2:
fprintf_filtered(stream, "TYPE ");
if (!TYPE_NAME(SYMBOL_TYPE(newsym))
|| (strcmp(TYPE_NAME((SYMBOL_TYPE(newsym))),
DEPRECATED_SYMBOL_NAME(newsym)) != 0))
fprintf_filtered(stream, "%s = ", SYMBOL_PRINT_NAME(newsym));
else
fprintf_filtered(stream, "<builtin> = ");
type_print(type, "", stream, 0);
break;
#endif /* _LANG_m2 */
#ifdef _LANG_pascal
case language_pascal:
fprintf_filtered(stream, "type ");
fprintf_filtered(stream, "%s = ", SYMBOL_PRINT_NAME(newsym));
type_print(type, "", stream, 0);
break;
#endif /* _LANG_pascal */
default:
error(_("Language not supported."));
}
fprintf_filtered(stream, ";\n");
}
struct type *
get_java_object_type (void)
{
struct symbol *sym;
sym = lookup_symbol ("java.lang.Object", NULL, STRUCT_DOMAIN, NULL);
if (sym == NULL)
error (_("cannot find java.lang.Object"));
return SYMBOL_TYPE (sym);
}
struct type *
find_function_type (CORE_ADDR pc)
{
struct symbol *sym = find_pc_function (pc);
if (sym != NULL && BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym)) == pc)
return SYMBOL_TYPE (sym);
return NULL;
}
struct type *
java_lookup_class (char *name)
{
struct symbol *sym;
sym = lookup_symbol (name, expression_context_block, STRUCT_DOMAIN, NULL);
if (sym != NULL)
return SYMBOL_TYPE (sym);
/* FIXME - should search inferior's symbol table. */
return NULL;
}
static struct block_symbol
cp_search_static_and_baseclasses (const char *name,
const struct block *block,
const domain_enum domain,
unsigned int prefix_len,
int is_in_anonymous)
{
struct block_symbol sym;
char *klass, *nested;
struct cleanup *cleanup;
struct block_symbol klass_sym;
struct type *klass_type;
/* The test here uses <= instead of < because Fortran also uses this,
and the module.exp testcase will pass "modmany::" for NAME here. */
gdb_assert (prefix_len + 2 <= strlen (name));
gdb_assert (name[prefix_len + 1] == ':');
/* Find the name of the class and the name of the method, variable, etc. */
/* The class name is everything up to and including PREFIX_LEN. */
klass = savestring (name, prefix_len);
/* The rest of the name is everything else past the initial scope
operator. */
nested = xstrdup (name + prefix_len + 2);
/* Add cleanups to free memory for these strings. */
cleanup = make_cleanup (xfree, klass);
make_cleanup (xfree, nested);
/* Lookup a class named KLASS. If none is found, there is nothing
more that can be done. KLASS could be a namespace, so always look
in VAR_DOMAIN. This works for classes too because of
symbol_matches_domain (which should be replaced with something else,
but it's what we have today). */
klass_sym = lookup_global_symbol (klass, block, VAR_DOMAIN);
if (klass_sym.symbol == NULL)
{
do_cleanups (cleanup);
return null_block_symbol;
}
klass_type = SYMBOL_TYPE (klass_sym.symbol);
/* Look for a symbol named NESTED in this class.
The caller is assumed to have already have done a basic lookup of NAME.
So we pass zero for BASIC_LOOKUP to cp_lookup_nested_symbol_1 here. */
sym = cp_lookup_nested_symbol_1 (klass_type, nested, name, block, domain,
0, is_in_anonymous);
do_cleanups (cleanup);
return sym;
}
int
value(const void *a0, const void *b0)
{
struct nlist * const *a = a0, * const *b = b0;
if (SYMBOL_TYPE((*a)->n_type) == N_UNDF)
if (SYMBOL_TYPE((*b)->n_type) == N_UNDF)
return(0);
else
return(-1);
else if (SYMBOL_TYPE((*b)->n_type) == N_UNDF)
return(1);
if (rev) {
if ((*a)->n_value == (*b)->n_value)
return(rname(a0, b0));
return((*b)->n_value > (*a)->n_value ? 1 : -1);
} else {
if ((*a)->n_value == (*b)->n_value)
return(fname(a0, b0));
return((*a)->n_value > (*b)->n_value ? 1 : -1);
}
}
struct value *
value_nsstring (struct gdbarch *gdbarch, char *ptr, int len)
{
struct type *char_type = builtin_type (gdbarch)->builtin_char;
struct value *stringValue[3];
struct value *function, *nsstringValue;
struct symbol *sym;
struct type *type;
if (!target_has_execution)
return 0; /* Can't call into inferior to create NSString. */
stringValue[2] = value_string(ptr, len, char_type);
stringValue[2] = value_coerce_array(stringValue[2]);
/* _NSNewStringFromCString replaces "istr" after Lantern2A. */
if (lookup_minimal_symbol("_NSNewStringFromCString", 0, 0).minsym)
{
function = find_function_in_inferior("_NSNewStringFromCString", NULL);
nsstringValue = call_function_by_hand(function, 1, &stringValue[2]);
}
else if (lookup_minimal_symbol("istr", 0, 0).minsym)
{
function = find_function_in_inferior("istr", NULL);
nsstringValue = call_function_by_hand(function, 1, &stringValue[2]);
}
else if (lookup_minimal_symbol("+[NSString stringWithCString:]", 0, 0).minsym)
{
function
= find_function_in_inferior("+[NSString stringWithCString:]", NULL);
type = builtin_type (gdbarch)->builtin_long;
stringValue[0] = value_from_longest
(type, lookup_objc_class (gdbarch, "NSString"));
stringValue[1] = value_from_longest
(type, lookup_child_selector (gdbarch, "stringWithCString:"));
nsstringValue = call_function_by_hand(function, 3, &stringValue[0]);
}
else
error (_("NSString: internal error -- no way to create new NSString"));
sym = lookup_struct_typedef("NSString", 0, 1);
if (sym == NULL)
sym = lookup_struct_typedef("NXString", 0, 1);
if (sym == NULL)
type = builtin_type (gdbarch)->builtin_data_ptr;
else
type = lookup_pointer_type(SYMBOL_TYPE (sym));
deprecated_set_value_type (nsstringValue, type);
return nsstringValue;
}
/*
* print_symbol()
* show one symbol
*/
void
print_symbol(const char *name, struct nlist *sym, int aout)
{
if (print_file_each_line)
(void)printf("%s:", name);
/*
* handle undefined-only format especially (no space is
* left for symbol values, no type field is printed)
*/
if (!print_only_undefined_symbols) {
/* print symbol's value */
if (SYMBOL_TYPE(sym->n_type) == N_UNDF ||
(show_extensions && SYMBOL_TYPE(sym->n_type) == N_INDR &&
sym->n_value == 0))
(void)printf(" ");
else
(void)printf("%08lx", sym->n_value);
/* print type information */
if (IS_DEBUGGER_SYMBOL(sym->n_type))
(void)printf(" - %02x %04x %5s ", sym->n_other,
sym->n_desc&0xffff, typestring(sym->n_type));
else if (show_extensions)
(void)printf(" %c%2s ", typeletter(sym, aout),
otherstring(sym));
else
(void)printf(" %c ", typeletter(sym, aout));
}
if (SYMBOL_TYPE(sym->n_type) == N_INDR && show_extensions) {
printf("%s -> %s\n", symname(sym, aout), symname(sym+1, aout));
}
else
(void)puts(symname(sym, aout));
}
static struct symbol *
add_class_symbol (struct type *type, CORE_ADDR addr)
{
struct symbol *sym;
sym = (struct symbol *)
obstack_alloc (&dynamics_objfile->objfile_obstack, sizeof (struct symbol));
memset (sym, 0, sizeof (struct symbol));
SYMBOL_LANGUAGE (sym) = language_java;
DEPRECATED_SYMBOL_NAME (sym) = TYPE_TAG_NAME (type);
SYMBOL_CLASS (sym) = LOC_TYPEDEF;
/* SYMBOL_VALUE (sym) = valu; */
SYMBOL_TYPE (sym) = type;
SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
SYMBOL_VALUE_ADDRESS (sym) = addr;
return sym;
}
static struct symbol *
add_class_symbol (struct type *type, CORE_ADDR addr)
{
struct symbol *sym;
struct objfile *objfile = get_dynamics_objfile (get_type_arch (type));
sym = allocate_symbol (objfile);
SYMBOL_SET_LANGUAGE (sym, language_java, &objfile->objfile_obstack);
SYMBOL_SET_LINKAGE_NAME (sym, TYPE_TAG_NAME (type));
SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
/* SYMBOL_VALUE (sym) = valu; */
SYMBOL_TYPE (sym) = type;
SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
SYMBOL_VALUE_ADDRESS (sym) = addr;
return sym;
}
static int
sparc32_struct_return_from_sym (struct symbol *sym)
{
struct type *type = check_typedef (SYMBOL_TYPE (sym));
enum type_code code = TYPE_CODE (type);
if (code == TYPE_CODE_FUNC || code == TYPE_CODE_METHOD)
{
type = check_typedef (TYPE_TARGET_TYPE (type));
if (sparc_structure_or_union_p (type)
|| (sparc_floating_p (type) && TYPE_LENGTH (type) == 16))
return 1;
}
return 0;
}
static struct type *
get_regs_type (struct objfile *objfile)
{
struct symbol *func_sym;
struct type *func_type, *regsp_type, *regs_type;
func_sym = lookup_global_symbol_from_objfile (objfile,
GCC_FE_WRAPPER_FUNCTION,
VAR_DOMAIN);
if (func_sym == NULL)
error (_("Cannot find function \"%s\" in compiled module \"%s\"."),
GCC_FE_WRAPPER_FUNCTION, objfile_name (objfile));
func_type = SYMBOL_TYPE (func_sym);
if (TYPE_CODE (func_type) != TYPE_CODE_FUNC)
error (_("Invalid type code %d of function \"%s\" in compiled "
"module \"%s\"."),
TYPE_CODE (func_type), GCC_FE_WRAPPER_FUNCTION,
objfile_name (objfile));
/* No register parameter present. */
if (TYPE_NFIELDS (func_type) == 0)
return NULL;
if (TYPE_NFIELDS (func_type) != 1)
error (_("Invalid %d parameters of function \"%s\" in compiled "
"module \"%s\"."),
TYPE_NFIELDS (func_type), GCC_FE_WRAPPER_FUNCTION,
objfile_name (objfile));
regsp_type = check_typedef (TYPE_FIELD_TYPE (func_type, 0));
if (TYPE_CODE (regsp_type) != TYPE_CODE_PTR)
error (_("Invalid type code %d of first parameter of function \"%s\" "
"in compiled module \"%s\"."),
TYPE_CODE (regsp_type), GCC_FE_WRAPPER_FUNCTION,
objfile_name (objfile));
regs_type = check_typedef (TYPE_TARGET_TYPE (regsp_type));
if (TYPE_CODE (regs_type) != TYPE_CODE_STRUCT)
error (_("Invalid type code %d of dereferenced first parameter "
"of function \"%s\" in compiled module \"%s\"."),
TYPE_CODE (regs_type), GCC_FE_WRAPPER_FUNCTION,
objfile_name (objfile));
return regs_type;
}
struct type *
java_lookup_class (char *name)
{
struct symbol *sym;
sym = lookup_symbol (name, expression_context_block, STRUCT_DOMAIN, NULL);
if (sym != NULL)
return SYMBOL_TYPE (sym);
#if 0
CORE_ADDR addr;
if (called from parser)
{
call lookup_class (or similar) in inferior;
if not
found:
return NULL;
addr = found in inferior;
}
void
compile_cplus_instance::enter_scope (compile_scope &&new_scope)
{
bool must_push = m_scopes.empty () || m_scopes.back () != new_scope;
new_scope.m_pushed = must_push;
/* Save the new scope. */
m_scopes.push_back (std::move (new_scope));
if (must_push)
{
if (debug_compile_cplus_scopes)
{
fprintf_unfiltered (gdb_stdlog, "entering new scope %s\n",
host_address_to_string (&m_scopes.back ()));
}
/* Push the global namespace. */
plugin ().push_namespace ("");
/* Push all other namespaces. Note that we do not push the last
scope_component -- that's the actual type we are converting. */
std::for_each
(m_scopes.back ().begin (), m_scopes.back ().end () - 1,
[this] (const scope_component &comp)
{
gdb_assert (TYPE_CODE (SYMBOL_TYPE (comp.bsymbol.symbol))
== TYPE_CODE_NAMESPACE);
const char *ns = (comp.name == CP_ANONYMOUS_NAMESPACE_STR ? nullptr
: comp.name.c_str ());
this->plugin ().push_namespace (ns);
});
}
else
{
if (debug_compile_cplus_scopes)
{
fprintf_unfiltered (gdb_stdlog, "staying in current scope -- "
"scopes are identical\n");
}
}
}
static struct symbol *
add_class_symbol (struct type *type, CORE_ADDR addr)
{
struct symbol *sym;
struct objfile *objfile = get_dynamics_objfile (get_type_arch (type));
sym = (struct symbol *)
obstack_alloc (&objfile->objfile_obstack, sizeof (struct symbol));
memset (sym, 0, sizeof (struct symbol));
SYMBOL_SET_LANGUAGE (sym, language_java);
SYMBOL_SET_LINKAGE_NAME (sym, TYPE_TAG_NAME (type));
SYMBOL_CLASS (sym) = LOC_TYPEDEF;
/* SYMBOL_VALUE (sym) = valu; */
SYMBOL_TYPE (sym) = type;
SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
SYMBOL_VALUE_ADDRESS (sym) = addr;
return sym;
}
static void
overload_list_add_symbol (struct symbol *sym, const char *oload_name)
{
int newsize;
int i;
char *sym_name;
/* If there is no type information, we can't do anything, so skip */
if (SYMBOL_TYPE (sym) == NULL)
return;
/* skip any symbols that we've already considered. */
for (i = 0; i < sym_return_val_index; ++i)
if (strcmp (SYMBOL_LINKAGE_NAME (sym),
SYMBOL_LINKAGE_NAME (sym_return_val[i])) == 0)
return;
/* Get the demangled name without parameters */
sym_name = cp_remove_params (SYMBOL_NATURAL_NAME (sym));
if (!sym_name)
return;
/* skip symbols that cannot match */
if (strcmp (sym_name, oload_name) != 0)
{
xfree (sym_name);
return;
}
xfree (sym_name);
/* We have a match for an overload instance, so add SYM to the current list
* of overload instances */
if (sym_return_val_index + 3 > sym_return_val_size)
{
newsize = (sym_return_val_size *= 2) * sizeof (struct symbol *);
sym_return_val = (struct symbol **) xrealloc ((char *) sym_return_val, newsize);
}
sym_return_val[sym_return_val_index++] = sym;
sym_return_val[sym_return_val_index] = NULL;
}
void
call_macro (symbol *sym, int argc, token_data **argv,
struct obstack *expansion)
{
switch (SYMBOL_TYPE (sym))
{
case TOKEN_FUNC:
(*SYMBOL_FUNC (sym)) (expansion, argc, argv);
break;
case TOKEN_TEXT:
expand_user_macro (expansion, sym, argc, argv);
break;
case TOKEN_VOID:
default:
M4ERROR ((warning_status, 0,
"INTERNAL ERROR: bad symbol type in call_macro ()"));
abort ();
}
}
/* Return the value of SYMBOL in FRAME using the DWARF-2 expression
evaluator to calculate the location. */
static struct value *
loclist_read_variable (struct symbol *symbol, struct frame_info *frame)
{
struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
struct value *val;
gdb_byte *data;
size_t size;
data = find_location_expression (dlbaton, &size,
frame ? get_frame_address_in_block (frame)
: 0);
if (data == NULL)
{
val = allocate_value (SYMBOL_TYPE (symbol));
VALUE_LVAL (val) = not_lval;
set_value_optimized_out (val, 1);
}
else
val = dwarf2_evaluate_loc_desc (symbol, frame, data, size,
dlbaton->objfile);
return val;
}
