sim: bfin: initial bf60x support

[thirdparty/binutils-gdb.git] / gdb / c-exp.h

diff --git a/gdb/c-exp.h b/gdb/c-exp.h
index dcb4557b2d58fd4abdf2ee7b27e9cebb400e0929..51e2d26eb2ef90f8cb1f3febe26c9f1e6e6001c7 100644 (file)
--- a/gdb/c-exp.h
+++ b/gdb/c-exp.h
@@ -1,6 +1,6 @@
 /* Definitions for C expressions
 
-   Copyright (C) 2020 Free Software Foundation, Inc.
+   Copyright (C) 2020-2023 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -27,6 +27,23 @@ extern struct value *eval_op_objc_selector (struct type *expect_type,
                                            struct expression *exp,
                                            enum noside noside,
                                            const char *sel);
+extern struct value *opencl_value_cast (struct type *type, struct value *arg);
+extern struct value *eval_opencl_assign (struct type *expect_type,
+                                        struct expression *exp,
+                                        enum noside noside,
+                                        enum exp_opcode op,
+                                        struct value *arg1,
+                                        struct value *arg2);
+extern struct value *opencl_relop (struct type *expect_type,
+                                  struct expression *exp,
+                                  enum noside noside, enum exp_opcode op,
+                                  struct value *arg1, struct value *arg2);
+extern struct value *opencl_logical_not (struct type *expect_type,
+                                        struct expression *exp,
+                                        enum noside noside,
+                                        enum exp_opcode op,
+                                        struct value *arg);
+
 namespace expr
 {
 
@@ -57,8 +74,6 @@ public:
                   struct expression *exp,
                   enum noside noside) override
   {
-    if (noside == EVAL_SKIP)
-      return eval_skip_value (exp);
     const std::string &str = std::get<0> (m_storage);
     return value_nsstring (exp->gdbarch, str.c_str (), str.size () + 1);
   }
@@ -78,8 +93,6 @@ public:
                   struct expression *exp,
                   enum noside noside) override
   {
-    if (noside == EVAL_SKIP)
-      return eval_skip_value (exp);
     return eval_op_objc_selector (expect_type, exp, noside,
                                  std::get<0> (m_storage).c_str ());
   }
@@ -88,6 +101,120 @@ public:
   { return OP_OBJC_SELECTOR; }
 };
 
+/* An Objective C message call.  */
+class objc_msgcall_operation
+  : public tuple_holding_operation<CORE_ADDR, operation_up,
+                                  std::vector<operation_up>>
+{
+public:
+
+  using tuple_holding_operation::tuple_holding_operation;
+
+  value *evaluate (struct type *expect_type,
+                  struct expression *exp,
+                  enum noside noside) override;
+
+  enum exp_opcode opcode () const override
+  { return OP_OBJC_MSGCALL; }
+};
+
+using opencl_cast_type_operation = cxx_cast_operation<UNOP_CAST_TYPE,
+                                                     opencl_value_cast>;
+
+/* Binary operations, as needed for OpenCL.  */
+template<enum exp_opcode OP, binary_ftype FUNC,
+        typename BASE = maybe_constant_operation<operation_up, operation_up>>
+class opencl_binop_operation
+  : public BASE
+{
+public:
+
+  using BASE::BASE;
+
+  value *evaluate (struct type *expect_type,
+                  struct expression *exp,
+                  enum noside noside) override
+  {
+    value *lhs
+      = std::get<0> (this->m_storage)->evaluate (nullptr, exp, noside);
+    value *rhs
+      = std::get<1> (this->m_storage)->evaluate (lhs->type (), exp,
+                                                noside);
+    return FUNC (expect_type, exp, noside, OP, lhs, rhs);
+  }
+
+  enum exp_opcode opcode () const override
+  { return OP; }
+};
+
+using opencl_assign_operation = opencl_binop_operation<BINOP_ASSIGN,
+                                                      eval_opencl_assign,
+                                                      assign_operation>;
+using opencl_equal_operation = opencl_binop_operation<BINOP_EQUAL,
+                                                     opencl_relop>;
+using opencl_notequal_operation = opencl_binop_operation<BINOP_NOTEQUAL,
+                                                        opencl_relop>;
+using opencl_less_operation = opencl_binop_operation<BINOP_LESS,
+                                                    opencl_relop>;
+using opencl_gtr_operation = opencl_binop_operation<BINOP_GTR,
+                                                   opencl_relop>;
+using opencl_geq_operation = opencl_binop_operation<BINOP_GEQ,
+                                                   opencl_relop>;
+using opencl_leq_operation = opencl_binop_operation<BINOP_LEQ,
+                                                   opencl_relop>;
+
+using opencl_not_operation = unop_operation<UNOP_LOGICAL_NOT,
+                                           opencl_logical_not>;
+
+/* STRUCTOP_STRUCT implementation for OpenCL.  */
+class opencl_structop_operation
+  : public structop_base_operation
+{
+public:
+
+  using structop_base_operation::structop_base_operation;
+
+  value *evaluate (struct type *expect_type,
+                  struct expression *exp,
+                  enum noside noside) override;
+
+  enum exp_opcode opcode () const override
+  { return STRUCTOP_STRUCT; }
+};
+
+/* This handles the "&&" and "||" operations for OpenCL.  */
+class opencl_logical_binop_operation
+  : public tuple_holding_operation<enum exp_opcode,
+                                  operation_up, operation_up>
+{
+public:
+
+  using tuple_holding_operation::tuple_holding_operation;
+
+  value *evaluate (struct type *expect_type,
+                  struct expression *exp,
+                  enum noside noside) override;
+
+  enum exp_opcode opcode () const override
+  { return std::get<0> (m_storage); }
+};
+
+/* The ?: ternary operator for OpenCL.  */
+class opencl_ternop_cond_operation
+  : public tuple_holding_operation<operation_up, operation_up, operation_up>
+{
+public:
+
+  using tuple_holding_operation::tuple_holding_operation;
+
+  value *evaluate (struct type *expect_type,
+                  struct expression *exp,
+                  enum noside noside) override;
+
+  enum exp_opcode opcode () const override
+  { return TERNOP_COND; }
+};
+
 }/* namespace expr */
 
 #endif /* C_EXP_H */