1 /* Definitions for C expressions 2 3 Copyright (C) 2020-2024 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 (lhs->type (), 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 */ 221
Indexes created Mon Mar 02 05:31:46 UTC 2026