#include "objfiles.h"
#include "user-regs.h"
#include <algorithm>
+#include "common/gdb_optional.h"
/* Standard set of definitions for printing, dumping, prefixifying,
* and evaluating expressions. */
write_exp_elt (ps, &tmp);
}
+void
+write_exp_elt_msym (struct parser_state *ps, minimal_symbol *expelt)
+{
+ union exp_element tmp;
+
+ memset (&tmp, 0, sizeof (union exp_element));
+ tmp.msymbol = expelt;
+ write_exp_elt (ps, &tmp);
+}
+
void
write_exp_elt_block (struct parser_state *ps, const struct block *b)
{
write_exp_elt_longcst (ps, (LONGEST) bits);
}
-/* Add the appropriate elements for a minimal symbol to the end of
- the expression. */
+/* Return the type of MSYMBOL, a minimal symbol of OBJFILE. If
+ ADDRESS_P is not NULL, set it to the MSYMBOL's resolved
+ address. */
-void
-write_exp_msymbol (struct parser_state *ps,
- struct bound_minimal_symbol bound_msym)
+type *
+find_minsym_type_and_address (minimal_symbol *msymbol,
+ struct objfile *objfile,
+ CORE_ADDR *address_p)
{
- struct minimal_symbol *msymbol = bound_msym.minsym;
- struct objfile *objfile = bound_msym.objfile;
+ bound_minimal_symbol bound_msym = {msymbol, objfile};
struct gdbarch *gdbarch = get_objfile_arch (objfile);
-
CORE_ADDR addr = BMSYMBOL_VALUE_ADDRESS (bound_msym);
struct obj_section *section = MSYMBOL_OBJ_SECTION (objfile, msymbol);
enum minimal_symbol_type type = MSYMBOL_TYPE (msymbol);
if (overlay_debugging)
addr = symbol_overlayed_address (addr, section);
- write_exp_elt_opcode (ps, OP_LONG);
- /* Let's make the type big enough to hold a 64-bit address. */
- write_exp_elt_type (ps, objfile_type (objfile)->builtin_core_addr);
- write_exp_elt_longcst (ps, (LONGEST) addr);
- write_exp_elt_opcode (ps, OP_LONG);
-
if (section && section->the_bfd_section->flags & SEC_THREAD_LOCAL)
{
- write_exp_elt_opcode (ps, UNOP_MEMVAL_TLS);
- write_exp_elt_objfile (ps, objfile);
- write_exp_elt_type (ps, objfile_type (objfile)->nodebug_tls_symbol);
- write_exp_elt_opcode (ps, UNOP_MEMVAL_TLS);
- return;
+ /* Skip translation if caller does not need the address. */
+ if (address_p != NULL)
+ *address_p = target_translate_tls_address (objfile, addr);
+ return objfile_type (objfile)->nodebug_tls_symbol;
}
- write_exp_elt_opcode (ps, UNOP_MEMVAL);
+ if (address_p != NULL)
+ *address_p = addr;
+
+ struct type *the_type;
+
switch (type)
{
case mst_text:
case mst_file_text:
case mst_solib_trampoline:
- write_exp_elt_type (ps, objfile_type (objfile)->nodebug_text_symbol);
- break;
+ return objfile_type (objfile)->nodebug_text_symbol;
case mst_text_gnu_ifunc:
- write_exp_elt_type (ps, objfile_type (objfile)
- ->nodebug_text_gnu_ifunc_symbol);
- break;
+ return objfile_type (objfile)->nodebug_text_gnu_ifunc_symbol;
case mst_data:
case mst_file_data:
case mst_bss:
case mst_file_bss:
- write_exp_elt_type (ps, objfile_type (objfile)->nodebug_data_symbol);
- break;
+ return objfile_type (objfile)->nodebug_data_symbol;
case mst_slot_got_plt:
- write_exp_elt_type (ps, objfile_type (objfile)->nodebug_got_plt_symbol);
- break;
+ return objfile_type (objfile)->nodebug_got_plt_symbol;
default:
- write_exp_elt_type (ps, objfile_type (objfile)->nodebug_unknown_symbol);
- break;
+ return objfile_type (objfile)->nodebug_unknown_symbol;
}
- write_exp_elt_opcode (ps, UNOP_MEMVAL);
+}
+
+/* Add the appropriate elements for a minimal symbol to the end of
+ the expression. */
+
+void
+write_exp_msymbol (struct parser_state *ps,
+ struct bound_minimal_symbol bound_msym)
+{
+ write_exp_elt_opcode (ps, OP_VAR_MSYM_VALUE);
+ write_exp_elt_objfile (ps, bound_msym.objfile);
+ write_exp_elt_msym (ps, bound_msym.minsym);
+ write_exp_elt_opcode (ps, OP_VAR_MSYM_VALUE);
}
/* Mark the current index as the starting location of a structure
case OP_DOUBLE:
case OP_DECFLOAT:
case OP_VAR_VALUE:
+ case OP_VAR_MSYM_VALUE:
oplen = 4;
break;
+ case OP_FUNC_STATIC_VAR:
+ oplen = longest_to_int (expr->elts[endpos - 2].longconst);
+ oplen = 4 + BYTES_TO_EXP_ELEM (oplen + 1);
+ args = 1;
+ break;
+
case OP_TYPE:
case OP_BOOL:
case OP_LAST:
args = 1;
break;
- case UNOP_MEMVAL_TLS:
- oplen = 4;
- args = 1;
- break;
-
case UNOP_ABS:
case UNOP_CAP:
case UNOP_CHR:
const struct block *block,
int comma, int void_context_p, int *out_subexp)
{
- struct cleanup *old_chain, *inner_chain;
+ struct cleanup *old_chain;
const struct language_defn *lang = NULL;
struct parser_state ps;
int subexp;
to the value matching SELECTED_FRAME as set by get_current_arch. */
initialize_expout (&ps, 10, lang, get_current_arch ());
- inner_chain = make_cleanup_restore_current_language ();
+
+ scoped_restore_current_language lang_saver;
set_language (lang->la_language);
TRY
if (expressiondebug)
dump_prefix_expression (ps.expout, gdb_stdlog);
- do_cleanups (inner_chain);
discard_cleanups (old_chain);
*stringptr = lexptr;
expression_up
parse_expression_with_language (const char *string, enum language lang)
{
- struct cleanup *old_chain = NULL;
-
+ gdb::optional<scoped_restore_current_language> lang_saver;
if (current_language->la_language != lang)
{
- old_chain = make_cleanup_restore_current_language ();
+ lang_saver.emplace ();
set_language (lang);
}
- expression_up expr = parse_expression (string);
-
- if (old_chain != NULL)
- do_cleanups (old_chain);
- return expr;
+ return parse_expression (string);
}
/* Parse STRING as an expression. If parsing ends in the middle of a
}
/* Insert a new type, TP, at the bottom of the type stack. If TP is
- tp_pointer or tp_reference, it is inserted at the bottom. If TP is
- a qualifier, it is inserted at slot 1 (just above a previous
- tp_pointer) if there is anything on the stack, or simply pushed if
- the stack is empty. Other values for TP are invalid. */
+ tp_pointer, tp_reference or tp_rvalue_reference, it is inserted at the
+ bottom. If TP is a qualifier, it is inserted at slot 1 (just above a
+ previous tp_pointer) if there is anything on the stack, or simply pushed
+ if the stack is empty. Other values for TP are invalid. */
void
insert_type (enum type_pieces tp)
int slot;
gdb_assert (tp == tp_pointer || tp == tp_reference
- || tp == tp_const || tp == tp_volatile);
+ || tp == tp_rvalue_reference || tp == tp_const
+ || tp == tp_volatile);
/* If there is anything on the stack (we know it will be a
tp_pointer), insert the qualifier above it. Otherwise, simply
make_addr_space = 0;
break;
case tp_reference:
- follow_type = lookup_lvalue_reference_type (follow_type);
- if (make_const)
- follow_type = make_cv_type (make_const,
- TYPE_VOLATILE (follow_type),
- follow_type, 0);
- if (make_volatile)
- follow_type = make_cv_type (TYPE_CONST (follow_type),
- make_volatile,
- follow_type, 0);
- if (make_addr_space)
- follow_type = make_type_with_address_space (follow_type,
- make_addr_space);
+ follow_type = lookup_lvalue_reference_type (follow_type);
+ goto process_reference;
+ case tp_rvalue_reference:
+ follow_type = lookup_rvalue_reference_type (follow_type);
+ process_reference:
+ if (make_const)
+ follow_type = make_cv_type (make_const,
+ TYPE_VOLATILE (follow_type),
+ follow_type, 0);
+ if (make_volatile)
+ follow_type = make_cv_type (TYPE_CONST (follow_type),
+ make_volatile,
+ follow_type, 0);
+ if (make_addr_space)
+ follow_type = make_type_with_address_space (follow_type,
+ make_addr_space);
make_const = make_volatile = 0;
make_addr_space = 0;
break;
}
break;
- case UNOP_MEMVAL_TLS:
- objfile = elts[pos + 1].objfile;
- type = elts[pos + 2].type;
- break;
-
case OP_VAR_VALUE:
{
const struct block *const block = elts[pos + 1].block;
type = SYMBOL_TYPE (symbol);
}
break;
+ case OP_VAR_MSYM_VALUE:
+ objfile = elts[pos + 1].objfile;
+ break;
}
/* Invoke callbacks for TYPE and OBJFILE if they were set as non-NULL. */
projects / deliverable / binutils-gdb.git / blobdiff