[PATCH 137/203] Implement the "&&" and "||" operators

Tom Tromey
2021-01-01T21:49:08Z

This implements the "&&" and "||" operators.

gdb/ChangeLog
2021-01-01 Tom Tromey <tom@tromey.com>

* expop.h (class logical_and_operation)
(class logical_or_operation): New.
* eval.c (logical_and_operation::evaluate)
(logical_or_operation::evaluate): New methods.
* ax-gdb.c (logical_and_operation::do_generate_ax)
(logical_or_operation::do_generate_ax): New methods.
---
gdb/ChangeLog | 9 ++++++++
gdb/ax-gdb.c | 56 +++++++++++++++++++++++++++++++++++++++++++++
gdb/eval.c | 63 +++++++++++++++++++++++++++++++++++++++++++++++++++
gdb/expop.h | 48 +++++++++++++++++++++++++++++++++++++++
4 files changed, 176 insertions(+)

diff --git a/gdb/ax-gdb.c b/gdb/ax-gdb.c
index bdf4a6dc39a..8ec3dd7cc3d 100644
--- a/gdb/ax-gdb.c
+++ b/gdb/ax-gdb.c
@@ -2693,6 +2693,62 @@ var_value_operation::do_generate_ax (struct expression *exp,
}
}

+void
+logical_and_operation::do_generate_ax (struct expression *exp,
+ struct agent_expr *ax,
+ struct axs_value *value,
+ struct type *cast_type)
+{
+ struct axs_value value1, value2;
+ int if1, go1, if2, go2, end;
+
+ /* Generate the obvious sequence of tests and jumps. */
+ std::get<0> (m_storage)->generate_ax (exp, ax, &value1);
+ gen_usual_unary (ax, &value1);
+ if1 = ax_goto (ax, aop_if_goto);
+ go1 = ax_goto (ax, aop_goto);
+ ax_label (ax, if1, ax->len);
+ std::get<1> (m_storage)->generate_ax (exp, ax, &value2);
+ gen_usual_unary (ax, &value2);
+ if2 = ax_goto (ax, aop_if_goto);
+ go2 = ax_goto (ax, aop_goto);
+ ax_label (ax, if2, ax->len);
+ ax_const_l (ax, 1);
+ end = ax_goto (ax, aop_goto);
+ ax_label (ax, go1, ax->len);
+ ax_label (ax, go2, ax->len);
+ ax_const_l (ax, 0);
+ ax_label (ax, end, ax->len);
+ value->kind = axs_rvalue;
+ value->type = builtin_type (ax->gdbarch)->builtin_int;
+}
+
+void
+logical_or_operation::do_generate_ax (struct expression *exp,
+ struct agent_expr *ax,
+ struct axs_value *value,
+ struct type *cast_type)
+{
+ struct axs_value value1, value2;
+ int if1, if2, end;
+
+ /* Generate the obvious sequence of tests and jumps. */
+ std::get<0> (m_storage)->generate_ax (exp, ax, &value1);
+ gen_usual_unary (ax, &value1);
+ if1 = ax_goto (ax, aop_if_goto);
+ std::get<1> (m_storage)->generate_ax (exp, ax, &value2);
+ gen_usual_unary (ax, &value2);
+ if2 = ax_goto (ax, aop_if_goto);
+ ax_const_l (ax, 0);
+ end = ax_goto (ax, aop_goto);
+ ax_label (ax, if1, ax->len);
+ ax_label (ax, if2, ax->len);
+ ax_const_l (ax, 1);
+ ax_label (ax, end, ax->len);
+ value->kind = axs_rvalue;
+ value->type = builtin_type (ax->gdbarch)->builtin_int;
+}
+
}

/* This handles the middle-to-right-side of code generation for binary
diff --git a/gdb/eval.c b/gdb/eval.c
index b1087d1329d..495cd4b26a3 100644
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -2461,6 +2461,69 @@ multi_subscript_operation::evaluate (struct type *expect_type,
gdb::make_array_view (argvec, values.size ()));
}

+value *
+logical_and_operation::evaluate (struct type *expect_type,
+ struct expression *exp,
+ enum noside noside)
+{
+ value *arg1 = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
+ if (noside == EVAL_SKIP)
+ return eval_skip_value (exp);
+
+ value *arg2 = std::get<1> (m_storage)->evaluate (nullptr, exp,
+ EVAL_AVOID_SIDE_EFFECTS);
+
+ if (binop_user_defined_p (BINOP_LOGICAL_AND, arg1, arg2))
+ {
+ arg2 = std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
+ return value_x_binop (arg1, arg2, BINOP_LOGICAL_AND, OP_NULL, noside);
+ }
+ else
+ {
+ int tem = value_logical_not (arg1);
+ if (!tem)
+ {
+ arg2 = std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
+ tem = value_logical_not (arg2);
+ }
+ struct type *type = language_bool_type (exp->language_defn,
+ exp->gdbarch);
+ return value_from_longest (type, !tem);
+ }
+}
+
+value *
+logical_or_operation::evaluate (struct type *expect_type,
+ struct expression *exp,
+ enum noside noside)
+{
+ value *arg1 = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
+ if (noside == EVAL_SKIP)
+ return eval_skip_value (exp);
+
+ value *arg2 = std::get<1> (m_storage)->evaluate (nullptr, exp,
+ EVAL_AVOID_SIDE_EFFECTS);
+
+ if (binop_user_defined_p (BINOP_LOGICAL_OR, arg1, arg2))
+ {
+ arg2 = std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
+ return value_x_binop (arg1, arg2, BINOP_LOGICAL_OR, OP_NULL, noside);
+ }
+ else
+ {
+ int tem = value_logical_not (arg1);
+ if (tem)
+ {
+ arg2 = std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
+ tem = value_logical_not (arg2);
+ }
+
+ struct type *type = language_bool_type (exp->language_defn,
+ exp->gdbarch);
+ return value_from_longest (type, !tem);
+ }
+}
+
}

struct value *
diff --git a/gdb/expop.h b/gdb/expop.h
index 21c7b9e25da..f858f591baf 100644
--- a/gdb/expop.h
+++ b/gdb/expop.h
@@ -1979,6 +1979,54 @@ class multi_subscript_operation
{ return MULTI_SUBSCRIPT; }
};

+/* The "&&" operator. */
+class logical_and_operation
+ : public maybe_constant_operation<operation_up, operation_up>
+{
+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 BINOP_LOGICAL_AND; }
+
+protected:
+
+ void do_generate_ax (struct expression *exp,
+ struct agent_expr *ax,
+ struct axs_value *value,
+ struct type *cast_type)
+ override;
+};
+
+/* The "||" operator. */
+class logical_or_operation
+ : public maybe_constant_operation<operation_up, operation_up>
+{
+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 BINOP_LOGICAL_OR; }
+
+protected:
+
+ void do_generate_ax (struct expression *exp,
+ struct agent_expr *ax,
+ struct axs_value *value,
+ struct type *cast_type)
+ override;
+};
+
} /* namespace expr */

#endif /* EXPOP_H */
--
2.26.2