gdb/c-exp.h

   1 /* Definitions for C expressions
   2
   3    Copyright (C) 2020 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #ifndef C_EXP_H
  21 #define C_EXP_H
  22
  23 #include "expop.h"
  24 #include "objc-lang.h"
  25
  26 extern struct value *eval_op_objc_selector (struct type *expect_type,
  27                                             struct expression *exp,
  28                                             enum noside noside,
  29                                             const char *sel);
  30 extern struct value *opencl_value_cast (struct type *type, struct value *arg);
  31 extern struct value *eval_opencl_assign (struct type *expect_type,
  32                                          struct expression *exp,
  33                                          enum noside noside,
  34                                          enum exp_opcode op,
  35                                          struct value *arg1,
  36                                          struct value *arg2);
  37 extern struct value *opencl_relop (struct type *expect_type,
  38                                    struct expression *exp,
  39                                    enum noside noside, enum exp_opcode op,
  40                                    struct value *arg1, struct value *arg2);
  41 extern struct value *opencl_logical_not (struct type *expect_type,
  42                                          struct expression *exp,
  43                                          enum noside noside,
  44                                          enum exp_opcode op,
  45                                          struct value *arg);
  46
  47 namespace expr
  48 {
  49
  50 class c_string_operation
  51   : public tuple_holding_operation<enum c_string_type_values,
  52                                    std::vector<std::string>>
  53 {
  54 public:
  55
  56   using tuple_holding_operation::tuple_holding_operation;
  57
  58   value *evaluate (struct type *expect_type,
  59                    struct expression *exp,
  60                    enum noside noside) override;
  61
  62   enum exp_opcode opcode () const override
  63   { return OP_STRING; }
  64 };
  65
  66 class objc_nsstring_operation
  67   : public tuple_holding_operation<std::string>
  68 {
  69 public:
  70
  71   using tuple_holding_operation::tuple_holding_operation;
  72
  73   value *evaluate (struct type *expect_type,
  74                    struct expression *exp,
  75                    enum noside noside) override
  76   {
  77     const std::string &str = std::get<0> (m_storage);
  78     return value_nsstring (exp->gdbarch, str.c_str (), str.size () + 1);
  79   }
  80
  81   enum exp_opcode opcode () const override
  82   { return OP_OBJC_NSSTRING; }
  83 };
  84
  85 class objc_selector_operation
  86   : public tuple_holding_operation<std::string>
  87 {
  88 public:
  89
  90   using tuple_holding_operation::tuple_holding_operation;
  91
  92   value *evaluate (struct type *expect_type,
  93                    struct expression *exp,
  94                    enum noside noside) override
  95   {
  96     return eval_op_objc_selector (expect_type, exp, noside,
  97                                   std::get<0> (m_storage).c_str ());
  98   }
  99
 100   enum exp_opcode opcode () const override
 101   { return OP_OBJC_SELECTOR; }
 102 };
 103
 104 /* An Objective C message call.  */
 105 class objc_msgcall_operation
 106   : public tuple_holding_operation<CORE_ADDR, operation_up,
 107                                    std::vector<operation_up>>
 108 {
 109 public:
 110
 111   using tuple_holding_operation::tuple_holding_operation;
 112
 113   value *evaluate (struct type *expect_type,
 114                    struct expression *exp,
 115                    enum noside noside) override;
 116
 117   enum exp_opcode opcode () const override
 118   { return OP_OBJC_MSGCALL; }
 119 };
 120
 121 using opencl_cast_type_operation = cxx_cast_operation<UNOP_CAST_TYPE,
 122                                                       opencl_value_cast>;
 123
 124 /* Binary operations, as needed for OpenCL.  */
 125 template<enum exp_opcode OP, binary_ftype FUNC,
 126          typename BASE = maybe_constant_operation<operation_up, operation_up>>
 127 class opencl_binop_operation
 128   : public BASE
 129 {
 130 public:
 131
 132   using BASE::BASE;
 133
 134   value *evaluate (struct type *expect_type,
 135                    struct expression *exp,
 136                    enum noside noside) override
 137   {
 138     value *lhs
 139       = std::get<0> (this->m_storage)->evaluate (nullptr, exp, noside);
 140     value *rhs
 141       = std::get<1> (this->m_storage)->evaluate (value_type (lhs), exp,
 142                                                  noside);
 143     return FUNC (expect_type, exp, noside, OP, lhs, rhs);
 144   }
 145
 146   enum exp_opcode opcode () const override
 147   { return OP; }
 148 };
 149
 150 using opencl_assign_operation = opencl_binop_operation<BINOP_ASSIGN,
 151                                                        eval_opencl_assign,
 152                                                        assign_operation>;
 153 using opencl_equal_operation = opencl_binop_operation<BINOP_EQUAL,
 154                                                       opencl_relop>;
 155 using opencl_notequal_operation = opencl_binop_operation<BINOP_NOTEQUAL,
 156                                                          opencl_relop>;
 157 using opencl_less_operation = opencl_binop_operation<BINOP_LESS,
 158                                                      opencl_relop>;
 159 using opencl_gtr_operation = opencl_binop_operation<BINOP_GTR,
 160                                                     opencl_relop>;
 161 using opencl_geq_operation = opencl_binop_operation<BINOP_GEQ,
 162                                                     opencl_relop>;
 163 using opencl_leq_operation = opencl_binop_operation<BINOP_LEQ,
 164                                                     opencl_relop>;
 165
 166 using opencl_not_operation = unop_operation<UNOP_LOGICAL_NOT,
 167                                             opencl_logical_not>;
 168
 169 /* STRUCTOP_STRUCT implementation for OpenCL.  */
 170 class opencl_structop_operation
 171   : public structop_base_operation
 172 {
 173 public:
 174
 175   using structop_base_operation::structop_base_operation;
 176
 177   value *evaluate (struct type *expect_type,
 178                    struct expression *exp,
 179                    enum noside noside) override;
 180
 181   enum exp_opcode opcode () const override
 182   { return STRUCTOP_STRUCT; }
 183 };
 184
 185 /* This handles the "&&" and "||" operations for OpenCL.  */
 186 class opencl_logical_binop_operation
 187   : public tuple_holding_operation<enum exp_opcode,
 188                                    operation_up, operation_up>
 189 {
 190 public:
 191
 192   using tuple_holding_operation::tuple_holding_operation;
 193
 194   value *evaluate (struct type *expect_type,
 195                    struct expression *exp,
 196                    enum noside noside) override;
 197
 198   enum exp_opcode opcode () const override
 199   { return std::get<0> (m_storage); }
 200 };
 201
 202 /* The ?: ternary operator for OpenCL.  */
 203 class opencl_ternop_cond_operation
 204   : public tuple_holding_operation<operation_up, operation_up, operation_up>
 205 {
 206 public:
 207
 208   using tuple_holding_operation::tuple_holding_operation;
 209
 210   value *evaluate (struct type *expect_type,
 211                    struct expression *exp,
 212                    enum noside noside) override;
 213
 214   enum exp_opcode opcode () const override
 215   { return TERNOP_COND; }
 216 };
 217
 218 }/* namespace expr */
 219
 220 #endif /* C_EXP_H */