1 /*
2 * builtin evaluation & expansion.
3 *
4 * Copyright (C) 2003 Transmeta Corp.
5 * 2003-2004 Linus Torvalds
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this software and associated documentation files (the "Software"), to deal
9 * in the Software without restriction, including without limitation the rights
10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 * copies of the Software, and to permit persons to whom the Software is
12 * furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23 * THE SOFTWARE.
24 */
25
26 #include "expression.h"
27 #include "expand.h"
28 #include "symbol.h"
29 #include "compat/bswap.h"
30
31 static int evaluate_to_int_const_expr(struct expression *expr)
32 {
33 expr->ctype = &int_ctype;
34 expr->flags |= CEF_SET_ICE;
35 return 1;
36 }
37
38 static int evaluate_pure_unop(struct expression *expr)
39 {
40 struct expression *arg = first_expression(expr->args);
41 int flags = arg->flags;
42
43 /*
44 * Allow such functions with a constant integer expression
45 * argument to be treated as a *constant* integer.
46 * This allow us to use them in switch() { case ...:
47 */
48 flags |= (flags & CEF_ICE) ? CEF_SET_INT : 0;
49 expr->flags = flags;
50 return 1;
51 }
52
53
54 static int evaluate_expect(struct expression *expr)
55 {
56 /* Should we evaluate it to return the type of the first argument? */
57 expr->ctype = &int_ctype;
58 return 1;
59 }
60
61 static int arguments_choose(struct expression *expr)
62 {
63 struct expression_list *arglist = expr->args;
64 struct expression *arg;
65 int i = 0;
66
67 FOR_EACH_PTR (arglist, arg) {
68 if (!evaluate_expression(arg))
69 return 0;
70 i++;
71 } END_FOR_EACH_PTR(arg);
72 if (i < 3) {
73 sparse_error(expr->pos,
74 "not enough arguments for __builtin_choose_expr");
75 return 0;
76 } if (i > 3) {
77 sparse_error(expr->pos,
78 "too many arguments for __builtin_choose_expr");
79 return 0;
80 }
81 return 1;
82 }
83
84 static int evaluate_choose(struct expression *expr)
85 {
86 struct expression_list *list = expr->args;
87 struct expression *arg, *args[3];
88 int n = 0;
89
90 /* there will be exactly 3; we'd already verified that */
91 FOR_EACH_PTR(list, arg) {
92 args[n++] = arg;
93 } END_FOR_EACH_PTR(arg);
94
95 *expr = get_expression_value(args[0]) ? *args[1] : *args[2];
96
97 return 1;
98 }
99
100 static int expand_expect(struct expression *expr, int cost)
101 {
102 struct expression *arg = first_ptr_list((struct ptr_list *) expr->args);
103
104 if (arg)
105 *expr = *arg;
106 return 0;
107 }
108
109 /*
110 * __builtin_warning() has type "int" and always returns 1,
111 * so that you can use it in conditionals or whatever
112 */
113 static int expand_warning(struct expression *expr, int cost)
114 {
115 struct expression *arg;
116 struct expression_list *arglist = expr->args;
117
118 FOR_EACH_PTR (arglist, arg) {
119 /*
120 * Constant strings get printed out as a warning. By the
121 * time we get here, the EXPR_STRING has been fully
122 * evaluated, so by now it's an anonymous symbol with a
123 * string initializer.
124 *
125 * Just for the heck of it, allow any constant string
126 * symbol.
127 */
128 if (arg->type == EXPR_SYMBOL) {
129 struct symbol *sym = arg->symbol;
130 if (sym->initializer && sym->initializer->type == EXPR_STRING) {
131 struct string *string = sym->initializer->string;
132 warning(expr->pos, "%*s", string->length-1, string->data);
133 }
134 continue;
135 }
136
137 /*
138 * Any other argument is a conditional. If it's
139 * non-constant, or it is false, we exit and do
140 * not print any warning.
141 */
142 if (arg->type != EXPR_VALUE)
143 goto out;
144 if (!arg->value)
145 goto out;
146 } END_FOR_EACH_PTR(arg);
147 out:
148 expr->type = EXPR_VALUE;
149 expr->value = 1;
150 expr->taint = 0;
151 return 0;
152 }
153
154 /* The arguments are constant if the cost of all of them is zero */
155 static int expand_constant_p(struct expression *expr, int cost)
156 {
157 expr->type = EXPR_VALUE;
158 expr->value = !cost;
159 expr->taint = 0;
160 return 0;
161 }
162
163 /* The arguments are safe, if their cost is less than SIDE_EFFECTS */
164 static int expand_safe_p(struct expression *expr, int cost)
165 {
166 expr->type = EXPR_VALUE;
167 expr->value = (cost < SIDE_EFFECTS);
168 expr->taint = 0;
169 return 0;
170 }
171
172 static struct symbol_op constant_p_op = {
173 .evaluate = evaluate_to_int_const_expr,
174 .expand = expand_constant_p
175 };
176
177 static struct symbol_op safe_p_op = {
178 .evaluate = evaluate_to_int_const_expr,
179 .expand = expand_safe_p
180 };
181
182 static struct symbol_op warning_op = {
183 .evaluate = evaluate_to_int_const_expr,
184 .expand = expand_warning
185 };
186
187 static struct symbol_op expect_op = {
188 .evaluate = evaluate_expect,
189 .expand = expand_expect
190 };
191
192 static struct symbol_op choose_op = {
193 .evaluate = evaluate_choose,
194 .args = arguments_choose,
195 };
196
197 /* The argument is constant and valid if the cost is zero */
198 static int expand_bswap(struct expression *expr, int cost)
199 {
200 struct expression *arg;
201 long long val;
202
203 if (cost)
204 return cost;
205
206 /* the arguments number & type have already been checked */
207 arg = first_expression(expr->args);
208 val = get_expression_value_silent(arg);
209 switch (expr->ctype->bit_size) {
210 case 16: expr->value = bswap16(val); break;
211 case 32: expr->value = bswap32(val); break;
212 case 64: expr->value = bswap64(val); break;
213 default: /* impossible error */
214 return SIDE_EFFECTS;
215 }
216
217 expr->type = EXPR_VALUE;
218 expr->taint = 0;
219 return 0;
220 }
221
222 static struct symbol_op bswap_op = {
223 .evaluate = evaluate_pure_unop,
224 .expand = expand_bswap,
225 };
226
227
228 /*
229 * Builtin functions
230 */
231 static struct symbol builtin_fn_type = { .type = SYM_FN /* , .variadic =1 */ };
232 static struct sym_init {
233 const char *name;
234 struct symbol *base_type;
235 unsigned int modifiers;
236 struct symbol_op *op;
237 } builtins_table[] = {
238 { "__builtin_constant_p", &builtin_fn_type, MOD_TOPLEVEL, &constant_p_op },
239 { "__builtin_safe_p", &builtin_fn_type, MOD_TOPLEVEL, &safe_p_op },
240 { "__builtin_warning", &builtin_fn_type, MOD_TOPLEVEL, &warning_op },
241 { "__builtin_expect", &builtin_fn_type, MOD_TOPLEVEL, &expect_op },
242 { "__builtin_choose_expr", &builtin_fn_type, MOD_TOPLEVEL, &choose_op },
243 { "__builtin_bswap16", NULL, MOD_TOPLEVEL, &bswap_op },
244 { "__builtin_bswap32", NULL, MOD_TOPLEVEL, &bswap_op },
245 { "__builtin_bswap64", NULL, MOD_TOPLEVEL, &bswap_op },
246 { NULL, NULL, 0 }
247 };
248
249 void init_builtins(int stream)
250 {
251 struct sym_init *ptr;
252
253 builtin_fn_type.variadic = 1;
254 for (ptr = builtins_table; ptr->name; ptr++) {
255 struct symbol *sym;
256 sym = create_symbol(stream, ptr->name, SYM_NODE, NS_SYMBOL);
257 sym->ctype.base_type = ptr->base_type;
258 sym->ctype.modifiers = ptr->modifiers;
259 sym->op = ptr->op;
260 }
261 }