1 #ifndef EXPRESSION_H 2 #define EXPRESSION_H 3 /* 4 * sparse/expression.h 5 * 6 * Copyright (C) 2003 Transmeta Corp. 7 * 2003 Linus Torvalds 8 * 9 * Permission is hereby granted, free of charge, to any person obtaining a copy 10 * of this software and associated documentation files (the "Software"), to deal 11 * in the Software without restriction, including without limitation the rights 12 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 13 * copies of the Software, and to permit persons to whom the Software is 14 * furnished to do so, subject to the following conditions: 15 * 16 * The above copyright notice and this permission notice shall be included in 17 * all copies or substantial portions of the Software. 18 * 19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 20 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 22 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 23 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 24 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 25 * THE SOFTWARE. 26 * 27 * Declarations and helper functions for expression parsing. 28 */ 29 30 #include "allocate.h" 31 #include "lib.h" 32 #include "symbol.h" 33 34 struct expression_list; 35 36 enum expression_type { 37 EXPR_VALUE = 1, 38 EXPR_STRING, 39 EXPR_SYMBOL, 40 EXPR_TYPE, 41 EXPR_BINOP, 42 EXPR_ASSIGNMENT, 43 EXPR_LOGICAL, 44 EXPR_DEREF, 45 EXPR_PREOP, 46 EXPR_POSTOP, 47 EXPR_CAST, 48 EXPR_FORCE_CAST, 49 EXPR_IMPLIED_CAST, 50 EXPR_SIZEOF, 51 EXPR_ALIGNOF, 52 EXPR_PTRSIZEOF, 53 EXPR_CONDITIONAL, 54 EXPR_SELECT, // a "safe" conditional expression 55 EXPR_STATEMENT, 56 EXPR_CALL, 57 EXPR_COMMA, 58 EXPR_COMPARE, 59 EXPR_LABEL, 60 EXPR_INITIALIZER, // initializer list 61 EXPR_IDENTIFIER, // identifier in initializer 62 EXPR_INDEX, // index in initializer 63 EXPR_POS, // position in initializer 64 EXPR_FVALUE, 65 EXPR_SLICE, 66 EXPR_OFFSETOF, 67 EXPR_ASM_OPERAND, 68 }; 69 70 71 /* 72 * Flags for tracking the promotion of constness related attributes 73 * from subexpressions to their parents. 74 * 75 * The flags are not independent as one might imply another. 76 * The implications are as follows: 77 * - CEF_INT, CEF_ENUM and 78 * CEF_CHAR imply CEF_ICE. 79 * 80 * Use the CEF_*_SET_MASK and CEF_*_CLEAR_MASK 81 * helper macros defined below to set or clear one of these flags. 82 */ 83 enum constexpr_flag { 84 CEF_NONE = 0, 85 /* 86 * A constant in the sense of [6.4.4]: 87 * - Integer constant [6.4.4.1] 88 * - Floating point constant [6.4.4.2] 89 * - Enumeration constant [6.4.4.3] 90 * - Character constant [6.4.4.4] 91 */ 92 CEF_INT = (1 << 0), 93 CEF_FLOAT = (1 << 1), 94 CEF_ENUM = (1 << 2), 95 CEF_CHAR = (1 << 3), 96 97 /* 98 * A constant expression in the sense of [6.6]: 99 * - integer constant expression [6.6(6)] 100 * - arithmetic constant expression [6.6(8)] 101 * - address constant [6.6(9)] 102 */ 103 CEF_ICE = (1 << 4), 104 CEF_ACE = (1 << 5), 105 CEF_ADDR = (1 << 6), 106 107 /* integer constant expression => arithmetic constant expression */ 108 CEF_SET_ICE = (CEF_ICE | CEF_ACE), 109 110 /* integer constant => integer constant expression */ 111 CEF_SET_INT = (CEF_INT | CEF_SET_ICE), 112 113 /* floating point constant => arithmetic constant expression */ 114 CEF_SET_FLOAT = (CEF_FLOAT | CEF_ACE), 115 116 /* enumeration constant => integer constant expression */ 117 CEF_SET_ENUM = (CEF_ENUM | CEF_SET_ICE), 118 119 /* character constant => integer constant expression */ 120 CEF_SET_CHAR = (CEF_CHAR | CEF_SET_ICE), 121 122 /* 123 * Remove any "Constant" [6.4.4] flag, but retain the "constant 124 * expression" [6.6] flags. 125 */ 126 CEF_CONST_MASK = (CEF_INT | CEF_FLOAT | CEF_CHAR), 127 128 /* 129 * not an integer constant expression => neither of integer, 130 * enumeration and character constant 131 */ 132 CEF_CLR_ICE = (CEF_ICE | CEF_INT | CEF_ENUM | CEF_CHAR), 133 }; 134 135 enum { 136 Handled = 1 << 0, 137 Tmp = 1 << 1, 138 Fake = 1 << 2, 139 }; /* for expr->smatch_flags */ 140 141 enum { 142 Taint_comma = 1, 143 }; /* for expr->taint */ 144 145 struct expression { 146 enum expression_type type:8; 147 unsigned flags:8; 148 unsigned smatch_flags:16; 149 int op; 150 struct position pos; 151 struct symbol *ctype; 152 unsigned long parent; 153 union { 154 // EXPR_VALUE 155 struct { 156 unsigned long long value; 157 unsigned taint; 158 }; 159 160 // EXPR_FVALUE 161 long double fvalue; 162 163 // EXPR_STRING 164 struct { 165 int wide; 166 struct string *string; 167 }; 168 169 // EXPR_UNOP, EXPR_PREOP and EXPR_POSTOP 170 struct /* unop */ { 171 struct expression *unop; 172 unsigned long op_value; 173 }; 174 175 // EXPR_SYMBOL, EXPR_TYPE 176 struct /* symbol_arg */ { 177 struct symbol *symbol; 178 struct ident *symbol_name; 179 }; 180 181 // EXPR_STATEMENT 182 struct statement *statement; 183 184 // EXPR_BINOP, EXPR_COMMA, EXPR_COMPARE, EXPR_LOGICAL and EXPR_ASSIGNMENT 185 struct /* binop_arg */ { 186 struct expression *left, *right; 187 }; 188 // EXPR_DEREF 189 struct /* deref_arg */ { 190 struct expression *deref; 191 struct ident *member; 192 int member_offset; 193 }; 194 // EXPR_SLICE 195 struct /* slice */ { 196 struct expression *base; 197 unsigned r_bitpos, r_nrbits; 198 }; 199 // EXPR_CAST, EXPR_FORCE_CAST, EXPR_IMPLIED_CAST, 200 // EXPR_SIZEOF, EXPR_ALIGNOF and EXPR_PTRSIZEOF 201 struct /* cast_arg */ { 202 struct symbol *cast_type; 203 struct expression *cast_expression; 204 }; 205 // EXPR_CONDITIONAL 206 // EXPR_SELECT 207 struct /* conditional_expr */ { 208 struct expression *conditional, *cond_true, *cond_false; 209 }; 210 // EXPR_CALL 211 struct /* call_expr */ { 212 struct expression *fn; 213 struct expression_list *args; 214 }; 215 // EXPR_LABEL 216 struct /* label_expr */ { 217 struct symbol *label_symbol; 218 }; 219 // EXPR_INITIALIZER 220 struct expression_list *expr_list; 221 // EXPR_IDENTIFIER 222 struct /* ident_expr */ { 223 int offset; 224 struct ident *expr_ident; 225 struct symbol *field; 226 struct expression *ident_expression; 227 }; 228 // EXPR_INDEX 229 struct /* index_expr */ { 230 unsigned int idx_from, idx_to; 231 struct expression *idx_expression; 232 }; 233 // EXPR_POS 234 struct /* initpos_expr */ { 235 unsigned int init_offset, init_nr; 236 struct expression *init_expr; 237 }; 238 // EXPR_OFFSETOF 239 struct { 240 struct symbol *in; 241 struct expression *down; 242 union { 243 struct ident *ident; 244 struct expression *index; 245 }; 246 }; 247 // EXPR_ASM_OPERAND 248 struct { 249 struct ident *name; 250 struct expression *constraint; 251 struct expression *expr; 252 }; 253 }; 254 }; 255 256 /// 257 // Constant expression values 258 // -------------------------- 259 260 /// 261 // test if an expression evaluates to the constant ``0``. 262 // @return: ``1`` if @expr evaluate to ``0``, 263 // ``0`` otherwise. 264 int is_zero_constant(struct expression *expr); 265 266 /// 267 // test the compile time truth value of an expression 268 // @return: 269 // * ``-1`` if @expr is not constant, 270 // * ``0`` or ``1`` depending on the truth value of @expr. 271 int expr_truth_value(struct expression *expr); 272 273 long long get_expression_value(struct expression *); 274 long long const_expression_value(struct expression *); 275 long long get_expression_value_silent(struct expression *expr); 276 277 /* Expression parsing */ 278 struct token *parse_expression(struct token *token, struct expression **tree); 279 struct token *conditional_expression(struct token *token, struct expression **tree); 280 struct token *primary_expression(struct token *token, struct expression **tree); 281 struct token *parens_expression(struct token *token, struct expression **expr, const char *where); 282 struct token *assignment_expression(struct token *token, struct expression **tree); 283 284 extern void evaluate_symbol_list(struct symbol_list *list); 285 extern struct symbol *evaluate_statement(struct statement *stmt); 286 extern struct symbol *evaluate_expression(struct expression *); 287 struct symbol *find_identifier(struct ident *ident, struct symbol_list *_list, int *offset); 288 289 extern int expand_symbol(struct symbol *); 290 291 static inline struct expression *alloc_expression(struct position pos, int type) 292 { 293 struct expression *expr = __alloc_expression(0); 294 expr->type = type; 295 expr->pos = pos; 296 expr->flags = CEF_NONE; 297 return expr; 298 } 299 300 static inline struct expression *alloc_const_expression(struct position pos, int value) 301 { 302 struct expression *expr = __alloc_expression(0); 303 expr->type = EXPR_VALUE; 304 expr->pos = pos; 305 expr->value = value; 306 expr->ctype = &int_ctype; 307 expr->flags = CEF_SET_INT; 308 return expr; 309 } 310 311 /* Type name parsing */ 312 struct token *typename(struct token *, struct symbol **, int *); 313 314 static inline int lookup_type(struct token *token) 315 { 316 if (token->pos.type == TOKEN_IDENT) { 317 struct symbol *sym = lookup_symbol(token->ident, NS_SYMBOL | NS_TYPEDEF); 318 return sym && (sym->namespace & NS_TYPEDEF); 319 } 320 return 0; 321 } 322 323 /* Statement parsing */ 324 struct statement *alloc_statement(struct position pos, int type); 325 struct token *initializer(struct expression **tree, struct token *token); 326 struct token *compound_statement(struct token *, struct statement *); 327 328 /* The preprocessor calls this 'constant_expression()' */ 329 #define constant_expression(token,tree) conditional_expression(token, tree) 330 331 /* Cast folding of constant values.. */ 332 void cast_value(struct expression *expr, struct symbol *newtype, 333 struct expression *old, struct symbol *oldtype); 334 335 #endif 336