/* Definitions for expressions in GDB
- Copyright (C) 2020 Free Software Foundation, Inc.
+ Copyright (C) 2020-2022 Free Software Foundation, Inc.
This file is part of GDB.
struct expression *exp,
enum noside noside,
bool outermost_p,
- minimal_symbol *msymbol,
- struct objfile *objfile);
+ bound_minimal_symbol msymbol);
extern struct value *eval_op_var_entry_value (struct type *expect_type,
struct expression *exp,
enum noside noside, symbol *sym);
extern struct value *eval_op_register (struct type *expect_type,
struct expression *exp,
enum noside noside, const char *name);
-extern struct value *eval_op_string (struct type *expect_type,
- struct expression *exp,
- enum noside noside, int len,
- const char *string);
extern struct value *eval_op_ternop (struct type *expect_type,
struct expression *exp,
enum noside noside,
struct expression *exp,
enum noside noside,
struct value *arg1, struct value *arg2);
-extern struct value *eval_op_concat (struct type *expect_type,
- struct expression *exp,
- enum noside noside,
- struct value *arg1, struct value *arg2);
extern struct value *eval_op_add (struct type *expect_type,
struct expression *exp,
enum noside noside,
namespace expr
{
+class ada_component;
+
/* The check_objfile overloads are used to check whether a particular
component of some operation references an objfile. The passed-in
objfile will never be a debug objfile. */
return exp_objfile == objfile;
}
-static inline bool
+static inline bool
check_objfile (struct type *type, struct objfile *objfile)
{
struct objfile *ty_objfile = type->objfile_owner ();
return false;
}
-static inline bool
+static inline bool
check_objfile (struct symbol *sym, struct objfile *objfile)
{
return check_objfile (symbol_objfile (sym), objfile);
}
-static inline bool
+static inline bool
check_objfile (const struct block *block, struct objfile *objfile)
{
return check_objfile (block_objfile (block), objfile);
}
static inline bool
-check_objfile (minimal_symbol *minsym, struct objfile *objfile)
+check_objfile (const block_symbol &sym, struct objfile *objfile)
{
- /* This may seem strange but minsyms are only used with an objfile
- as well. */
- return false;
+ return (check_objfile (sym.symbol, objfile)
+ || check_objfile (sym.block, objfile));
+}
+
+static inline bool
+check_objfile (bound_minimal_symbol minsym, struct objfile *objfile)
+{
+ return check_objfile (minsym.objfile, objfile);
}
static inline bool
return false;
}
-static inline bool
+static inline bool
check_objfile (const operation_up &op, struct objfile *objfile)
{
return op->uses_objfile (objfile);
}
template<typename T>
-static inline bool
+static inline bool
check_objfile (const std::vector<T> &collection, struct objfile *objfile)
{
for (const auto &item : collection)
}
template<typename S, typename T>
-static inline bool
+static inline bool
check_objfile (const std::pair<S, T> &item, struct objfile *objfile)
{
return (check_objfile (item.first, objfile)
|| check_objfile (item.second, objfile));
}
+extern bool check_objfile (const std::unique_ptr<ada_component> &comp,
+ struct objfile *objfile);
+
static inline void
dump_for_expression (struct ui_file *stream, int depth,
const operation_up &op)
extern void dump_for_expression (struct ui_file *stream, int depth,
symbol *sym);
extern void dump_for_expression (struct ui_file *stream, int depth,
- minimal_symbol *msym);
+ const block_symbol &sym);
+extern void dump_for_expression (struct ui_file *stream, int depth,
+ bound_minimal_symbol msym);
extern void dump_for_expression (struct ui_file *stream, int depth,
const block *bl);
extern void dump_for_expression (struct ui_file *stream, int depth,
extern void dump_for_expression (struct ui_file *stream, int depth,
enum range_flag flags);
extern void dump_for_expression (struct ui_file *stream, int depth,
- objfile *objf);
+ const std::unique_ptr<ada_component> &comp);
template<typename T>
void
dump_for_expression (struct ui_file *stream, int depth,
const std::vector<T> &vals)
{
- fprintf_filtered (stream, _("%*sVector:\n"), depth, "");
+ gdb_printf (stream, _("%*sVector:\n"), depth, "");
for (auto &item : vals)
dump_for_expression (stream, depth + 1, item);
}
}
static inline bool
-check_constant (struct minimal_symbol *msym)
+check_constant (bound_minimal_symbol msym)
{
return false;
}
return true;
}
-static inline bool
-check_constant (struct objfile *objfile)
-{
- return true;
-}
-
static inline bool
check_constant (ULONGEST cst)
{
static inline bool
check_constant (struct symbol *sym)
{
- enum address_class sc = SYMBOL_CLASS (sym);
+ enum address_class sc = sym->aclass ();
return (sc == LOC_BLOCK
|| sc == LOC_CONST
|| sc == LOC_CONST_BYTES
|| sc == LOC_LABEL);
}
+static inline bool
+check_constant (const block_symbol &sym)
+{
+ /* We know the block is constant, so we only need to check the
+ symbol. */
+ return check_constant (sym.symbol);
+}
+
template<typename T>
static inline bool
check_constant (const std::vector<T> &collection)
/* Compute the value of a variable. */
class var_value_operation
- : public maybe_constant_operation<symbol *, const block *>
+ : public maybe_constant_operation<block_symbol>
{
public:
enum exp_opcode opcode () const override
{ return OP_VAR_VALUE; }
+ /* Return the symbol referenced by this object. */
+ symbol *get_symbol () const
+ {
+ return std::get<0> (m_storage).symbol;
+ }
+
protected:
void do_generate_ax (struct expression *exp,
};
class var_msym_value_operation
- : public maybe_constant_operation<minimal_symbol *, struct objfile *>
+ : public maybe_constant_operation<bound_minimal_symbol>
{
public:
enum noside noside) override
{
return eval_op_var_msym_value (expect_type, exp, noside, m_outermost,
- std::get<0> (m_storage),
- std::get<1> (m_storage));
+ std::get<0> (m_storage));
}
value *evaluate_for_sizeof (struct expression *exp, enum noside noside)
enum noside noside,
const std::vector<operation_up> &args) override
{
- const char *name = std::get<0> (m_storage)->print_name ();
+ const char *name = std::get<0> (m_storage).minsym->print_name ();
return operation::evaluate_funcall (expect_type, exp, noside, name, args);
}
enum exp_opcode opcode () const override
{ return OP_REGISTER; }
+ /* Return the name of the register. */
+ const char *get_name () const
+ {
+ return std::get<0> (m_storage).c_str ();
+ }
+
protected:
void do_generate_ax (struct expression *exp,
value *evaluate (struct type *expect_type,
struct expression *exp,
- enum noside noside) override
- {
- const std::string &str = std::get<0> (m_storage);
- return eval_op_string (expect_type, exp, noside,
- str.size (), str.c_str ());
- }
+ enum noside noside) override;
enum exp_opcode opcode () const override
{ return OP_STRING; }
= std::get<0> (m_storage)->evaluate_with_coercion (exp, noside);
value *rhs
= std::get<1> (m_storage)->evaluate_with_coercion (exp, noside);
- return eval_op_concat (expect_type, exp, noside, lhs, rhs);
+ return value_concat (lhs, rhs);
}
enum exp_opcode opcode () const override
}
};
-using equal_operation = comparison_operation<BINOP_EQUAL, eval_op_equal>;
+class equal_operation
+ : public comparison_operation<BINOP_EQUAL, eval_op_equal>
+{
+public:
+
+ using comparison_operation::comparison_operation;
+
+ operation *get_lhs () const
+ {
+ return std::get<0> (m_storage).get ();
+ }
+
+ operation *get_rhs () const
+ {
+ return std::get<1> (m_storage).get ();
+ }
+};
+
using notequal_operation
= comparison_operation<BINOP_NOTEQUAL, eval_op_notequal>;
using less_operation = comparison_operation<BINOP_LESS, eval_op_less>;
struct expression *exp,
enum noside noside) override
{
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
- else if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ if (noside == EVAL_AVOID_SIDE_EFFECTS)
return std::get<0> (m_storage)->evaluate (nullptr, exp,
EVAL_AVOID_SIDE_EFFECTS);
else
struct expression *exp,
enum noside noside) override
{
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
- else if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
value *result
= std::get<0> (m_storage)->evaluate (nullptr, exp,
enum noside noside) override
{
/* C++: check for and handle pointer to members. */
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
- else
- return std::get<0> (m_storage)->evaluate_for_address (exp, noside);
+ return std::get<0> (m_storage)->evaluate_for_address (exp, noside);
}
enum exp_opcode opcode () const override
{ return UNOP_ADDR; }
+ /* Return the subexpression. */
+ const operation_up &get_expression () const
+ {
+ return std::get<0> (m_storage);
+ }
+
protected:
void do_generate_ax (struct expression *exp,
struct expression *exp,
enum noside noside) override
{
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
return std::get<0> (m_storage)->evaluate_for_sizeof (exp, noside);
}
enum exp_opcode opcode () const override
{ return UNOP_MEMVAL; }
+ /* Return the type referenced by this object. */
+ struct type *get_type () const
+ {
+ return std::get<1> (m_storage);
+ }
+
protected:
void do_generate_ax (struct expression *exp,
: value_type (lhs));
value *rhs = std::get<1> (m_storage)->evaluate (xtype, exp, noside);
- if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
+ if (noside == EVAL_AVOID_SIDE_EFFECTS)
return lhs;
if (binop_user_defined_p (BINOP_ASSIGN, lhs, rhs))
return value_x_binop (lhs, rhs, BINOP_ASSIGN, OP_NULL, noside);
enum exp_opcode opcode () const override
{ return BINOP_ASSIGN; }
+ /* Return the left-hand-side of the assignment. */
+ operation *get_lhs () const
+ {
+ return std::get<0> (m_storage).get ();
+ }
+
protected:
void do_generate_ax (struct expression *exp,
override;
};
+/* Not a cast! Extract a value of a given type from the contents of a
+ value. The new value is extracted from the least significant bytes
+ of the old value. The new value's type must be no bigger than the
+ old values type. */
+class unop_extract_operation
+ : public maybe_constant_operation<operation_up, struct type *>
+{
+public:
+
+ using maybe_constant_operation::maybe_constant_operation;
+
+ value *evaluate (struct type *expect_type, struct expression *exp,
+ enum noside noside) override;
+
+ enum exp_opcode opcode () const override
+ { return UNOP_EXTRACT; }
+
+ /* Return the type referenced by this object. */
+ struct type *get_type () const
+ {
+ return std::get<1> (m_storage);
+ }
+
+protected:
+
+ void do_generate_ax (struct expression *exp,
+ struct agent_expr *ax,
+ struct axs_value *value,
+ struct type *cast_type) override;
+};
+
/* A type cast. */
class unop_cast_operation
: public maybe_constant_operation<operation_up, struct type *>
enum exp_opcode opcode () const override
{ return UNOP_CAST; }
+ /* Return the type referenced by this object. */
+ struct type *get_type () const
+ {
+ return std::get<1> (m_storage);
+ }
+
protected:
void do_generate_ax (struct expression *exp,
EVAL_AVOID_SIDE_EFFECTS);
struct type *type = value_type (val);
value *rhs = std::get<1> (m_storage)->evaluate (type, exp, noside);
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
return FUNC (type, rhs);
}
projects / binutils-gdb.git / blobdiff