1/* Definitions for C expressions 2 3 Copyright (C) 2020-2023 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 26extern struct value *eval_op_objc_selector (struct type *expect_type, 27 struct expression *exp, 28 enum noside noside, 29 const char *sel); 30extern struct value *opencl_value_cast (struct type *type, struct value *arg); 31extern 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); 37extern 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); 41extern 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 47namespace expr 48{ 49 50class c_string_operation 51 : public tuple_holding_operation<enum c_string_type_values, 52 std::vector<std::string>> 53{ 54public: 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 66class objc_nsstring_operation 67 : public tuple_holding_operation<std::string> 68{ 69public: 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 85class objc_selector_operation 86 : public tuple_holding_operation<std::string> 87{ 88public: 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. */ 105class objc_msgcall_operation 106 : public tuple_holding_operation<CORE_ADDR, operation_up, 107 std::vector<operation_up>> 108{ 109public: 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 121using opencl_cast_type_operation = cxx_cast_operation<UNOP_CAST_TYPE, 122 opencl_value_cast>; 123 124/* Binary operations, as needed for OpenCL. */ 125template<enum exp_opcode OP, binary_ftype FUNC, 126 typename BASE = maybe_constant_operation<operation_up, operation_up>> 127class opencl_binop_operation 128 : public BASE 129{ 130public: 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 150using opencl_assign_operation = opencl_binop_operation<BINOP_ASSIGN, 151 eval_opencl_assign, 152 assign_operation>; 153using opencl_equal_operation = opencl_binop_operation<BINOP_EQUAL, 154 opencl_relop>; 155using opencl_notequal_operation = opencl_binop_operation<BINOP_NOTEQUAL, 156 opencl_relop>; 157using opencl_less_operation = opencl_binop_operation<BINOP_LESS, 158 opencl_relop>; 159using opencl_gtr_operation = opencl_binop_operation<BINOP_GTR, 160 opencl_relop>; 161using opencl_geq_operation = opencl_binop_operation<BINOP_GEQ, 162 opencl_relop>; 163using opencl_leq_operation = opencl_binop_operation<BINOP_LEQ, 164 opencl_relop>; 165 166using opencl_not_operation = unop_operation<UNOP_LOGICAL_NOT, 167 opencl_logical_not>; 168 169/* STRUCTOP_STRUCT implementation for OpenCL. */ 170class opencl_structop_operation 171 : public structop_base_operation 172{ 173public: 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. */ 186class opencl_logical_binop_operation 187 : public tuple_holding_operation<enum exp_opcode, 188 operation_up, operation_up> 189{ 190public: 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. */ 203class opencl_ternop_cond_operation 204 : public tuple_holding_operation<operation_up, operation_up, operation_up> 205{ 206public: 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