xref: /illumos-gate/usr/src/tools/smatch/src/expression.h (revision 6523a3aa7f325d64841382707603be7a86e68147)
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 
alloc_expression(struct position pos,int type)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 
alloc_const_expression(struct position pos,int value)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 
lookup_type(struct token * token)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