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 } 262