1 /* Expand builtin functions. 2 Copyright (C) 1988-2016 Free Software Foundation, Inc. 3 4 This file is part of GCC. 5 6 GCC is free software; you can redistribute it and/or modify it under 7 the terms of the GNU General Public License as published by the Free 8 Software Foundation; either version 3, or (at your option) any later 9 version. 10 11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 12 WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with GCC; see the file COPYING3. If not see 18 <http://www.gnu.org/licenses/>. */ 19 20 /* Legacy warning! Please add no further builtin simplifications here 21 (apart from pure constant folding) - builtin simplifications should go 22 to match.pd or gimple-fold.c instead. */ 23 24 #include "config.h" 25 #include "system.h" 26 #include "coretypes.h" 27 #include "backend.h" 28 #include "target.h" 29 #include "rtl.h" 30 #include "tree.h" 31 #include "gimple.h" 32 #include "predict.h" 33 #include "tm_p.h" 34 #include "stringpool.h" 35 #include "tree-ssanames.h" 36 #include "expmed.h" 37 #include "optabs.h" 38 #include "emit-rtl.h" 39 #include "recog.h" 40 #include "diagnostic-core.h" 41 #include "alias.h" 42 #include "fold-const.h" 43 #include "fold-const-call.h" 44 #include "stor-layout.h" 45 #include "calls.h" 46 #include "varasm.h" 47 #include "tree-object-size.h" 48 #include "realmpfr.h" 49 #include "cfgrtl.h" 50 #include "except.h" 51 #include "dojump.h" 52 #include "explow.h" 53 #include "stmt.h" 54 #include "expr.h" 55 #include "libfuncs.h" 56 #include "output.h" 57 #include "typeclass.h" 58 #include "langhooks.h" 59 #include "value-prof.h" 60 #include "builtins.h" 61 #include "asan.h" 62 #include "cilk.h" 63 #include "tree-chkp.h" 64 #include "rtl-chkp.h" 65 #include "internal-fn.h" 66 #include "case-cfn-macros.h" 67 68 69 struct target_builtins default_target_builtins; 70 #if SWITCHABLE_TARGET 71 struct target_builtins *this_target_builtins = &default_target_builtins; 72 #endif 73 74 /* Define the names of the builtin function types and codes. */ 75 const char *const built_in_class_names[BUILT_IN_LAST] 76 = {"NOT_BUILT_IN", "BUILT_IN_FRONTEND", "BUILT_IN_MD", "BUILT_IN_NORMAL"}; 77 78 #define DEF_BUILTIN(X, N, C, T, LT, B, F, NA, AT, IM, COND) #X, 79 const char * built_in_names[(int) END_BUILTINS] = 80 { 81 #include "builtins.def" 82 }; 83 84 /* Setup an array of builtin_info_type, make sure each element decl is 85 initialized to NULL_TREE. */ 86 builtin_info_type builtin_info[(int)END_BUILTINS]; 87 88 /* Non-zero if __builtin_constant_p should be folded right away. */ 89 bool force_folding_builtin_constant_p; 90 91 static rtx c_readstr (const char *, machine_mode); 92 static int target_char_cast (tree, char *); 93 static rtx get_memory_rtx (tree, tree); 94 static int apply_args_size (void); 95 static int apply_result_size (void); 96 static rtx result_vector (int, rtx); 97 static void expand_builtin_prefetch (tree); 98 static rtx expand_builtin_apply_args (void); 99 static rtx expand_builtin_apply_args_1 (void); 100 static rtx expand_builtin_apply (rtx, rtx, rtx); 101 static void expand_builtin_return (rtx); 102 static enum type_class type_to_class (tree); 103 static rtx expand_builtin_classify_type (tree); 104 static rtx expand_builtin_mathfn_3 (tree, rtx, rtx); 105 static rtx expand_builtin_mathfn_ternary (tree, rtx, rtx); 106 static rtx expand_builtin_interclass_mathfn (tree, rtx); 107 static rtx expand_builtin_sincos (tree); 108 static rtx expand_builtin_cexpi (tree, rtx); 109 static rtx expand_builtin_int_roundingfn (tree, rtx); 110 static rtx expand_builtin_int_roundingfn_2 (tree, rtx); 111 static rtx expand_builtin_next_arg (void); 112 static rtx expand_builtin_va_start (tree); 113 static rtx expand_builtin_va_end (tree); 114 static rtx expand_builtin_va_copy (tree); 115 static rtx expand_builtin_strcmp (tree, rtx); 116 static rtx expand_builtin_strncmp (tree, rtx, machine_mode); 117 static rtx builtin_memcpy_read_str (void *, HOST_WIDE_INT, machine_mode); 118 static rtx expand_builtin_memcpy (tree, rtx); 119 static rtx expand_builtin_memcpy_with_bounds (tree, rtx); 120 static rtx expand_builtin_memcpy_args (tree, tree, tree, rtx, tree); 121 static rtx expand_builtin_mempcpy (tree, rtx, machine_mode); 122 static rtx expand_builtin_mempcpy_with_bounds (tree, rtx, machine_mode); 123 static rtx expand_builtin_mempcpy_args (tree, tree, tree, rtx, 124 machine_mode, int, tree); 125 static rtx expand_builtin_strcpy (tree, rtx); 126 static rtx expand_builtin_strcpy_args (tree, tree, rtx); 127 static rtx expand_builtin_stpcpy (tree, rtx, machine_mode); 128 static rtx expand_builtin_strncpy (tree, rtx); 129 static rtx builtin_memset_gen_str (void *, HOST_WIDE_INT, machine_mode); 130 static rtx expand_builtin_memset (tree, rtx, machine_mode); 131 static rtx expand_builtin_memset_with_bounds (tree, rtx, machine_mode); 132 static rtx expand_builtin_memset_args (tree, tree, tree, rtx, machine_mode, tree); 133 static rtx expand_builtin_bzero (tree); 134 static rtx expand_builtin_strlen (tree, rtx, machine_mode); 135 static rtx expand_builtin_alloca (tree, bool); 136 static rtx expand_builtin_unop (machine_mode, tree, rtx, rtx, optab); 137 static rtx expand_builtin_frame_address (tree, tree); 138 static tree stabilize_va_list_loc (location_t, tree, int); 139 static rtx expand_builtin_expect (tree, rtx); 140 static tree fold_builtin_constant_p (tree); 141 static tree fold_builtin_classify_type (tree); 142 static tree fold_builtin_strlen (location_t, tree, tree); 143 static tree fold_builtin_inf (location_t, tree, int); 144 static tree rewrite_call_expr (location_t, tree, int, tree, int, ...); 145 static bool validate_arg (const_tree, enum tree_code code); 146 static rtx expand_builtin_fabs (tree, rtx, rtx); 147 static rtx expand_builtin_signbit (tree, rtx); 148 static tree fold_builtin_strchr (location_t, tree, tree, tree); 149 static tree fold_builtin_memchr (location_t, tree, tree, tree, tree); 150 static tree fold_builtin_memcmp (location_t, tree, tree, tree); 151 static tree fold_builtin_strcmp (location_t, tree, tree); 152 static tree fold_builtin_strncmp (location_t, tree, tree, tree); 153 static tree fold_builtin_isascii (location_t, tree); 154 static tree fold_builtin_toascii (location_t, tree); 155 static tree fold_builtin_isdigit (location_t, tree); 156 static tree fold_builtin_fabs (location_t, tree, tree); 157 static tree fold_builtin_abs (location_t, tree, tree); 158 static tree fold_builtin_unordered_cmp (location_t, tree, tree, tree, enum tree_code, 159 enum tree_code); 160 static tree fold_builtin_0 (location_t, tree); 161 static tree fold_builtin_1 (location_t, tree, tree); 162 static tree fold_builtin_2 (location_t, tree, tree, tree); 163 static tree fold_builtin_3 (location_t, tree, tree, tree, tree); 164 static tree fold_builtin_varargs (location_t, tree, tree*, int); 165 166 static tree fold_builtin_strpbrk (location_t, tree, tree, tree); 167 static tree fold_builtin_strstr (location_t, tree, tree, tree); 168 static tree fold_builtin_strrchr (location_t, tree, tree, tree); 169 static tree fold_builtin_strspn (location_t, tree, tree); 170 static tree fold_builtin_strcspn (location_t, tree, tree); 171 172 static rtx expand_builtin_object_size (tree); 173 static rtx expand_builtin_memory_chk (tree, rtx, machine_mode, 174 enum built_in_function); 175 static void maybe_emit_chk_warning (tree, enum built_in_function); 176 static void maybe_emit_sprintf_chk_warning (tree, enum built_in_function); 177 static void maybe_emit_free_warning (tree); 178 static tree fold_builtin_object_size (tree, tree); 179 180 unsigned HOST_WIDE_INT target_newline; 181 unsigned HOST_WIDE_INT target_percent; 182 static unsigned HOST_WIDE_INT target_c; 183 static unsigned HOST_WIDE_INT target_s; 184 char target_percent_c[3]; 185 char target_percent_s[3]; 186 char target_percent_s_newline[4]; 187 static tree do_mpfr_remquo (tree, tree, tree); 188 static tree do_mpfr_lgamma_r (tree, tree, tree); 189 static void expand_builtin_sync_synchronize (void); 190 191 /* Return true if NAME starts with __builtin_ or __sync_. */ 192 193 static bool 194 is_builtin_name (const char *name) 195 { 196 if (strncmp (name, "__builtin_", 10) == 0) 197 return true; 198 if (strncmp (name, "__sync_", 7) == 0) 199 return true; 200 if (strncmp (name, "__atomic_", 9) == 0) 201 return true; 202 if (flag_cilkplus 203 && (!strcmp (name, "__cilkrts_detach") 204 || !strcmp (name, "__cilkrts_pop_frame"))) 205 return true; 206 return false; 207 } 208 209 210 /* Return true if DECL is a function symbol representing a built-in. */ 211 212 bool 213 is_builtin_fn (tree decl) 214 { 215 return TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl); 216 } 217 218 /* Return true if NODE should be considered for inline expansion regardless 219 of the optimization level. This means whenever a function is invoked with 220 its "internal" name, which normally contains the prefix "__builtin". */ 221 222 bool 223 called_as_built_in (tree node) 224 { 225 /* Note that we must use DECL_NAME, not DECL_ASSEMBLER_NAME_SET_P since 226 we want the name used to call the function, not the name it 227 will have. */ 228 const char *name = IDENTIFIER_POINTER (DECL_NAME (node)); 229 return is_builtin_name (name); 230 } 231 232 /* Compute values M and N such that M divides (address of EXP - N) and such 233 that N < M. If these numbers can be determined, store M in alignp and N in 234 *BITPOSP and return true. Otherwise return false and store BITS_PER_UNIT to 235 *alignp and any bit-offset to *bitposp. 236 237 Note that the address (and thus the alignment) computed here is based 238 on the address to which a symbol resolves, whereas DECL_ALIGN is based 239 on the address at which an object is actually located. These two 240 addresses are not always the same. For example, on ARM targets, 241 the address &foo of a Thumb function foo() has the lowest bit set, 242 whereas foo() itself starts on an even address. 243 244 If ADDR_P is true we are taking the address of the memory reference EXP 245 and thus cannot rely on the access taking place. */ 246 247 static bool 248 get_object_alignment_2 (tree exp, unsigned int *alignp, 249 unsigned HOST_WIDE_INT *bitposp, bool addr_p) 250 { 251 HOST_WIDE_INT bitsize, bitpos; 252 tree offset; 253 machine_mode mode; 254 int unsignedp, reversep, volatilep; 255 unsigned int align = BITS_PER_UNIT; 256 bool known_alignment = false; 257 258 /* Get the innermost object and the constant (bitpos) and possibly 259 variable (offset) offset of the access. */ 260 exp = get_inner_reference (exp, &bitsize, &bitpos, &offset, &mode, 261 &unsignedp, &reversep, &volatilep, true); 262 263 /* Extract alignment information from the innermost object and 264 possibly adjust bitpos and offset. */ 265 if (TREE_CODE (exp) == FUNCTION_DECL) 266 { 267 /* Function addresses can encode extra information besides their 268 alignment. However, if TARGET_PTRMEMFUNC_VBIT_LOCATION 269 allows the low bit to be used as a virtual bit, we know 270 that the address itself must be at least 2-byte aligned. */ 271 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn) 272 align = 2 * BITS_PER_UNIT; 273 } 274 else if (TREE_CODE (exp) == LABEL_DECL) 275 ; 276 else if (TREE_CODE (exp) == CONST_DECL) 277 { 278 /* The alignment of a CONST_DECL is determined by its initializer. */ 279 exp = DECL_INITIAL (exp); 280 align = TYPE_ALIGN (TREE_TYPE (exp)); 281 if (CONSTANT_CLASS_P (exp)) 282 align = (unsigned) CONSTANT_ALIGNMENT (exp, align); 283 284 known_alignment = true; 285 } 286 else if (DECL_P (exp)) 287 { 288 align = DECL_ALIGN (exp); 289 known_alignment = true; 290 } 291 else if (TREE_CODE (exp) == VIEW_CONVERT_EXPR) 292 { 293 align = TYPE_ALIGN (TREE_TYPE (exp)); 294 } 295 else if (TREE_CODE (exp) == INDIRECT_REF 296 || TREE_CODE (exp) == MEM_REF 297 || TREE_CODE (exp) == TARGET_MEM_REF) 298 { 299 tree addr = TREE_OPERAND (exp, 0); 300 unsigned ptr_align; 301 unsigned HOST_WIDE_INT ptr_bitpos; 302 unsigned HOST_WIDE_INT ptr_bitmask = ~0; 303 304 /* If the address is explicitely aligned, handle that. */ 305 if (TREE_CODE (addr) == BIT_AND_EXPR 306 && TREE_CODE (TREE_OPERAND (addr, 1)) == INTEGER_CST) 307 { 308 ptr_bitmask = TREE_INT_CST_LOW (TREE_OPERAND (addr, 1)); 309 ptr_bitmask *= BITS_PER_UNIT; 310 align = ptr_bitmask & -ptr_bitmask; 311 addr = TREE_OPERAND (addr, 0); 312 } 313 314 known_alignment 315 = get_pointer_alignment_1 (addr, &ptr_align, &ptr_bitpos); 316 align = MAX (ptr_align, align); 317 318 /* Re-apply explicit alignment to the bitpos. */ 319 ptr_bitpos &= ptr_bitmask; 320 321 /* The alignment of the pointer operand in a TARGET_MEM_REF 322 has to take the variable offset parts into account. */ 323 if (TREE_CODE (exp) == TARGET_MEM_REF) 324 { 325 if (TMR_INDEX (exp)) 326 { 327 unsigned HOST_WIDE_INT step = 1; 328 if (TMR_STEP (exp)) 329 step = TREE_INT_CST_LOW (TMR_STEP (exp)); 330 align = MIN (align, (step & -step) * BITS_PER_UNIT); 331 } 332 if (TMR_INDEX2 (exp)) 333 align = BITS_PER_UNIT; 334 known_alignment = false; 335 } 336 337 /* When EXP is an actual memory reference then we can use 338 TYPE_ALIGN of a pointer indirection to derive alignment. 339 Do so only if get_pointer_alignment_1 did not reveal absolute 340 alignment knowledge and if using that alignment would 341 improve the situation. */ 342 if (!addr_p && !known_alignment 343 && TYPE_ALIGN (TREE_TYPE (exp)) > align) 344 align = TYPE_ALIGN (TREE_TYPE (exp)); 345 else 346 { 347 /* Else adjust bitpos accordingly. */ 348 bitpos += ptr_bitpos; 349 if (TREE_CODE (exp) == MEM_REF 350 || TREE_CODE (exp) == TARGET_MEM_REF) 351 bitpos += mem_ref_offset (exp).to_short_addr () * BITS_PER_UNIT; 352 } 353 } 354 else if (TREE_CODE (exp) == STRING_CST) 355 { 356 /* STRING_CST are the only constant objects we allow to be not 357 wrapped inside a CONST_DECL. */ 358 align = TYPE_ALIGN (TREE_TYPE (exp)); 359 if (CONSTANT_CLASS_P (exp)) 360 align = (unsigned) CONSTANT_ALIGNMENT (exp, align); 361 362 known_alignment = true; 363 } 364 365 /* If there is a non-constant offset part extract the maximum 366 alignment that can prevail. */ 367 if (offset) 368 { 369 unsigned int trailing_zeros = tree_ctz (offset); 370 if (trailing_zeros < HOST_BITS_PER_INT) 371 { 372 unsigned int inner = (1U << trailing_zeros) * BITS_PER_UNIT; 373 if (inner) 374 align = MIN (align, inner); 375 } 376 } 377 378 *alignp = align; 379 *bitposp = bitpos & (*alignp - 1); 380 return known_alignment; 381 } 382 383 /* For a memory reference expression EXP compute values M and N such that M 384 divides (&EXP - N) and such that N < M. If these numbers can be determined, 385 store M in alignp and N in *BITPOSP and return true. Otherwise return false 386 and store BITS_PER_UNIT to *alignp and any bit-offset to *bitposp. */ 387 388 bool 389 get_object_alignment_1 (tree exp, unsigned int *alignp, 390 unsigned HOST_WIDE_INT *bitposp) 391 { 392 return get_object_alignment_2 (exp, alignp, bitposp, false); 393 } 394 395 /* Return the alignment in bits of EXP, an object. */ 396 397 unsigned int 398 get_object_alignment (tree exp) 399 { 400 unsigned HOST_WIDE_INT bitpos = 0; 401 unsigned int align; 402 403 get_object_alignment_1 (exp, &align, &bitpos); 404 405 /* align and bitpos now specify known low bits of the pointer. 406 ptr & (align - 1) == bitpos. */ 407 408 if (bitpos != 0) 409 align = (bitpos & -bitpos); 410 return align; 411 } 412 413 /* For a pointer valued expression EXP compute values M and N such that M 414 divides (EXP - N) and such that N < M. If these numbers can be determined, 415 store M in alignp and N in *BITPOSP and return true. Return false if 416 the results are just a conservative approximation. 417 418 If EXP is not a pointer, false is returned too. */ 419 420 bool 421 get_pointer_alignment_1 (tree exp, unsigned int *alignp, 422 unsigned HOST_WIDE_INT *bitposp) 423 { 424 STRIP_NOPS (exp); 425 426 if (TREE_CODE (exp) == ADDR_EXPR) 427 return get_object_alignment_2 (TREE_OPERAND (exp, 0), 428 alignp, bitposp, true); 429 else if (TREE_CODE (exp) == POINTER_PLUS_EXPR) 430 { 431 unsigned int align; 432 unsigned HOST_WIDE_INT bitpos; 433 bool res = get_pointer_alignment_1 (TREE_OPERAND (exp, 0), 434 &align, &bitpos); 435 if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST) 436 bitpos += TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)) * BITS_PER_UNIT; 437 else 438 { 439 unsigned int trailing_zeros = tree_ctz (TREE_OPERAND (exp, 1)); 440 if (trailing_zeros < HOST_BITS_PER_INT) 441 { 442 unsigned int inner = (1U << trailing_zeros) * BITS_PER_UNIT; 443 if (inner) 444 align = MIN (align, inner); 445 } 446 } 447 *alignp = align; 448 *bitposp = bitpos & (align - 1); 449 return res; 450 } 451 else if (TREE_CODE (exp) == SSA_NAME 452 && POINTER_TYPE_P (TREE_TYPE (exp))) 453 { 454 unsigned int ptr_align, ptr_misalign; 455 struct ptr_info_def *pi = SSA_NAME_PTR_INFO (exp); 456 457 if (pi && get_ptr_info_alignment (pi, &ptr_align, &ptr_misalign)) 458 { 459 *bitposp = ptr_misalign * BITS_PER_UNIT; 460 *alignp = ptr_align * BITS_PER_UNIT; 461 /* Make sure to return a sensible alignment when the multiplication 462 by BITS_PER_UNIT overflowed. */ 463 if (*alignp == 0) 464 *alignp = 1u << (HOST_BITS_PER_INT - 1); 465 /* We cannot really tell whether this result is an approximation. */ 466 return false; 467 } 468 else 469 { 470 *bitposp = 0; 471 *alignp = BITS_PER_UNIT; 472 return false; 473 } 474 } 475 else if (TREE_CODE (exp) == INTEGER_CST) 476 { 477 *alignp = BIGGEST_ALIGNMENT; 478 *bitposp = ((TREE_INT_CST_LOW (exp) * BITS_PER_UNIT) 479 & (BIGGEST_ALIGNMENT - 1)); 480 return true; 481 } 482 483 *bitposp = 0; 484 *alignp = BITS_PER_UNIT; 485 return false; 486 } 487 488 /* Return the alignment in bits of EXP, a pointer valued expression. 489 The alignment returned is, by default, the alignment of the thing that 490 EXP points to. If it is not a POINTER_TYPE, 0 is returned. 491 492 Otherwise, look at the expression to see if we can do better, i.e., if the 493 expression is actually pointing at an object whose alignment is tighter. */ 494 495 unsigned int 496 get_pointer_alignment (tree exp) 497 { 498 unsigned HOST_WIDE_INT bitpos = 0; 499 unsigned int align; 500 501 get_pointer_alignment_1 (exp, &align, &bitpos); 502 503 /* align and bitpos now specify known low bits of the pointer. 504 ptr & (align - 1) == bitpos. */ 505 506 if (bitpos != 0) 507 align = (bitpos & -bitpos); 508 509 return align; 510 } 511 512 /* Compute the length of a C string. TREE_STRING_LENGTH is not the right 513 way, because it could contain a zero byte in the middle. 514 TREE_STRING_LENGTH is the size of the character array, not the string. 515 516 ONLY_VALUE should be nonzero if the result is not going to be emitted 517 into the instruction stream and zero if it is going to be expanded. 518 E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is nonzero, constant 3 519 is returned, otherwise NULL, since 520 len = c_strlen (src, 1); if (len) expand_expr (len, ...); would not 521 evaluate the side-effects. 522 523 If ONLY_VALUE is two then we do not emit warnings about out-of-bound 524 accesses. Note that this implies the result is not going to be emitted 525 into the instruction stream. 526 527 The value returned is of type `ssizetype'. 528 529 Unfortunately, string_constant can't access the values of const char 530 arrays with initializers, so neither can we do so here. */ 531 532 tree 533 c_strlen (tree src, int only_value) 534 { 535 tree offset_node; 536 HOST_WIDE_INT offset; 537 int max; 538 const char *ptr; 539 location_t loc; 540 541 STRIP_NOPS (src); 542 if (TREE_CODE (src) == COND_EXPR 543 && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0)))) 544 { 545 tree len1, len2; 546 547 len1 = c_strlen (TREE_OPERAND (src, 1), only_value); 548 len2 = c_strlen (TREE_OPERAND (src, 2), only_value); 549 if (tree_int_cst_equal (len1, len2)) 550 return len1; 551 } 552 553 if (TREE_CODE (src) == COMPOUND_EXPR 554 && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0)))) 555 return c_strlen (TREE_OPERAND (src, 1), only_value); 556 557 loc = EXPR_LOC_OR_LOC (src, input_location); 558 559 src = string_constant (src, &offset_node); 560 if (src == 0) 561 return NULL_TREE; 562 563 max = TREE_STRING_LENGTH (src) - 1; 564 ptr = TREE_STRING_POINTER (src); 565 566 if (offset_node && TREE_CODE (offset_node) != INTEGER_CST) 567 { 568 /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't 569 compute the offset to the following null if we don't know where to 570 start searching for it. */ 571 int i; 572 573 for (i = 0; i < max; i++) 574 if (ptr[i] == 0) 575 return NULL_TREE; 576 577 /* We don't know the starting offset, but we do know that the string 578 has no internal zero bytes. We can assume that the offset falls 579 within the bounds of the string; otherwise, the programmer deserves 580 what he gets. Subtract the offset from the length of the string, 581 and return that. This would perhaps not be valid if we were dealing 582 with named arrays in addition to literal string constants. */ 583 584 return size_diffop_loc (loc, size_int (max), offset_node); 585 } 586 587 /* We have a known offset into the string. Start searching there for 588 a null character if we can represent it as a single HOST_WIDE_INT. */ 589 if (offset_node == 0) 590 offset = 0; 591 else if (! tree_fits_shwi_p (offset_node)) 592 offset = -1; 593 else 594 offset = tree_to_shwi (offset_node); 595 596 /* If the offset is known to be out of bounds, warn, and call strlen at 597 runtime. */ 598 if (offset < 0 || offset > max) 599 { 600 /* Suppress multiple warnings for propagated constant strings. */ 601 if (only_value != 2 602 && !TREE_NO_WARNING (src)) 603 { 604 warning_at (loc, 0, "offset outside bounds of constant string"); 605 TREE_NO_WARNING (src) = 1; 606 } 607 return NULL_TREE; 608 } 609 610 /* Use strlen to search for the first zero byte. Since any strings 611 constructed with build_string will have nulls appended, we win even 612 if we get handed something like (char[4])"abcd". 613 614 Since OFFSET is our starting index into the string, no further 615 calculation is needed. */ 616 return ssize_int (strlen (ptr + offset)); 617 } 618 619 /* Return a constant integer corresponding to target reading 620 GET_MODE_BITSIZE (MODE) bits from string constant STR. */ 621 622 static rtx 623 c_readstr (const char *str, machine_mode mode) 624 { 625 HOST_WIDE_INT ch; 626 unsigned int i, j; 627 HOST_WIDE_INT tmp[MAX_BITSIZE_MODE_ANY_INT / HOST_BITS_PER_WIDE_INT]; 628 629 gcc_assert (GET_MODE_CLASS (mode) == MODE_INT); 630 unsigned int len = (GET_MODE_PRECISION (mode) + HOST_BITS_PER_WIDE_INT - 1) 631 / HOST_BITS_PER_WIDE_INT; 632 633 gcc_assert (len <= MAX_BITSIZE_MODE_ANY_INT / HOST_BITS_PER_WIDE_INT); 634 for (i = 0; i < len; i++) 635 tmp[i] = 0; 636 637 ch = 1; 638 for (i = 0; i < GET_MODE_SIZE (mode); i++) 639 { 640 j = i; 641 if (WORDS_BIG_ENDIAN) 642 j = GET_MODE_SIZE (mode) - i - 1; 643 if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN 644 && GET_MODE_SIZE (mode) >= UNITS_PER_WORD) 645 j = j + UNITS_PER_WORD - 2 * (j % UNITS_PER_WORD) - 1; 646 j *= BITS_PER_UNIT; 647 648 if (ch) 649 ch = (unsigned char) str[i]; 650 tmp[j / HOST_BITS_PER_WIDE_INT] |= ch << (j % HOST_BITS_PER_WIDE_INT); 651 } 652 653 wide_int c = wide_int::from_array (tmp, len, GET_MODE_PRECISION (mode)); 654 return immed_wide_int_const (c, mode); 655 } 656 657 /* Cast a target constant CST to target CHAR and if that value fits into 658 host char type, return zero and put that value into variable pointed to by 659 P. */ 660 661 static int 662 target_char_cast (tree cst, char *p) 663 { 664 unsigned HOST_WIDE_INT val, hostval; 665 666 if (TREE_CODE (cst) != INTEGER_CST 667 || CHAR_TYPE_SIZE > HOST_BITS_PER_WIDE_INT) 668 return 1; 669 670 /* Do not care if it fits or not right here. */ 671 val = TREE_INT_CST_LOW (cst); 672 673 if (CHAR_TYPE_SIZE < HOST_BITS_PER_WIDE_INT) 674 val &= (((unsigned HOST_WIDE_INT) 1) << CHAR_TYPE_SIZE) - 1; 675 676 hostval = val; 677 if (HOST_BITS_PER_CHAR < HOST_BITS_PER_WIDE_INT) 678 hostval &= (((unsigned HOST_WIDE_INT) 1) << HOST_BITS_PER_CHAR) - 1; 679 680 if (val != hostval) 681 return 1; 682 683 *p = hostval; 684 return 0; 685 } 686 687 /* Similar to save_expr, but assumes that arbitrary code is not executed 688 in between the multiple evaluations. In particular, we assume that a 689 non-addressable local variable will not be modified. */ 690 691 static tree 692 builtin_save_expr (tree exp) 693 { 694 if (TREE_CODE (exp) == SSA_NAME 695 || (TREE_ADDRESSABLE (exp) == 0 696 && (TREE_CODE (exp) == PARM_DECL 697 || (TREE_CODE (exp) == VAR_DECL && !TREE_STATIC (exp))))) 698 return exp; 699 700 return save_expr (exp); 701 } 702 703 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT 704 times to get the address of either a higher stack frame, or a return 705 address located within it (depending on FNDECL_CODE). */ 706 707 static rtx 708 expand_builtin_return_addr (enum built_in_function fndecl_code, int count) 709 { 710 int i; 711 rtx tem = INITIAL_FRAME_ADDRESS_RTX; 712 if (tem == NULL_RTX) 713 { 714 /* For a zero count with __builtin_return_address, we don't care what 715 frame address we return, because target-specific definitions will 716 override us. Therefore frame pointer elimination is OK, and using 717 the soft frame pointer is OK. 718 719 For a nonzero count, or a zero count with __builtin_frame_address, 720 we require a stable offset from the current frame pointer to the 721 previous one, so we must use the hard frame pointer, and 722 we must disable frame pointer elimination. */ 723 if (count == 0 && fndecl_code == BUILT_IN_RETURN_ADDRESS) 724 tem = frame_pointer_rtx; 725 else 726 { 727 tem = hard_frame_pointer_rtx; 728 729 /* Tell reload not to eliminate the frame pointer. */ 730 crtl->accesses_prior_frames = 1; 731 } 732 } 733 734 if (count > 0) 735 SETUP_FRAME_ADDRESSES (); 736 737 /* On the SPARC, the return address is not in the frame, it is in a 738 register. There is no way to access it off of the current frame 739 pointer, but it can be accessed off the previous frame pointer by 740 reading the value from the register window save area. */ 741 if (RETURN_ADDR_IN_PREVIOUS_FRAME && fndecl_code == BUILT_IN_RETURN_ADDRESS) 742 count--; 743 744 /* Scan back COUNT frames to the specified frame. */ 745 for (i = 0; i < count; i++) 746 { 747 /* Assume the dynamic chain pointer is in the word that the 748 frame address points to, unless otherwise specified. */ 749 tem = DYNAMIC_CHAIN_ADDRESS (tem); 750 tem = memory_address (Pmode, tem); 751 tem = gen_frame_mem (Pmode, tem); 752 tem = copy_to_reg (tem); 753 } 754 755 /* For __builtin_frame_address, return what we've got. But, on 756 the SPARC for example, we may have to add a bias. */ 757 if (fndecl_code == BUILT_IN_FRAME_ADDRESS) 758 return FRAME_ADDR_RTX (tem); 759 760 /* For __builtin_return_address, get the return address from that frame. */ 761 #ifdef RETURN_ADDR_RTX 762 tem = RETURN_ADDR_RTX (count, tem); 763 #else 764 tem = memory_address (Pmode, 765 plus_constant (Pmode, tem, GET_MODE_SIZE (Pmode))); 766 tem = gen_frame_mem (Pmode, tem); 767 #endif 768 return tem; 769 } 770 771 /* Alias set used for setjmp buffer. */ 772 static alias_set_type setjmp_alias_set = -1; 773 774 /* Construct the leading half of a __builtin_setjmp call. Control will 775 return to RECEIVER_LABEL. This is also called directly by the SJLJ 776 exception handling code. */ 777 778 void 779 expand_builtin_setjmp_setup (rtx buf_addr, rtx receiver_label) 780 { 781 machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL); 782 rtx stack_save; 783 rtx mem; 784 785 if (setjmp_alias_set == -1) 786 setjmp_alias_set = new_alias_set (); 787 788 buf_addr = convert_memory_address (Pmode, buf_addr); 789 790 buf_addr = force_reg (Pmode, force_operand (buf_addr, NULL_RTX)); 791 792 /* We store the frame pointer and the address of receiver_label in 793 the buffer and use the rest of it for the stack save area, which 794 is machine-dependent. */ 795 796 mem = gen_rtx_MEM (Pmode, buf_addr); 797 set_mem_alias_set (mem, setjmp_alias_set); 798 emit_move_insn (mem, targetm.builtin_setjmp_frame_value ()); 799 800 mem = gen_rtx_MEM (Pmode, plus_constant (Pmode, buf_addr, 801 GET_MODE_SIZE (Pmode))), 802 set_mem_alias_set (mem, setjmp_alias_set); 803 804 emit_move_insn (validize_mem (mem), 805 force_reg (Pmode, gen_rtx_LABEL_REF (Pmode, receiver_label))); 806 807 stack_save = gen_rtx_MEM (sa_mode, 808 plus_constant (Pmode, buf_addr, 809 2 * GET_MODE_SIZE (Pmode))); 810 set_mem_alias_set (stack_save, setjmp_alias_set); 811 emit_stack_save (SAVE_NONLOCAL, &stack_save); 812 813 /* If there is further processing to do, do it. */ 814 if (targetm.have_builtin_setjmp_setup ()) 815 emit_insn (targetm.gen_builtin_setjmp_setup (buf_addr)); 816 817 /* We have a nonlocal label. */ 818 cfun->has_nonlocal_label = 1; 819 } 820 821 /* Construct the trailing part of a __builtin_setjmp call. This is 822 also called directly by the SJLJ exception handling code. 823 If RECEIVER_LABEL is NULL, instead contruct a nonlocal goto handler. */ 824 825 void 826 expand_builtin_setjmp_receiver (rtx receiver_label) 827 { 828 rtx chain; 829 830 /* Mark the FP as used when we get here, so we have to make sure it's 831 marked as used by this function. */ 832 emit_use (hard_frame_pointer_rtx); 833 834 /* Mark the static chain as clobbered here so life information 835 doesn't get messed up for it. */ 836 chain = targetm.calls.static_chain (current_function_decl, true); 837 if (chain && REG_P (chain)) 838 emit_clobber (chain); 839 840 /* Now put in the code to restore the frame pointer, and argument 841 pointer, if needed. */ 842 if (! targetm.have_nonlocal_goto ()) 843 { 844 /* First adjust our frame pointer to its actual value. It was 845 previously set to the start of the virtual area corresponding to 846 the stacked variables when we branched here and now needs to be 847 adjusted to the actual hardware fp value. 848 849 Assignments to virtual registers are converted by 850 instantiate_virtual_regs into the corresponding assignment 851 to the underlying register (fp in this case) that makes 852 the original assignment true. 853 So the following insn will actually be decrementing fp by 854 STARTING_FRAME_OFFSET. */ 855 emit_move_insn (virtual_stack_vars_rtx, hard_frame_pointer_rtx); 856 857 /* Restoring the frame pointer also modifies the hard frame pointer. 858 Mark it used (so that the previous assignment remains live once 859 the frame pointer is eliminated) and clobbered (to represent the 860 implicit update from the assignment). */ 861 emit_use (hard_frame_pointer_rtx); 862 emit_clobber (hard_frame_pointer_rtx); 863 } 864 865 if (!HARD_FRAME_POINTER_IS_ARG_POINTER && fixed_regs[ARG_POINTER_REGNUM]) 866 { 867 #ifdef ELIMINABLE_REGS 868 /* If the argument pointer can be eliminated in favor of the 869 frame pointer, we don't need to restore it. We assume here 870 that if such an elimination is present, it can always be used. 871 This is the case on all known machines; if we don't make this 872 assumption, we do unnecessary saving on many machines. */ 873 size_t i; 874 static const struct elims {const int from, to;} elim_regs[] = ELIMINABLE_REGS; 875 876 for (i = 0; i < ARRAY_SIZE (elim_regs); i++) 877 if (elim_regs[i].from == ARG_POINTER_REGNUM 878 && elim_regs[i].to == HARD_FRAME_POINTER_REGNUM) 879 break; 880 881 if (i == ARRAY_SIZE (elim_regs)) 882 #endif 883 { 884 /* Now restore our arg pointer from the address at which it 885 was saved in our stack frame. */ 886 emit_move_insn (crtl->args.internal_arg_pointer, 887 copy_to_reg (get_arg_pointer_save_area ())); 888 } 889 } 890 891 if (receiver_label != NULL && targetm.have_builtin_setjmp_receiver ()) 892 emit_insn (targetm.gen_builtin_setjmp_receiver (receiver_label)); 893 else if (targetm.have_nonlocal_goto_receiver ()) 894 emit_insn (targetm.gen_nonlocal_goto_receiver ()); 895 else 896 { /* Nothing */ } 897 898 /* We must not allow the code we just generated to be reordered by 899 scheduling. Specifically, the update of the frame pointer must 900 happen immediately, not later. */ 901 emit_insn (gen_blockage ()); 902 } 903 904 /* __builtin_longjmp is passed a pointer to an array of five words (not 905 all will be used on all machines). It operates similarly to the C 906 library function of the same name, but is more efficient. Much of 907 the code below is copied from the handling of non-local gotos. */ 908 909 static void 910 expand_builtin_longjmp (rtx buf_addr, rtx value) 911 { 912 rtx fp, lab, stack; 913 rtx_insn *insn, *last; 914 machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL); 915 916 /* DRAP is needed for stack realign if longjmp is expanded to current 917 function */ 918 if (SUPPORTS_STACK_ALIGNMENT) 919 crtl->need_drap = true; 920 921 if (setjmp_alias_set == -1) 922 setjmp_alias_set = new_alias_set (); 923 924 buf_addr = convert_memory_address (Pmode, buf_addr); 925 926 buf_addr = force_reg (Pmode, buf_addr); 927 928 /* We require that the user must pass a second argument of 1, because 929 that is what builtin_setjmp will return. */ 930 gcc_assert (value == const1_rtx); 931 932 last = get_last_insn (); 933 if (targetm.have_builtin_longjmp ()) 934 emit_insn (targetm.gen_builtin_longjmp (buf_addr)); 935 else 936 { 937 fp = gen_rtx_MEM (Pmode, buf_addr); 938 lab = gen_rtx_MEM (Pmode, plus_constant (Pmode, buf_addr, 939 GET_MODE_SIZE (Pmode))); 940 941 stack = gen_rtx_MEM (sa_mode, plus_constant (Pmode, buf_addr, 942 2 * GET_MODE_SIZE (Pmode))); 943 set_mem_alias_set (fp, setjmp_alias_set); 944 set_mem_alias_set (lab, setjmp_alias_set); 945 set_mem_alias_set (stack, setjmp_alias_set); 946 947 /* Pick up FP, label, and SP from the block and jump. This code is 948 from expand_goto in stmt.c; see there for detailed comments. */ 949 if (targetm.have_nonlocal_goto ()) 950 /* We have to pass a value to the nonlocal_goto pattern that will 951 get copied into the static_chain pointer, but it does not matter 952 what that value is, because builtin_setjmp does not use it. */ 953 emit_insn (targetm.gen_nonlocal_goto (value, lab, stack, fp)); 954 else 955 { 956 lab = copy_to_reg (lab); 957 958 emit_clobber (gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode))); 959 emit_clobber (gen_rtx_MEM (BLKmode, hard_frame_pointer_rtx)); 960 961 emit_move_insn (hard_frame_pointer_rtx, fp); 962 emit_stack_restore (SAVE_NONLOCAL, stack); 963 964 emit_use (hard_frame_pointer_rtx); 965 emit_use (stack_pointer_rtx); 966 emit_indirect_jump (lab); 967 } 968 } 969 970 /* Search backwards and mark the jump insn as a non-local goto. 971 Note that this precludes the use of __builtin_longjmp to a 972 __builtin_setjmp target in the same function. However, we've 973 already cautioned the user that these functions are for 974 internal exception handling use only. */ 975 for (insn = get_last_insn (); insn; insn = PREV_INSN (insn)) 976 { 977 gcc_assert (insn != last); 978 979 if (JUMP_P (insn)) 980 { 981 add_reg_note (insn, REG_NON_LOCAL_GOTO, const0_rtx); 982 break; 983 } 984 else if (CALL_P (insn)) 985 break; 986 } 987 } 988 989 static inline bool 990 more_const_call_expr_args_p (const const_call_expr_arg_iterator *iter) 991 { 992 return (iter->i < iter->n); 993 } 994 995 /* This function validates the types of a function call argument list 996 against a specified list of tree_codes. If the last specifier is a 0, 997 that represents an ellipses, otherwise the last specifier must be a 998 VOID_TYPE. */ 999 1000 static bool 1001 validate_arglist (const_tree callexpr, ...) 1002 { 1003 enum tree_code code; 1004 bool res = 0; 1005 va_list ap; 1006 const_call_expr_arg_iterator iter; 1007 const_tree arg; 1008 1009 va_start (ap, callexpr); 1010 init_const_call_expr_arg_iterator (callexpr, &iter); 1011 1012 do 1013 { 1014 code = (enum tree_code) va_arg (ap, int); 1015 switch (code) 1016 { 1017 case 0: 1018 /* This signifies an ellipses, any further arguments are all ok. */ 1019 res = true; 1020 goto end; 1021 case VOID_TYPE: 1022 /* This signifies an endlink, if no arguments remain, return 1023 true, otherwise return false. */ 1024 res = !more_const_call_expr_args_p (&iter); 1025 goto end; 1026 default: 1027 /* If no parameters remain or the parameter's code does not 1028 match the specified code, return false. Otherwise continue 1029 checking any remaining arguments. */ 1030 arg = next_const_call_expr_arg (&iter); 1031 if (!validate_arg (arg, code)) 1032 goto end; 1033 break; 1034 } 1035 } 1036 while (1); 1037 1038 /* We need gotos here since we can only have one VA_CLOSE in a 1039 function. */ 1040 end: ; 1041 va_end (ap); 1042 1043 return res; 1044 } 1045 1046 /* Expand a call to __builtin_nonlocal_goto. We're passed the target label 1047 and the address of the save area. */ 1048 1049 static rtx 1050 expand_builtin_nonlocal_goto (tree exp) 1051 { 1052 tree t_label, t_save_area; 1053 rtx r_label, r_save_area, r_fp, r_sp; 1054 rtx_insn *insn; 1055 1056 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE)) 1057 return NULL_RTX; 1058 1059 t_label = CALL_EXPR_ARG (exp, 0); 1060 t_save_area = CALL_EXPR_ARG (exp, 1); 1061 1062 r_label = expand_normal (t_label); 1063 r_label = convert_memory_address (Pmode, r_label); 1064 r_save_area = expand_normal (t_save_area); 1065 r_save_area = convert_memory_address (Pmode, r_save_area); 1066 /* Copy the address of the save location to a register just in case it was 1067 based on the frame pointer. */ 1068 r_save_area = copy_to_reg (r_save_area); 1069 r_fp = gen_rtx_MEM (Pmode, r_save_area); 1070 r_sp = gen_rtx_MEM (STACK_SAVEAREA_MODE (SAVE_NONLOCAL), 1071 plus_constant (Pmode, r_save_area, 1072 GET_MODE_SIZE (Pmode))); 1073 1074 crtl->has_nonlocal_goto = 1; 1075 1076 /* ??? We no longer need to pass the static chain value, afaik. */ 1077 if (targetm.have_nonlocal_goto ()) 1078 emit_insn (targetm.gen_nonlocal_goto (const0_rtx, r_label, r_sp, r_fp)); 1079 else 1080 { 1081 r_label = copy_to_reg (r_label); 1082 1083 emit_clobber (gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode))); 1084 emit_clobber (gen_rtx_MEM (BLKmode, hard_frame_pointer_rtx)); 1085 1086 /* Restore frame pointer for containing function. */ 1087 emit_move_insn (hard_frame_pointer_rtx, r_fp); 1088 emit_stack_restore (SAVE_NONLOCAL, r_sp); 1089 1090 /* USE of hard_frame_pointer_rtx added for consistency; 1091 not clear if really needed. */ 1092 emit_use (hard_frame_pointer_rtx); 1093 emit_use (stack_pointer_rtx); 1094 1095 /* If the architecture is using a GP register, we must 1096 conservatively assume that the target function makes use of it. 1097 The prologue of functions with nonlocal gotos must therefore 1098 initialize the GP register to the appropriate value, and we 1099 must then make sure that this value is live at the point 1100 of the jump. (Note that this doesn't necessarily apply 1101 to targets with a nonlocal_goto pattern; they are free 1102 to implement it in their own way. Note also that this is 1103 a no-op if the GP register is a global invariant.) */ 1104 if ((unsigned) PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM 1105 && fixed_regs[PIC_OFFSET_TABLE_REGNUM]) 1106 emit_use (pic_offset_table_rtx); 1107 1108 emit_indirect_jump (r_label); 1109 } 1110 1111 /* Search backwards to the jump insn and mark it as a 1112 non-local goto. */ 1113 for (insn = get_last_insn (); insn; insn = PREV_INSN (insn)) 1114 { 1115 if (JUMP_P (insn)) 1116 { 1117 add_reg_note (insn, REG_NON_LOCAL_GOTO, const0_rtx); 1118 break; 1119 } 1120 else if (CALL_P (insn)) 1121 break; 1122 } 1123 1124 return const0_rtx; 1125 } 1126 1127 /* __builtin_update_setjmp_buf is passed a pointer to an array of five words 1128 (not all will be used on all machines) that was passed to __builtin_setjmp. 1129 It updates the stack pointer in that block to the current value. This is 1130 also called directly by the SJLJ exception handling code. */ 1131 1132 void 1133 expand_builtin_update_setjmp_buf (rtx buf_addr) 1134 { 1135 machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL); 1136 rtx stack_save 1137 = gen_rtx_MEM (sa_mode, 1138 memory_address 1139 (sa_mode, 1140 plus_constant (Pmode, buf_addr, 1141 2 * GET_MODE_SIZE (Pmode)))); 1142 1143 emit_stack_save (SAVE_NONLOCAL, &stack_save); 1144 } 1145 1146 /* Expand a call to __builtin_prefetch. For a target that does not support 1147 data prefetch, evaluate the memory address argument in case it has side 1148 effects. */ 1149 1150 static void 1151 expand_builtin_prefetch (tree exp) 1152 { 1153 tree arg0, arg1, arg2; 1154 int nargs; 1155 rtx op0, op1, op2; 1156 1157 if (!validate_arglist (exp, POINTER_TYPE, 0)) 1158 return; 1159 1160 arg0 = CALL_EXPR_ARG (exp, 0); 1161 1162 /* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to 1163 zero (read) and argument 2 (locality) defaults to 3 (high degree of 1164 locality). */ 1165 nargs = call_expr_nargs (exp); 1166 if (nargs > 1) 1167 arg1 = CALL_EXPR_ARG (exp, 1); 1168 else 1169 arg1 = integer_zero_node; 1170 if (nargs > 2) 1171 arg2 = CALL_EXPR_ARG (exp, 2); 1172 else 1173 arg2 = integer_three_node; 1174 1175 /* Argument 0 is an address. */ 1176 op0 = expand_expr (arg0, NULL_RTX, Pmode, EXPAND_NORMAL); 1177 1178 /* Argument 1 (read/write flag) must be a compile-time constant int. */ 1179 if (TREE_CODE (arg1) != INTEGER_CST) 1180 { 1181 error ("second argument to %<__builtin_prefetch%> must be a constant"); 1182 arg1 = integer_zero_node; 1183 } 1184 op1 = expand_normal (arg1); 1185 /* Argument 1 must be either zero or one. */ 1186 if (INTVAL (op1) != 0 && INTVAL (op1) != 1) 1187 { 1188 warning (0, "invalid second argument to %<__builtin_prefetch%>;" 1189 " using zero"); 1190 op1 = const0_rtx; 1191 } 1192 1193 /* Argument 2 (locality) must be a compile-time constant int. */ 1194 if (TREE_CODE (arg2) != INTEGER_CST) 1195 { 1196 error ("third argument to %<__builtin_prefetch%> must be a constant"); 1197 arg2 = integer_zero_node; 1198 } 1199 op2 = expand_normal (arg2); 1200 /* Argument 2 must be 0, 1, 2, or 3. */ 1201 if (INTVAL (op2) < 0 || INTVAL (op2) > 3) 1202 { 1203 warning (0, "invalid third argument to %<__builtin_prefetch%>; using zero"); 1204 op2 = const0_rtx; 1205 } 1206 1207 if (targetm.have_prefetch ()) 1208 { 1209 struct expand_operand ops[3]; 1210 1211 create_address_operand (&ops[0], op0); 1212 create_integer_operand (&ops[1], INTVAL (op1)); 1213 create_integer_operand (&ops[2], INTVAL (op2)); 1214 if (maybe_expand_insn (targetm.code_for_prefetch, 3, ops)) 1215 return; 1216 } 1217 1218 /* Don't do anything with direct references to volatile memory, but 1219 generate code to handle other side effects. */ 1220 if (!MEM_P (op0) && side_effects_p (op0)) 1221 emit_insn (op0); 1222 } 1223 1224 /* Get a MEM rtx for expression EXP which is the address of an operand 1225 to be used in a string instruction (cmpstrsi, movmemsi, ..). LEN is 1226 the maximum length of the block of memory that might be accessed or 1227 NULL if unknown. */ 1228 1229 static rtx 1230 get_memory_rtx (tree exp, tree len) 1231 { 1232 tree orig_exp = exp; 1233 rtx addr, mem; 1234 1235 /* When EXP is not resolved SAVE_EXPR, MEM_ATTRS can be still derived 1236 from its expression, for expr->a.b only <variable>.a.b is recorded. */ 1237 if (TREE_CODE (exp) == SAVE_EXPR && !SAVE_EXPR_RESOLVED_P (exp)) 1238 exp = TREE_OPERAND (exp, 0); 1239 1240 addr = expand_expr (orig_exp, NULL_RTX, ptr_mode, EXPAND_NORMAL); 1241 mem = gen_rtx_MEM (BLKmode, memory_address (BLKmode, addr)); 1242 1243 /* Get an expression we can use to find the attributes to assign to MEM. 1244 First remove any nops. */ 1245 while (CONVERT_EXPR_P (exp) 1246 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (exp, 0)))) 1247 exp = TREE_OPERAND (exp, 0); 1248 1249 /* Build a MEM_REF representing the whole accessed area as a byte blob, 1250 (as builtin stringops may alias with anything). */ 1251 exp = fold_build2 (MEM_REF, 1252 build_array_type (char_type_node, 1253 build_range_type (sizetype, 1254 size_one_node, len)), 1255 exp, build_int_cst (ptr_type_node, 0)); 1256 1257 /* If the MEM_REF has no acceptable address, try to get the base object 1258 from the original address we got, and build an all-aliasing 1259 unknown-sized access to that one. */ 1260 if (is_gimple_mem_ref_addr (TREE_OPERAND (exp, 0))) 1261 set_mem_attributes (mem, exp, 0); 1262 else if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR 1263 && (exp = get_base_address (TREE_OPERAND (TREE_OPERAND (exp, 0), 1264 0)))) 1265 { 1266 exp = build_fold_addr_expr (exp); 1267 exp = fold_build2 (MEM_REF, 1268 build_array_type (char_type_node, 1269 build_range_type (sizetype, 1270 size_zero_node, 1271 NULL)), 1272 exp, build_int_cst (ptr_type_node, 0)); 1273 set_mem_attributes (mem, exp, 0); 1274 } 1275 set_mem_alias_set (mem, 0); 1276 return mem; 1277 } 1278 1279 /* Built-in functions to perform an untyped call and return. */ 1280 1281 #define apply_args_mode \ 1282 (this_target_builtins->x_apply_args_mode) 1283 #define apply_result_mode \ 1284 (this_target_builtins->x_apply_result_mode) 1285 1286 /* Return the size required for the block returned by __builtin_apply_args, 1287 and initialize apply_args_mode. */ 1288 1289 static int 1290 apply_args_size (void) 1291 { 1292 static int size = -1; 1293 int align; 1294 unsigned int regno; 1295 machine_mode mode; 1296 1297 /* The values computed by this function never change. */ 1298 if (size < 0) 1299 { 1300 /* The first value is the incoming arg-pointer. */ 1301 size = GET_MODE_SIZE (Pmode); 1302 1303 /* The second value is the structure value address unless this is 1304 passed as an "invisible" first argument. */ 1305 if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0)) 1306 size += GET_MODE_SIZE (Pmode); 1307 1308 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++) 1309 if (FUNCTION_ARG_REGNO_P (regno)) 1310 { 1311 mode = targetm.calls.get_raw_arg_mode (regno); 1312 1313 gcc_assert (mode != VOIDmode); 1314 1315 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT; 1316 if (size % align != 0) 1317 size = CEIL (size, align) * align; 1318 size += GET_MODE_SIZE (mode); 1319 apply_args_mode[regno] = mode; 1320 } 1321 else 1322 { 1323 apply_args_mode[regno] = VOIDmode; 1324 } 1325 } 1326 return size; 1327 } 1328 1329 /* Return the size required for the block returned by __builtin_apply, 1330 and initialize apply_result_mode. */ 1331 1332 static int 1333 apply_result_size (void) 1334 { 1335 static int size = -1; 1336 int align, regno; 1337 machine_mode mode; 1338 1339 /* The values computed by this function never change. */ 1340 if (size < 0) 1341 { 1342 size = 0; 1343 1344 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++) 1345 if (targetm.calls.function_value_regno_p (regno)) 1346 { 1347 mode = targetm.calls.get_raw_result_mode (regno); 1348 1349 gcc_assert (mode != VOIDmode); 1350 1351 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT; 1352 if (size % align != 0) 1353 size = CEIL (size, align) * align; 1354 size += GET_MODE_SIZE (mode); 1355 apply_result_mode[regno] = mode; 1356 } 1357 else 1358 apply_result_mode[regno] = VOIDmode; 1359 1360 /* Allow targets that use untyped_call and untyped_return to override 1361 the size so that machine-specific information can be stored here. */ 1362 #ifdef APPLY_RESULT_SIZE 1363 size = APPLY_RESULT_SIZE; 1364 #endif 1365 } 1366 return size; 1367 } 1368 1369 /* Create a vector describing the result block RESULT. If SAVEP is true, 1370 the result block is used to save the values; otherwise it is used to 1371 restore the values. */ 1372 1373 static rtx 1374 result_vector (int savep, rtx result) 1375 { 1376 int regno, size, align, nelts; 1377 machine_mode mode; 1378 rtx reg, mem; 1379 rtx *savevec = XALLOCAVEC (rtx, FIRST_PSEUDO_REGISTER); 1380 1381 size = nelts = 0; 1382 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++) 1383 if ((mode = apply_result_mode[regno]) != VOIDmode) 1384 { 1385 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT; 1386 if (size % align != 0) 1387 size = CEIL (size, align) * align; 1388 reg = gen_rtx_REG (mode, savep ? regno : INCOMING_REGNO (regno)); 1389 mem = adjust_address (result, mode, size); 1390 savevec[nelts++] = (savep 1391 ? gen_rtx_SET (mem, reg) 1392 : gen_rtx_SET (reg, mem)); 1393 size += GET_MODE_SIZE (mode); 1394 } 1395 return gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelts, savevec)); 1396 } 1397 1398 /* Save the state required to perform an untyped call with the same 1399 arguments as were passed to the current function. */ 1400 1401 static rtx 1402 expand_builtin_apply_args_1 (void) 1403 { 1404 rtx registers, tem; 1405 int size, align, regno; 1406 machine_mode mode; 1407 rtx struct_incoming_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 1); 1408 1409 /* Create a block where the arg-pointer, structure value address, 1410 and argument registers can be saved. */ 1411 registers = assign_stack_local (BLKmode, apply_args_size (), -1); 1412 1413 /* Walk past the arg-pointer and structure value address. */ 1414 size = GET_MODE_SIZE (Pmode); 1415 if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0)) 1416 size += GET_MODE_SIZE (Pmode); 1417 1418 /* Save each register used in calling a function to the block. */ 1419 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++) 1420 if ((mode = apply_args_mode[regno]) != VOIDmode) 1421 { 1422 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT; 1423 if (size % align != 0) 1424 size = CEIL (size, align) * align; 1425 1426 tem = gen_rtx_REG (mode, INCOMING_REGNO (regno)); 1427 1428 emit_move_insn (adjust_address (registers, mode, size), tem); 1429 size += GET_MODE_SIZE (mode); 1430 } 1431 1432 /* Save the arg pointer to the block. */ 1433 tem = copy_to_reg (crtl->args.internal_arg_pointer); 1434 /* We need the pointer as the caller actually passed them to us, not 1435 as we might have pretended they were passed. Make sure it's a valid 1436 operand, as emit_move_insn isn't expected to handle a PLUS. */ 1437 if (STACK_GROWS_DOWNWARD) 1438 tem 1439 = force_operand (plus_constant (Pmode, tem, 1440 crtl->args.pretend_args_size), 1441 NULL_RTX); 1442 emit_move_insn (adjust_address (registers, Pmode, 0), tem); 1443 1444 size = GET_MODE_SIZE (Pmode); 1445 1446 /* Save the structure value address unless this is passed as an 1447 "invisible" first argument. */ 1448 if (struct_incoming_value) 1449 { 1450 emit_move_insn (adjust_address (registers, Pmode, size), 1451 copy_to_reg (struct_incoming_value)); 1452 size += GET_MODE_SIZE (Pmode); 1453 } 1454 1455 /* Return the address of the block. */ 1456 return copy_addr_to_reg (XEXP (registers, 0)); 1457 } 1458 1459 /* __builtin_apply_args returns block of memory allocated on 1460 the stack into which is stored the arg pointer, structure 1461 value address, static chain, and all the registers that might 1462 possibly be used in performing a function call. The code is 1463 moved to the start of the function so the incoming values are 1464 saved. */ 1465 1466 static rtx 1467 expand_builtin_apply_args (void) 1468 { 1469 /* Don't do __builtin_apply_args more than once in a function. 1470 Save the result of the first call and reuse it. */ 1471 if (apply_args_value != 0) 1472 return apply_args_value; 1473 { 1474 /* When this function is called, it means that registers must be 1475 saved on entry to this function. So we migrate the 1476 call to the first insn of this function. */ 1477 rtx temp; 1478 1479 start_sequence (); 1480 temp = expand_builtin_apply_args_1 (); 1481 rtx_insn *seq = get_insns (); 1482 end_sequence (); 1483 1484 apply_args_value = temp; 1485 1486 /* Put the insns after the NOTE that starts the function. 1487 If this is inside a start_sequence, make the outer-level insn 1488 chain current, so the code is placed at the start of the 1489 function. If internal_arg_pointer is a non-virtual pseudo, 1490 it needs to be placed after the function that initializes 1491 that pseudo. */ 1492 push_topmost_sequence (); 1493 if (REG_P (crtl->args.internal_arg_pointer) 1494 && REGNO (crtl->args.internal_arg_pointer) > LAST_VIRTUAL_REGISTER) 1495 emit_insn_before (seq, parm_birth_insn); 1496 else 1497 emit_insn_before (seq, NEXT_INSN (entry_of_function ())); 1498 pop_topmost_sequence (); 1499 return temp; 1500 } 1501 } 1502 1503 /* Perform an untyped call and save the state required to perform an 1504 untyped return of whatever value was returned by the given function. */ 1505 1506 static rtx 1507 expand_builtin_apply (rtx function, rtx arguments, rtx argsize) 1508 { 1509 int size, align, regno; 1510 machine_mode mode; 1511 rtx incoming_args, result, reg, dest, src; 1512 rtx_call_insn *call_insn; 1513 rtx old_stack_level = 0; 1514 rtx call_fusage = 0; 1515 rtx struct_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0); 1516 1517 arguments = convert_memory_address (Pmode, arguments); 1518 1519 /* Create a block where the return registers can be saved. */ 1520 result = assign_stack_local (BLKmode, apply_result_size (), -1); 1521 1522 /* Fetch the arg pointer from the ARGUMENTS block. */ 1523 incoming_args = gen_reg_rtx (Pmode); 1524 emit_move_insn (incoming_args, gen_rtx_MEM (Pmode, arguments)); 1525 if (!STACK_GROWS_DOWNWARD) 1526 incoming_args = expand_simple_binop (Pmode, MINUS, incoming_args, argsize, 1527 incoming_args, 0, OPTAB_LIB_WIDEN); 1528 1529 /* Push a new argument block and copy the arguments. Do not allow 1530 the (potential) memcpy call below to interfere with our stack 1531 manipulations. */ 1532 do_pending_stack_adjust (); 1533 NO_DEFER_POP; 1534 1535 /* Save the stack with nonlocal if available. */ 1536 if (targetm.have_save_stack_nonlocal ()) 1537 emit_stack_save (SAVE_NONLOCAL, &old_stack_level); 1538 else 1539 emit_stack_save (SAVE_BLOCK, &old_stack_level); 1540 1541 /* Allocate a block of memory onto the stack and copy the memory 1542 arguments to the outgoing arguments address. We can pass TRUE 1543 as the 4th argument because we just saved the stack pointer 1544 and will restore it right after the call. */ 1545 allocate_dynamic_stack_space (argsize, 0, BIGGEST_ALIGNMENT, true); 1546 1547 /* Set DRAP flag to true, even though allocate_dynamic_stack_space 1548 may have already set current_function_calls_alloca to true. 1549 current_function_calls_alloca won't be set if argsize is zero, 1550 so we have to guarantee need_drap is true here. */ 1551 if (SUPPORTS_STACK_ALIGNMENT) 1552 crtl->need_drap = true; 1553 1554 dest = virtual_outgoing_args_rtx; 1555 if (!STACK_GROWS_DOWNWARD) 1556 { 1557 if (CONST_INT_P (argsize)) 1558 dest = plus_constant (Pmode, dest, -INTVAL (argsize)); 1559 else 1560 dest = gen_rtx_PLUS (Pmode, dest, negate_rtx (Pmode, argsize)); 1561 } 1562 dest = gen_rtx_MEM (BLKmode, dest); 1563 set_mem_align (dest, PARM_BOUNDARY); 1564 src = gen_rtx_MEM (BLKmode, incoming_args); 1565 set_mem_align (src, PARM_BOUNDARY); 1566 emit_block_move (dest, src, argsize, BLOCK_OP_NORMAL); 1567 1568 /* Refer to the argument block. */ 1569 apply_args_size (); 1570 arguments = gen_rtx_MEM (BLKmode, arguments); 1571 set_mem_align (arguments, PARM_BOUNDARY); 1572 1573 /* Walk past the arg-pointer and structure value address. */ 1574 size = GET_MODE_SIZE (Pmode); 1575 if (struct_value) 1576 size += GET_MODE_SIZE (Pmode); 1577 1578 /* Restore each of the registers previously saved. Make USE insns 1579 for each of these registers for use in making the call. */ 1580 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++) 1581 if ((mode = apply_args_mode[regno]) != VOIDmode) 1582 { 1583 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT; 1584 if (size % align != 0) 1585 size = CEIL (size, align) * align; 1586 reg = gen_rtx_REG (mode, regno); 1587 emit_move_insn (reg, adjust_address (arguments, mode, size)); 1588 use_reg (&call_fusage, reg); 1589 size += GET_MODE_SIZE (mode); 1590 } 1591 1592 /* Restore the structure value address unless this is passed as an 1593 "invisible" first argument. */ 1594 size = GET_MODE_SIZE (Pmode); 1595 if (struct_value) 1596 { 1597 rtx value = gen_reg_rtx (Pmode); 1598 emit_move_insn (value, adjust_address (arguments, Pmode, size)); 1599 emit_move_insn (struct_value, value); 1600 if (REG_P (struct_value)) 1601 use_reg (&call_fusage, struct_value); 1602 size += GET_MODE_SIZE (Pmode); 1603 } 1604 1605 /* All arguments and registers used for the call are set up by now! */ 1606 function = prepare_call_address (NULL, function, NULL, &call_fusage, 0, 0); 1607 1608 /* Ensure address is valid. SYMBOL_REF is already valid, so no need, 1609 and we don't want to load it into a register as an optimization, 1610 because prepare_call_address already did it if it should be done. */ 1611 if (GET_CODE (function) != SYMBOL_REF) 1612 function = memory_address (FUNCTION_MODE, function); 1613 1614 /* Generate the actual call instruction and save the return value. */ 1615 if (targetm.have_untyped_call ()) 1616 { 1617 rtx mem = gen_rtx_MEM (FUNCTION_MODE, function); 1618 emit_call_insn (targetm.gen_untyped_call (mem, result, 1619 result_vector (1, result))); 1620 } 1621 else if (targetm.have_call_value ()) 1622 { 1623 rtx valreg = 0; 1624 1625 /* Locate the unique return register. It is not possible to 1626 express a call that sets more than one return register using 1627 call_value; use untyped_call for that. In fact, untyped_call 1628 only needs to save the return registers in the given block. */ 1629 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++) 1630 if ((mode = apply_result_mode[regno]) != VOIDmode) 1631 { 1632 gcc_assert (!valreg); /* have_untyped_call required. */ 1633 1634 valreg = gen_rtx_REG (mode, regno); 1635 } 1636 1637 emit_insn (targetm.gen_call_value (valreg, 1638 gen_rtx_MEM (FUNCTION_MODE, function), 1639 const0_rtx, NULL_RTX, const0_rtx)); 1640 1641 emit_move_insn (adjust_address (result, GET_MODE (valreg), 0), valreg); 1642 } 1643 else 1644 gcc_unreachable (); 1645 1646 /* Find the CALL insn we just emitted, and attach the register usage 1647 information. */ 1648 call_insn = last_call_insn (); 1649 add_function_usage_to (call_insn, call_fusage); 1650 1651 /* Restore the stack. */ 1652 if (targetm.have_save_stack_nonlocal ()) 1653 emit_stack_restore (SAVE_NONLOCAL, old_stack_level); 1654 else 1655 emit_stack_restore (SAVE_BLOCK, old_stack_level); 1656 fixup_args_size_notes (call_insn, get_last_insn (), 0); 1657 1658 OK_DEFER_POP; 1659 1660 /* Return the address of the result block. */ 1661 result = copy_addr_to_reg (XEXP (result, 0)); 1662 return convert_memory_address (ptr_mode, result); 1663 } 1664 1665 /* Perform an untyped return. */ 1666 1667 static void 1668 expand_builtin_return (rtx result) 1669 { 1670 int size, align, regno; 1671 machine_mode mode; 1672 rtx reg; 1673 rtx_insn *call_fusage = 0; 1674 1675 result = convert_memory_address (Pmode, result); 1676 1677 apply_result_size (); 1678 result = gen_rtx_MEM (BLKmode, result); 1679 1680 if (targetm.have_untyped_return ()) 1681 { 1682 rtx vector = result_vector (0, result); 1683 emit_jump_insn (targetm.gen_untyped_return (result, vector)); 1684 emit_barrier (); 1685 return; 1686 } 1687 1688 /* Restore the return value and note that each value is used. */ 1689 size = 0; 1690 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++) 1691 if ((mode = apply_result_mode[regno]) != VOIDmode) 1692 { 1693 align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT; 1694 if (size % align != 0) 1695 size = CEIL (size, align) * align; 1696 reg = gen_rtx_REG (mode, INCOMING_REGNO (regno)); 1697 emit_move_insn (reg, adjust_address (result, mode, size)); 1698 1699 push_to_sequence (call_fusage); 1700 emit_use (reg); 1701 call_fusage = get_insns (); 1702 end_sequence (); 1703 size += GET_MODE_SIZE (mode); 1704 } 1705 1706 /* Put the USE insns before the return. */ 1707 emit_insn (call_fusage); 1708 1709 /* Return whatever values was restored by jumping directly to the end 1710 of the function. */ 1711 expand_naked_return (); 1712 } 1713 1714 /* Used by expand_builtin_classify_type and fold_builtin_classify_type. */ 1715 1716 static enum type_class 1717 type_to_class (tree type) 1718 { 1719 switch (TREE_CODE (type)) 1720 { 1721 case VOID_TYPE: return void_type_class; 1722 case INTEGER_TYPE: return integer_type_class; 1723 case ENUMERAL_TYPE: return enumeral_type_class; 1724 case BOOLEAN_TYPE: return boolean_type_class; 1725 case POINTER_TYPE: return pointer_type_class; 1726 case REFERENCE_TYPE: return reference_type_class; 1727 case OFFSET_TYPE: return offset_type_class; 1728 case REAL_TYPE: return real_type_class; 1729 case COMPLEX_TYPE: return complex_type_class; 1730 case FUNCTION_TYPE: return function_type_class; 1731 case METHOD_TYPE: return method_type_class; 1732 case RECORD_TYPE: return record_type_class; 1733 case UNION_TYPE: 1734 case QUAL_UNION_TYPE: return union_type_class; 1735 case ARRAY_TYPE: return (TYPE_STRING_FLAG (type) 1736 ? string_type_class : array_type_class); 1737 case LANG_TYPE: return lang_type_class; 1738 default: return no_type_class; 1739 } 1740 } 1741 1742 /* Expand a call EXP to __builtin_classify_type. */ 1743 1744 static rtx 1745 expand_builtin_classify_type (tree exp) 1746 { 1747 if (call_expr_nargs (exp)) 1748 return GEN_INT (type_to_class (TREE_TYPE (CALL_EXPR_ARG (exp, 0)))); 1749 return GEN_INT (no_type_class); 1750 } 1751 1752 /* This helper macro, meant to be used in mathfn_built_in below, 1753 determines which among a set of three builtin math functions is 1754 appropriate for a given type mode. The `F' and `L' cases are 1755 automatically generated from the `double' case. */ 1756 #define CASE_MATHFN(MATHFN) \ 1757 CASE_CFN_##MATHFN: \ 1758 fcode = BUILT_IN_##MATHFN; fcodef = BUILT_IN_##MATHFN##F ; \ 1759 fcodel = BUILT_IN_##MATHFN##L ; break; 1760 /* Similar to above, but appends _R after any F/L suffix. */ 1761 #define CASE_MATHFN_REENT(MATHFN) \ 1762 case CFN_BUILT_IN_##MATHFN##_R: \ 1763 case CFN_BUILT_IN_##MATHFN##F_R: \ 1764 case CFN_BUILT_IN_##MATHFN##L_R: \ 1765 fcode = BUILT_IN_##MATHFN##_R; fcodef = BUILT_IN_##MATHFN##F_R ; \ 1766 fcodel = BUILT_IN_##MATHFN##L_R ; break; 1767 1768 /* Return a function equivalent to FN but operating on floating-point 1769 values of type TYPE, or END_BUILTINS if no such function exists. 1770 This is purely an operation on function codes; it does not guarantee 1771 that the target actually has an implementation of the function. */ 1772 1773 static built_in_function 1774 mathfn_built_in_2 (tree type, combined_fn fn) 1775 { 1776 built_in_function fcode, fcodef, fcodel; 1777 1778 switch (fn) 1779 { 1780 CASE_MATHFN (ACOS) 1781 CASE_MATHFN (ACOSH) 1782 CASE_MATHFN (ASIN) 1783 CASE_MATHFN (ASINH) 1784 CASE_MATHFN (ATAN) 1785 CASE_MATHFN (ATAN2) 1786 CASE_MATHFN (ATANH) 1787 CASE_MATHFN (CBRT) 1788 CASE_MATHFN (CEIL) 1789 CASE_MATHFN (CEXPI) 1790 CASE_MATHFN (COPYSIGN) 1791 CASE_MATHFN (COS) 1792 CASE_MATHFN (COSH) 1793 CASE_MATHFN (DREM) 1794 CASE_MATHFN (ERF) 1795 CASE_MATHFN (ERFC) 1796 CASE_MATHFN (EXP) 1797 CASE_MATHFN (EXP10) 1798 CASE_MATHFN (EXP2) 1799 CASE_MATHFN (EXPM1) 1800 CASE_MATHFN (FABS) 1801 CASE_MATHFN (FDIM) 1802 CASE_MATHFN (FLOOR) 1803 CASE_MATHFN (FMA) 1804 CASE_MATHFN (FMAX) 1805 CASE_MATHFN (FMIN) 1806 CASE_MATHFN (FMOD) 1807 CASE_MATHFN (FREXP) 1808 CASE_MATHFN (GAMMA) 1809 CASE_MATHFN_REENT (GAMMA) /* GAMMA_R */ 1810 CASE_MATHFN (HUGE_VAL) 1811 CASE_MATHFN (HYPOT) 1812 CASE_MATHFN (ILOGB) 1813 CASE_MATHFN (ICEIL) 1814 CASE_MATHFN (IFLOOR) 1815 CASE_MATHFN (INF) 1816 CASE_MATHFN (IRINT) 1817 CASE_MATHFN (IROUND) 1818 CASE_MATHFN (ISINF) 1819 CASE_MATHFN (J0) 1820 CASE_MATHFN (J1) 1821 CASE_MATHFN (JN) 1822 CASE_MATHFN (LCEIL) 1823 CASE_MATHFN (LDEXP) 1824 CASE_MATHFN (LFLOOR) 1825 CASE_MATHFN (LGAMMA) 1826 CASE_MATHFN_REENT (LGAMMA) /* LGAMMA_R */ 1827 CASE_MATHFN (LLCEIL) 1828 CASE_MATHFN (LLFLOOR) 1829 CASE_MATHFN (LLRINT) 1830 CASE_MATHFN (LLROUND) 1831 CASE_MATHFN (LOG) 1832 CASE_MATHFN (LOG10) 1833 CASE_MATHFN (LOG1P) 1834 CASE_MATHFN (LOG2) 1835 CASE_MATHFN (LOGB) 1836 CASE_MATHFN (LRINT) 1837 CASE_MATHFN (LROUND) 1838 CASE_MATHFN (MODF) 1839 CASE_MATHFN (NAN) 1840 CASE_MATHFN (NANS) 1841 CASE_MATHFN (NEARBYINT) 1842 CASE_MATHFN (NEXTAFTER) 1843 CASE_MATHFN (NEXTTOWARD) 1844 CASE_MATHFN (POW) 1845 CASE_MATHFN (POWI) 1846 CASE_MATHFN (POW10) 1847 CASE_MATHFN (REMAINDER) 1848 CASE_MATHFN (REMQUO) 1849 CASE_MATHFN (RINT) 1850 CASE_MATHFN (ROUND) 1851 CASE_MATHFN (SCALB) 1852 CASE_MATHFN (SCALBLN) 1853 CASE_MATHFN (SCALBN) 1854 CASE_MATHFN (SIGNBIT) 1855 CASE_MATHFN (SIGNIFICAND) 1856 CASE_MATHFN (SIN) 1857 CASE_MATHFN (SINCOS) 1858 CASE_MATHFN (SINH) 1859 CASE_MATHFN (SQRT) 1860 CASE_MATHFN (TAN) 1861 CASE_MATHFN (TANH) 1862 CASE_MATHFN (TGAMMA) 1863 CASE_MATHFN (TRUNC) 1864 CASE_MATHFN (Y0) 1865 CASE_MATHFN (Y1) 1866 CASE_MATHFN (YN) 1867 1868 default: 1869 return END_BUILTINS; 1870 } 1871 1872 if (TYPE_MAIN_VARIANT (type) == double_type_node) 1873 return fcode; 1874 else if (TYPE_MAIN_VARIANT (type) == float_type_node) 1875 return fcodef; 1876 else if (TYPE_MAIN_VARIANT (type) == long_double_type_node) 1877 return fcodel; 1878 else 1879 return END_BUILTINS; 1880 } 1881 1882 /* Return mathematic function equivalent to FN but operating directly on TYPE, 1883 if available. If IMPLICIT_P is true use the implicit builtin declaration, 1884 otherwise use the explicit declaration. If we can't do the conversion, 1885 return null. */ 1886 1887 static tree 1888 mathfn_built_in_1 (tree type, combined_fn fn, bool implicit_p) 1889 { 1890 built_in_function fcode2 = mathfn_built_in_2 (type, fn); 1891 if (fcode2 == END_BUILTINS) 1892 return NULL_TREE; 1893 1894 if (implicit_p && !builtin_decl_implicit_p (fcode2)) 1895 return NULL_TREE; 1896 1897 return builtin_decl_explicit (fcode2); 1898 } 1899 1900 /* Like mathfn_built_in_1, but always use the implicit array. */ 1901 1902 tree 1903 mathfn_built_in (tree type, combined_fn fn) 1904 { 1905 return mathfn_built_in_1 (type, fn, /*implicit=*/ 1); 1906 } 1907 1908 /* Like mathfn_built_in_1, but take a built_in_function and 1909 always use the implicit array. */ 1910 1911 tree 1912 mathfn_built_in (tree type, enum built_in_function fn) 1913 { 1914 return mathfn_built_in_1 (type, as_combined_fn (fn), /*implicit=*/ 1); 1915 } 1916 1917 /* If BUILT_IN_NORMAL function FNDECL has an associated internal function, 1918 return its code, otherwise return IFN_LAST. Note that this function 1919 only tests whether the function is defined in internals.def, not whether 1920 it is actually available on the target. */ 1921 1922 internal_fn 1923 associated_internal_fn (tree fndecl) 1924 { 1925 gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL); 1926 tree return_type = TREE_TYPE (TREE_TYPE (fndecl)); 1927 switch (DECL_FUNCTION_CODE (fndecl)) 1928 { 1929 #define DEF_INTERNAL_FLT_FN(NAME, FLAGS, OPTAB, TYPE) \ 1930 CASE_FLT_FN (BUILT_IN_##NAME): return IFN_##NAME; 1931 #define DEF_INTERNAL_INT_FN(NAME, FLAGS, OPTAB, TYPE) \ 1932 CASE_INT_FN (BUILT_IN_##NAME): return IFN_##NAME; 1933 #include "internal-fn.def" 1934 1935 CASE_FLT_FN (BUILT_IN_POW10): 1936 return IFN_EXP10; 1937 1938 CASE_FLT_FN (BUILT_IN_DREM): 1939 return IFN_REMAINDER; 1940 1941 CASE_FLT_FN (BUILT_IN_SCALBN): 1942 CASE_FLT_FN (BUILT_IN_SCALBLN): 1943 if (REAL_MODE_FORMAT (TYPE_MODE (return_type))->b == 2) 1944 return IFN_LDEXP; 1945 return IFN_LAST; 1946 1947 default: 1948 return IFN_LAST; 1949 } 1950 } 1951 1952 /* If CALL is a call to a BUILT_IN_NORMAL function that could be replaced 1953 on the current target by a call to an internal function, return the 1954 code of that internal function, otherwise return IFN_LAST. The caller 1955 is responsible for ensuring that any side-effects of the built-in 1956 call are dealt with correctly. E.g. if CALL sets errno, the caller 1957 must decide that the errno result isn't needed or make it available 1958 in some other way. */ 1959 1960 internal_fn 1961 replacement_internal_fn (gcall *call) 1962 { 1963 if (gimple_call_builtin_p (call, BUILT_IN_NORMAL)) 1964 { 1965 internal_fn ifn = associated_internal_fn (gimple_call_fndecl (call)); 1966 if (ifn != IFN_LAST) 1967 { 1968 tree_pair types = direct_internal_fn_types (ifn, call); 1969 optimization_type opt_type = bb_optimization_type (gimple_bb (call)); 1970 if (direct_internal_fn_supported_p (ifn, types, opt_type)) 1971 return ifn; 1972 } 1973 } 1974 return IFN_LAST; 1975 } 1976 1977 /* Expand a call to the builtin trinary math functions (fma). 1978 Return NULL_RTX if a normal call should be emitted rather than expanding the 1979 function in-line. EXP is the expression that is a call to the builtin 1980 function; if convenient, the result should be placed in TARGET. 1981 SUBTARGET may be used as the target for computing one of EXP's 1982 operands. */ 1983 1984 static rtx 1985 expand_builtin_mathfn_ternary (tree exp, rtx target, rtx subtarget) 1986 { 1987 optab builtin_optab; 1988 rtx op0, op1, op2, result; 1989 rtx_insn *insns; 1990 tree fndecl = get_callee_fndecl (exp); 1991 tree arg0, arg1, arg2; 1992 machine_mode mode; 1993 1994 if (!validate_arglist (exp, REAL_TYPE, REAL_TYPE, REAL_TYPE, VOID_TYPE)) 1995 return NULL_RTX; 1996 1997 arg0 = CALL_EXPR_ARG (exp, 0); 1998 arg1 = CALL_EXPR_ARG (exp, 1); 1999 arg2 = CALL_EXPR_ARG (exp, 2); 2000 2001 switch (DECL_FUNCTION_CODE (fndecl)) 2002 { 2003 CASE_FLT_FN (BUILT_IN_FMA): 2004 builtin_optab = fma_optab; break; 2005 default: 2006 gcc_unreachable (); 2007 } 2008 2009 /* Make a suitable register to place result in. */ 2010 mode = TYPE_MODE (TREE_TYPE (exp)); 2011 2012 /* Before working hard, check whether the instruction is available. */ 2013 if (optab_handler (builtin_optab, mode) == CODE_FOR_nothing) 2014 return NULL_RTX; 2015 2016 result = gen_reg_rtx (mode); 2017 2018 /* Always stabilize the argument list. */ 2019 CALL_EXPR_ARG (exp, 0) = arg0 = builtin_save_expr (arg0); 2020 CALL_EXPR_ARG (exp, 1) = arg1 = builtin_save_expr (arg1); 2021 CALL_EXPR_ARG (exp, 2) = arg2 = builtin_save_expr (arg2); 2022 2023 op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL); 2024 op1 = expand_normal (arg1); 2025 op2 = expand_normal (arg2); 2026 2027 start_sequence (); 2028 2029 /* Compute into RESULT. 2030 Set RESULT to wherever the result comes back. */ 2031 result = expand_ternary_op (mode, builtin_optab, op0, op1, op2, 2032 result, 0); 2033 2034 /* If we were unable to expand via the builtin, stop the sequence 2035 (without outputting the insns) and call to the library function 2036 with the stabilized argument list. */ 2037 if (result == 0) 2038 { 2039 end_sequence (); 2040 return expand_call (exp, target, target == const0_rtx); 2041 } 2042 2043 /* Output the entire sequence. */ 2044 insns = get_insns (); 2045 end_sequence (); 2046 emit_insn (insns); 2047 2048 return result; 2049 } 2050 2051 /* Expand a call to the builtin sin and cos math functions. 2052 Return NULL_RTX if a normal call should be emitted rather than expanding the 2053 function in-line. EXP is the expression that is a call to the builtin 2054 function; if convenient, the result should be placed in TARGET. 2055 SUBTARGET may be used as the target for computing one of EXP's 2056 operands. */ 2057 2058 static rtx 2059 expand_builtin_mathfn_3 (tree exp, rtx target, rtx subtarget) 2060 { 2061 optab builtin_optab; 2062 rtx op0; 2063 rtx_insn *insns; 2064 tree fndecl = get_callee_fndecl (exp); 2065 machine_mode mode; 2066 tree arg; 2067 2068 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE)) 2069 return NULL_RTX; 2070 2071 arg = CALL_EXPR_ARG (exp, 0); 2072 2073 switch (DECL_FUNCTION_CODE (fndecl)) 2074 { 2075 CASE_FLT_FN (BUILT_IN_SIN): 2076 CASE_FLT_FN (BUILT_IN_COS): 2077 builtin_optab = sincos_optab; break; 2078 default: 2079 gcc_unreachable (); 2080 } 2081 2082 /* Make a suitable register to place result in. */ 2083 mode = TYPE_MODE (TREE_TYPE (exp)); 2084 2085 /* Check if sincos insn is available, otherwise fallback 2086 to sin or cos insn. */ 2087 if (optab_handler (builtin_optab, mode) == CODE_FOR_nothing) 2088 switch (DECL_FUNCTION_CODE (fndecl)) 2089 { 2090 CASE_FLT_FN (BUILT_IN_SIN): 2091 builtin_optab = sin_optab; break; 2092 CASE_FLT_FN (BUILT_IN_COS): 2093 builtin_optab = cos_optab; break; 2094 default: 2095 gcc_unreachable (); 2096 } 2097 2098 /* Before working hard, check whether the instruction is available. */ 2099 if (optab_handler (builtin_optab, mode) != CODE_FOR_nothing) 2100 { 2101 rtx result = gen_reg_rtx (mode); 2102 2103 /* Wrap the computation of the argument in a SAVE_EXPR, as we may 2104 need to expand the argument again. This way, we will not perform 2105 side-effects more the once. */ 2106 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg); 2107 2108 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL); 2109 2110 start_sequence (); 2111 2112 /* Compute into RESULT. 2113 Set RESULT to wherever the result comes back. */ 2114 if (builtin_optab == sincos_optab) 2115 { 2116 int ok; 2117 2118 switch (DECL_FUNCTION_CODE (fndecl)) 2119 { 2120 CASE_FLT_FN (BUILT_IN_SIN): 2121 ok = expand_twoval_unop (builtin_optab, op0, 0, result, 0); 2122 break; 2123 CASE_FLT_FN (BUILT_IN_COS): 2124 ok = expand_twoval_unop (builtin_optab, op0, result, 0, 0); 2125 break; 2126 default: 2127 gcc_unreachable (); 2128 } 2129 gcc_assert (ok); 2130 } 2131 else 2132 result = expand_unop (mode, builtin_optab, op0, result, 0); 2133 2134 if (result != 0) 2135 { 2136 /* Output the entire sequence. */ 2137 insns = get_insns (); 2138 end_sequence (); 2139 emit_insn (insns); 2140 return result; 2141 } 2142 2143 /* If we were unable to expand via the builtin, stop the sequence 2144 (without outputting the insns) and call to the library function 2145 with the stabilized argument list. */ 2146 end_sequence (); 2147 } 2148 2149 return expand_call (exp, target, target == const0_rtx); 2150 } 2151 2152 /* Given an interclass math builtin decl FNDECL and it's argument ARG 2153 return an RTL instruction code that implements the functionality. 2154 If that isn't possible or available return CODE_FOR_nothing. */ 2155 2156 static enum insn_code 2157 interclass_mathfn_icode (tree arg, tree fndecl) 2158 { 2159 bool errno_set = false; 2160 optab builtin_optab = unknown_optab; 2161 machine_mode mode; 2162 2163 switch (DECL_FUNCTION_CODE (fndecl)) 2164 { 2165 CASE_FLT_FN (BUILT_IN_ILOGB): 2166 errno_set = true; builtin_optab = ilogb_optab; break; 2167 CASE_FLT_FN (BUILT_IN_ISINF): 2168 builtin_optab = isinf_optab; break; 2169 case BUILT_IN_ISNORMAL: 2170 case BUILT_IN_ISFINITE: 2171 CASE_FLT_FN (BUILT_IN_FINITE): 2172 case BUILT_IN_FINITED32: 2173 case BUILT_IN_FINITED64: 2174 case BUILT_IN_FINITED128: 2175 case BUILT_IN_ISINFD32: 2176 case BUILT_IN_ISINFD64: 2177 case BUILT_IN_ISINFD128: 2178 /* These builtins have no optabs (yet). */ 2179 break; 2180 default: 2181 gcc_unreachable (); 2182 } 2183 2184 /* There's no easy way to detect the case we need to set EDOM. */ 2185 if (flag_errno_math && errno_set) 2186 return CODE_FOR_nothing; 2187 2188 /* Optab mode depends on the mode of the input argument. */ 2189 mode = TYPE_MODE (TREE_TYPE (arg)); 2190 2191 if (builtin_optab) 2192 return optab_handler (builtin_optab, mode); 2193 return CODE_FOR_nothing; 2194 } 2195 2196 /* Expand a call to one of the builtin math functions that operate on 2197 floating point argument and output an integer result (ilogb, isinf, 2198 isnan, etc). 2199 Return 0 if a normal call should be emitted rather than expanding the 2200 function in-line. EXP is the expression that is a call to the builtin 2201 function; if convenient, the result should be placed in TARGET. */ 2202 2203 static rtx 2204 expand_builtin_interclass_mathfn (tree exp, rtx target) 2205 { 2206 enum insn_code icode = CODE_FOR_nothing; 2207 rtx op0; 2208 tree fndecl = get_callee_fndecl (exp); 2209 machine_mode mode; 2210 tree arg; 2211 2212 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE)) 2213 return NULL_RTX; 2214 2215 arg = CALL_EXPR_ARG (exp, 0); 2216 icode = interclass_mathfn_icode (arg, fndecl); 2217 mode = TYPE_MODE (TREE_TYPE (arg)); 2218 2219 if (icode != CODE_FOR_nothing) 2220 { 2221 struct expand_operand ops[1]; 2222 rtx_insn *last = get_last_insn (); 2223 tree orig_arg = arg; 2224 2225 /* Wrap the computation of the argument in a SAVE_EXPR, as we may 2226 need to expand the argument again. This way, we will not perform 2227 side-effects more the once. */ 2228 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg); 2229 2230 op0 = expand_expr (arg, NULL_RTX, VOIDmode, EXPAND_NORMAL); 2231 2232 if (mode != GET_MODE (op0)) 2233 op0 = convert_to_mode (mode, op0, 0); 2234 2235 create_output_operand (&ops[0], target, TYPE_MODE (TREE_TYPE (exp))); 2236 if (maybe_legitimize_operands (icode, 0, 1, ops) 2237 && maybe_emit_unop_insn (icode, ops[0].value, op0, UNKNOWN)) 2238 return ops[0].value; 2239 2240 delete_insns_since (last); 2241 CALL_EXPR_ARG (exp, 0) = orig_arg; 2242 } 2243 2244 return NULL_RTX; 2245 } 2246 2247 /* Expand a call to the builtin sincos math function. 2248 Return NULL_RTX if a normal call should be emitted rather than expanding the 2249 function in-line. EXP is the expression that is a call to the builtin 2250 function. */ 2251 2252 static rtx 2253 expand_builtin_sincos (tree exp) 2254 { 2255 rtx op0, op1, op2, target1, target2; 2256 machine_mode mode; 2257 tree arg, sinp, cosp; 2258 int result; 2259 location_t loc = EXPR_LOCATION (exp); 2260 tree alias_type, alias_off; 2261 2262 if (!validate_arglist (exp, REAL_TYPE, 2263 POINTER_TYPE, POINTER_TYPE, VOID_TYPE)) 2264 return NULL_RTX; 2265 2266 arg = CALL_EXPR_ARG (exp, 0); 2267 sinp = CALL_EXPR_ARG (exp, 1); 2268 cosp = CALL_EXPR_ARG (exp, 2); 2269 2270 /* Make a suitable register to place result in. */ 2271 mode = TYPE_MODE (TREE_TYPE (arg)); 2272 2273 /* Check if sincos insn is available, otherwise emit the call. */ 2274 if (optab_handler (sincos_optab, mode) == CODE_FOR_nothing) 2275 return NULL_RTX; 2276 2277 target1 = gen_reg_rtx (mode); 2278 target2 = gen_reg_rtx (mode); 2279 2280 op0 = expand_normal (arg); 2281 alias_type = build_pointer_type_for_mode (TREE_TYPE (arg), ptr_mode, true); 2282 alias_off = build_int_cst (alias_type, 0); 2283 op1 = expand_normal (fold_build2_loc (loc, MEM_REF, TREE_TYPE (arg), 2284 sinp, alias_off)); 2285 op2 = expand_normal (fold_build2_loc (loc, MEM_REF, TREE_TYPE (arg), 2286 cosp, alias_off)); 2287 2288 /* Compute into target1 and target2. 2289 Set TARGET to wherever the result comes back. */ 2290 result = expand_twoval_unop (sincos_optab, op0, target2, target1, 0); 2291 gcc_assert (result); 2292 2293 /* Move target1 and target2 to the memory locations indicated 2294 by op1 and op2. */ 2295 emit_move_insn (op1, target1); 2296 emit_move_insn (op2, target2); 2297 2298 return const0_rtx; 2299 } 2300 2301 /* Expand a call to the internal cexpi builtin to the sincos math function. 2302 EXP is the expression that is a call to the builtin function; if convenient, 2303 the result should be placed in TARGET. */ 2304 2305 static rtx 2306 expand_builtin_cexpi (tree exp, rtx target) 2307 { 2308 tree fndecl = get_callee_fndecl (exp); 2309 tree arg, type; 2310 machine_mode mode; 2311 rtx op0, op1, op2; 2312 location_t loc = EXPR_LOCATION (exp); 2313 2314 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE)) 2315 return NULL_RTX; 2316 2317 arg = CALL_EXPR_ARG (exp, 0); 2318 type = TREE_TYPE (arg); 2319 mode = TYPE_MODE (TREE_TYPE (arg)); 2320 2321 /* Try expanding via a sincos optab, fall back to emitting a libcall 2322 to sincos or cexp. We are sure we have sincos or cexp because cexpi 2323 is only generated from sincos, cexp or if we have either of them. */ 2324 if (optab_handler (sincos_optab, mode) != CODE_FOR_nothing) 2325 { 2326 op1 = gen_reg_rtx (mode); 2327 op2 = gen_reg_rtx (mode); 2328 2329 op0 = expand_expr (arg, NULL_RTX, VOIDmode, EXPAND_NORMAL); 2330 2331 /* Compute into op1 and op2. */ 2332 expand_twoval_unop (sincos_optab, op0, op2, op1, 0); 2333 } 2334 else if (targetm.libc_has_function (function_sincos)) 2335 { 2336 tree call, fn = NULL_TREE; 2337 tree top1, top2; 2338 rtx op1a, op2a; 2339 2340 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF) 2341 fn = builtin_decl_explicit (BUILT_IN_SINCOSF); 2342 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI) 2343 fn = builtin_decl_explicit (BUILT_IN_SINCOS); 2344 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL) 2345 fn = builtin_decl_explicit (BUILT_IN_SINCOSL); 2346 else 2347 gcc_unreachable (); 2348 2349 op1 = assign_temp (TREE_TYPE (arg), 1, 1); 2350 op2 = assign_temp (TREE_TYPE (arg), 1, 1); 2351 op1a = copy_addr_to_reg (XEXP (op1, 0)); 2352 op2a = copy_addr_to_reg (XEXP (op2, 0)); 2353 top1 = make_tree (build_pointer_type (TREE_TYPE (arg)), op1a); 2354 top2 = make_tree (build_pointer_type (TREE_TYPE (arg)), op2a); 2355 2356 /* Make sure not to fold the sincos call again. */ 2357 call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn); 2358 expand_normal (build_call_nary (TREE_TYPE (TREE_TYPE (fn)), 2359 call, 3, arg, top1, top2)); 2360 } 2361 else 2362 { 2363 tree call, fn = NULL_TREE, narg; 2364 tree ctype = build_complex_type (type); 2365 2366 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF) 2367 fn = builtin_decl_explicit (BUILT_IN_CEXPF); 2368 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI) 2369 fn = builtin_decl_explicit (BUILT_IN_CEXP); 2370 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL) 2371 fn = builtin_decl_explicit (BUILT_IN_CEXPL); 2372 else 2373 gcc_unreachable (); 2374 2375 /* If we don't have a decl for cexp create one. This is the 2376 friendliest fallback if the user calls __builtin_cexpi 2377 without full target C99 function support. */ 2378 if (fn == NULL_TREE) 2379 { 2380 tree fntype; 2381 const char *name = NULL; 2382 2383 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF) 2384 name = "cexpf"; 2385 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI) 2386 name = "cexp"; 2387 else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL) 2388 name = "cexpl"; 2389 2390 fntype = build_function_type_list (ctype, ctype, NULL_TREE); 2391 fn = build_fn_decl (name, fntype); 2392 } 2393 2394 narg = fold_build2_loc (loc, COMPLEX_EXPR, ctype, 2395 build_real (type, dconst0), arg); 2396 2397 /* Make sure not to fold the cexp call again. */ 2398 call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn); 2399 return expand_expr (build_call_nary (ctype, call, 1, narg), 2400 target, VOIDmode, EXPAND_NORMAL); 2401 } 2402 2403 /* Now build the proper return type. */ 2404 return expand_expr (build2 (COMPLEX_EXPR, build_complex_type (type), 2405 make_tree (TREE_TYPE (arg), op2), 2406 make_tree (TREE_TYPE (arg), op1)), 2407 target, VOIDmode, EXPAND_NORMAL); 2408 } 2409 2410 /* Conveniently construct a function call expression. FNDECL names the 2411 function to be called, N is the number of arguments, and the "..." 2412 parameters are the argument expressions. Unlike build_call_exr 2413 this doesn't fold the call, hence it will always return a CALL_EXPR. */ 2414 2415 static tree 2416 build_call_nofold_loc (location_t loc, tree fndecl, int n, ...) 2417 { 2418 va_list ap; 2419 tree fntype = TREE_TYPE (fndecl); 2420 tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl); 2421 2422 va_start (ap, n); 2423 fn = build_call_valist (TREE_TYPE (fntype), fn, n, ap); 2424 va_end (ap); 2425 SET_EXPR_LOCATION (fn, loc); 2426 return fn; 2427 } 2428 2429 /* Expand a call to one of the builtin rounding functions gcc defines 2430 as an extension (lfloor and lceil). As these are gcc extensions we 2431 do not need to worry about setting errno to EDOM. 2432 If expanding via optab fails, lower expression to (int)(floor(x)). 2433 EXP is the expression that is a call to the builtin function; 2434 if convenient, the result should be placed in TARGET. */ 2435 2436 static rtx 2437 expand_builtin_int_roundingfn (tree exp, rtx target) 2438 { 2439 convert_optab builtin_optab; 2440 rtx op0, tmp; 2441 rtx_insn *insns; 2442 tree fndecl = get_callee_fndecl (exp); 2443 enum built_in_function fallback_fn; 2444 tree fallback_fndecl; 2445 machine_mode mode; 2446 tree arg; 2447 2448 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE)) 2449 gcc_unreachable (); 2450 2451 arg = CALL_EXPR_ARG (exp, 0); 2452 2453 switch (DECL_FUNCTION_CODE (fndecl)) 2454 { 2455 CASE_FLT_FN (BUILT_IN_ICEIL): 2456 CASE_FLT_FN (BUILT_IN_LCEIL): 2457 CASE_FLT_FN (BUILT_IN_LLCEIL): 2458 builtin_optab = lceil_optab; 2459 fallback_fn = BUILT_IN_CEIL; 2460 break; 2461 2462 CASE_FLT_FN (BUILT_IN_IFLOOR): 2463 CASE_FLT_FN (BUILT_IN_LFLOOR): 2464 CASE_FLT_FN (BUILT_IN_LLFLOOR): 2465 builtin_optab = lfloor_optab; 2466 fallback_fn = BUILT_IN_FLOOR; 2467 break; 2468 2469 default: 2470 gcc_unreachable (); 2471 } 2472 2473 /* Make a suitable register to place result in. */ 2474 mode = TYPE_MODE (TREE_TYPE (exp)); 2475 2476 target = gen_reg_rtx (mode); 2477 2478 /* Wrap the computation of the argument in a SAVE_EXPR, as we may 2479 need to expand the argument again. This way, we will not perform 2480 side-effects more the once. */ 2481 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg); 2482 2483 op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL); 2484 2485 start_sequence (); 2486 2487 /* Compute into TARGET. */ 2488 if (expand_sfix_optab (target, op0, builtin_optab)) 2489 { 2490 /* Output the entire sequence. */ 2491 insns = get_insns (); 2492 end_sequence (); 2493 emit_insn (insns); 2494 return target; 2495 } 2496 2497 /* If we were unable to expand via the builtin, stop the sequence 2498 (without outputting the insns). */ 2499 end_sequence (); 2500 2501 /* Fall back to floating point rounding optab. */ 2502 fallback_fndecl = mathfn_built_in (TREE_TYPE (arg), fallback_fn); 2503 2504 /* For non-C99 targets we may end up without a fallback fndecl here 2505 if the user called __builtin_lfloor directly. In this case emit 2506 a call to the floor/ceil variants nevertheless. This should result 2507 in the best user experience for not full C99 targets. */ 2508 if (fallback_fndecl == NULL_TREE) 2509 { 2510 tree fntype; 2511 const char *name = NULL; 2512 2513 switch (DECL_FUNCTION_CODE (fndecl)) 2514 { 2515 case BUILT_IN_ICEIL: 2516 case BUILT_IN_LCEIL: 2517 case BUILT_IN_LLCEIL: 2518 name = "ceil"; 2519 break; 2520 case BUILT_IN_ICEILF: 2521 case BUILT_IN_LCEILF: 2522 case BUILT_IN_LLCEILF: 2523 name = "ceilf"; 2524 break; 2525 case BUILT_IN_ICEILL: 2526 case BUILT_IN_LCEILL: 2527 case BUILT_IN_LLCEILL: 2528 name = "ceill"; 2529 break; 2530 case BUILT_IN_IFLOOR: 2531 case BUILT_IN_LFLOOR: 2532 case BUILT_IN_LLFLOOR: 2533 name = "floor"; 2534 break; 2535 case BUILT_IN_IFLOORF: 2536 case BUILT_IN_LFLOORF: 2537 case BUILT_IN_LLFLOORF: 2538 name = "floorf"; 2539 break; 2540 case BUILT_IN_IFLOORL: 2541 case BUILT_IN_LFLOORL: 2542 case BUILT_IN_LLFLOORL: 2543 name = "floorl"; 2544 break; 2545 default: 2546 gcc_unreachable (); 2547 } 2548 2549 fntype = build_function_type_list (TREE_TYPE (arg), 2550 TREE_TYPE (arg), NULL_TREE); 2551 fallback_fndecl = build_fn_decl (name, fntype); 2552 } 2553 2554 exp = build_call_nofold_loc (EXPR_LOCATION (exp), fallback_fndecl, 1, arg); 2555 2556 tmp = expand_normal (exp); 2557 tmp = maybe_emit_group_store (tmp, TREE_TYPE (exp)); 2558 2559 /* Truncate the result of floating point optab to integer 2560 via expand_fix (). */ 2561 target = gen_reg_rtx (mode); 2562 expand_fix (target, tmp, 0); 2563 2564 return target; 2565 } 2566 2567 /* Expand a call to one of the builtin math functions doing integer 2568 conversion (lrint). 2569 Return 0 if a normal call should be emitted rather than expanding the 2570 function in-line. EXP is the expression that is a call to the builtin 2571 function; if convenient, the result should be placed in TARGET. */ 2572 2573 static rtx 2574 expand_builtin_int_roundingfn_2 (tree exp, rtx target) 2575 { 2576 convert_optab builtin_optab; 2577 rtx op0; 2578 rtx_insn *insns; 2579 tree fndecl = get_callee_fndecl (exp); 2580 tree arg; 2581 machine_mode mode; 2582 enum built_in_function fallback_fn = BUILT_IN_NONE; 2583 2584 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE)) 2585 gcc_unreachable (); 2586 2587 arg = CALL_EXPR_ARG (exp, 0); 2588 2589 switch (DECL_FUNCTION_CODE (fndecl)) 2590 { 2591 CASE_FLT_FN (BUILT_IN_IRINT): 2592 fallback_fn = BUILT_IN_LRINT; 2593 /* FALLTHRU */ 2594 CASE_FLT_FN (BUILT_IN_LRINT): 2595 CASE_FLT_FN (BUILT_IN_LLRINT): 2596 builtin_optab = lrint_optab; 2597 break; 2598 2599 CASE_FLT_FN (BUILT_IN_IROUND): 2600 fallback_fn = BUILT_IN_LROUND; 2601 /* FALLTHRU */ 2602 CASE_FLT_FN (BUILT_IN_LROUND): 2603 CASE_FLT_FN (BUILT_IN_LLROUND): 2604 builtin_optab = lround_optab; 2605 break; 2606 2607 default: 2608 gcc_unreachable (); 2609 } 2610 2611 /* There's no easy way to detect the case we need to set EDOM. */ 2612 if (flag_errno_math && fallback_fn == BUILT_IN_NONE) 2613 return NULL_RTX; 2614 2615 /* Make a suitable register to place result in. */ 2616 mode = TYPE_MODE (TREE_TYPE (exp)); 2617 2618 /* There's no easy way to detect the case we need to set EDOM. */ 2619 if (!flag_errno_math) 2620 { 2621 rtx result = gen_reg_rtx (mode); 2622 2623 /* Wrap the computation of the argument in a SAVE_EXPR, as we may 2624 need to expand the argument again. This way, we will not perform 2625 side-effects more the once. */ 2626 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg); 2627 2628 op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL); 2629 2630 start_sequence (); 2631 2632 if (expand_sfix_optab (result, op0, builtin_optab)) 2633 { 2634 /* Output the entire sequence. */ 2635 insns = get_insns (); 2636 end_sequence (); 2637 emit_insn (insns); 2638 return result; 2639 } 2640 2641 /* If we were unable to expand via the builtin, stop the sequence 2642 (without outputting the insns) and call to the library function 2643 with the stabilized argument list. */ 2644 end_sequence (); 2645 } 2646 2647 if (fallback_fn != BUILT_IN_NONE) 2648 { 2649 /* Fall back to rounding to long int. Use implicit_p 0 - for non-C99 2650 targets, (int) round (x) should never be transformed into 2651 BUILT_IN_IROUND and if __builtin_iround is called directly, emit 2652 a call to lround in the hope that the target provides at least some 2653 C99 functions. This should result in the best user experience for 2654 not full C99 targets. */ 2655 tree fallback_fndecl = mathfn_built_in_1 2656 (TREE_TYPE (arg), as_combined_fn (fallback_fn), 0); 2657 2658 exp = build_call_nofold_loc (EXPR_LOCATION (exp), 2659 fallback_fndecl, 1, arg); 2660 2661 target = expand_call (exp, NULL_RTX, target == const0_rtx); 2662 target = maybe_emit_group_store (target, TREE_TYPE (exp)); 2663 return convert_to_mode (mode, target, 0); 2664 } 2665 2666 return expand_call (exp, target, target == const0_rtx); 2667 } 2668 2669 /* Expand a call to the powi built-in mathematical function. Return NULL_RTX if 2670 a normal call should be emitted rather than expanding the function 2671 in-line. EXP is the expression that is a call to the builtin 2672 function; if convenient, the result should be placed in TARGET. */ 2673 2674 static rtx 2675 expand_builtin_powi (tree exp, rtx target) 2676 { 2677 tree arg0, arg1; 2678 rtx op0, op1; 2679 machine_mode mode; 2680 machine_mode mode2; 2681 2682 if (! validate_arglist (exp, REAL_TYPE, INTEGER_TYPE, VOID_TYPE)) 2683 return NULL_RTX; 2684 2685 arg0 = CALL_EXPR_ARG (exp, 0); 2686 arg1 = CALL_EXPR_ARG (exp, 1); 2687 mode = TYPE_MODE (TREE_TYPE (exp)); 2688 2689 /* Emit a libcall to libgcc. */ 2690 2691 /* Mode of the 2nd argument must match that of an int. */ 2692 mode2 = mode_for_size (INT_TYPE_SIZE, MODE_INT, 0); 2693 2694 if (target == NULL_RTX) 2695 target = gen_reg_rtx (mode); 2696 2697 op0 = expand_expr (arg0, NULL_RTX, mode, EXPAND_NORMAL); 2698 if (GET_MODE (op0) != mode) 2699 op0 = convert_to_mode (mode, op0, 0); 2700 op1 = expand_expr (arg1, NULL_RTX, mode2, EXPAND_NORMAL); 2701 if (GET_MODE (op1) != mode2) 2702 op1 = convert_to_mode (mode2, op1, 0); 2703 2704 target = emit_library_call_value (optab_libfunc (powi_optab, mode), 2705 target, LCT_CONST, mode, 2, 2706 op0, mode, op1, mode2); 2707 2708 return target; 2709 } 2710 2711 /* Expand expression EXP which is a call to the strlen builtin. Return 2712 NULL_RTX if we failed the caller should emit a normal call, otherwise 2713 try to get the result in TARGET, if convenient. */ 2714 2715 static rtx 2716 expand_builtin_strlen (tree exp, rtx target, 2717 machine_mode target_mode) 2718 { 2719 if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE)) 2720 return NULL_RTX; 2721 else 2722 { 2723 struct expand_operand ops[4]; 2724 rtx pat; 2725 tree len; 2726 tree src = CALL_EXPR_ARG (exp, 0); 2727 rtx src_reg; 2728 rtx_insn *before_strlen; 2729 machine_mode insn_mode = target_mode; 2730 enum insn_code icode = CODE_FOR_nothing; 2731 unsigned int align; 2732 2733 /* If the length can be computed at compile-time, return it. */ 2734 len = c_strlen (src, 0); 2735 if (len) 2736 return expand_expr (len, target, target_mode, EXPAND_NORMAL); 2737 2738 /* If the length can be computed at compile-time and is constant 2739 integer, but there are side-effects in src, evaluate 2740 src for side-effects, then return len. 2741 E.g. x = strlen (i++ ? "xfoo" + 1 : "bar"); 2742 can be optimized into: i++; x = 3; */ 2743 len = c_strlen (src, 1); 2744 if (len && TREE_CODE (len) == INTEGER_CST) 2745 { 2746 expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL); 2747 return expand_expr (len, target, target_mode, EXPAND_NORMAL); 2748 } 2749 2750 align = get_pointer_alignment (src) / BITS_PER_UNIT; 2751 2752 /* If SRC is not a pointer type, don't do this operation inline. */ 2753 if (align == 0) 2754 return NULL_RTX; 2755 2756 /* Bail out if we can't compute strlen in the right mode. */ 2757 while (insn_mode != VOIDmode) 2758 { 2759 icode = optab_handler (strlen_optab, insn_mode); 2760 if (icode != CODE_FOR_nothing) 2761 break; 2762 2763 insn_mode = GET_MODE_WIDER_MODE (insn_mode); 2764 } 2765 if (insn_mode == VOIDmode) 2766 return NULL_RTX; 2767 2768 /* Make a place to hold the source address. We will not expand 2769 the actual source until we are sure that the expansion will 2770 not fail -- there are trees that cannot be expanded twice. */ 2771 src_reg = gen_reg_rtx (Pmode); 2772 2773 /* Mark the beginning of the strlen sequence so we can emit the 2774 source operand later. */ 2775 before_strlen = get_last_insn (); 2776 2777 create_output_operand (&ops[0], target, insn_mode); 2778 create_fixed_operand (&ops[1], gen_rtx_MEM (BLKmode, src_reg)); 2779 create_integer_operand (&ops[2], 0); 2780 create_integer_operand (&ops[3], align); 2781 if (!maybe_expand_insn (icode, 4, ops)) 2782 return NULL_RTX; 2783 2784 /* Now that we are assured of success, expand the source. */ 2785 start_sequence (); 2786 pat = expand_expr (src, src_reg, Pmode, EXPAND_NORMAL); 2787 if (pat != src_reg) 2788 { 2789 #ifdef POINTERS_EXTEND_UNSIGNED 2790 if (GET_MODE (pat) != Pmode) 2791 pat = convert_to_mode (Pmode, pat, 2792 POINTERS_EXTEND_UNSIGNED); 2793 #endif 2794 emit_move_insn (src_reg, pat); 2795 } 2796 pat = get_insns (); 2797 end_sequence (); 2798 2799 if (before_strlen) 2800 emit_insn_after (pat, before_strlen); 2801 else 2802 emit_insn_before (pat, get_insns ()); 2803 2804 /* Return the value in the proper mode for this function. */ 2805 if (GET_MODE (ops[0].value) == target_mode) 2806 target = ops[0].value; 2807 else if (target != 0) 2808 convert_move (target, ops[0].value, 0); 2809 else 2810 target = convert_to_mode (target_mode, ops[0].value, 0); 2811 2812 return target; 2813 } 2814 } 2815 2816 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE) 2817 bytes from constant string DATA + OFFSET and return it as target 2818 constant. */ 2819 2820 static rtx 2821 builtin_memcpy_read_str (void *data, HOST_WIDE_INT offset, 2822 machine_mode mode) 2823 { 2824 const char *str = (const char *) data; 2825 2826 gcc_assert (offset >= 0 2827 && ((unsigned HOST_WIDE_INT) offset + GET_MODE_SIZE (mode) 2828 <= strlen (str) + 1)); 2829 2830 return c_readstr (str + offset, mode); 2831 } 2832 2833 /* LEN specify length of the block of memcpy/memset operation. 2834 Figure out its range and put it into MIN_SIZE/MAX_SIZE. 2835 In some cases we can make very likely guess on max size, then we 2836 set it into PROBABLE_MAX_SIZE. */ 2837 2838 static void 2839 determine_block_size (tree len, rtx len_rtx, 2840 unsigned HOST_WIDE_INT *min_size, 2841 unsigned HOST_WIDE_INT *max_size, 2842 unsigned HOST_WIDE_INT *probable_max_size) 2843 { 2844 if (CONST_INT_P (len_rtx)) 2845 { 2846 *min_size = *max_size = *probable_max_size = UINTVAL (len_rtx); 2847 return; 2848 } 2849 else 2850 { 2851 wide_int min, max; 2852 enum value_range_type range_type = VR_UNDEFINED; 2853 2854 /* Determine bounds from the type. */ 2855 if (tree_fits_uhwi_p (TYPE_MIN_VALUE (TREE_TYPE (len)))) 2856 *min_size = tree_to_uhwi (TYPE_MIN_VALUE (TREE_TYPE (len))); 2857 else 2858 *min_size = 0; 2859 if (tree_fits_uhwi_p (TYPE_MAX_VALUE (TREE_TYPE (len)))) 2860 *probable_max_size = *max_size 2861 = tree_to_uhwi (TYPE_MAX_VALUE (TREE_TYPE (len))); 2862 else 2863 *probable_max_size = *max_size = GET_MODE_MASK (GET_MODE (len_rtx)); 2864 2865 if (TREE_CODE (len) == SSA_NAME) 2866 range_type = get_range_info (len, &min, &max); 2867 if (range_type == VR_RANGE) 2868 { 2869 if (wi::fits_uhwi_p (min) && *min_size < min.to_uhwi ()) 2870 *min_size = min.to_uhwi (); 2871 if (wi::fits_uhwi_p (max) && *max_size > max.to_uhwi ()) 2872 *probable_max_size = *max_size = max.to_uhwi (); 2873 } 2874 else if (range_type == VR_ANTI_RANGE) 2875 { 2876 /* Anti range 0...N lets us to determine minimal size to N+1. */ 2877 if (min == 0) 2878 { 2879 if (wi::fits_uhwi_p (max) && max.to_uhwi () + 1 != 0) 2880 *min_size = max.to_uhwi () + 1; 2881 } 2882 /* Code like 2883 2884 int n; 2885 if (n < 100) 2886 memcpy (a, b, n) 2887 2888 Produce anti range allowing negative values of N. We still 2889 can use the information and make a guess that N is not negative. 2890 */ 2891 else if (!wi::leu_p (max, 1 << 30) && wi::fits_uhwi_p (min)) 2892 *probable_max_size = min.to_uhwi () - 1; 2893 } 2894 } 2895 gcc_checking_assert (*max_size <= 2896 (unsigned HOST_WIDE_INT) 2897 GET_MODE_MASK (GET_MODE (len_rtx))); 2898 } 2899 2900 /* Helper function to do the actual work for expand_builtin_memcpy. */ 2901 2902 static rtx 2903 expand_builtin_memcpy_args (tree dest, tree src, tree len, rtx target, tree exp) 2904 { 2905 const char *src_str; 2906 unsigned int src_align = get_pointer_alignment (src); 2907 unsigned int dest_align = get_pointer_alignment (dest); 2908 rtx dest_mem, src_mem, dest_addr, len_rtx; 2909 HOST_WIDE_INT expected_size = -1; 2910 unsigned int expected_align = 0; 2911 unsigned HOST_WIDE_INT min_size; 2912 unsigned HOST_WIDE_INT max_size; 2913 unsigned HOST_WIDE_INT probable_max_size; 2914 2915 /* If DEST is not a pointer type, call the normal function. */ 2916 if (dest_align == 0) 2917 return NULL_RTX; 2918 2919 /* If either SRC is not a pointer type, don't do this 2920 operation in-line. */ 2921 if (src_align == 0) 2922 return NULL_RTX; 2923 2924 if (currently_expanding_gimple_stmt) 2925 stringop_block_profile (currently_expanding_gimple_stmt, 2926 &expected_align, &expected_size); 2927 2928 if (expected_align < dest_align) 2929 expected_align = dest_align; 2930 dest_mem = get_memory_rtx (dest, len); 2931 set_mem_align (dest_mem, dest_align); 2932 len_rtx = expand_normal (len); 2933 determine_block_size (len, len_rtx, &min_size, &max_size, 2934 &probable_max_size); 2935 src_str = c_getstr (src); 2936 2937 /* If SRC is a string constant and block move would be done 2938 by pieces, we can avoid loading the string from memory 2939 and only stored the computed constants. */ 2940 if (src_str 2941 && CONST_INT_P (len_rtx) 2942 && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1 2943 && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str, 2944 CONST_CAST (char *, src_str), 2945 dest_align, false)) 2946 { 2947 dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx), 2948 builtin_memcpy_read_str, 2949 CONST_CAST (char *, src_str), 2950 dest_align, false, 0); 2951 dest_mem = force_operand (XEXP (dest_mem, 0), target); 2952 dest_mem = convert_memory_address (ptr_mode, dest_mem); 2953 return dest_mem; 2954 } 2955 2956 src_mem = get_memory_rtx (src, len); 2957 set_mem_align (src_mem, src_align); 2958 2959 /* Copy word part most expediently. */ 2960 dest_addr = emit_block_move_hints (dest_mem, src_mem, len_rtx, 2961 CALL_EXPR_TAILCALL (exp) 2962 ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL, 2963 expected_align, expected_size, 2964 min_size, max_size, probable_max_size); 2965 2966 if (dest_addr == 0) 2967 { 2968 dest_addr = force_operand (XEXP (dest_mem, 0), target); 2969 dest_addr = convert_memory_address (ptr_mode, dest_addr); 2970 } 2971 2972 return dest_addr; 2973 } 2974 2975 /* Expand a call EXP to the memcpy builtin. 2976 Return NULL_RTX if we failed, the caller should emit a normal call, 2977 otherwise try to get the result in TARGET, if convenient (and in 2978 mode MODE if that's convenient). */ 2979 2980 static rtx 2981 expand_builtin_memcpy (tree exp, rtx target) 2982 { 2983 if (!validate_arglist (exp, 2984 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE)) 2985 return NULL_RTX; 2986 else 2987 { 2988 tree dest = CALL_EXPR_ARG (exp, 0); 2989 tree src = CALL_EXPR_ARG (exp, 1); 2990 tree len = CALL_EXPR_ARG (exp, 2); 2991 return expand_builtin_memcpy_args (dest, src, len, target, exp); 2992 } 2993 } 2994 2995 /* Expand an instrumented call EXP to the memcpy builtin. 2996 Return NULL_RTX if we failed, the caller should emit a normal call, 2997 otherwise try to get the result in TARGET, if convenient (and in 2998 mode MODE if that's convenient). */ 2999 3000 static rtx 3001 expand_builtin_memcpy_with_bounds (tree exp, rtx target) 3002 { 3003 if (!validate_arglist (exp, 3004 POINTER_TYPE, POINTER_BOUNDS_TYPE, 3005 POINTER_TYPE, POINTER_BOUNDS_TYPE, 3006 INTEGER_TYPE, VOID_TYPE)) 3007 return NULL_RTX; 3008 else 3009 { 3010 tree dest = CALL_EXPR_ARG (exp, 0); 3011 tree src = CALL_EXPR_ARG (exp, 2); 3012 tree len = CALL_EXPR_ARG (exp, 4); 3013 rtx res = expand_builtin_memcpy_args (dest, src, len, target, exp); 3014 3015 /* Return src bounds with the result. */ 3016 if (res) 3017 { 3018 rtx bnd = force_reg (targetm.chkp_bound_mode (), 3019 expand_normal (CALL_EXPR_ARG (exp, 1))); 3020 res = chkp_join_splitted_slot (res, bnd); 3021 } 3022 return res; 3023 } 3024 } 3025 3026 /* Expand a call EXP to the mempcpy builtin. 3027 Return NULL_RTX if we failed; the caller should emit a normal call, 3028 otherwise try to get the result in TARGET, if convenient (and in 3029 mode MODE if that's convenient). If ENDP is 0 return the 3030 destination pointer, if ENDP is 1 return the end pointer ala 3031 mempcpy, and if ENDP is 2 return the end pointer minus one ala 3032 stpcpy. */ 3033 3034 static rtx 3035 expand_builtin_mempcpy (tree exp, rtx target, machine_mode mode) 3036 { 3037 if (!validate_arglist (exp, 3038 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE)) 3039 return NULL_RTX; 3040 else 3041 { 3042 tree dest = CALL_EXPR_ARG (exp, 0); 3043 tree src = CALL_EXPR_ARG (exp, 1); 3044 tree len = CALL_EXPR_ARG (exp, 2); 3045 return expand_builtin_mempcpy_args (dest, src, len, 3046 target, mode, /*endp=*/ 1, 3047 exp); 3048 } 3049 } 3050 3051 /* Expand an instrumented call EXP to the mempcpy builtin. 3052 Return NULL_RTX if we failed, the caller should emit a normal call, 3053 otherwise try to get the result in TARGET, if convenient (and in 3054 mode MODE if that's convenient). */ 3055 3056 static rtx 3057 expand_builtin_mempcpy_with_bounds (tree exp, rtx target, machine_mode mode) 3058 { 3059 if (!validate_arglist (exp, 3060 POINTER_TYPE, POINTER_BOUNDS_TYPE, 3061 POINTER_TYPE, POINTER_BOUNDS_TYPE, 3062 INTEGER_TYPE, VOID_TYPE)) 3063 return NULL_RTX; 3064 else 3065 { 3066 tree dest = CALL_EXPR_ARG (exp, 0); 3067 tree src = CALL_EXPR_ARG (exp, 2); 3068 tree len = CALL_EXPR_ARG (exp, 4); 3069 rtx res = expand_builtin_mempcpy_args (dest, src, len, target, 3070 mode, 1, exp); 3071 3072 /* Return src bounds with the result. */ 3073 if (res) 3074 { 3075 rtx bnd = force_reg (targetm.chkp_bound_mode (), 3076 expand_normal (CALL_EXPR_ARG (exp, 1))); 3077 res = chkp_join_splitted_slot (res, bnd); 3078 } 3079 return res; 3080 } 3081 } 3082 3083 /* Helper function to do the actual work for expand_builtin_mempcpy. The 3084 arguments to the builtin_mempcpy call DEST, SRC, and LEN are broken out 3085 so that this can also be called without constructing an actual CALL_EXPR. 3086 The other arguments and return value are the same as for 3087 expand_builtin_mempcpy. */ 3088 3089 static rtx 3090 expand_builtin_mempcpy_args (tree dest, tree src, tree len, 3091 rtx target, machine_mode mode, int endp, 3092 tree orig_exp) 3093 { 3094 tree fndecl = get_callee_fndecl (orig_exp); 3095 3096 /* If return value is ignored, transform mempcpy into memcpy. */ 3097 if (target == const0_rtx 3098 && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CHKP_MEMPCPY_NOBND_NOCHK_CHKP 3099 && builtin_decl_implicit_p (BUILT_IN_CHKP_MEMCPY_NOBND_NOCHK_CHKP)) 3100 { 3101 tree fn = builtin_decl_implicit (BUILT_IN_CHKP_MEMCPY_NOBND_NOCHK_CHKP); 3102 tree result = build_call_nofold_loc (UNKNOWN_LOCATION, fn, 3, 3103 dest, src, len); 3104 return expand_expr (result, target, mode, EXPAND_NORMAL); 3105 } 3106 else if (target == const0_rtx 3107 && builtin_decl_implicit_p (BUILT_IN_MEMCPY)) 3108 { 3109 tree fn = builtin_decl_implicit (BUILT_IN_MEMCPY); 3110 tree result = build_call_nofold_loc (UNKNOWN_LOCATION, fn, 3, 3111 dest, src, len); 3112 return expand_expr (result, target, mode, EXPAND_NORMAL); 3113 } 3114 else 3115 { 3116 const char *src_str; 3117 unsigned int src_align = get_pointer_alignment (src); 3118 unsigned int dest_align = get_pointer_alignment (dest); 3119 rtx dest_mem, src_mem, len_rtx; 3120 3121 /* If either SRC or DEST is not a pointer type, don't do this 3122 operation in-line. */ 3123 if (dest_align == 0 || src_align == 0) 3124 return NULL_RTX; 3125 3126 /* If LEN is not constant, call the normal function. */ 3127 if (! tree_fits_uhwi_p (len)) 3128 return NULL_RTX; 3129 3130 len_rtx = expand_normal (len); 3131 src_str = c_getstr (src); 3132 3133 /* If SRC is a string constant and block move would be done 3134 by pieces, we can avoid loading the string from memory 3135 and only stored the computed constants. */ 3136 if (src_str 3137 && CONST_INT_P (len_rtx) 3138 && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1 3139 && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str, 3140 CONST_CAST (char *, src_str), 3141 dest_align, false)) 3142 { 3143 dest_mem = get_memory_rtx (dest, len); 3144 set_mem_align (dest_mem, dest_align); 3145 dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx), 3146 builtin_memcpy_read_str, 3147 CONST_CAST (char *, src_str), 3148 dest_align, false, endp); 3149 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX); 3150 dest_mem = convert_memory_address (ptr_mode, dest_mem); 3151 return dest_mem; 3152 } 3153 3154 if (CONST_INT_P (len_rtx) 3155 && can_move_by_pieces (INTVAL (len_rtx), 3156 MIN (dest_align, src_align))) 3157 { 3158 dest_mem = get_memory_rtx (dest, len); 3159 set_mem_align (dest_mem, dest_align); 3160 src_mem = get_memory_rtx (src, len); 3161 set_mem_align (src_mem, src_align); 3162 dest_mem = move_by_pieces (dest_mem, src_mem, INTVAL (len_rtx), 3163 MIN (dest_align, src_align), endp); 3164 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX); 3165 dest_mem = convert_memory_address (ptr_mode, dest_mem); 3166 return dest_mem; 3167 } 3168 3169 return NULL_RTX; 3170 } 3171 } 3172 3173 /* Expand into a movstr instruction, if one is available. Return NULL_RTX if 3174 we failed, the caller should emit a normal call, otherwise try to 3175 get the result in TARGET, if convenient. If ENDP is 0 return the 3176 destination pointer, if ENDP is 1 return the end pointer ala 3177 mempcpy, and if ENDP is 2 return the end pointer minus one ala 3178 stpcpy. */ 3179 3180 static rtx 3181 expand_movstr (tree dest, tree src, rtx target, int endp) 3182 { 3183 struct expand_operand ops[3]; 3184 rtx dest_mem; 3185 rtx src_mem; 3186 3187 if (!targetm.have_movstr ()) 3188 return NULL_RTX; 3189 3190 dest_mem = get_memory_rtx (dest, NULL); 3191 src_mem = get_memory_rtx (src, NULL); 3192 if (!endp) 3193 { 3194 target = force_reg (Pmode, XEXP (dest_mem, 0)); 3195 dest_mem = replace_equiv_address (dest_mem, target); 3196 } 3197 3198 create_output_operand (&ops[0], endp ? target : NULL_RTX, Pmode); 3199 create_fixed_operand (&ops[1], dest_mem); 3200 create_fixed_operand (&ops[2], src_mem); 3201 if (!maybe_expand_insn (targetm.code_for_movstr, 3, ops)) 3202 return NULL_RTX; 3203 3204 if (endp && target != const0_rtx) 3205 { 3206 target = ops[0].value; 3207 /* movstr is supposed to set end to the address of the NUL 3208 terminator. If the caller requested a mempcpy-like return value, 3209 adjust it. */ 3210 if (endp == 1) 3211 { 3212 rtx tem = plus_constant (GET_MODE (target), 3213 gen_lowpart (GET_MODE (target), target), 1); 3214 emit_move_insn (target, force_operand (tem, NULL_RTX)); 3215 } 3216 } 3217 return target; 3218 } 3219 3220 /* Expand expression EXP, which is a call to the strcpy builtin. Return 3221 NULL_RTX if we failed the caller should emit a normal call, otherwise 3222 try to get the result in TARGET, if convenient (and in mode MODE if that's 3223 convenient). */ 3224 3225 static rtx 3226 expand_builtin_strcpy (tree exp, rtx target) 3227 { 3228 if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE)) 3229 { 3230 tree dest = CALL_EXPR_ARG (exp, 0); 3231 tree src = CALL_EXPR_ARG (exp, 1); 3232 return expand_builtin_strcpy_args (dest, src, target); 3233 } 3234 return NULL_RTX; 3235 } 3236 3237 /* Helper function to do the actual work for expand_builtin_strcpy. The 3238 arguments to the builtin_strcpy call DEST and SRC are broken out 3239 so that this can also be called without constructing an actual CALL_EXPR. 3240 The other arguments and return value are the same as for 3241 expand_builtin_strcpy. */ 3242 3243 static rtx 3244 expand_builtin_strcpy_args (tree dest, tree src, rtx target) 3245 { 3246 return expand_movstr (dest, src, target, /*endp=*/0); 3247 } 3248 3249 /* Expand a call EXP to the stpcpy builtin. 3250 Return NULL_RTX if we failed the caller should emit a normal call, 3251 otherwise try to get the result in TARGET, if convenient (and in 3252 mode MODE if that's convenient). */ 3253 3254 static rtx 3255 expand_builtin_stpcpy (tree exp, rtx target, machine_mode mode) 3256 { 3257 tree dst, src; 3258 location_t loc = EXPR_LOCATION (exp); 3259 3260 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE)) 3261 return NULL_RTX; 3262 3263 dst = CALL_EXPR_ARG (exp, 0); 3264 src = CALL_EXPR_ARG (exp, 1); 3265 3266 /* If return value is ignored, transform stpcpy into strcpy. */ 3267 if (target == const0_rtx && builtin_decl_implicit (BUILT_IN_STRCPY)) 3268 { 3269 tree fn = builtin_decl_implicit (BUILT_IN_STRCPY); 3270 tree result = build_call_nofold_loc (loc, fn, 2, dst, src); 3271 return expand_expr (result, target, mode, EXPAND_NORMAL); 3272 } 3273 else 3274 { 3275 tree len, lenp1; 3276 rtx ret; 3277 3278 /* Ensure we get an actual string whose length can be evaluated at 3279 compile-time, not an expression containing a string. This is 3280 because the latter will potentially produce pessimized code 3281 when used to produce the return value. */ 3282 if (! c_getstr (src) || ! (len = c_strlen (src, 0))) 3283 return expand_movstr (dst, src, target, /*endp=*/2); 3284 3285 lenp1 = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1)); 3286 ret = expand_builtin_mempcpy_args (dst, src, lenp1, 3287 target, mode, /*endp=*/2, 3288 exp); 3289 3290 if (ret) 3291 return ret; 3292 3293 if (TREE_CODE (len) == INTEGER_CST) 3294 { 3295 rtx len_rtx = expand_normal (len); 3296 3297 if (CONST_INT_P (len_rtx)) 3298 { 3299 ret = expand_builtin_strcpy_args (dst, src, target); 3300 3301 if (ret) 3302 { 3303 if (! target) 3304 { 3305 if (mode != VOIDmode) 3306 target = gen_reg_rtx (mode); 3307 else 3308 target = gen_reg_rtx (GET_MODE (ret)); 3309 } 3310 if (GET_MODE (target) != GET_MODE (ret)) 3311 ret = gen_lowpart (GET_MODE (target), ret); 3312 3313 ret = plus_constant (GET_MODE (ret), ret, INTVAL (len_rtx)); 3314 ret = emit_move_insn (target, force_operand (ret, NULL_RTX)); 3315 gcc_assert (ret); 3316 3317 return target; 3318 } 3319 } 3320 } 3321 3322 return expand_movstr (dst, src, target, /*endp=*/2); 3323 } 3324 } 3325 3326 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE) 3327 bytes from constant string DATA + OFFSET and return it as target 3328 constant. */ 3329 3330 rtx 3331 builtin_strncpy_read_str (void *data, HOST_WIDE_INT offset, 3332 machine_mode mode) 3333 { 3334 const char *str = (const char *) data; 3335 3336 if ((unsigned HOST_WIDE_INT) offset > strlen (str)) 3337 return const0_rtx; 3338 3339 return c_readstr (str + offset, mode); 3340 } 3341 3342 /* Expand expression EXP, which is a call to the strncpy builtin. Return 3343 NULL_RTX if we failed the caller should emit a normal call. */ 3344 3345 static rtx 3346 expand_builtin_strncpy (tree exp, rtx target) 3347 { 3348 location_t loc = EXPR_LOCATION (exp); 3349 3350 if (validate_arglist (exp, 3351 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE)) 3352 { 3353 tree dest = CALL_EXPR_ARG (exp, 0); 3354 tree src = CALL_EXPR_ARG (exp, 1); 3355 tree len = CALL_EXPR_ARG (exp, 2); 3356 tree slen = c_strlen (src, 1); 3357 3358 /* We must be passed a constant len and src parameter. */ 3359 if (!tree_fits_uhwi_p (len) || !slen || !tree_fits_uhwi_p (slen)) 3360 return NULL_RTX; 3361 3362 slen = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1)); 3363 3364 /* We're required to pad with trailing zeros if the requested 3365 len is greater than strlen(s2)+1. In that case try to 3366 use store_by_pieces, if it fails, punt. */ 3367 if (tree_int_cst_lt (slen, len)) 3368 { 3369 unsigned int dest_align = get_pointer_alignment (dest); 3370 const char *p = c_getstr (src); 3371 rtx dest_mem; 3372 3373 if (!p || dest_align == 0 || !tree_fits_uhwi_p (len) 3374 || !can_store_by_pieces (tree_to_uhwi (len), 3375 builtin_strncpy_read_str, 3376 CONST_CAST (char *, p), 3377 dest_align, false)) 3378 return NULL_RTX; 3379 3380 dest_mem = get_memory_rtx (dest, len); 3381 store_by_pieces (dest_mem, tree_to_uhwi (len), 3382 builtin_strncpy_read_str, 3383 CONST_CAST (char *, p), dest_align, false, 0); 3384 dest_mem = force_operand (XEXP (dest_mem, 0), target); 3385 dest_mem = convert_memory_address (ptr_mode, dest_mem); 3386 return dest_mem; 3387 } 3388 } 3389 return NULL_RTX; 3390 } 3391 3392 /* Callback routine for store_by_pieces. Read GET_MODE_BITSIZE (MODE) 3393 bytes from constant string DATA + OFFSET and return it as target 3394 constant. */ 3395 3396 rtx 3397 builtin_memset_read_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED, 3398 machine_mode mode) 3399 { 3400 const char *c = (const char *) data; 3401 char *p = XALLOCAVEC (char, GET_MODE_SIZE (mode)); 3402 3403 memset (p, *c, GET_MODE_SIZE (mode)); 3404 3405 return c_readstr (p, mode); 3406 } 3407 3408 /* Callback routine for store_by_pieces. Return the RTL of a register 3409 containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned 3410 char value given in the RTL register data. For example, if mode is 3411 4 bytes wide, return the RTL for 0x01010101*data. */ 3412 3413 static rtx 3414 builtin_memset_gen_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED, 3415 machine_mode mode) 3416 { 3417 rtx target, coeff; 3418 size_t size; 3419 char *p; 3420 3421 size = GET_MODE_SIZE (mode); 3422 if (size == 1) 3423 return (rtx) data; 3424 3425 p = XALLOCAVEC (char, size); 3426 memset (p, 1, size); 3427 coeff = c_readstr (p, mode); 3428 3429 target = convert_to_mode (mode, (rtx) data, 1); 3430 target = expand_mult (mode, target, coeff, NULL_RTX, 1); 3431 return force_reg (mode, target); 3432 } 3433 3434 /* Expand expression EXP, which is a call to the memset builtin. Return 3435 NULL_RTX if we failed the caller should emit a normal call, otherwise 3436 try to get the result in TARGET, if convenient (and in mode MODE if that's 3437 convenient). */ 3438 3439 static rtx 3440 expand_builtin_memset (tree exp, rtx target, machine_mode mode) 3441 { 3442 if (!validate_arglist (exp, 3443 POINTER_TYPE, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE)) 3444 return NULL_RTX; 3445 else 3446 { 3447 tree dest = CALL_EXPR_ARG (exp, 0); 3448 tree val = CALL_EXPR_ARG (exp, 1); 3449 tree len = CALL_EXPR_ARG (exp, 2); 3450 return expand_builtin_memset_args (dest, val, len, target, mode, exp); 3451 } 3452 } 3453 3454 /* Expand expression EXP, which is an instrumented call to the memset builtin. 3455 Return NULL_RTX if we failed the caller should emit a normal call, otherwise 3456 try to get the result in TARGET, if convenient (and in mode MODE if that's 3457 convenient). */ 3458 3459 static rtx 3460 expand_builtin_memset_with_bounds (tree exp, rtx target, machine_mode mode) 3461 { 3462 if (!validate_arglist (exp, 3463 POINTER_TYPE, POINTER_BOUNDS_TYPE, 3464 INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE)) 3465 return NULL_RTX; 3466 else 3467 { 3468 tree dest = CALL_EXPR_ARG (exp, 0); 3469 tree val = CALL_EXPR_ARG (exp, 2); 3470 tree len = CALL_EXPR_ARG (exp, 3); 3471 rtx res = expand_builtin_memset_args (dest, val, len, target, mode, exp); 3472 3473 /* Return src bounds with the result. */ 3474 if (res) 3475 { 3476 rtx bnd = force_reg (targetm.chkp_bound_mode (), 3477 expand_normal (CALL_EXPR_ARG (exp, 1))); 3478 res = chkp_join_splitted_slot (res, bnd); 3479 } 3480 return res; 3481 } 3482 } 3483 3484 /* Helper function to do the actual work for expand_builtin_memset. The 3485 arguments to the builtin_memset call DEST, VAL, and LEN are broken out 3486 so that this can also be called without constructing an actual CALL_EXPR. 3487 The other arguments and return value are the same as for 3488 expand_builtin_memset. */ 3489 3490 static rtx 3491 expand_builtin_memset_args (tree dest, tree val, tree len, 3492 rtx target, machine_mode mode, tree orig_exp) 3493 { 3494 tree fndecl, fn; 3495 enum built_in_function fcode; 3496 machine_mode val_mode; 3497 char c; 3498 unsigned int dest_align; 3499 rtx dest_mem, dest_addr, len_rtx; 3500 HOST_WIDE_INT expected_size = -1; 3501 unsigned int expected_align = 0; 3502 unsigned HOST_WIDE_INT min_size; 3503 unsigned HOST_WIDE_INT max_size; 3504 unsigned HOST_WIDE_INT probable_max_size; 3505 3506 dest_align = get_pointer_alignment (dest); 3507 3508 /* If DEST is not a pointer type, don't do this operation in-line. */ 3509 if (dest_align == 0) 3510 return NULL_RTX; 3511 3512 if (currently_expanding_gimple_stmt) 3513 stringop_block_profile (currently_expanding_gimple_stmt, 3514 &expected_align, &expected_size); 3515 3516 if (expected_align < dest_align) 3517 expected_align = dest_align; 3518 3519 /* If the LEN parameter is zero, return DEST. */ 3520 if (integer_zerop (len)) 3521 { 3522 /* Evaluate and ignore VAL in case it has side-effects. */ 3523 expand_expr (val, const0_rtx, VOIDmode, EXPAND_NORMAL); 3524 return expand_expr (dest, target, mode, EXPAND_NORMAL); 3525 } 3526 3527 /* Stabilize the arguments in case we fail. */ 3528 dest = builtin_save_expr (dest); 3529 val = builtin_save_expr (val); 3530 len = builtin_save_expr (len); 3531 3532 len_rtx = expand_normal (len); 3533 determine_block_size (len, len_rtx, &min_size, &max_size, 3534 &probable_max_size); 3535 dest_mem = get_memory_rtx (dest, len); 3536 val_mode = TYPE_MODE (unsigned_char_type_node); 3537 3538 if (TREE_CODE (val) != INTEGER_CST) 3539 { 3540 rtx val_rtx; 3541 3542 val_rtx = expand_normal (val); 3543 val_rtx = convert_to_mode (val_mode, val_rtx, 0); 3544 3545 /* Assume that we can memset by pieces if we can store 3546 * the coefficients by pieces (in the required modes). 3547 * We can't pass builtin_memset_gen_str as that emits RTL. */ 3548 c = 1; 3549 if (tree_fits_uhwi_p (len) 3550 && can_store_by_pieces (tree_to_uhwi (len), 3551 builtin_memset_read_str, &c, dest_align, 3552 true)) 3553 { 3554 val_rtx = force_reg (val_mode, val_rtx); 3555 store_by_pieces (dest_mem, tree_to_uhwi (len), 3556 builtin_memset_gen_str, val_rtx, dest_align, 3557 true, 0); 3558 } 3559 else if (!set_storage_via_setmem (dest_mem, len_rtx, val_rtx, 3560 dest_align, expected_align, 3561 expected_size, min_size, max_size, 3562 probable_max_size)) 3563 goto do_libcall; 3564 3565 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX); 3566 dest_mem = convert_memory_address (ptr_mode, dest_mem); 3567 return dest_mem; 3568 } 3569 3570 if (target_char_cast (val, &c)) 3571 goto do_libcall; 3572 3573 if (c) 3574 { 3575 if (tree_fits_uhwi_p (len) 3576 && can_store_by_pieces (tree_to_uhwi (len), 3577 builtin_memset_read_str, &c, dest_align, 3578 true)) 3579 store_by_pieces (dest_mem, tree_to_uhwi (len), 3580 builtin_memset_read_str, &c, dest_align, true, 0); 3581 else if (!set_storage_via_setmem (dest_mem, len_rtx, 3582 gen_int_mode (c, val_mode), 3583 dest_align, expected_align, 3584 expected_size, min_size, max_size, 3585 probable_max_size)) 3586 goto do_libcall; 3587 3588 dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX); 3589 dest_mem = convert_memory_address (ptr_mode, dest_mem); 3590 return dest_mem; 3591 } 3592 3593 set_mem_align (dest_mem, dest_align); 3594 dest_addr = clear_storage_hints (dest_mem, len_rtx, 3595 CALL_EXPR_TAILCALL (orig_exp) 3596 ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL, 3597 expected_align, expected_size, 3598 min_size, max_size, 3599 probable_max_size); 3600 3601 if (dest_addr == 0) 3602 { 3603 dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX); 3604 dest_addr = convert_memory_address (ptr_mode, dest_addr); 3605 } 3606 3607 return dest_addr; 3608 3609 do_libcall: 3610 fndecl = get_callee_fndecl (orig_exp); 3611 fcode = DECL_FUNCTION_CODE (fndecl); 3612 if (fcode == BUILT_IN_MEMSET 3613 || fcode == BUILT_IN_CHKP_MEMSET_NOBND_NOCHK_CHKP) 3614 fn = build_call_nofold_loc (EXPR_LOCATION (orig_exp), fndecl, 3, 3615 dest, val, len); 3616 else if (fcode == BUILT_IN_BZERO) 3617 fn = build_call_nofold_loc (EXPR_LOCATION (orig_exp), fndecl, 2, 3618 dest, len); 3619 else 3620 gcc_unreachable (); 3621 gcc_assert (TREE_CODE (fn) == CALL_EXPR); 3622 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (orig_exp); 3623 return expand_call (fn, target, target == const0_rtx); 3624 } 3625 3626 /* Expand expression EXP, which is a call to the bzero builtin. Return 3627 NULL_RTX if we failed the caller should emit a normal call. */ 3628 3629 static rtx 3630 expand_builtin_bzero (tree exp) 3631 { 3632 tree dest, size; 3633 location_t loc = EXPR_LOCATION (exp); 3634 3635 if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE)) 3636 return NULL_RTX; 3637 3638 dest = CALL_EXPR_ARG (exp, 0); 3639 size = CALL_EXPR_ARG (exp, 1); 3640 3641 /* New argument list transforming bzero(ptr x, int y) to 3642 memset(ptr x, int 0, size_t y). This is done this way 3643 so that if it isn't expanded inline, we fallback to 3644 calling bzero instead of memset. */ 3645 3646 return expand_builtin_memset_args (dest, integer_zero_node, 3647 fold_convert_loc (loc, 3648 size_type_node, size), 3649 const0_rtx, VOIDmode, exp); 3650 } 3651 3652 /* Try to expand cmpstr operation ICODE with the given operands. 3653 Return the result rtx on success, otherwise return null. */ 3654 3655 static rtx 3656 expand_cmpstr (insn_code icode, rtx target, rtx arg1_rtx, rtx arg2_rtx, 3657 HOST_WIDE_INT align) 3658 { 3659 machine_mode insn_mode = insn_data[icode].operand[0].mode; 3660 3661 if (target && (!REG_P (target) || HARD_REGISTER_P (target))) 3662 target = NULL_RTX; 3663 3664 struct expand_operand ops[4]; 3665 create_output_operand (&ops[0], target, insn_mode); 3666 create_fixed_operand (&ops[1], arg1_rtx); 3667 create_fixed_operand (&ops[2], arg2_rtx); 3668 create_integer_operand (&ops[3], align); 3669 if (maybe_expand_insn (icode, 4, ops)) 3670 return ops[0].value; 3671 return NULL_RTX; 3672 } 3673 3674 /* Try to expand cmpstrn or cmpmem operation ICODE with the given operands. 3675 ARG3_TYPE is the type of ARG3_RTX. Return the result rtx on success, 3676 otherwise return null. */ 3677 3678 static rtx 3679 expand_cmpstrn_or_cmpmem (insn_code icode, rtx target, rtx arg1_rtx, 3680 rtx arg2_rtx, tree arg3_type, rtx arg3_rtx, 3681 HOST_WIDE_INT align) 3682 { 3683 machine_mode insn_mode = insn_data[icode].operand[0].mode; 3684 3685 if (target && (!REG_P (target) || HARD_REGISTER_P (target))) 3686 target = NULL_RTX; 3687 3688 struct expand_operand ops[5]; 3689 create_output_operand (&ops[0], target, insn_mode); 3690 create_fixed_operand (&ops[1], arg1_rtx); 3691 create_fixed_operand (&ops[2], arg2_rtx); 3692 create_convert_operand_from (&ops[3], arg3_rtx, TYPE_MODE (arg3_type), 3693 TYPE_UNSIGNED (arg3_type)); 3694 create_integer_operand (&ops[4], align); 3695 if (maybe_expand_insn (icode, 5, ops)) 3696 return ops[0].value; 3697 return NULL_RTX; 3698 } 3699 3700 /* Expand expression EXP, which is a call to the memcmp built-in function. 3701 Return NULL_RTX if we failed and the caller should emit a normal call, 3702 otherwise try to get the result in TARGET, if convenient. */ 3703 3704 static rtx 3705 expand_builtin_memcmp (tree exp, rtx target) 3706 { 3707 if (!validate_arglist (exp, 3708 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE)) 3709 return NULL_RTX; 3710 3711 /* Note: The cmpstrnsi pattern, if it exists, is not suitable for 3712 implementing memcmp because it will stop if it encounters two 3713 zero bytes. */ 3714 insn_code icode = direct_optab_handler (cmpmem_optab, SImode); 3715 if (icode == CODE_FOR_nothing) 3716 return NULL_RTX; 3717 3718 tree arg1 = CALL_EXPR_ARG (exp, 0); 3719 tree arg2 = CALL_EXPR_ARG (exp, 1); 3720 tree len = CALL_EXPR_ARG (exp, 2); 3721 3722 unsigned int arg1_align = get_pointer_alignment (arg1) / BITS_PER_UNIT; 3723 unsigned int arg2_align = get_pointer_alignment (arg2) / BITS_PER_UNIT; 3724 3725 /* If we don't have POINTER_TYPE, call the function. */ 3726 if (arg1_align == 0 || arg2_align == 0) 3727 return NULL_RTX; 3728 3729 machine_mode mode = TYPE_MODE (TREE_TYPE (exp)); 3730 location_t loc = EXPR_LOCATION (exp); 3731 rtx arg1_rtx = get_memory_rtx (arg1, len); 3732 rtx arg2_rtx = get_memory_rtx (arg2, len); 3733 rtx arg3_rtx = expand_normal (fold_convert_loc (loc, sizetype, len)); 3734 3735 /* Set MEM_SIZE as appropriate. */ 3736 if (CONST_INT_P (arg3_rtx)) 3737 { 3738 set_mem_size (arg1_rtx, INTVAL (arg3_rtx)); 3739 set_mem_size (arg2_rtx, INTVAL (arg3_rtx)); 3740 } 3741 3742 rtx result = expand_cmpstrn_or_cmpmem (icode, target, arg1_rtx, arg2_rtx, 3743 TREE_TYPE (len), arg3_rtx, 3744 MIN (arg1_align, arg2_align)); 3745 if (result) 3746 { 3747 /* Return the value in the proper mode for this function. */ 3748 if (GET_MODE (result) == mode) 3749 return result; 3750 3751 if (target != 0) 3752 { 3753 convert_move (target, result, 0); 3754 return target; 3755 } 3756 3757 return convert_to_mode (mode, result, 0); 3758 } 3759 3760 result = target; 3761 if (! (result != 0 3762 && REG_P (result) && GET_MODE (result) == mode 3763 && REGNO (result) >= FIRST_PSEUDO_REGISTER)) 3764 result = gen_reg_rtx (mode); 3765 3766 emit_library_call_value (memcmp_libfunc, result, LCT_PURE, 3767 TYPE_MODE (integer_type_node), 3, 3768 XEXP (arg1_rtx, 0), Pmode, 3769 XEXP (arg2_rtx, 0), Pmode, 3770 convert_to_mode (TYPE_MODE (sizetype), arg3_rtx, 3771 TYPE_UNSIGNED (sizetype)), 3772 TYPE_MODE (sizetype)); 3773 return result; 3774 } 3775 3776 /* Expand expression EXP, which is a call to the strcmp builtin. Return NULL_RTX 3777 if we failed the caller should emit a normal call, otherwise try to get 3778 the result in TARGET, if convenient. */ 3779 3780 static rtx 3781 expand_builtin_strcmp (tree exp, ATTRIBUTE_UNUSED rtx target) 3782 { 3783 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE)) 3784 return NULL_RTX; 3785 3786 insn_code cmpstr_icode = direct_optab_handler (cmpstr_optab, SImode); 3787 insn_code cmpstrn_icode = direct_optab_handler (cmpstrn_optab, SImode); 3788 if (cmpstr_icode != CODE_FOR_nothing || cmpstrn_icode != CODE_FOR_nothing) 3789 { 3790 rtx arg1_rtx, arg2_rtx; 3791 tree fndecl, fn; 3792 tree arg1 = CALL_EXPR_ARG (exp, 0); 3793 tree arg2 = CALL_EXPR_ARG (exp, 1); 3794 rtx result = NULL_RTX; 3795 3796 unsigned int arg1_align = get_pointer_alignment (arg1) / BITS_PER_UNIT; 3797 unsigned int arg2_align = get_pointer_alignment (arg2) / BITS_PER_UNIT; 3798 3799 /* If we don't have POINTER_TYPE, call the function. */ 3800 if (arg1_align == 0 || arg2_align == 0) 3801 return NULL_RTX; 3802 3803 /* Stabilize the arguments in case gen_cmpstr(n)si fail. */ 3804 arg1 = builtin_save_expr (arg1); 3805 arg2 = builtin_save_expr (arg2); 3806 3807 arg1_rtx = get_memory_rtx (arg1, NULL); 3808 arg2_rtx = get_memory_rtx (arg2, NULL); 3809 3810 /* Try to call cmpstrsi. */ 3811 if (cmpstr_icode != CODE_FOR_nothing) 3812 result = expand_cmpstr (cmpstr_icode, target, arg1_rtx, arg2_rtx, 3813 MIN (arg1_align, arg2_align)); 3814 3815 /* Try to determine at least one length and call cmpstrnsi. */ 3816 if (!result && cmpstrn_icode != CODE_FOR_nothing) 3817 { 3818 tree len; 3819 rtx arg3_rtx; 3820 3821 tree len1 = c_strlen (arg1, 1); 3822 tree len2 = c_strlen (arg2, 1); 3823 3824 if (len1) 3825 len1 = size_binop (PLUS_EXPR, ssize_int (1), len1); 3826 if (len2) 3827 len2 = size_binop (PLUS_EXPR, ssize_int (1), len2); 3828 3829 /* If we don't have a constant length for the first, use the length 3830 of the second, if we know it. We don't require a constant for 3831 this case; some cost analysis could be done if both are available 3832 but neither is constant. For now, assume they're equally cheap, 3833 unless one has side effects. If both strings have constant lengths, 3834 use the smaller. */ 3835 3836 if (!len1) 3837 len = len2; 3838 else if (!len2) 3839 len = len1; 3840 else if (TREE_SIDE_EFFECTS (len1)) 3841 len = len2; 3842 else if (TREE_SIDE_EFFECTS (len2)) 3843 len = len1; 3844 else if (TREE_CODE (len1) != INTEGER_CST) 3845 len = len2; 3846 else if (TREE_CODE (len2) != INTEGER_CST) 3847 len = len1; 3848 else if (tree_int_cst_lt (len1, len2)) 3849 len = len1; 3850 else 3851 len = len2; 3852 3853 /* If both arguments have side effects, we cannot optimize. */ 3854 if (len && !TREE_SIDE_EFFECTS (len)) 3855 { 3856 arg3_rtx = expand_normal (len); 3857 result = expand_cmpstrn_or_cmpmem 3858 (cmpstrn_icode, target, arg1_rtx, arg2_rtx, TREE_TYPE (len), 3859 arg3_rtx, MIN (arg1_align, arg2_align)); 3860 } 3861 } 3862 3863 if (result) 3864 { 3865 /* Return the value in the proper mode for this function. */ 3866 machine_mode mode = TYPE_MODE (TREE_TYPE (exp)); 3867 if (GET_MODE (result) == mode) 3868 return result; 3869 if (target == 0) 3870 return convert_to_mode (mode, result, 0); 3871 convert_move (target, result, 0); 3872 return target; 3873 } 3874 3875 /* Expand the library call ourselves using a stabilized argument 3876 list to avoid re-evaluating the function's arguments twice. */ 3877 fndecl = get_callee_fndecl (exp); 3878 fn = build_call_nofold_loc (EXPR_LOCATION (exp), fndecl, 2, arg1, arg2); 3879 gcc_assert (TREE_CODE (fn) == CALL_EXPR); 3880 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp); 3881 return expand_call (fn, target, target == const0_rtx); 3882 } 3883 return NULL_RTX; 3884 } 3885 3886 /* Expand expression EXP, which is a call to the strncmp builtin. Return 3887 NULL_RTX if we failed the caller should emit a normal call, otherwise try to get 3888 the result in TARGET, if convenient. */ 3889 3890 static rtx 3891 expand_builtin_strncmp (tree exp, ATTRIBUTE_UNUSED rtx target, 3892 ATTRIBUTE_UNUSED machine_mode mode) 3893 { 3894 location_t loc ATTRIBUTE_UNUSED = EXPR_LOCATION (exp); 3895 3896 if (!validate_arglist (exp, 3897 POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE)) 3898 return NULL_RTX; 3899 3900 /* If c_strlen can determine an expression for one of the string 3901 lengths, and it doesn't have side effects, then emit cmpstrnsi 3902 using length MIN(strlen(string)+1, arg3). */ 3903 insn_code cmpstrn_icode = direct_optab_handler (cmpstrn_optab, SImode); 3904 if (cmpstrn_icode != CODE_FOR_nothing) 3905 { 3906 tree len, len1, len2; 3907 rtx arg1_rtx, arg2_rtx, arg3_rtx; 3908 rtx result; 3909 tree fndecl, fn; 3910 tree arg1 = CALL_EXPR_ARG (exp, 0); 3911 tree arg2 = CALL_EXPR_ARG (exp, 1); 3912 tree arg3 = CALL_EXPR_ARG (exp, 2); 3913 3914 unsigned int arg1_align = get_pointer_alignment (arg1) / BITS_PER_UNIT; 3915 unsigned int arg2_align = get_pointer_alignment (arg2) / BITS_PER_UNIT; 3916 3917 len1 = c_strlen (arg1, 1); 3918 len2 = c_strlen (arg2, 1); 3919 3920 if (len1) 3921 len1 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1), len1); 3922 if (len2) 3923 len2 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1), len2); 3924 3925 /* If we don't have a constant length for the first, use the length 3926 of the second, if we know it. We don't require a constant for 3927 this case; some cost analysis could be done if both are available 3928 but neither is constant. For now, assume they're equally cheap, 3929 unless one has side effects. If both strings have constant lengths, 3930 use the smaller. */ 3931 3932 if (!len1) 3933 len = len2; 3934 else if (!len2) 3935 len = len1; 3936 else if (TREE_SIDE_EFFECTS (len1)) 3937 len = len2; 3938 else if (TREE_SIDE_EFFECTS (len2)) 3939 len = len1; 3940 else if (TREE_CODE (len1) != INTEGER_CST) 3941 len = len2; 3942 else if (TREE_CODE (len2) != INTEGER_CST) 3943 len = len1; 3944 else if (tree_int_cst_lt (len1, len2)) 3945 len = len1; 3946 else 3947 len = len2; 3948 3949 /* If both arguments have side effects, we cannot optimize. */ 3950 if (!len || TREE_SIDE_EFFECTS (len)) 3951 return NULL_RTX; 3952 3953 /* The actual new length parameter is MIN(len,arg3). */ 3954 len = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (len), len, 3955 fold_convert_loc (loc, TREE_TYPE (len), arg3)); 3956 3957 /* If we don't have POINTER_TYPE, call the function. */ 3958 if (arg1_align == 0 || arg2_align == 0) 3959 return NULL_RTX; 3960 3961 /* Stabilize the arguments in case gen_cmpstrnsi fails. */ 3962 arg1 = builtin_save_expr (arg1); 3963 arg2 = builtin_save_expr (arg2); 3964 len = builtin_save_expr (len); 3965 3966 arg1_rtx = get_memory_rtx (arg1, len); 3967 arg2_rtx = get_memory_rtx (arg2, len); 3968 arg3_rtx = expand_normal (len); 3969 result = expand_cmpstrn_or_cmpmem (cmpstrn_icode, target, arg1_rtx, 3970 arg2_rtx, TREE_TYPE (len), arg3_rtx, 3971 MIN (arg1_align, arg2_align)); 3972 if (result) 3973 { 3974 /* Return the value in the proper mode for this function. */ 3975 mode = TYPE_MODE (TREE_TYPE (exp)); 3976 if (GET_MODE (result) == mode) 3977 return result; 3978 if (target == 0) 3979 return convert_to_mode (mode, result, 0); 3980 convert_move (target, result, 0); 3981 return target; 3982 } 3983 3984 /* Expand the library call ourselves using a stabilized argument 3985 list to avoid re-evaluating the function's arguments twice. */ 3986 fndecl = get_callee_fndecl (exp); 3987 fn = build_call_nofold_loc (EXPR_LOCATION (exp), fndecl, 3, 3988 arg1, arg2, len); 3989 gcc_assert (TREE_CODE (fn) == CALL_EXPR); 3990 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp); 3991 return expand_call (fn, target, target == const0_rtx); 3992 } 3993 return NULL_RTX; 3994 } 3995 3996 /* Expand a call to __builtin_saveregs, generating the result in TARGET, 3997 if that's convenient. */ 3998 3999 rtx 4000 expand_builtin_saveregs (void) 4001 { 4002 rtx val; 4003 rtx_insn *seq; 4004 4005 /* Don't do __builtin_saveregs more than once in a function. 4006 Save the result of the first call and reuse it. */ 4007 if (saveregs_value != 0) 4008 return saveregs_value; 4009 4010 /* When this function is called, it means that registers must be 4011 saved on entry to this function. So we migrate the call to the 4012 first insn of this function. */ 4013 4014 start_sequence (); 4015 4016 /* Do whatever the machine needs done in this case. */ 4017 val = targetm.calls.expand_builtin_saveregs (); 4018 4019 seq = get_insns (); 4020 end_sequence (); 4021 4022 saveregs_value = val; 4023 4024 /* Put the insns after the NOTE that starts the function. If this 4025 is inside a start_sequence, make the outer-level insn chain current, so 4026 the code is placed at the start of the function. */ 4027 push_topmost_sequence (); 4028 emit_insn_after (seq, entry_of_function ()); 4029 pop_topmost_sequence (); 4030 4031 return val; 4032 } 4033 4034 /* Expand a call to __builtin_next_arg. */ 4035 4036 static rtx 4037 expand_builtin_next_arg (void) 4038 { 4039 /* Checking arguments is already done in fold_builtin_next_arg 4040 that must be called before this function. */ 4041 return expand_binop (ptr_mode, add_optab, 4042 crtl->args.internal_arg_pointer, 4043 crtl->args.arg_offset_rtx, 4044 NULL_RTX, 0, OPTAB_LIB_WIDEN); 4045 } 4046 4047 /* Make it easier for the backends by protecting the valist argument 4048 from multiple evaluations. */ 4049 4050 static tree 4051 stabilize_va_list_loc (location_t loc, tree valist, int needs_lvalue) 4052 { 4053 tree vatype = targetm.canonical_va_list_type (TREE_TYPE (valist)); 4054 4055 /* The current way of determining the type of valist is completely 4056 bogus. We should have the information on the va builtin instead. */ 4057 if (!vatype) 4058 vatype = targetm.fn_abi_va_list (cfun->decl); 4059 4060 if (TREE_CODE (vatype) == ARRAY_TYPE) 4061 { 4062 if (TREE_SIDE_EFFECTS (valist)) 4063 valist = save_expr (valist); 4064 4065 /* For this case, the backends will be expecting a pointer to 4066 vatype, but it's possible we've actually been given an array 4067 (an actual TARGET_CANONICAL_VA_LIST_TYPE (valist)). 4068 So fix it. */ 4069 if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE) 4070 { 4071 tree p1 = build_pointer_type (TREE_TYPE (vatype)); 4072 valist = build_fold_addr_expr_with_type_loc (loc, valist, p1); 4073 } 4074 } 4075 else 4076 { 4077 tree pt = build_pointer_type (vatype); 4078 4079 if (! needs_lvalue) 4080 { 4081 if (! TREE_SIDE_EFFECTS (valist)) 4082 return valist; 4083 4084 valist = fold_build1_loc (loc, ADDR_EXPR, pt, valist); 4085 TREE_SIDE_EFFECTS (valist) = 1; 4086 } 4087 4088 if (TREE_SIDE_EFFECTS (valist)) 4089 valist = save_expr (valist); 4090 valist = fold_build2_loc (loc, MEM_REF, 4091 vatype, valist, build_int_cst (pt, 0)); 4092 } 4093 4094 return valist; 4095 } 4096 4097 /* The "standard" definition of va_list is void*. */ 4098 4099 tree 4100 std_build_builtin_va_list (void) 4101 { 4102 return ptr_type_node; 4103 } 4104 4105 /* The "standard" abi va_list is va_list_type_node. */ 4106 4107 tree 4108 std_fn_abi_va_list (tree fndecl ATTRIBUTE_UNUSED) 4109 { 4110 return va_list_type_node; 4111 } 4112 4113 /* The "standard" type of va_list is va_list_type_node. */ 4114 4115 tree 4116 std_canonical_va_list_type (tree type) 4117 { 4118 tree wtype, htype; 4119 4120 if (INDIRECT_REF_P (type)) 4121 type = TREE_TYPE (type); 4122 else if (POINTER_TYPE_P (type) && POINTER_TYPE_P (TREE_TYPE (type))) 4123 type = TREE_TYPE (type); 4124 wtype = va_list_type_node; 4125 htype = type; 4126 /* Treat structure va_list types. */ 4127 if (TREE_CODE (wtype) == RECORD_TYPE && POINTER_TYPE_P (htype)) 4128 htype = TREE_TYPE (htype); 4129 else if (TREE_CODE (wtype) == ARRAY_TYPE) 4130 { 4131 /* If va_list is an array type, the argument may have decayed 4132 to a pointer type, e.g. by being passed to another function. 4133 In that case, unwrap both types so that we can compare the 4134 underlying records. */ 4135 if (TREE_CODE (htype) == ARRAY_TYPE 4136 || POINTER_TYPE_P (htype)) 4137 { 4138 wtype = TREE_TYPE (wtype); 4139 htype = TREE_TYPE (htype); 4140 } 4141 } 4142 if (TYPE_MAIN_VARIANT (wtype) == TYPE_MAIN_VARIANT (htype)) 4143 return va_list_type_node; 4144 4145 return NULL_TREE; 4146 } 4147 4148 /* The "standard" implementation of va_start: just assign `nextarg' to 4149 the variable. */ 4150 4151 void 4152 std_expand_builtin_va_start (tree valist, rtx nextarg) 4153 { 4154 rtx va_r = expand_expr (valist, NULL_RTX, VOIDmode, EXPAND_WRITE); 4155 convert_move (va_r, nextarg, 0); 4156 4157 /* We do not have any valid bounds for the pointer, so 4158 just store zero bounds for it. */ 4159 if (chkp_function_instrumented_p (current_function_decl)) 4160 chkp_expand_bounds_reset_for_mem (valist, 4161 make_tree (TREE_TYPE (valist), 4162 nextarg)); 4163 } 4164 4165 /* Expand EXP, a call to __builtin_va_start. */ 4166 4167 static rtx 4168 expand_builtin_va_start (tree exp) 4169 { 4170 rtx nextarg; 4171 tree valist; 4172 location_t loc = EXPR_LOCATION (exp); 4173 4174 if (call_expr_nargs (exp) < 2) 4175 { 4176 error_at (loc, "too few arguments to function %<va_start%>"); 4177 return const0_rtx; 4178 } 4179 4180 if (fold_builtin_next_arg (exp, true)) 4181 return const0_rtx; 4182 4183 nextarg = expand_builtin_next_arg (); 4184 valist = stabilize_va_list_loc (loc, CALL_EXPR_ARG (exp, 0), 1); 4185 4186 if (targetm.expand_builtin_va_start) 4187 targetm.expand_builtin_va_start (valist, nextarg); 4188 else 4189 std_expand_builtin_va_start (valist, nextarg); 4190 4191 return const0_rtx; 4192 } 4193 4194 /* Expand EXP, a call to __builtin_va_end. */ 4195 4196 static rtx 4197 expand_builtin_va_end (tree exp) 4198 { 4199 tree valist = CALL_EXPR_ARG (exp, 0); 4200 4201 /* Evaluate for side effects, if needed. I hate macros that don't 4202 do that. */ 4203 if (TREE_SIDE_EFFECTS (valist)) 4204 expand_expr (valist, const0_rtx, VOIDmode, EXPAND_NORMAL); 4205 4206 return const0_rtx; 4207 } 4208 4209 /* Expand EXP, a call to __builtin_va_copy. We do this as a 4210 builtin rather than just as an assignment in stdarg.h because of the 4211 nastiness of array-type va_list types. */ 4212 4213 static rtx 4214 expand_builtin_va_copy (tree exp) 4215 { 4216 tree dst, src, t; 4217 location_t loc = EXPR_LOCATION (exp); 4218 4219 dst = CALL_EXPR_ARG (exp, 0); 4220 src = CALL_EXPR_ARG (exp, 1); 4221 4222 dst = stabilize_va_list_loc (loc, dst, 1); 4223 src = stabilize_va_list_loc (loc, src, 0); 4224 4225 gcc_assert (cfun != NULL && cfun->decl != NULL_TREE); 4226 4227 if (TREE_CODE (targetm.fn_abi_va_list (cfun->decl)) != ARRAY_TYPE) 4228 { 4229 t = build2 (MODIFY_EXPR, targetm.fn_abi_va_list (cfun->decl), dst, src); 4230 TREE_SIDE_EFFECTS (t) = 1; 4231 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL); 4232 } 4233 else 4234 { 4235 rtx dstb, srcb, size; 4236 4237 /* Evaluate to pointers. */ 4238 dstb = expand_expr (dst, NULL_RTX, Pmode, EXPAND_NORMAL); 4239 srcb = expand_expr (src, NULL_RTX, Pmode, EXPAND_NORMAL); 4240 size = expand_expr (TYPE_SIZE_UNIT (targetm.fn_abi_va_list (cfun->decl)), 4241 NULL_RTX, VOIDmode, EXPAND_NORMAL); 4242 4243 dstb = convert_memory_address (Pmode, dstb); 4244 srcb = convert_memory_address (Pmode, srcb); 4245 4246 /* "Dereference" to BLKmode memories. */ 4247 dstb = gen_rtx_MEM (BLKmode, dstb); 4248 set_mem_alias_set (dstb, get_alias_set (TREE_TYPE (TREE_TYPE (dst)))); 4249 set_mem_align (dstb, TYPE_ALIGN (targetm.fn_abi_va_list (cfun->decl))); 4250 srcb = gen_rtx_MEM (BLKmode, srcb); 4251 set_mem_alias_set (srcb, get_alias_set (TREE_TYPE (TREE_TYPE (src)))); 4252 set_mem_align (srcb, TYPE_ALIGN (targetm.fn_abi_va_list (cfun->decl))); 4253 4254 /* Copy. */ 4255 emit_block_move (dstb, srcb, size, BLOCK_OP_NORMAL); 4256 } 4257 4258 return const0_rtx; 4259 } 4260 4261 /* Expand a call to one of the builtin functions __builtin_frame_address or 4262 __builtin_return_address. */ 4263 4264 static rtx 4265 expand_builtin_frame_address (tree fndecl, tree exp) 4266 { 4267 /* The argument must be a nonnegative integer constant. 4268 It counts the number of frames to scan up the stack. 4269 The value is either the frame pointer value or the return 4270 address saved in that frame. */ 4271 if (call_expr_nargs (exp) == 0) 4272 /* Warning about missing arg was already issued. */ 4273 return const0_rtx; 4274 else if (! tree_fits_uhwi_p (CALL_EXPR_ARG (exp, 0))) 4275 { 4276 error ("invalid argument to %qD", fndecl); 4277 return const0_rtx; 4278 } 4279 else 4280 { 4281 /* Number of frames to scan up the stack. */ 4282 unsigned HOST_WIDE_INT count = tree_to_uhwi (CALL_EXPR_ARG (exp, 0)); 4283 4284 rtx tem = expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl), count); 4285 4286 /* Some ports cannot access arbitrary stack frames. */ 4287 if (tem == NULL) 4288 { 4289 warning (0, "unsupported argument to %qD", fndecl); 4290 return const0_rtx; 4291 } 4292 4293 if (count) 4294 { 4295 /* Warn since no effort is made to ensure that any frame 4296 beyond the current one exists or can be safely reached. */ 4297 warning (OPT_Wframe_address, "calling %qD with " 4298 "a nonzero argument is unsafe", fndecl); 4299 } 4300 4301 /* For __builtin_frame_address, return what we've got. */ 4302 if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS) 4303 return tem; 4304 4305 if (!REG_P (tem) 4306 && ! CONSTANT_P (tem)) 4307 tem = copy_addr_to_reg (tem); 4308 return tem; 4309 } 4310 } 4311 4312 /* Expand EXP, a call to the alloca builtin. Return NULL_RTX if we 4313 failed and the caller should emit a normal call. CANNOT_ACCUMULATE 4314 is the same as for allocate_dynamic_stack_space. */ 4315 4316 static rtx 4317 expand_builtin_alloca (tree exp, bool cannot_accumulate) 4318 { 4319 rtx op0; 4320 rtx result; 4321 bool valid_arglist; 4322 unsigned int align; 4323 bool alloca_with_align = (DECL_FUNCTION_CODE (get_callee_fndecl (exp)) 4324 == BUILT_IN_ALLOCA_WITH_ALIGN); 4325 4326 valid_arglist 4327 = (alloca_with_align 4328 ? validate_arglist (exp, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE) 4329 : validate_arglist (exp, INTEGER_TYPE, VOID_TYPE)); 4330 4331 if (!valid_arglist) 4332 return NULL_RTX; 4333 4334 /* Compute the argument. */ 4335 op0 = expand_normal (CALL_EXPR_ARG (exp, 0)); 4336 4337 /* Compute the alignment. */ 4338 align = (alloca_with_align 4339 ? TREE_INT_CST_LOW (CALL_EXPR_ARG (exp, 1)) 4340 : BIGGEST_ALIGNMENT); 4341 4342 /* Allocate the desired space. */ 4343 result = allocate_dynamic_stack_space (op0, 0, align, cannot_accumulate); 4344 result = convert_memory_address (ptr_mode, result); 4345 4346 return result; 4347 } 4348 4349 /* Expand a call to bswap builtin in EXP. 4350 Return NULL_RTX if a normal call should be emitted rather than expanding the 4351 function in-line. If convenient, the result should be placed in TARGET. 4352 SUBTARGET may be used as the target for computing one of EXP's operands. */ 4353 4354 static rtx 4355 expand_builtin_bswap (machine_mode target_mode, tree exp, rtx target, 4356 rtx subtarget) 4357 { 4358 tree arg; 4359 rtx op0; 4360 4361 if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE)) 4362 return NULL_RTX; 4363 4364 arg = CALL_EXPR_ARG (exp, 0); 4365 op0 = expand_expr (arg, 4366 subtarget && GET_MODE (subtarget) == target_mode 4367 ? subtarget : NULL_RTX, 4368 target_mode, EXPAND_NORMAL); 4369 if (GET_MODE (op0) != target_mode) 4370 op0 = convert_to_mode (target_mode, op0, 1); 4371 4372 target = expand_unop (target_mode, bswap_optab, op0, target, 1); 4373 4374 gcc_assert (target); 4375 4376 return convert_to_mode (target_mode, target, 1); 4377 } 4378 4379 /* Expand a call to a unary builtin in EXP. 4380 Return NULL_RTX if a normal call should be emitted rather than expanding the 4381 function in-line. If convenient, the result should be placed in TARGET. 4382 SUBTARGET may be used as the target for computing one of EXP's operands. */ 4383 4384 static rtx 4385 expand_builtin_unop (machine_mode target_mode, tree exp, rtx target, 4386 rtx subtarget, optab op_optab) 4387 { 4388 rtx op0; 4389 4390 if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE)) 4391 return NULL_RTX; 4392 4393 /* Compute the argument. */ 4394 op0 = expand_expr (CALL_EXPR_ARG (exp, 0), 4395 (subtarget 4396 && (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 0))) 4397 == GET_MODE (subtarget))) ? subtarget : NULL_RTX, 4398 VOIDmode, EXPAND_NORMAL); 4399 /* Compute op, into TARGET if possible. 4400 Set TARGET to wherever the result comes back. */ 4401 target = expand_unop (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 0))), 4402 op_optab, op0, target, op_optab != clrsb_optab); 4403 gcc_assert (target); 4404 4405 return convert_to_mode (target_mode, target, 0); 4406 } 4407 4408 /* Expand a call to __builtin_expect. We just return our argument 4409 as the builtin_expect semantic should've been already executed by 4410 tree branch prediction pass. */ 4411 4412 static rtx 4413 expand_builtin_expect (tree exp, rtx target) 4414 { 4415 tree arg; 4416 4417 if (call_expr_nargs (exp) < 2) 4418 return const0_rtx; 4419 arg = CALL_EXPR_ARG (exp, 0); 4420 4421 target = expand_expr (arg, target, VOIDmode, EXPAND_NORMAL); 4422 /* When guessing was done, the hints should be already stripped away. */ 4423 gcc_assert (!flag_guess_branch_prob 4424 || optimize == 0 || seen_error ()); 4425 return target; 4426 } 4427 4428 /* Expand a call to __builtin_assume_aligned. We just return our first 4429 argument as the builtin_assume_aligned semantic should've been already 4430 executed by CCP. */ 4431 4432 static rtx 4433 expand_builtin_assume_aligned (tree exp, rtx target) 4434 { 4435 if (call_expr_nargs (exp) < 2) 4436 return const0_rtx; 4437 target = expand_expr (CALL_EXPR_ARG (exp, 0), target, VOIDmode, 4438 EXPAND_NORMAL); 4439 gcc_assert (!TREE_SIDE_EFFECTS (CALL_EXPR_ARG (exp, 1)) 4440 && (call_expr_nargs (exp) < 3 4441 || !TREE_SIDE_EFFECTS (CALL_EXPR_ARG (exp, 2)))); 4442 return target; 4443 } 4444 4445 void 4446 expand_builtin_trap (void) 4447 { 4448 if (targetm.have_trap ()) 4449 { 4450 rtx_insn *insn = emit_insn (targetm.gen_trap ()); 4451 /* For trap insns when not accumulating outgoing args force 4452 REG_ARGS_SIZE note to prevent crossjumping of calls with 4453 different args sizes. */ 4454 if (!ACCUMULATE_OUTGOING_ARGS) 4455 add_reg_note (insn, REG_ARGS_SIZE, GEN_INT (stack_pointer_delta)); 4456 } 4457 else 4458 emit_library_call (abort_libfunc, LCT_NORETURN, VOIDmode, 0); 4459 emit_barrier (); 4460 } 4461 4462 /* Expand a call to __builtin_unreachable. We do nothing except emit 4463 a barrier saying that control flow will not pass here. 4464 4465 It is the responsibility of the program being compiled to ensure 4466 that control flow does never reach __builtin_unreachable. */ 4467 static void 4468 expand_builtin_unreachable (void) 4469 { 4470 emit_barrier (); 4471 } 4472 4473 /* Expand EXP, a call to fabs, fabsf or fabsl. 4474 Return NULL_RTX if a normal call should be emitted rather than expanding 4475 the function inline. If convenient, the result should be placed 4476 in TARGET. SUBTARGET may be used as the target for computing 4477 the operand. */ 4478 4479 static rtx 4480 expand_builtin_fabs (tree exp, rtx target, rtx subtarget) 4481 { 4482 machine_mode mode; 4483 tree arg; 4484 rtx op0; 4485 4486 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE)) 4487 return NULL_RTX; 4488 4489 arg = CALL_EXPR_ARG (exp, 0); 4490 CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg); 4491 mode = TYPE_MODE (TREE_TYPE (arg)); 4492 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL); 4493 return expand_abs (mode, op0, target, 0, safe_from_p (target, arg, 1)); 4494 } 4495 4496 /* Expand EXP, a call to copysign, copysignf, or copysignl. 4497 Return NULL is a normal call should be emitted rather than expanding the 4498 function inline. If convenient, the result should be placed in TARGET. 4499 SUBTARGET may be used as the target for computing the operand. */ 4500 4501 static rtx 4502 expand_builtin_copysign (tree exp, rtx target, rtx subtarget) 4503 { 4504 rtx op0, op1; 4505 tree arg; 4506 4507 if (!validate_arglist (exp, REAL_TYPE, REAL_TYPE, VOID_TYPE)) 4508 return NULL_RTX; 4509 4510 arg = CALL_EXPR_ARG (exp, 0); 4511 op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL); 4512 4513 arg = CALL_EXPR_ARG (exp, 1); 4514 op1 = expand_normal (arg); 4515 4516 return expand_copysign (op0, op1, target); 4517 } 4518 4519 /* Expand a call to __builtin___clear_cache. */ 4520 4521 static rtx 4522 expand_builtin___clear_cache (tree exp) 4523 { 4524 if (!targetm.code_for_clear_cache) 4525 { 4526 #ifdef CLEAR_INSN_CACHE 4527 /* There is no "clear_cache" insn, and __clear_cache() in libgcc 4528 does something. Just do the default expansion to a call to 4529 __clear_cache(). */ 4530 return NULL_RTX; 4531 #else 4532 /* There is no "clear_cache" insn, and __clear_cache() in libgcc 4533 does nothing. There is no need to call it. Do nothing. */ 4534 return const0_rtx; 4535 #endif /* CLEAR_INSN_CACHE */ 4536 } 4537 4538 /* We have a "clear_cache" insn, and it will handle everything. */ 4539 tree begin, end; 4540 rtx begin_rtx, end_rtx; 4541 4542 /* We must not expand to a library call. If we did, any 4543 fallback library function in libgcc that might contain a call to 4544 __builtin___clear_cache() would recurse infinitely. */ 4545 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE)) 4546 { 4547 error ("both arguments to %<__builtin___clear_cache%> must be pointers"); 4548 return const0_rtx; 4549 } 4550 4551 if (targetm.have_clear_cache ()) 4552 { 4553 struct expand_operand ops[2]; 4554 4555 begin = CALL_EXPR_ARG (exp, 0); 4556 begin_rtx = expand_expr (begin, NULL_RTX, Pmode, EXPAND_NORMAL); 4557 4558 end = CALL_EXPR_ARG (exp, 1); 4559 end_rtx = expand_expr (end, NULL_RTX, Pmode, EXPAND_NORMAL); 4560 4561 create_address_operand (&ops[0], begin_rtx); 4562 create_address_operand (&ops[1], end_rtx); 4563 if (maybe_expand_insn (targetm.code_for_clear_cache, 2, ops)) 4564 return const0_rtx; 4565 } 4566 return const0_rtx; 4567 } 4568 4569 /* Given a trampoline address, make sure it satisfies TRAMPOLINE_ALIGNMENT. */ 4570 4571 static rtx 4572 round_trampoline_addr (rtx tramp) 4573 { 4574 rtx temp, addend, mask; 4575 4576 /* If we don't need too much alignment, we'll have been guaranteed 4577 proper alignment by get_trampoline_type. */ 4578 if (TRAMPOLINE_ALIGNMENT <= STACK_BOUNDARY) 4579 return tramp; 4580 4581 /* Round address up to desired boundary. */ 4582 temp = gen_reg_rtx (Pmode); 4583 addend = gen_int_mode (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT - 1, Pmode); 4584 mask = gen_int_mode (-TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT, Pmode); 4585 4586 temp = expand_simple_binop (Pmode, PLUS, tramp, addend, 4587 temp, 0, OPTAB_LIB_WIDEN); 4588 tramp = expand_simple_binop (Pmode, AND, temp, mask, 4589 temp, 0, OPTAB_LIB_WIDEN); 4590 4591 return tramp; 4592 } 4593 4594 static rtx 4595 expand_builtin_init_trampoline (tree exp, bool onstack) 4596 { 4597 tree t_tramp, t_func, t_chain; 4598 rtx m_tramp, r_tramp, r_chain, tmp; 4599 4600 if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, 4601 POINTER_TYPE, VOID_TYPE)) 4602 return NULL_RTX; 4603 4604 t_tramp = CALL_EXPR_ARG (exp, 0); 4605 t_func = CALL_EXPR_ARG (exp, 1); 4606 t_chain = CALL_EXPR_ARG (exp, 2); 4607 4608 r_tramp = expand_normal (t_tramp); 4609 m_tramp = gen_rtx_MEM (BLKmode, r_tramp); 4610 MEM_NOTRAP_P (m_tramp) = 1; 4611 4612 /* If ONSTACK, the TRAMP argument should be the address of a field 4613 within the local function's FRAME decl. Either way, let's see if 4614 we can fill in the MEM_ATTRs for this memory. */ 4615 if (TREE_CODE (t_tramp) == ADDR_EXPR) 4616 set_mem_attributes (m_tramp, TREE_OPERAND (t_tramp, 0), true); 4617 4618 /* Creator of a heap trampoline is responsible for making sure the 4619 address is aligned to at least STACK_BOUNDARY. Normally malloc 4620 will ensure this anyhow. */ 4621 tmp = round_trampoline_addr (r_tramp); 4622 if (tmp != r_tramp) 4623 { 4624 m_tramp = change_address (m_tramp, BLKmode, tmp); 4625 set_mem_align (m_tramp, TRAMPOLINE_ALIGNMENT); 4626 set_mem_size (m_tramp, TRAMPOLINE_SIZE); 4627 } 4628 4629 /* The FUNC argument should be the address of the nested function. 4630 Extract the actual function decl to pass to the hook. */ 4631 gcc_assert (TREE_CODE (t_func) == ADDR_EXPR); 4632 t_func = TREE_OPERAND (t_func, 0); 4633 gcc_assert (TREE_CODE (t_func) == FUNCTION_DECL); 4634 4635 r_chain = expand_normal (t_chain); 4636 4637 /* Generate insns to initialize the trampoline. */ 4638 targetm.calls.trampoline_init (m_tramp, t_func, r_chain); 4639 4640 if (onstack) 4641 { 4642 trampolines_created = 1; 4643 4644 warning_at (DECL_SOURCE_LOCATION (t_func), OPT_Wtrampolines, 4645 "trampoline generated for nested function %qD", t_func); 4646 } 4647 4648 return const0_rtx; 4649 } 4650 4651 static rtx 4652 expand_builtin_adjust_trampoline (tree exp) 4653 { 4654 rtx tramp; 4655 4656 if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE)) 4657 return NULL_RTX; 4658 4659 tramp = expand_normal (CALL_EXPR_ARG (exp, 0)); 4660 tramp = round_trampoline_addr (tramp); 4661 if (targetm.calls.trampoline_adjust_address) 4662 tramp = targetm.calls.trampoline_adjust_address (tramp); 4663 4664 return tramp; 4665 } 4666 4667 /* Expand the call EXP to the built-in signbit, signbitf or signbitl 4668 function. The function first checks whether the back end provides 4669 an insn to implement signbit for the respective mode. If not, it 4670 checks whether the floating point format of the value is such that 4671 the sign bit can be extracted. If that is not the case, error out. 4672 EXP is the expression that is a call to the builtin function; if 4673 convenient, the result should be placed in TARGET. */ 4674 static rtx 4675 expand_builtin_signbit (tree exp, rtx target) 4676 { 4677 const struct real_format *fmt; 4678 machine_mode fmode, imode, rmode; 4679 tree arg; 4680 int word, bitpos; 4681 enum insn_code icode; 4682 rtx temp; 4683 location_t loc = EXPR_LOCATION (exp); 4684 4685 if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE)) 4686 return NULL_RTX; 4687 4688 arg = CALL_EXPR_ARG (exp, 0); 4689 fmode = TYPE_MODE (TREE_TYPE (arg)); 4690 rmode = TYPE_MODE (TREE_TYPE (exp)); 4691 fmt = REAL_MODE_FORMAT (fmode); 4692 4693 arg = builtin_save_expr (arg); 4694 4695 /* Expand the argument yielding a RTX expression. */ 4696 temp = expand_normal (arg); 4697 4698 /* Check if the back end provides an insn that handles signbit for the 4699 argument's mode. */ 4700 icode = optab_handler (signbit_optab, fmode); 4701 if (icode != CODE_FOR_nothing) 4702 { 4703 rtx_insn *last = get_last_insn (); 4704 target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp))); 4705 if (maybe_emit_unop_insn (icode, target, temp, UNKNOWN)) 4706 return target; 4707 delete_insns_since (last); 4708 } 4709 4710 /* For floating point formats without a sign bit, implement signbit 4711 as "ARG < 0.0". */ 4712 bitpos = fmt->signbit_ro; 4713 if (bitpos < 0) 4714 { 4715 /* But we can't do this if the format supports signed zero. */ 4716 gcc_assert (!fmt->has_signed_zero || !HONOR_SIGNED_ZEROS (fmode)); 4717 4718 arg = fold_build2_loc (loc, LT_EXPR, TREE_TYPE (exp), arg, 4719 build_real (TREE_TYPE (arg), dconst0)); 4720 return expand_expr (arg, target, VOIDmode, EXPAND_NORMAL); 4721 } 4722 4723 if (GET_MODE_SIZE (fmode) <= UNITS_PER_WORD) 4724 { 4725 imode = int_mode_for_mode (fmode); 4726 gcc_assert (imode != BLKmode); 4727 temp = gen_lowpart (imode, temp); 4728 } 4729 else 4730 { 4731 imode = word_mode; 4732 /* Handle targets with different FP word orders. */ 4733 if (FLOAT_WORDS_BIG_ENDIAN) 4734 word = (GET_MODE_BITSIZE (fmode) - bitpos) / BITS_PER_WORD; 4735 else 4736 word = bitpos / BITS_PER_WORD; 4737 temp = operand_subword_force (temp, word, fmode); 4738 bitpos = bitpos % BITS_PER_WORD; 4739 } 4740 4741 /* Force the intermediate word_mode (or narrower) result into a 4742 register. This avoids attempting to create paradoxical SUBREGs 4743 of floating point modes below. */ 4744 temp = force_reg (imode, temp); 4745 4746 /* If the bitpos is within the "result mode" lowpart, the operation 4747 can be implement with a single bitwise AND. Otherwise, we need 4748 a right shift and an AND. */ 4749 4750 if (bitpos < GET_MODE_BITSIZE (rmode)) 4751 { 4752 wide_int mask = wi::set_bit_in_zero (bitpos, GET_MODE_PRECISION (rmode)); 4753 4754 if (GET_MODE_SIZE (imode) > GET_MODE_SIZE (rmode)) 4755 temp = gen_lowpart (rmode, temp); 4756 temp = expand_binop (rmode, and_optab, temp, 4757 immed_wide_int_const (mask, rmode), 4758 NULL_RTX, 1, OPTAB_LIB_WIDEN); 4759 } 4760 else 4761 { 4762 /* Perform a logical right shift to place the signbit in the least 4763 significant bit, then truncate the result to the desired mode 4764 and mask just this bit. */ 4765 temp = expand_shift (RSHIFT_EXPR, imode, temp, bitpos, NULL_RTX, 1); 4766 temp = gen_lowpart (rmode, temp); 4767 temp = expand_binop (rmode, and_optab, temp, const1_rtx, 4768 NULL_RTX, 1, OPTAB_LIB_WIDEN); 4769 } 4770 4771 return temp; 4772 } 4773 4774 /* Expand fork or exec calls. TARGET is the desired target of the 4775 call. EXP is the call. FN is the 4776 identificator of the actual function. IGNORE is nonzero if the 4777 value is to be ignored. */ 4778 4779 static rtx 4780 expand_builtin_fork_or_exec (tree fn, tree exp, rtx target, int ignore) 4781 { 4782 tree id, decl; 4783 tree call; 4784 4785 /* If we are not profiling, just call the function. */ 4786 if (!profile_arc_flag) 4787 return NULL_RTX; 4788 4789 /* Otherwise call the wrapper. This should be equivalent for the rest of 4790 compiler, so the code does not diverge, and the wrapper may run the 4791 code necessary for keeping the profiling sane. */ 4792 4793 switch (DECL_FUNCTION_CODE (fn)) 4794 { 4795 case BUILT_IN_FORK: 4796 id = get_identifier ("__gcov_fork"); 4797 break; 4798 4799 case BUILT_IN_EXECL: 4800 id = get_identifier ("__gcov_execl"); 4801 break; 4802 4803 case BUILT_IN_EXECV: 4804 id = get_identifier ("__gcov_execv"); 4805 break; 4806 4807 case BUILT_IN_EXECLP: 4808 id = get_identifier ("__gcov_execlp"); 4809 break; 4810 4811 case BUILT_IN_EXECLE: 4812 id = get_identifier ("__gcov_execle"); 4813 break; 4814 4815 case BUILT_IN_EXECVP: 4816 id = get_identifier ("__gcov_execvp"); 4817 break; 4818 4819 case BUILT_IN_EXECVE: 4820 id = get_identifier ("__gcov_execve"); 4821 break; 4822 4823 default: 4824 gcc_unreachable (); 4825 } 4826 4827 decl = build_decl (DECL_SOURCE_LOCATION (fn), 4828 FUNCTION_DECL, id, TREE_TYPE (fn)); 4829 DECL_EXTERNAL (decl) = 1; 4830 TREE_PUBLIC (decl) = 1; 4831 DECL_ARTIFICIAL (decl) = 1; 4832 TREE_NOTHROW (decl) = 1; 4833 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT; 4834 DECL_VISIBILITY_SPECIFIED (decl) = 1; 4835 call = rewrite_call_expr (EXPR_LOCATION (exp), exp, 0, decl, 0); 4836 return expand_call (call, target, ignore); 4837 } 4838 4839 4840 4841 /* Reconstitute a mode for a __sync intrinsic operation. Since the type of 4842 the pointer in these functions is void*, the tree optimizers may remove 4843 casts. The mode computed in expand_builtin isn't reliable either, due 4844 to __sync_bool_compare_and_swap. 4845 4846 FCODE_DIFF should be fcode - base, where base is the FOO_1 code for the 4847 group of builtins. This gives us log2 of the mode size. */ 4848 4849 static inline machine_mode 4850 get_builtin_sync_mode (int fcode_diff) 4851 { 4852 /* The size is not negotiable, so ask not to get BLKmode in return 4853 if the target indicates that a smaller size would be better. */ 4854 return mode_for_size (BITS_PER_UNIT << fcode_diff, MODE_INT, 0); 4855 } 4856 4857 /* Expand the memory expression LOC and return the appropriate memory operand 4858 for the builtin_sync operations. */ 4859 4860 static rtx 4861 get_builtin_sync_mem (tree loc, machine_mode mode) 4862 { 4863 rtx addr, mem; 4864 4865 addr = expand_expr (loc, NULL_RTX, ptr_mode, EXPAND_SUM); 4866 addr = convert_memory_address (Pmode, addr); 4867 4868 /* Note that we explicitly do not want any alias information for this 4869 memory, so that we kill all other live memories. Otherwise we don't 4870 satisfy the full barrier semantics of the intrinsic. */ 4871 mem = validize_mem (gen_rtx_MEM (mode, addr)); 4872 4873 /* The alignment needs to be at least according to that of the mode. */ 4874 set_mem_align (mem, MAX (GET_MODE_ALIGNMENT (mode), 4875 get_pointer_alignment (loc))); 4876 set_mem_alias_set (mem, ALIAS_SET_MEMORY_BARRIER); 4877 MEM_VOLATILE_P (mem) = 1; 4878 4879 return mem; 4880 } 4881 4882 /* Make sure an argument is in the right mode. 4883 EXP is the tree argument. 4884 MODE is the mode it should be in. */ 4885 4886 static rtx 4887 expand_expr_force_mode (tree exp, machine_mode mode) 4888 { 4889 rtx val; 4890 machine_mode old_mode; 4891 4892 val = expand_expr (exp, NULL_RTX, mode, EXPAND_NORMAL); 4893 /* If VAL is promoted to a wider mode, convert it back to MODE. Take care 4894 of CONST_INTs, where we know the old_mode only from the call argument. */ 4895 4896 old_mode = GET_MODE (val); 4897 if (old_mode == VOIDmode) 4898 old_mode = TYPE_MODE (TREE_TYPE (exp)); 4899 val = convert_modes (mode, old_mode, val, 1); 4900 return val; 4901 } 4902 4903 4904 /* Expand the __sync_xxx_and_fetch and __sync_fetch_and_xxx intrinsics. 4905 EXP is the CALL_EXPR. CODE is the rtx code 4906 that corresponds to the arithmetic or logical operation from the name; 4907 an exception here is that NOT actually means NAND. TARGET is an optional 4908 place for us to store the results; AFTER is true if this is the 4909 fetch_and_xxx form. */ 4910 4911 static rtx 4912 expand_builtin_sync_operation (machine_mode mode, tree exp, 4913 enum rtx_code code, bool after, 4914 rtx target) 4915 { 4916 rtx val, mem; 4917 location_t loc = EXPR_LOCATION (exp); 4918 4919 if (code == NOT && warn_sync_nand) 4920 { 4921 tree fndecl = get_callee_fndecl (exp); 4922 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl); 4923 4924 static bool warned_f_a_n, warned_n_a_f; 4925 4926 switch (fcode) 4927 { 4928 case BUILT_IN_SYNC_FETCH_AND_NAND_1: 4929 case BUILT_IN_SYNC_FETCH_AND_NAND_2: 4930 case BUILT_IN_SYNC_FETCH_AND_NAND_4: 4931 case BUILT_IN_SYNC_FETCH_AND_NAND_8: 4932 case BUILT_IN_SYNC_FETCH_AND_NAND_16: 4933 if (warned_f_a_n) 4934 break; 4935 4936 fndecl = builtin_decl_implicit (BUILT_IN_SYNC_FETCH_AND_NAND_N); 4937 inform (loc, "%qD changed semantics in GCC 4.4", fndecl); 4938 warned_f_a_n = true; 4939 break; 4940 4941 case BUILT_IN_SYNC_NAND_AND_FETCH_1: 4942 case BUILT_IN_SYNC_NAND_AND_FETCH_2: 4943 case BUILT_IN_SYNC_NAND_AND_FETCH_4: 4944 case BUILT_IN_SYNC_NAND_AND_FETCH_8: 4945 case BUILT_IN_SYNC_NAND_AND_FETCH_16: 4946 if (warned_n_a_f) 4947 break; 4948 4949 fndecl = builtin_decl_implicit (BUILT_IN_SYNC_NAND_AND_FETCH_N); 4950 inform (loc, "%qD changed semantics in GCC 4.4", fndecl); 4951 warned_n_a_f = true; 4952 break; 4953 4954 default: 4955 gcc_unreachable (); 4956 } 4957 } 4958 4959 /* Expand the operands. */ 4960 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode); 4961 val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode); 4962 4963 return expand_atomic_fetch_op (target, mem, val, code, MEMMODEL_SYNC_SEQ_CST, 4964 after); 4965 } 4966 4967 /* Expand the __sync_val_compare_and_swap and __sync_bool_compare_and_swap 4968 intrinsics. EXP is the CALL_EXPR. IS_BOOL is 4969 true if this is the boolean form. TARGET is a place for us to store the 4970 results; this is NOT optional if IS_BOOL is true. */ 4971 4972 static rtx 4973 expand_builtin_compare_and_swap (machine_mode mode, tree exp, 4974 bool is_bool, rtx target) 4975 { 4976 rtx old_val, new_val, mem; 4977 rtx *pbool, *poval; 4978 4979 /* Expand the operands. */ 4980 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode); 4981 old_val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode); 4982 new_val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 2), mode); 4983 4984 pbool = poval = NULL; 4985 if (target != const0_rtx) 4986 { 4987 if (is_bool) 4988 pbool = ⌖ 4989 else 4990 poval = ⌖ 4991 } 4992 if (!expand_atomic_compare_and_swap (pbool, poval, mem, old_val, new_val, 4993 false, MEMMODEL_SYNC_SEQ_CST, 4994 MEMMODEL_SYNC_SEQ_CST)) 4995 return NULL_RTX; 4996 4997 return target; 4998 } 4999 5000 /* Expand the __sync_lock_test_and_set intrinsic. Note that the most 5001 general form is actually an atomic exchange, and some targets only 5002 support a reduced form with the second argument being a constant 1. 5003 EXP is the CALL_EXPR; TARGET is an optional place for us to store 5004 the results. */ 5005 5006 static rtx 5007 expand_builtin_sync_lock_test_and_set (machine_mode mode, tree exp, 5008 rtx target) 5009 { 5010 rtx val, mem; 5011 5012 /* Expand the operands. */ 5013 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode); 5014 val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode); 5015 5016 return expand_sync_lock_test_and_set (target, mem, val); 5017 } 5018 5019 /* Expand the __sync_lock_release intrinsic. EXP is the CALL_EXPR. */ 5020 5021 static void 5022 expand_builtin_sync_lock_release (machine_mode mode, tree exp) 5023 { 5024 rtx mem; 5025 5026 /* Expand the operands. */ 5027 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode); 5028 5029 expand_atomic_store (mem, const0_rtx, MEMMODEL_SYNC_RELEASE, true); 5030 } 5031 5032 /* Given an integer representing an ``enum memmodel'', verify its 5033 correctness and return the memory model enum. */ 5034 5035 static enum memmodel 5036 get_memmodel (tree exp) 5037 { 5038 rtx op; 5039 unsigned HOST_WIDE_INT val; 5040 source_location loc 5041 = expansion_point_location_if_in_system_header (input_location); 5042 5043 /* If the parameter is not a constant, it's a run time value so we'll just 5044 convert it to MEMMODEL_SEQ_CST to avoid annoying runtime checking. */ 5045 if (TREE_CODE (exp) != INTEGER_CST) 5046 return MEMMODEL_SEQ_CST; 5047 5048 op = expand_normal (exp); 5049 5050 val = INTVAL (op); 5051 if (targetm.memmodel_check) 5052 val = targetm.memmodel_check (val); 5053 else if (val & ~MEMMODEL_MASK) 5054 { 5055 warning_at (loc, OPT_Winvalid_memory_model, 5056 "unknown architecture specifier in memory model to builtin"); 5057 return MEMMODEL_SEQ_CST; 5058 } 5059 5060 /* Should never see a user explicit SYNC memodel model, so >= LAST works. */ 5061 if (memmodel_base (val) >= MEMMODEL_LAST) 5062 { 5063 warning_at (loc, OPT_Winvalid_memory_model, 5064 "invalid memory model argument to builtin"); 5065 return MEMMODEL_SEQ_CST; 5066 } 5067 5068 /* Workaround for Bugzilla 59448. GCC doesn't track consume properly, so 5069 be conservative and promote consume to acquire. */ 5070 if (val == MEMMODEL_CONSUME) 5071 val = MEMMODEL_ACQUIRE; 5072 5073 return (enum memmodel) val; 5074 } 5075 5076 /* Expand the __atomic_exchange intrinsic: 5077 TYPE __atomic_exchange (TYPE *object, TYPE desired, enum memmodel) 5078 EXP is the CALL_EXPR. 5079 TARGET is an optional place for us to store the results. */ 5080 5081 static rtx 5082 expand_builtin_atomic_exchange (machine_mode mode, tree exp, rtx target) 5083 { 5084 rtx val, mem; 5085 enum memmodel model; 5086 5087 model = get_memmodel (CALL_EXPR_ARG (exp, 2)); 5088 5089 if (!flag_inline_atomics) 5090 return NULL_RTX; 5091 5092 /* Expand the operands. */ 5093 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode); 5094 val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode); 5095 5096 return expand_atomic_exchange (target, mem, val, model); 5097 } 5098 5099 /* Expand the __atomic_compare_exchange intrinsic: 5100 bool __atomic_compare_exchange (TYPE *object, TYPE *expect, 5101 TYPE desired, BOOL weak, 5102 enum memmodel success, 5103 enum memmodel failure) 5104 EXP is the CALL_EXPR. 5105 TARGET is an optional place for us to store the results. */ 5106 5107 static rtx 5108 expand_builtin_atomic_compare_exchange (machine_mode mode, tree exp, 5109 rtx target) 5110 { 5111 rtx expect, desired, mem, oldval; 5112 rtx_code_label *label; 5113 enum memmodel success, failure; 5114 tree weak; 5115 bool is_weak; 5116 source_location loc 5117 = expansion_point_location_if_in_system_header (input_location); 5118 5119 success = get_memmodel (CALL_EXPR_ARG (exp, 4)); 5120 failure = get_memmodel (CALL_EXPR_ARG (exp, 5)); 5121 5122 if (failure > success) 5123 { 5124 warning_at (loc, OPT_Winvalid_memory_model, 5125 "failure memory model cannot be stronger than success " 5126 "memory model for %<__atomic_compare_exchange%>"); 5127 success = MEMMODEL_SEQ_CST; 5128 } 5129 5130 if (is_mm_release (failure) || is_mm_acq_rel (failure)) 5131 { 5132 warning_at (loc, OPT_Winvalid_memory_model, 5133 "invalid failure memory model for " 5134 "%<__atomic_compare_exchange%>"); 5135 failure = MEMMODEL_SEQ_CST; 5136 success = MEMMODEL_SEQ_CST; 5137 } 5138 5139 5140 if (!flag_inline_atomics) 5141 return NULL_RTX; 5142 5143 /* Expand the operands. */ 5144 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode); 5145 5146 expect = expand_normal (CALL_EXPR_ARG (exp, 1)); 5147 expect = convert_memory_address (Pmode, expect); 5148 expect = gen_rtx_MEM (mode, expect); 5149 desired = expand_expr_force_mode (CALL_EXPR_ARG (exp, 2), mode); 5150 5151 weak = CALL_EXPR_ARG (exp, 3); 5152 is_weak = false; 5153 if (tree_fits_shwi_p (weak) && tree_to_shwi (weak) != 0) 5154 is_weak = true; 5155 5156 if (target == const0_rtx) 5157 target = NULL; 5158 5159 /* Lest the rtl backend create a race condition with an imporoper store 5160 to memory, always create a new pseudo for OLDVAL. */ 5161 oldval = NULL; 5162 5163 if (!expand_atomic_compare_and_swap (&target, &oldval, mem, expect, desired, 5164 is_weak, success, failure)) 5165 return NULL_RTX; 5166 5167 /* Conditionally store back to EXPECT, lest we create a race condition 5168 with an improper store to memory. */ 5169 /* ??? With a rearrangement of atomics at the gimple level, we can handle 5170 the normal case where EXPECT is totally private, i.e. a register. At 5171 which point the store can be unconditional. */ 5172 label = gen_label_rtx (); 5173 emit_cmp_and_jump_insns (target, const0_rtx, NE, NULL, 5174 GET_MODE (target), 1, label); 5175 emit_move_insn (expect, oldval); 5176 emit_label (label); 5177 5178 return target; 5179 } 5180 5181 /* Expand the __atomic_load intrinsic: 5182 TYPE __atomic_load (TYPE *object, enum memmodel) 5183 EXP is the CALL_EXPR. 5184 TARGET is an optional place for us to store the results. */ 5185 5186 static rtx 5187 expand_builtin_atomic_load (machine_mode mode, tree exp, rtx target) 5188 { 5189 rtx mem; 5190 enum memmodel model; 5191 5192 model = get_memmodel (CALL_EXPR_ARG (exp, 1)); 5193 if (is_mm_release (model) || is_mm_acq_rel (model)) 5194 { 5195 source_location loc 5196 = expansion_point_location_if_in_system_header (input_location); 5197 warning_at (loc, OPT_Winvalid_memory_model, 5198 "invalid memory model for %<__atomic_load%>"); 5199 model = MEMMODEL_SEQ_CST; 5200 } 5201 5202 if (!flag_inline_atomics) 5203 return NULL_RTX; 5204 5205 /* Expand the operand. */ 5206 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode); 5207 5208 return expand_atomic_load (target, mem, model); 5209 } 5210 5211 5212 /* Expand the __atomic_store intrinsic: 5213 void __atomic_store (TYPE *object, TYPE desired, enum memmodel) 5214 EXP is the CALL_EXPR. 5215 TARGET is an optional place for us to store the results. */ 5216 5217 static rtx 5218 expand_builtin_atomic_store (machine_mode mode, tree exp) 5219 { 5220 rtx mem, val; 5221 enum memmodel model; 5222 5223 model = get_memmodel (CALL_EXPR_ARG (exp, 2)); 5224 if (!(is_mm_relaxed (model) || is_mm_seq_cst (model) 5225 || is_mm_release (model))) 5226 { 5227 source_location loc 5228 = expansion_point_location_if_in_system_header (input_location); 5229 warning_at (loc, OPT_Winvalid_memory_model, 5230 "invalid memory model for %<__atomic_store%>"); 5231 model = MEMMODEL_SEQ_CST; 5232 } 5233 5234 if (!flag_inline_atomics) 5235 return NULL_RTX; 5236 5237 /* Expand the operands. */ 5238 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode); 5239 val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode); 5240 5241 return expand_atomic_store (mem, val, model, false); 5242 } 5243 5244 /* Expand the __atomic_fetch_XXX intrinsic: 5245 TYPE __atomic_fetch_XXX (TYPE *object, TYPE val, enum memmodel) 5246 EXP is the CALL_EXPR. 5247 TARGET is an optional place for us to store the results. 5248 CODE is the operation, PLUS, MINUS, ADD, XOR, or IOR. 5249 FETCH_AFTER is true if returning the result of the operation. 5250 FETCH_AFTER is false if returning the value before the operation. 5251 IGNORE is true if the result is not used. 5252 EXT_CALL is the correct builtin for an external call if this cannot be 5253 resolved to an instruction sequence. */ 5254 5255 static rtx 5256 expand_builtin_atomic_fetch_op (machine_mode mode, tree exp, rtx target, 5257 enum rtx_code code, bool fetch_after, 5258 bool ignore, enum built_in_function ext_call) 5259 { 5260 rtx val, mem, ret; 5261 enum memmodel model; 5262 tree fndecl; 5263 tree addr; 5264 5265 model = get_memmodel (CALL_EXPR_ARG (exp, 2)); 5266 5267 /* Expand the operands. */ 5268 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode); 5269 val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode); 5270 5271 /* Only try generating instructions if inlining is turned on. */ 5272 if (flag_inline_atomics) 5273 { 5274 ret = expand_atomic_fetch_op (target, mem, val, code, model, fetch_after); 5275 if (ret) 5276 return ret; 5277 } 5278 5279 /* Return if a different routine isn't needed for the library call. */ 5280 if (ext_call == BUILT_IN_NONE) 5281 return NULL_RTX; 5282 5283 /* Change the call to the specified function. */ 5284 fndecl = get_callee_fndecl (exp); 5285 addr = CALL_EXPR_FN (exp); 5286 STRIP_NOPS (addr); 5287 5288 gcc_assert (TREE_OPERAND (addr, 0) == fndecl); 5289 TREE_OPERAND (addr, 0) = builtin_decl_explicit (ext_call); 5290 5291 /* If we will emit code after the call, the call can not be a tail call. 5292 If it is emitted as a tail call, a barrier is emitted after it, and 5293 then all trailing code is removed. */ 5294 if (!ignore) 5295 CALL_EXPR_TAILCALL (exp) = 0; 5296 5297 /* Expand the call here so we can emit trailing code. */ 5298 ret = expand_call (exp, target, ignore); 5299 5300 /* Replace the original function just in case it matters. */ 5301 TREE_OPERAND (addr, 0) = fndecl; 5302 5303 /* Then issue the arithmetic correction to return the right result. */ 5304 if (!ignore) 5305 { 5306 if (code == NOT) 5307 { 5308 ret = expand_simple_binop (mode, AND, ret, val, NULL_RTX, true, 5309 OPTAB_LIB_WIDEN); 5310 ret = expand_simple_unop (mode, NOT, ret, target, true); 5311 } 5312 else 5313 ret = expand_simple_binop (mode, code, ret, val, target, true, 5314 OPTAB_LIB_WIDEN); 5315 } 5316 return ret; 5317 } 5318 5319 /* Expand an atomic clear operation. 5320 void _atomic_clear (BOOL *obj, enum memmodel) 5321 EXP is the call expression. */ 5322 5323 static rtx 5324 expand_builtin_atomic_clear (tree exp) 5325 { 5326 machine_mode mode; 5327 rtx mem, ret; 5328 enum memmodel model; 5329 5330 mode = mode_for_size (BOOL_TYPE_SIZE, MODE_INT, 0); 5331 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode); 5332 model = get_memmodel (CALL_EXPR_ARG (exp, 1)); 5333 5334 if (is_mm_consume (model) || is_mm_acquire (model) || is_mm_acq_rel (model)) 5335 { 5336 source_location loc 5337 = expansion_point_location_if_in_system_header (input_location); 5338 warning_at (loc, OPT_Winvalid_memory_model, 5339 "invalid memory model for %<__atomic_store%>"); 5340 model = MEMMODEL_SEQ_CST; 5341 } 5342 5343 /* Try issuing an __atomic_store, and allow fallback to __sync_lock_release. 5344 Failing that, a store is issued by __atomic_store. The only way this can 5345 fail is if the bool type is larger than a word size. Unlikely, but 5346 handle it anyway for completeness. Assume a single threaded model since 5347 there is no atomic support in this case, and no barriers are required. */ 5348 ret = expand_atomic_store (mem, const0_rtx, model, true); 5349 if (!ret) 5350 emit_move_insn (mem, const0_rtx); 5351 return const0_rtx; 5352 } 5353 5354 /* Expand an atomic test_and_set operation. 5355 bool _atomic_test_and_set (BOOL *obj, enum memmodel) 5356 EXP is the call expression. */ 5357 5358 static rtx 5359 expand_builtin_atomic_test_and_set (tree exp, rtx target) 5360 { 5361 rtx mem; 5362 enum memmodel model; 5363 machine_mode mode; 5364 5365 mode = mode_for_size (BOOL_TYPE_SIZE, MODE_INT, 0); 5366 mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode); 5367 model = get_memmodel (CALL_EXPR_ARG (exp, 1)); 5368 5369 return expand_atomic_test_and_set (target, mem, model); 5370 } 5371 5372 5373 /* Return true if (optional) argument ARG1 of size ARG0 is always lock free on 5374 this architecture. If ARG1 is NULL, use typical alignment for size ARG0. */ 5375 5376 static tree 5377 fold_builtin_atomic_always_lock_free (tree arg0, tree arg1) 5378 { 5379 int size; 5380 machine_mode mode; 5381 unsigned int mode_align, type_align; 5382 5383 if (TREE_CODE (arg0) != INTEGER_CST) 5384 return NULL_TREE; 5385 5386 size = INTVAL (expand_normal (arg0)) * BITS_PER_UNIT; 5387 mode = mode_for_size (size, MODE_INT, 0); 5388 mode_align = GET_MODE_ALIGNMENT (mode); 5389 5390 if (TREE_CODE (arg1) == INTEGER_CST) 5391 { 5392 unsigned HOST_WIDE_INT val = UINTVAL (expand_normal (arg1)); 5393 5394 /* Either this argument is null, or it's a fake pointer encoding 5395 the alignment of the object. */ 5396 val = val & -val; 5397 val *= BITS_PER_UNIT; 5398 5399 if (val == 0 || mode_align < val) 5400 type_align = mode_align; 5401 else 5402 type_align = val; 5403 } 5404 else 5405 { 5406 tree ttype = TREE_TYPE (arg1); 5407 5408 /* This function is usually invoked and folded immediately by the front 5409 end before anything else has a chance to look at it. The pointer 5410 parameter at this point is usually cast to a void *, so check for that 5411 and look past the cast. */ 5412 if (CONVERT_EXPR_P (arg1) 5413 && POINTER_TYPE_P (ttype) 5414 && VOID_TYPE_P (TREE_TYPE (ttype)) 5415 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (arg1, 0)))) 5416 arg1 = TREE_OPERAND (arg1, 0); 5417 5418 ttype = TREE_TYPE (arg1); 5419 gcc_assert (POINTER_TYPE_P (ttype)); 5420 5421 /* Get the underlying type of the object. */ 5422 ttype = TREE_TYPE (ttype); 5423 type_align = TYPE_ALIGN (ttype); 5424 } 5425 5426 /* If the object has smaller alignment, the lock free routines cannot 5427 be used. */ 5428 if (type_align < mode_align) 5429 return boolean_false_node; 5430 5431 /* Check if a compare_and_swap pattern exists for the mode which represents 5432 the required size. The pattern is not allowed to fail, so the existence 5433 of the pattern indicates support is present. */ 5434 if (can_compare_and_swap_p (mode, true)) 5435 return boolean_true_node; 5436 else 5437 return boolean_false_node; 5438 } 5439 5440 /* Return true if the parameters to call EXP represent an object which will 5441 always generate lock free instructions. The first argument represents the 5442 size of the object, and the second parameter is a pointer to the object 5443 itself. If NULL is passed for the object, then the result is based on 5444 typical alignment for an object of the specified size. Otherwise return 5445 false. */ 5446 5447 static rtx 5448 expand_builtin_atomic_always_lock_free (tree exp) 5449 { 5450 tree size; 5451 tree arg0 = CALL_EXPR_ARG (exp, 0); 5452 tree arg1 = CALL_EXPR_ARG (exp, 1); 5453 5454 if (TREE_CODE (arg0) != INTEGER_CST) 5455 { 5456 error ("non-constant argument 1 to __atomic_always_lock_free"); 5457 return const0_rtx; 5458 } 5459 5460 size = fold_builtin_atomic_always_lock_free (arg0, arg1); 5461 if (size == boolean_true_node) 5462 return const1_rtx; 5463 return const0_rtx; 5464 } 5465 5466 /* Return a one or zero if it can be determined that object ARG1 of size ARG 5467 is lock free on this architecture. */ 5468 5469 static tree 5470 fold_builtin_atomic_is_lock_free (tree arg0, tree arg1) 5471 { 5472 if (!flag_inline_atomics) 5473 return NULL_TREE; 5474 5475 /* If it isn't always lock free, don't generate a result. */ 5476 if (fold_builtin_atomic_always_lock_free (arg0, arg1) == boolean_true_node) 5477 return boolean_true_node; 5478 5479 return NULL_TREE; 5480 } 5481 5482 /* Return true if the parameters to call EXP represent an object which will 5483 always generate lock free instructions. The first argument represents the 5484 size of the object, and the second parameter is a pointer to the object 5485 itself. If NULL is passed for the object, then the result is based on 5486 typical alignment for an object of the specified size. Otherwise return 5487 NULL*/ 5488 5489 static rtx 5490 expand_builtin_atomic_is_lock_free (tree exp) 5491 { 5492 tree size; 5493 tree arg0 = CALL_EXPR_ARG (exp, 0); 5494 tree arg1 = CALL_EXPR_ARG (exp, 1); 5495 5496 if (!INTEGRAL_TYPE_P (TREE_TYPE (arg0))) 5497 { 5498 error ("non-integer argument 1 to __atomic_is_lock_free"); 5499 return NULL_RTX; 5500 } 5501 5502 if (!flag_inline_atomics) 5503 return NULL_RTX; 5504 5505 /* If the value is known at compile time, return the RTX for it. */ 5506 size = fold_builtin_atomic_is_lock_free (arg0, arg1); 5507 if (size == boolean_true_node) 5508 return const1_rtx; 5509 5510 return NULL_RTX; 5511 } 5512 5513 /* Expand the __atomic_thread_fence intrinsic: 5514 void __atomic_thread_fence (enum memmodel) 5515 EXP is the CALL_EXPR. */ 5516 5517 static void 5518 expand_builtin_atomic_thread_fence (tree exp) 5519 { 5520 enum memmodel model = get_memmodel (CALL_EXPR_ARG (exp, 0)); 5521 expand_mem_thread_fence (model); 5522 } 5523 5524 /* Expand the __atomic_signal_fence intrinsic: 5525 void __atomic_signal_fence (enum memmodel) 5526 EXP is the CALL_EXPR. */ 5527 5528 static void 5529 expand_builtin_atomic_signal_fence (tree exp) 5530 { 5531 enum memmodel model = get_memmodel (CALL_EXPR_ARG (exp, 0)); 5532 expand_mem_signal_fence (model); 5533 } 5534 5535 /* Expand the __sync_synchronize intrinsic. */ 5536 5537 static void 5538 expand_builtin_sync_synchronize (void) 5539 { 5540 expand_mem_thread_fence (MEMMODEL_SYNC_SEQ_CST); 5541 } 5542 5543 static rtx 5544 expand_builtin_thread_pointer (tree exp, rtx target) 5545 { 5546 enum insn_code icode; 5547 if (!validate_arglist (exp, VOID_TYPE)) 5548 return const0_rtx; 5549 icode = direct_optab_handler (get_thread_pointer_optab, Pmode); 5550 if (icode != CODE_FOR_nothing) 5551 { 5552 struct expand_operand op; 5553 /* If the target is not sutitable then create a new target. */ 5554 if (target == NULL_RTX 5555 || !REG_P (target) 5556 || GET_MODE (target) != Pmode) 5557 target = gen_reg_rtx (Pmode); 5558 create_output_operand (&op, target, Pmode); 5559 expand_insn (icode, 1, &op); 5560 return target; 5561 } 5562 error ("__builtin_thread_pointer is not supported on this target"); 5563 return const0_rtx; 5564 } 5565 5566 static void 5567 expand_builtin_set_thread_pointer (tree exp) 5568 { 5569 enum insn_code icode; 5570 if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE)) 5571 return; 5572 icode = direct_optab_handler (set_thread_pointer_optab, Pmode); 5573 if (icode != CODE_FOR_nothing) 5574 { 5575 struct expand_operand op; 5576 rtx val = expand_expr (CALL_EXPR_ARG (exp, 0), NULL_RTX, 5577 Pmode, EXPAND_NORMAL); 5578 create_input_operand (&op, val, Pmode); 5579 expand_insn (icode, 1, &op); 5580 return; 5581 } 5582 error ("__builtin_set_thread_pointer is not supported on this target"); 5583 } 5584 5585 5586 /* Emit code to restore the current value of stack. */ 5587 5588 static void 5589 expand_stack_restore (tree var) 5590 { 5591 rtx_insn *prev; 5592 rtx sa = expand_normal (var); 5593 5594 sa = convert_memory_address (Pmode, sa); 5595 5596 prev = get_last_insn (); 5597 emit_stack_restore (SAVE_BLOCK, sa); 5598 5599 record_new_stack_level (); 5600 5601 fixup_args_size_notes (prev, get_last_insn (), 0); 5602 } 5603 5604 /* Emit code to save the current value of stack. */ 5605 5606 static rtx 5607 expand_stack_save (void) 5608 { 5609 rtx ret = NULL_RTX; 5610 5611 emit_stack_save (SAVE_BLOCK, &ret); 5612 return ret; 5613 } 5614 5615 5616 /* Expand an expression EXP that calls a built-in function, 5617 with result going to TARGET if that's convenient 5618 (and in mode MODE if that's convenient). 5619 SUBTARGET may be used as the target for computing one of EXP's operands. 5620 IGNORE is nonzero if the value is to be ignored. */ 5621 5622 rtx 5623 expand_builtin (tree exp, rtx target, rtx subtarget, machine_mode mode, 5624 int ignore) 5625 { 5626 tree fndecl = get_callee_fndecl (exp); 5627 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl); 5628 machine_mode target_mode = TYPE_MODE (TREE_TYPE (exp)); 5629 int flags; 5630 5631 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD) 5632 return targetm.expand_builtin (exp, target, subtarget, mode, ignore); 5633 5634 /* When ASan is enabled, we don't want to expand some memory/string 5635 builtins and rely on libsanitizer's hooks. This allows us to avoid 5636 redundant checks and be sure, that possible overflow will be detected 5637 by ASan. */ 5638 5639 if ((flag_sanitize & SANITIZE_ADDRESS) && asan_intercepted_p (fcode)) 5640 return expand_call (exp, target, ignore); 5641 5642 /* When not optimizing, generate calls to library functions for a certain 5643 set of builtins. */ 5644 if (!optimize 5645 && !called_as_built_in (fndecl) 5646 && fcode != BUILT_IN_FORK 5647 && fcode != BUILT_IN_EXECL 5648 && fcode != BUILT_IN_EXECV 5649 && fcode != BUILT_IN_EXECLP 5650 && fcode != BUILT_IN_EXECLE 5651 && fcode != BUILT_IN_EXECVP 5652 && fcode != BUILT_IN_EXECVE 5653 && fcode != BUILT_IN_ALLOCA 5654 && fcode != BUILT_IN_ALLOCA_WITH_ALIGN 5655 && fcode != BUILT_IN_FREE 5656 && fcode != BUILT_IN_CHKP_SET_PTR_BOUNDS 5657 && fcode != BUILT_IN_CHKP_INIT_PTR_BOUNDS 5658 && fcode != BUILT_IN_CHKP_NULL_PTR_BOUNDS 5659 && fcode != BUILT_IN_CHKP_COPY_PTR_BOUNDS 5660 && fcode != BUILT_IN_CHKP_NARROW_PTR_BOUNDS 5661 && fcode != BUILT_IN_CHKP_STORE_PTR_BOUNDS 5662 && fcode != BUILT_IN_CHKP_CHECK_PTR_LBOUNDS 5663 && fcode != BUILT_IN_CHKP_CHECK_PTR_UBOUNDS 5664 && fcode != BUILT_IN_CHKP_CHECK_PTR_BOUNDS 5665 && fcode != BUILT_IN_CHKP_GET_PTR_LBOUND 5666 && fcode != BUILT_IN_CHKP_GET_PTR_UBOUND 5667 && fcode != BUILT_IN_CHKP_BNDRET) 5668 return expand_call (exp, target, ignore); 5669 5670 /* The built-in function expanders test for target == const0_rtx 5671 to determine whether the function's result will be ignored. */ 5672 if (ignore) 5673 target = const0_rtx; 5674 5675 /* If the result of a pure or const built-in function is ignored, and 5676 none of its arguments are volatile, we can avoid expanding the 5677 built-in call and just evaluate the arguments for side-effects. */ 5678 if (target == const0_rtx 5679 && ((flags = flags_from_decl_or_type (fndecl)) & (ECF_CONST | ECF_PURE)) 5680 && !(flags & ECF_LOOPING_CONST_OR_PURE)) 5681 { 5682 bool volatilep = false; 5683 tree arg; 5684 call_expr_arg_iterator iter; 5685 5686 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp) 5687 if (TREE_THIS_VOLATILE (arg)) 5688 { 5689 volatilep = true; 5690 break; 5691 } 5692 5693 if (! volatilep) 5694 { 5695 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp) 5696 expand_expr (arg, const0_rtx, VOIDmode, EXPAND_NORMAL); 5697 return const0_rtx; 5698 } 5699 } 5700 5701 /* expand_builtin_with_bounds is supposed to be used for 5702 instrumented builtin calls. */ 5703 gcc_assert (!CALL_WITH_BOUNDS_P (exp)); 5704 5705 switch (fcode) 5706 { 5707 CASE_FLT_FN (BUILT_IN_FABS): 5708 case BUILT_IN_FABSD32: 5709 case BUILT_IN_FABSD64: 5710 case BUILT_IN_FABSD128: 5711 target = expand_builtin_fabs (exp, target, subtarget); 5712 if (target) 5713 return target; 5714 break; 5715 5716 CASE_FLT_FN (BUILT_IN_COPYSIGN): 5717 target = expand_builtin_copysign (exp, target, subtarget); 5718 if (target) 5719 return target; 5720 break; 5721 5722 /* Just do a normal library call if we were unable to fold 5723 the values. */ 5724 CASE_FLT_FN (BUILT_IN_CABS): 5725 break; 5726 5727 CASE_FLT_FN (BUILT_IN_FMA): 5728 target = expand_builtin_mathfn_ternary (exp, target, subtarget); 5729 if (target) 5730 return target; 5731 break; 5732 5733 CASE_FLT_FN (BUILT_IN_ILOGB): 5734 if (! flag_unsafe_math_optimizations) 5735 break; 5736 CASE_FLT_FN (BUILT_IN_ISINF): 5737 CASE_FLT_FN (BUILT_IN_FINITE): 5738 case BUILT_IN_ISFINITE: 5739 case BUILT_IN_ISNORMAL: 5740 target = expand_builtin_interclass_mathfn (exp, target); 5741 if (target) 5742 return target; 5743 break; 5744 5745 CASE_FLT_FN (BUILT_IN_ICEIL): 5746 CASE_FLT_FN (BUILT_IN_LCEIL): 5747 CASE_FLT_FN (BUILT_IN_LLCEIL): 5748 CASE_FLT_FN (BUILT_IN_LFLOOR): 5749 CASE_FLT_FN (BUILT_IN_IFLOOR): 5750 CASE_FLT_FN (BUILT_IN_LLFLOOR): 5751 target = expand_builtin_int_roundingfn (exp, target); 5752 if (target) 5753 return target; 5754 break; 5755 5756 CASE_FLT_FN (BUILT_IN_IRINT): 5757 CASE_FLT_FN (BUILT_IN_LRINT): 5758 CASE_FLT_FN (BUILT_IN_LLRINT): 5759 CASE_FLT_FN (BUILT_IN_IROUND): 5760 CASE_FLT_FN (BUILT_IN_LROUND): 5761 CASE_FLT_FN (BUILT_IN_LLROUND): 5762 target = expand_builtin_int_roundingfn_2 (exp, target); 5763 if (target) 5764 return target; 5765 break; 5766 5767 CASE_FLT_FN (BUILT_IN_POWI): 5768 target = expand_builtin_powi (exp, target); 5769 if (target) 5770 return target; 5771 break; 5772 5773 CASE_FLT_FN (BUILT_IN_CEXPI): 5774 target = expand_builtin_cexpi (exp, target); 5775 gcc_assert (target); 5776 return target; 5777 5778 CASE_FLT_FN (BUILT_IN_SIN): 5779 CASE_FLT_FN (BUILT_IN_COS): 5780 if (! flag_unsafe_math_optimizations) 5781 break; 5782 target = expand_builtin_mathfn_3 (exp, target, subtarget); 5783 if (target) 5784 return target; 5785 break; 5786 5787 CASE_FLT_FN (BUILT_IN_SINCOS): 5788 if (! flag_unsafe_math_optimizations) 5789 break; 5790 target = expand_builtin_sincos (exp); 5791 if (target) 5792 return target; 5793 break; 5794 5795 case BUILT_IN_APPLY_ARGS: 5796 return expand_builtin_apply_args (); 5797 5798 /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes 5799 FUNCTION with a copy of the parameters described by 5800 ARGUMENTS, and ARGSIZE. It returns a block of memory 5801 allocated on the stack into which is stored all the registers 5802 that might possibly be used for returning the result of a 5803 function. ARGUMENTS is the value returned by 5804 __builtin_apply_args. ARGSIZE is the number of bytes of 5805 arguments that must be copied. ??? How should this value be 5806 computed? We'll also need a safe worst case value for varargs 5807 functions. */ 5808 case BUILT_IN_APPLY: 5809 if (!validate_arglist (exp, POINTER_TYPE, 5810 POINTER_TYPE, INTEGER_TYPE, VOID_TYPE) 5811 && !validate_arglist (exp, REFERENCE_TYPE, 5812 POINTER_TYPE, INTEGER_TYPE, VOID_TYPE)) 5813 return const0_rtx; 5814 else 5815 { 5816 rtx ops[3]; 5817 5818 ops[0] = expand_normal (CALL_EXPR_ARG (exp, 0)); 5819 ops[1] = expand_normal (CALL_EXPR_ARG (exp, 1)); 5820 ops[2] = expand_normal (CALL_EXPR_ARG (exp, 2)); 5821 5822 return expand_builtin_apply (ops[0], ops[1], ops[2]); 5823 } 5824 5825 /* __builtin_return (RESULT) causes the function to return the 5826 value described by RESULT. RESULT is address of the block of 5827 memory returned by __builtin_apply. */ 5828 case BUILT_IN_RETURN: 5829 if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE)) 5830 expand_builtin_return (expand_normal (CALL_EXPR_ARG (exp, 0))); 5831 return const0_rtx; 5832 5833 case BUILT_IN_SAVEREGS: 5834 return expand_builtin_saveregs (); 5835 5836 case BUILT_IN_VA_ARG_PACK: 5837 /* All valid uses of __builtin_va_arg_pack () are removed during 5838 inlining. */ 5839 error ("%Kinvalid use of %<__builtin_va_arg_pack ()%>", exp); 5840 return const0_rtx; 5841 5842 case BUILT_IN_VA_ARG_PACK_LEN: 5843 /* All valid uses of __builtin_va_arg_pack_len () are removed during 5844 inlining. */ 5845 error ("%Kinvalid use of %<__builtin_va_arg_pack_len ()%>", exp); 5846 return const0_rtx; 5847 5848 /* Return the address of the first anonymous stack arg. */ 5849 case BUILT_IN_NEXT_ARG: 5850 if (fold_builtin_next_arg (exp, false)) 5851 return const0_rtx; 5852 return expand_builtin_next_arg (); 5853 5854 case BUILT_IN_CLEAR_CACHE: 5855 target = expand_builtin___clear_cache (exp); 5856 if (target) 5857 return target; 5858 break; 5859 5860 case BUILT_IN_CLASSIFY_TYPE: 5861 return expand_builtin_classify_type (exp); 5862 5863 case BUILT_IN_CONSTANT_P: 5864 return const0_rtx; 5865 5866 case BUILT_IN_FRAME_ADDRESS: 5867 case BUILT_IN_RETURN_ADDRESS: 5868 return expand_builtin_frame_address (fndecl, exp); 5869 5870 /* Returns the address of the area where the structure is returned. 5871 0 otherwise. */ 5872 case BUILT_IN_AGGREGATE_INCOMING_ADDRESS: 5873 if (call_expr_nargs (exp) != 0 5874 || ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl))) 5875 || !MEM_P (DECL_RTL (DECL_RESULT (current_function_decl)))) 5876 return const0_rtx; 5877 else 5878 return XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0); 5879 5880 case BUILT_IN_ALLOCA: 5881 case BUILT_IN_ALLOCA_WITH_ALIGN: 5882 /* If the allocation stems from the declaration of a variable-sized 5883 object, it cannot accumulate. */ 5884 target = expand_builtin_alloca (exp, CALL_ALLOCA_FOR_VAR_P (exp)); 5885 if (target) 5886 return target; 5887 break; 5888 5889 case BUILT_IN_STACK_SAVE: 5890 return expand_stack_save (); 5891 5892 case BUILT_IN_STACK_RESTORE: 5893 expand_stack_restore (CALL_EXPR_ARG (exp, 0)); 5894 return const0_rtx; 5895 5896 case BUILT_IN_BSWAP16: 5897 case BUILT_IN_BSWAP32: 5898 case BUILT_IN_BSWAP64: 5899 target = expand_builtin_bswap (target_mode, exp, target, subtarget); 5900 if (target) 5901 return target; 5902 break; 5903 5904 CASE_INT_FN (BUILT_IN_FFS): 5905 target = expand_builtin_unop (target_mode, exp, target, 5906 subtarget, ffs_optab); 5907 if (target) 5908 return target; 5909 break; 5910 5911 CASE_INT_FN (BUILT_IN_CLZ): 5912 target = expand_builtin_unop (target_mode, exp, target, 5913 subtarget, clz_optab); 5914 if (target) 5915 return target; 5916 break; 5917 5918 CASE_INT_FN (BUILT_IN_CTZ): 5919 target = expand_builtin_unop (target_mode, exp, target, 5920 subtarget, ctz_optab); 5921 if (target) 5922 return target; 5923 break; 5924 5925 CASE_INT_FN (BUILT_IN_CLRSB): 5926 target = expand_builtin_unop (target_mode, exp, target, 5927 subtarget, clrsb_optab); 5928 if (target) 5929 return target; 5930 break; 5931 5932 CASE_INT_FN (BUILT_IN_POPCOUNT): 5933 target = expand_builtin_unop (target_mode, exp, target, 5934 subtarget, popcount_optab); 5935 if (target) 5936 return target; 5937 break; 5938 5939 CASE_INT_FN (BUILT_IN_PARITY): 5940 target = expand_builtin_unop (target_mode, exp, target, 5941 subtarget, parity_optab); 5942 if (target) 5943 return target; 5944 break; 5945 5946 case BUILT_IN_STRLEN: 5947 target = expand_builtin_strlen (exp, target, target_mode); 5948 if (target) 5949 return target; 5950 break; 5951 5952 case BUILT_IN_STRCPY: 5953 target = expand_builtin_strcpy (exp, target); 5954 if (target) 5955 return target; 5956 break; 5957 5958 case BUILT_IN_STRNCPY: 5959 target = expand_builtin_strncpy (exp, target); 5960 if (target) 5961 return target; 5962 break; 5963 5964 case BUILT_IN_STPCPY: 5965 target = expand_builtin_stpcpy (exp, target, mode); 5966 if (target) 5967 return target; 5968 break; 5969 5970 case BUILT_IN_MEMCPY: 5971 target = expand_builtin_memcpy (exp, target); 5972 if (target) 5973 return target; 5974 break; 5975 5976 case BUILT_IN_MEMPCPY: 5977 target = expand_builtin_mempcpy (exp, target, mode); 5978 if (target) 5979 return target; 5980 break; 5981 5982 case BUILT_IN_MEMSET: 5983 target = expand_builtin_memset (exp, target, mode); 5984 if (target) 5985 return target; 5986 break; 5987 5988 case BUILT_IN_BZERO: 5989 target = expand_builtin_bzero (exp); 5990 if (target) 5991 return target; 5992 break; 5993 5994 case BUILT_IN_STRCMP: 5995 target = expand_builtin_strcmp (exp, target); 5996 if (target) 5997 return target; 5998 break; 5999 6000 case BUILT_IN_STRNCMP: 6001 target = expand_builtin_strncmp (exp, target, mode); 6002 if (target) 6003 return target; 6004 break; 6005 6006 case BUILT_IN_BCMP: 6007 case BUILT_IN_MEMCMP: 6008 target = expand_builtin_memcmp (exp, target); 6009 if (target) 6010 return target; 6011 break; 6012 6013 case BUILT_IN_SETJMP: 6014 /* This should have been lowered to the builtins below. */ 6015 gcc_unreachable (); 6016 6017 case BUILT_IN_SETJMP_SETUP: 6018 /* __builtin_setjmp_setup is passed a pointer to an array of five words 6019 and the receiver label. */ 6020 if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE)) 6021 { 6022 rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget, 6023 VOIDmode, EXPAND_NORMAL); 6024 tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 1), 0); 6025 rtx_insn *label_r = label_rtx (label); 6026 6027 /* This is copied from the handling of non-local gotos. */ 6028 expand_builtin_setjmp_setup (buf_addr, label_r); 6029 nonlocal_goto_handler_labels 6030 = gen_rtx_INSN_LIST (VOIDmode, label_r, 6031 nonlocal_goto_handler_labels); 6032 /* ??? Do not let expand_label treat us as such since we would 6033 not want to be both on the list of non-local labels and on 6034 the list of forced labels. */ 6035 FORCED_LABEL (label) = 0; 6036 return const0_rtx; 6037 } 6038 break; 6039 6040 case BUILT_IN_SETJMP_RECEIVER: 6041 /* __builtin_setjmp_receiver is passed the receiver label. */ 6042 if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE)) 6043 { 6044 tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 0), 0); 6045 rtx_insn *label_r = label_rtx (label); 6046 6047 expand_builtin_setjmp_receiver (label_r); 6048 return const0_rtx; 6049 } 6050 break; 6051 6052 /* __builtin_longjmp is passed a pointer to an array of five words. 6053 It's similar to the C library longjmp function but works with 6054 __builtin_setjmp above. */ 6055 case BUILT_IN_LONGJMP: 6056 if (validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE)) 6057 { 6058 rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget, 6059 VOIDmode, EXPAND_NORMAL); 6060 rtx value = expand_normal (CALL_EXPR_ARG (exp, 1)); 6061 6062 if (value != const1_rtx) 6063 { 6064 error ("%<__builtin_longjmp%> second argument must be 1"); 6065 return const0_rtx; 6066 } 6067 6068 expand_builtin_longjmp (buf_addr, value); 6069 return const0_rtx; 6070 } 6071 break; 6072 6073 case BUILT_IN_NONLOCAL_GOTO: 6074 target = expand_builtin_nonlocal_goto (exp); 6075 if (target) 6076 return target; 6077 break; 6078 6079 /* This updates the setjmp buffer that is its argument with the value 6080 of the current stack pointer. */ 6081 case BUILT_IN_UPDATE_SETJMP_BUF: 6082 if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE)) 6083 { 6084 rtx buf_addr 6085 = expand_normal (CALL_EXPR_ARG (exp, 0)); 6086 6087 expand_builtin_update_setjmp_buf (buf_addr); 6088 return const0_rtx; 6089 } 6090 break; 6091 6092 case BUILT_IN_TRAP: 6093 expand_builtin_trap (); 6094 return const0_rtx; 6095 6096 case BUILT_IN_UNREACHABLE: 6097 expand_builtin_unreachable (); 6098 return const0_rtx; 6099 6100 CASE_FLT_FN (BUILT_IN_SIGNBIT): 6101 case BUILT_IN_SIGNBITD32: 6102 case BUILT_IN_SIGNBITD64: 6103 case BUILT_IN_SIGNBITD128: 6104 target = expand_builtin_signbit (exp, target); 6105 if (target) 6106 return target; 6107 break; 6108 6109 /* Various hooks for the DWARF 2 __throw routine. */ 6110 case BUILT_IN_UNWIND_INIT: 6111 expand_builtin_unwind_init (); 6112 return const0_rtx; 6113 case BUILT_IN_DWARF_CFA: 6114 return virtual_cfa_rtx; 6115 #ifdef DWARF2_UNWIND_INFO 6116 case BUILT_IN_DWARF_SP_COLUMN: 6117 return expand_builtin_dwarf_sp_column (); 6118 case BUILT_IN_INIT_DWARF_REG_SIZES: 6119 expand_builtin_init_dwarf_reg_sizes (CALL_EXPR_ARG (exp, 0)); 6120 return const0_rtx; 6121 #endif 6122 case BUILT_IN_FROB_RETURN_ADDR: 6123 return expand_builtin_frob_return_addr (CALL_EXPR_ARG (exp, 0)); 6124 case BUILT_IN_EXTRACT_RETURN_ADDR: 6125 return expand_builtin_extract_return_addr (CALL_EXPR_ARG (exp, 0)); 6126 case BUILT_IN_EH_RETURN: 6127 expand_builtin_eh_return (CALL_EXPR_ARG (exp, 0), 6128 CALL_EXPR_ARG (exp, 1)); 6129 return const0_rtx; 6130 case BUILT_IN_EH_RETURN_DATA_REGNO: 6131 return expand_builtin_eh_return_data_regno (exp); 6132 case BUILT_IN_EXTEND_POINTER: 6133 return expand_builtin_extend_pointer (CALL_EXPR_ARG (exp, 0)); 6134 case BUILT_IN_EH_POINTER: 6135 return expand_builtin_eh_pointer (exp); 6136 case BUILT_IN_EH_FILTER: 6137 return expand_builtin_eh_filter (exp); 6138 case BUILT_IN_EH_COPY_VALUES: 6139 return expand_builtin_eh_copy_values (exp); 6140 6141 case BUILT_IN_VA_START: 6142 return expand_builtin_va_start (exp); 6143 case BUILT_IN_VA_END: 6144 return expand_builtin_va_end (exp); 6145 case BUILT_IN_VA_COPY: 6146 return expand_builtin_va_copy (exp); 6147 case BUILT_IN_EXPECT: 6148 return expand_builtin_expect (exp, target); 6149 case BUILT_IN_ASSUME_ALIGNED: 6150 return expand_builtin_assume_aligned (exp, target); 6151 case BUILT_IN_PREFETCH: 6152 expand_builtin_prefetch (exp); 6153 return const0_rtx; 6154 6155 case BUILT_IN_INIT_TRAMPOLINE: 6156 return expand_builtin_init_trampoline (exp, true); 6157 case BUILT_IN_INIT_HEAP_TRAMPOLINE: 6158 return expand_builtin_init_trampoline (exp, false); 6159 case BUILT_IN_ADJUST_TRAMPOLINE: 6160 return expand_builtin_adjust_trampoline (exp); 6161 6162 case BUILT_IN_FORK: 6163 case BUILT_IN_EXECL: 6164 case BUILT_IN_EXECV: 6165 case BUILT_IN_EXECLP: 6166 case BUILT_IN_EXECLE: 6167 case BUILT_IN_EXECVP: 6168 case BUILT_IN_EXECVE: 6169 target = expand_builtin_fork_or_exec (fndecl, exp, target, ignore); 6170 if (target) 6171 return target; 6172 break; 6173 6174 case BUILT_IN_SYNC_FETCH_AND_ADD_1: 6175 case BUILT_IN_SYNC_FETCH_AND_ADD_2: 6176 case BUILT_IN_SYNC_FETCH_AND_ADD_4: 6177 case BUILT_IN_SYNC_FETCH_AND_ADD_8: 6178 case BUILT_IN_SYNC_FETCH_AND_ADD_16: 6179 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_ADD_1); 6180 target = expand_builtin_sync_operation (mode, exp, PLUS, false, target); 6181 if (target) 6182 return target; 6183 break; 6184 6185 case BUILT_IN_SYNC_FETCH_AND_SUB_1: 6186 case BUILT_IN_SYNC_FETCH_AND_SUB_2: 6187 case BUILT_IN_SYNC_FETCH_AND_SUB_4: 6188 case BUILT_IN_SYNC_FETCH_AND_SUB_8: 6189 case BUILT_IN_SYNC_FETCH_AND_SUB_16: 6190 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_SUB_1); 6191 target = expand_builtin_sync_operation (mode, exp, MINUS, false, target); 6192 if (target) 6193 return target; 6194 break; 6195 6196 case BUILT_IN_SYNC_FETCH_AND_OR_1: 6197 case BUILT_IN_SYNC_FETCH_AND_OR_2: 6198 case BUILT_IN_SYNC_FETCH_AND_OR_4: 6199 case BUILT_IN_SYNC_FETCH_AND_OR_8: 6200 case BUILT_IN_SYNC_FETCH_AND_OR_16: 6201 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_OR_1); 6202 target = expand_builtin_sync_operation (mode, exp, IOR, false, target); 6203 if (target) 6204 return target; 6205 break; 6206 6207 case BUILT_IN_SYNC_FETCH_AND_AND_1: 6208 case BUILT_IN_SYNC_FETCH_AND_AND_2: 6209 case BUILT_IN_SYNC_FETCH_AND_AND_4: 6210 case BUILT_IN_SYNC_FETCH_AND_AND_8: 6211 case BUILT_IN_SYNC_FETCH_AND_AND_16: 6212 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_AND_1); 6213 target = expand_builtin_sync_operation (mode, exp, AND, false, target); 6214 if (target) 6215 return target; 6216 break; 6217 6218 case BUILT_IN_SYNC_FETCH_AND_XOR_1: 6219 case BUILT_IN_SYNC_FETCH_AND_XOR_2: 6220 case BUILT_IN_SYNC_FETCH_AND_XOR_4: 6221 case BUILT_IN_SYNC_FETCH_AND_XOR_8: 6222 case BUILT_IN_SYNC_FETCH_AND_XOR_16: 6223 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_XOR_1); 6224 target = expand_builtin_sync_operation (mode, exp, XOR, false, target); 6225 if (target) 6226 return target; 6227 break; 6228 6229 case BUILT_IN_SYNC_FETCH_AND_NAND_1: 6230 case BUILT_IN_SYNC_FETCH_AND_NAND_2: 6231 case BUILT_IN_SYNC_FETCH_AND_NAND_4: 6232 case BUILT_IN_SYNC_FETCH_AND_NAND_8: 6233 case BUILT_IN_SYNC_FETCH_AND_NAND_16: 6234 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_NAND_1); 6235 target = expand_builtin_sync_operation (mode, exp, NOT, false, target); 6236 if (target) 6237 return target; 6238 break; 6239 6240 case BUILT_IN_SYNC_ADD_AND_FETCH_1: 6241 case BUILT_IN_SYNC_ADD_AND_FETCH_2: 6242 case BUILT_IN_SYNC_ADD_AND_FETCH_4: 6243 case BUILT_IN_SYNC_ADD_AND_FETCH_8: 6244 case BUILT_IN_SYNC_ADD_AND_FETCH_16: 6245 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_ADD_AND_FETCH_1); 6246 target = expand_builtin_sync_operation (mode, exp, PLUS, true, target); 6247 if (target) 6248 return target; 6249 break; 6250 6251 case BUILT_IN_SYNC_SUB_AND_FETCH_1: 6252 case BUILT_IN_SYNC_SUB_AND_FETCH_2: 6253 case BUILT_IN_SYNC_SUB_AND_FETCH_4: 6254 case BUILT_IN_SYNC_SUB_AND_FETCH_8: 6255 case BUILT_IN_SYNC_SUB_AND_FETCH_16: 6256 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_SUB_AND_FETCH_1); 6257 target = expand_builtin_sync_operation (mode, exp, MINUS, true, target); 6258 if (target) 6259 return target; 6260 break; 6261 6262 case BUILT_IN_SYNC_OR_AND_FETCH_1: 6263 case BUILT_IN_SYNC_OR_AND_FETCH_2: 6264 case BUILT_IN_SYNC_OR_AND_FETCH_4: 6265 case BUILT_IN_SYNC_OR_AND_FETCH_8: 6266 case BUILT_IN_SYNC_OR_AND_FETCH_16: 6267 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_OR_AND_FETCH_1); 6268 target = expand_builtin_sync_operation (mode, exp, IOR, true, target); 6269 if (target) 6270 return target; 6271 break; 6272 6273 case BUILT_IN_SYNC_AND_AND_FETCH_1: 6274 case BUILT_IN_SYNC_AND_AND_FETCH_2: 6275 case BUILT_IN_SYNC_AND_AND_FETCH_4: 6276 case BUILT_IN_SYNC_AND_AND_FETCH_8: 6277 case BUILT_IN_SYNC_AND_AND_FETCH_16: 6278 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_AND_AND_FETCH_1); 6279 target = expand_builtin_sync_operation (mode, exp, AND, true, target); 6280 if (target) 6281 return target; 6282 break; 6283 6284 case BUILT_IN_SYNC_XOR_AND_FETCH_1: 6285 case BUILT_IN_SYNC_XOR_AND_FETCH_2: 6286 case BUILT_IN_SYNC_XOR_AND_FETCH_4: 6287 case BUILT_IN_SYNC_XOR_AND_FETCH_8: 6288 case BUILT_IN_SYNC_XOR_AND_FETCH_16: 6289 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_XOR_AND_FETCH_1); 6290 target = expand_builtin_sync_operation (mode, exp, XOR, true, target); 6291 if (target) 6292 return target; 6293 break; 6294 6295 case BUILT_IN_SYNC_NAND_AND_FETCH_1: 6296 case BUILT_IN_SYNC_NAND_AND_FETCH_2: 6297 case BUILT_IN_SYNC_NAND_AND_FETCH_4: 6298 case BUILT_IN_SYNC_NAND_AND_FETCH_8: 6299 case BUILT_IN_SYNC_NAND_AND_FETCH_16: 6300 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_NAND_AND_FETCH_1); 6301 target = expand_builtin_sync_operation (mode, exp, NOT, true, target); 6302 if (target) 6303 return target; 6304 break; 6305 6306 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_1: 6307 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_2: 6308 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_4: 6309 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_8: 6310 case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_16: 6311 if (mode == VOIDmode) 6312 mode = TYPE_MODE (boolean_type_node); 6313 if (!target || !register_operand (target, mode)) 6314 target = gen_reg_rtx (mode); 6315 6316 mode = get_builtin_sync_mode 6317 (fcode - BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_1); 6318 target = expand_builtin_compare_and_swap (mode, exp, true, target); 6319 if (target) 6320 return target; 6321 break; 6322 6323 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_1: 6324 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_2: 6325 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_4: 6326 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_8: 6327 case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_16: 6328 mode = get_builtin_sync_mode 6329 (fcode - BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_1); 6330 target = expand_builtin_compare_and_swap (mode, exp, false, target); 6331 if (target) 6332 return target; 6333 break; 6334 6335 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_1: 6336 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_2: 6337 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_4: 6338 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_8: 6339 case BUILT_IN_SYNC_LOCK_TEST_AND_SET_16: 6340 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_LOCK_TEST_AND_SET_1); 6341 target = expand_builtin_sync_lock_test_and_set (mode, exp, target); 6342 if (target) 6343 return target; 6344 break; 6345 6346 case BUILT_IN_SYNC_LOCK_RELEASE_1: 6347 case BUILT_IN_SYNC_LOCK_RELEASE_2: 6348 case BUILT_IN_SYNC_LOCK_RELEASE_4: 6349 case BUILT_IN_SYNC_LOCK_RELEASE_8: 6350 case BUILT_IN_SYNC_LOCK_RELEASE_16: 6351 mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_LOCK_RELEASE_1); 6352 expand_builtin_sync_lock_release (mode, exp); 6353 return const0_rtx; 6354 6355 case BUILT_IN_SYNC_SYNCHRONIZE: 6356 expand_builtin_sync_synchronize (); 6357 return const0_rtx; 6358 6359 case BUILT_IN_ATOMIC_EXCHANGE_1: 6360 case BUILT_IN_ATOMIC_EXCHANGE_2: 6361 case BUILT_IN_ATOMIC_EXCHANGE_4: 6362 case BUILT_IN_ATOMIC_EXCHANGE_8: 6363 case BUILT_IN_ATOMIC_EXCHANGE_16: 6364 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_EXCHANGE_1); 6365 target = expand_builtin_atomic_exchange (mode, exp, target); 6366 if (target) 6367 return target; 6368 break; 6369 6370 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_1: 6371 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_2: 6372 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_4: 6373 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_8: 6374 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_16: 6375 { 6376 unsigned int nargs, z; 6377 vec<tree, va_gc> *vec; 6378 6379 mode = 6380 get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_COMPARE_EXCHANGE_1); 6381 target = expand_builtin_atomic_compare_exchange (mode, exp, target); 6382 if (target) 6383 return target; 6384 6385 /* If this is turned into an external library call, the weak parameter 6386 must be dropped to match the expected parameter list. */ 6387 nargs = call_expr_nargs (exp); 6388 vec_alloc (vec, nargs - 1); 6389 for (z = 0; z < 3; z++) 6390 vec->quick_push (CALL_EXPR_ARG (exp, z)); 6391 /* Skip the boolean weak parameter. */ 6392 for (z = 4; z < 6; z++) 6393 vec->quick_push (CALL_EXPR_ARG (exp, z)); 6394 exp = build_call_vec (TREE_TYPE (exp), CALL_EXPR_FN (exp), vec); 6395 break; 6396 } 6397 6398 case BUILT_IN_ATOMIC_LOAD_1: 6399 case BUILT_IN_ATOMIC_LOAD_2: 6400 case BUILT_IN_ATOMIC_LOAD_4: 6401 case BUILT_IN_ATOMIC_LOAD_8: 6402 case BUILT_IN_ATOMIC_LOAD_16: 6403 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_LOAD_1); 6404 target = expand_builtin_atomic_load (mode, exp, target); 6405 if (target) 6406 return target; 6407 break; 6408 6409 case BUILT_IN_ATOMIC_STORE_1: 6410 case BUILT_IN_ATOMIC_STORE_2: 6411 case BUILT_IN_ATOMIC_STORE_4: 6412 case BUILT_IN_ATOMIC_STORE_8: 6413 case BUILT_IN_ATOMIC_STORE_16: 6414 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_STORE_1); 6415 target = expand_builtin_atomic_store (mode, exp); 6416 if (target) 6417 return const0_rtx; 6418 break; 6419 6420 case BUILT_IN_ATOMIC_ADD_FETCH_1: 6421 case BUILT_IN_ATOMIC_ADD_FETCH_2: 6422 case BUILT_IN_ATOMIC_ADD_FETCH_4: 6423 case BUILT_IN_ATOMIC_ADD_FETCH_8: 6424 case BUILT_IN_ATOMIC_ADD_FETCH_16: 6425 { 6426 enum built_in_function lib; 6427 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_ADD_FETCH_1); 6428 lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_ADD_1 + 6429 (fcode - BUILT_IN_ATOMIC_ADD_FETCH_1)); 6430 target = expand_builtin_atomic_fetch_op (mode, exp, target, PLUS, true, 6431 ignore, lib); 6432 if (target) 6433 return target; 6434 break; 6435 } 6436 case BUILT_IN_ATOMIC_SUB_FETCH_1: 6437 case BUILT_IN_ATOMIC_SUB_FETCH_2: 6438 case BUILT_IN_ATOMIC_SUB_FETCH_4: 6439 case BUILT_IN_ATOMIC_SUB_FETCH_8: 6440 case BUILT_IN_ATOMIC_SUB_FETCH_16: 6441 { 6442 enum built_in_function lib; 6443 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_SUB_FETCH_1); 6444 lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_SUB_1 + 6445 (fcode - BUILT_IN_ATOMIC_SUB_FETCH_1)); 6446 target = expand_builtin_atomic_fetch_op (mode, exp, target, MINUS, true, 6447 ignore, lib); 6448 if (target) 6449 return target; 6450 break; 6451 } 6452 case BUILT_IN_ATOMIC_AND_FETCH_1: 6453 case BUILT_IN_ATOMIC_AND_FETCH_2: 6454 case BUILT_IN_ATOMIC_AND_FETCH_4: 6455 case BUILT_IN_ATOMIC_AND_FETCH_8: 6456 case BUILT_IN_ATOMIC_AND_FETCH_16: 6457 { 6458 enum built_in_function lib; 6459 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_AND_FETCH_1); 6460 lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_AND_1 + 6461 (fcode - BUILT_IN_ATOMIC_AND_FETCH_1)); 6462 target = expand_builtin_atomic_fetch_op (mode, exp, target, AND, true, 6463 ignore, lib); 6464 if (target) 6465 return target; 6466 break; 6467 } 6468 case BUILT_IN_ATOMIC_NAND_FETCH_1: 6469 case BUILT_IN_ATOMIC_NAND_FETCH_2: 6470 case BUILT_IN_ATOMIC_NAND_FETCH_4: 6471 case BUILT_IN_ATOMIC_NAND_FETCH_8: 6472 case BUILT_IN_ATOMIC_NAND_FETCH_16: 6473 { 6474 enum built_in_function lib; 6475 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_NAND_FETCH_1); 6476 lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_NAND_1 + 6477 (fcode - BUILT_IN_ATOMIC_NAND_FETCH_1)); 6478 target = expand_builtin_atomic_fetch_op (mode, exp, target, NOT, true, 6479 ignore, lib); 6480 if (target) 6481 return target; 6482 break; 6483 } 6484 case BUILT_IN_ATOMIC_XOR_FETCH_1: 6485 case BUILT_IN_ATOMIC_XOR_FETCH_2: 6486 case BUILT_IN_ATOMIC_XOR_FETCH_4: 6487 case BUILT_IN_ATOMIC_XOR_FETCH_8: 6488 case BUILT_IN_ATOMIC_XOR_FETCH_16: 6489 { 6490 enum built_in_function lib; 6491 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_XOR_FETCH_1); 6492 lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_XOR_1 + 6493 (fcode - BUILT_IN_ATOMIC_XOR_FETCH_1)); 6494 target = expand_builtin_atomic_fetch_op (mode, exp, target, XOR, true, 6495 ignore, lib); 6496 if (target) 6497 return target; 6498 break; 6499 } 6500 case BUILT_IN_ATOMIC_OR_FETCH_1: 6501 case BUILT_IN_ATOMIC_OR_FETCH_2: 6502 case BUILT_IN_ATOMIC_OR_FETCH_4: 6503 case BUILT_IN_ATOMIC_OR_FETCH_8: 6504 case BUILT_IN_ATOMIC_OR_FETCH_16: 6505 { 6506 enum built_in_function lib; 6507 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_OR_FETCH_1); 6508 lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_OR_1 + 6509 (fcode - BUILT_IN_ATOMIC_OR_FETCH_1)); 6510 target = expand_builtin_atomic_fetch_op (mode, exp, target, IOR, true, 6511 ignore, lib); 6512 if (target) 6513 return target; 6514 break; 6515 } 6516 case BUILT_IN_ATOMIC_FETCH_ADD_1: 6517 case BUILT_IN_ATOMIC_FETCH_ADD_2: 6518 case BUILT_IN_ATOMIC_FETCH_ADD_4: 6519 case BUILT_IN_ATOMIC_FETCH_ADD_8: 6520 case BUILT_IN_ATOMIC_FETCH_ADD_16: 6521 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_ADD_1); 6522 target = expand_builtin_atomic_fetch_op (mode, exp, target, PLUS, false, 6523 ignore, BUILT_IN_NONE); 6524 if (target) 6525 return target; 6526 break; 6527 6528 case BUILT_IN_ATOMIC_FETCH_SUB_1: 6529 case BUILT_IN_ATOMIC_FETCH_SUB_2: 6530 case BUILT_IN_ATOMIC_FETCH_SUB_4: 6531 case BUILT_IN_ATOMIC_FETCH_SUB_8: 6532 case BUILT_IN_ATOMIC_FETCH_SUB_16: 6533 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_SUB_1); 6534 target = expand_builtin_atomic_fetch_op (mode, exp, target, MINUS, false, 6535 ignore, BUILT_IN_NONE); 6536 if (target) 6537 return target; 6538 break; 6539 6540 case BUILT_IN_ATOMIC_FETCH_AND_1: 6541 case BUILT_IN_ATOMIC_FETCH_AND_2: 6542 case BUILT_IN_ATOMIC_FETCH_AND_4: 6543 case BUILT_IN_ATOMIC_FETCH_AND_8: 6544 case BUILT_IN_ATOMIC_FETCH_AND_16: 6545 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_AND_1); 6546 target = expand_builtin_atomic_fetch_op (mode, exp, target, AND, false, 6547 ignore, BUILT_IN_NONE); 6548 if (target) 6549 return target; 6550 break; 6551 6552 case BUILT_IN_ATOMIC_FETCH_NAND_1: 6553 case BUILT_IN_ATOMIC_FETCH_NAND_2: 6554 case BUILT_IN_ATOMIC_FETCH_NAND_4: 6555 case BUILT_IN_ATOMIC_FETCH_NAND_8: 6556 case BUILT_IN_ATOMIC_FETCH_NAND_16: 6557 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_NAND_1); 6558 target = expand_builtin_atomic_fetch_op (mode, exp, target, NOT, false, 6559 ignore, BUILT_IN_NONE); 6560 if (target) 6561 return target; 6562 break; 6563 6564 case BUILT_IN_ATOMIC_FETCH_XOR_1: 6565 case BUILT_IN_ATOMIC_FETCH_XOR_2: 6566 case BUILT_IN_ATOMIC_FETCH_XOR_4: 6567 case BUILT_IN_ATOMIC_FETCH_XOR_8: 6568 case BUILT_IN_ATOMIC_FETCH_XOR_16: 6569 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_XOR_1); 6570 target = expand_builtin_atomic_fetch_op (mode, exp, target, XOR, false, 6571 ignore, BUILT_IN_NONE); 6572 if (target) 6573 return target; 6574 break; 6575 6576 case BUILT_IN_ATOMIC_FETCH_OR_1: 6577 case BUILT_IN_ATOMIC_FETCH_OR_2: 6578 case BUILT_IN_ATOMIC_FETCH_OR_4: 6579 case BUILT_IN_ATOMIC_FETCH_OR_8: 6580 case BUILT_IN_ATOMIC_FETCH_OR_16: 6581 mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_OR_1); 6582 target = expand_builtin_atomic_fetch_op (mode, exp, target, IOR, false, 6583 ignore, BUILT_IN_NONE); 6584 if (target) 6585 return target; 6586 break; 6587 6588 case BUILT_IN_ATOMIC_TEST_AND_SET: 6589 return expand_builtin_atomic_test_and_set (exp, target); 6590 6591 case BUILT_IN_ATOMIC_CLEAR: 6592 return expand_builtin_atomic_clear (exp); 6593 6594 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE: 6595 return expand_builtin_atomic_always_lock_free (exp); 6596 6597 case BUILT_IN_ATOMIC_IS_LOCK_FREE: 6598 target = expand_builtin_atomic_is_lock_free (exp); 6599 if (target) 6600 return target; 6601 break; 6602 6603 case BUILT_IN_ATOMIC_THREAD_FENCE: 6604 expand_builtin_atomic_thread_fence (exp); 6605 return const0_rtx; 6606 6607 case BUILT_IN_ATOMIC_SIGNAL_FENCE: 6608 expand_builtin_atomic_signal_fence (exp); 6609 return const0_rtx; 6610 6611 case BUILT_IN_OBJECT_SIZE: 6612 return expand_builtin_object_size (exp); 6613 6614 case BUILT_IN_MEMCPY_CHK: 6615 case BUILT_IN_MEMPCPY_CHK: 6616 case BUILT_IN_MEMMOVE_CHK: 6617 case BUILT_IN_MEMSET_CHK: 6618 target = expand_builtin_memory_chk (exp, target, mode, fcode); 6619 if (target) 6620 return target; 6621 break; 6622 6623 case BUILT_IN_STRCPY_CHK: 6624 case BUILT_IN_STPCPY_CHK: 6625 case BUILT_IN_STRNCPY_CHK: 6626 case BUILT_IN_STPNCPY_CHK: 6627 case BUILT_IN_STRCAT_CHK: 6628 case BUILT_IN_STRNCAT_CHK: 6629 case BUILT_IN_SNPRINTF_CHK: 6630 case BUILT_IN_VSNPRINTF_CHK: 6631 maybe_emit_chk_warning (exp, fcode); 6632 break; 6633 6634 case BUILT_IN_SPRINTF_CHK: 6635 case BUILT_IN_VSPRINTF_CHK: 6636 maybe_emit_sprintf_chk_warning (exp, fcode); 6637 break; 6638 6639 case BUILT_IN_FREE: 6640 if (warn_free_nonheap_object) 6641 maybe_emit_free_warning (exp); 6642 break; 6643 6644 case BUILT_IN_THREAD_POINTER: 6645 return expand_builtin_thread_pointer (exp, target); 6646 6647 case BUILT_IN_SET_THREAD_POINTER: 6648 expand_builtin_set_thread_pointer (exp); 6649 return const0_rtx; 6650 6651 case BUILT_IN_CILK_DETACH: 6652 expand_builtin_cilk_detach (exp); 6653 return const0_rtx; 6654 6655 case BUILT_IN_CILK_POP_FRAME: 6656 expand_builtin_cilk_pop_frame (exp); 6657 return const0_rtx; 6658 6659 case BUILT_IN_CHKP_INIT_PTR_BOUNDS: 6660 case BUILT_IN_CHKP_NULL_PTR_BOUNDS: 6661 case BUILT_IN_CHKP_COPY_PTR_BOUNDS: 6662 case BUILT_IN_CHKP_CHECK_PTR_LBOUNDS: 6663 case BUILT_IN_CHKP_CHECK_PTR_UBOUNDS: 6664 case BUILT_IN_CHKP_CHECK_PTR_BOUNDS: 6665 case BUILT_IN_CHKP_SET_PTR_BOUNDS: 6666 case BUILT_IN_CHKP_NARROW_PTR_BOUNDS: 6667 case BUILT_IN_CHKP_STORE_PTR_BOUNDS: 6668 case BUILT_IN_CHKP_GET_PTR_LBOUND: 6669 case BUILT_IN_CHKP_GET_PTR_UBOUND: 6670 /* We allow user CHKP builtins if Pointer Bounds 6671 Checker is off. */ 6672 if (!chkp_function_instrumented_p (current_function_decl)) 6673 { 6674 if (fcode == BUILT_IN_CHKP_SET_PTR_BOUNDS 6675 || fcode == BUILT_IN_CHKP_NARROW_PTR_BOUNDS 6676 || fcode == BUILT_IN_CHKP_INIT_PTR_BOUNDS 6677 || fcode == BUILT_IN_CHKP_NULL_PTR_BOUNDS 6678 || fcode == BUILT_IN_CHKP_COPY_PTR_BOUNDS) 6679 return expand_normal (CALL_EXPR_ARG (exp, 0)); 6680 else if (fcode == BUILT_IN_CHKP_GET_PTR_LBOUND) 6681 return expand_normal (size_zero_node); 6682 else if (fcode == BUILT_IN_CHKP_GET_PTR_UBOUND) 6683 return expand_normal (size_int (-1)); 6684 else 6685 return const0_rtx; 6686 } 6687 /* FALLTHROUGH */ 6688 6689 case BUILT_IN_CHKP_BNDMK: 6690 case BUILT_IN_CHKP_BNDSTX: 6691 case BUILT_IN_CHKP_BNDCL: 6692 case BUILT_IN_CHKP_BNDCU: 6693 case BUILT_IN_CHKP_BNDLDX: 6694 case BUILT_IN_CHKP_BNDRET: 6695 case BUILT_IN_CHKP_INTERSECT: 6696 case BUILT_IN_CHKP_NARROW: 6697 case BUILT_IN_CHKP_EXTRACT_LOWER: 6698 case BUILT_IN_CHKP_EXTRACT_UPPER: 6699 /* Software implementation of Pointer Bounds Checker is NYI. 6700 Target support is required. */ 6701 error ("Your target platform does not support -fcheck-pointer-bounds"); 6702 break; 6703 6704 case BUILT_IN_ACC_ON_DEVICE: 6705 /* Do library call, if we failed to expand the builtin when 6706 folding. */ 6707 break; 6708 6709 default: /* just do library call, if unknown builtin */ 6710 break; 6711 } 6712 6713 /* The switch statement above can drop through to cause the function 6714 to be called normally. */ 6715 return expand_call (exp, target, ignore); 6716 } 6717 6718 /* Similar to expand_builtin but is used for instrumented calls. */ 6719 6720 rtx 6721 expand_builtin_with_bounds (tree exp, rtx target, 6722 rtx subtarget ATTRIBUTE_UNUSED, 6723 machine_mode mode, int ignore) 6724 { 6725 tree fndecl = get_callee_fndecl (exp); 6726 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl); 6727 6728 gcc_assert (CALL_WITH_BOUNDS_P (exp)); 6729 6730 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD) 6731 return targetm.expand_builtin (exp, target, subtarget, mode, ignore); 6732 6733 gcc_assert (fcode > BEGIN_CHKP_BUILTINS 6734 && fcode < END_CHKP_BUILTINS); 6735 6736 switch (fcode) 6737 { 6738 case BUILT_IN_CHKP_MEMCPY_NOBND_NOCHK_CHKP: 6739 target = expand_builtin_memcpy_with_bounds (exp, target); 6740 if (target) 6741 return target; 6742 break; 6743 6744 case BUILT_IN_CHKP_MEMPCPY_NOBND_NOCHK_CHKP: 6745 target = expand_builtin_mempcpy_with_bounds (exp, target, mode); 6746 if (target) 6747 return target; 6748 break; 6749 6750 case BUILT_IN_CHKP_MEMSET_NOBND_NOCHK_CHKP: 6751 target = expand_builtin_memset_with_bounds (exp, target, mode); 6752 if (target) 6753 return target; 6754 break; 6755 6756 default: 6757 break; 6758 } 6759 6760 /* The switch statement above can drop through to cause the function 6761 to be called normally. */ 6762 return expand_call (exp, target, ignore); 6763 } 6764 6765 /* Determine whether a tree node represents a call to a built-in 6766 function. If the tree T is a call to a built-in function with 6767 the right number of arguments of the appropriate types, return 6768 the DECL_FUNCTION_CODE of the call, e.g. BUILT_IN_SQRT. 6769 Otherwise the return value is END_BUILTINS. */ 6770 6771 enum built_in_function 6772 builtin_mathfn_code (const_tree t) 6773 { 6774 const_tree fndecl, arg, parmlist; 6775 const_tree argtype, parmtype; 6776 const_call_expr_arg_iterator iter; 6777 6778 if (TREE_CODE (t) != CALL_EXPR 6779 || TREE_CODE (CALL_EXPR_FN (t)) != ADDR_EXPR) 6780 return END_BUILTINS; 6781 6782 fndecl = get_callee_fndecl (t); 6783 if (fndecl == NULL_TREE 6784 || TREE_CODE (fndecl) != FUNCTION_DECL 6785 || ! DECL_BUILT_IN (fndecl) 6786 || DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD) 6787 return END_BUILTINS; 6788 6789 parmlist = TYPE_ARG_TYPES (TREE_TYPE (fndecl)); 6790 init_const_call_expr_arg_iterator (t, &iter); 6791 for (; parmlist; parmlist = TREE_CHAIN (parmlist)) 6792 { 6793 /* If a function doesn't take a variable number of arguments, 6794 the last element in the list will have type `void'. */ 6795 parmtype = TREE_VALUE (parmlist); 6796 if (VOID_TYPE_P (parmtype)) 6797 { 6798 if (more_const_call_expr_args_p (&iter)) 6799 return END_BUILTINS; 6800 return DECL_FUNCTION_CODE (fndecl); 6801 } 6802 6803 if (! more_const_call_expr_args_p (&iter)) 6804 return END_BUILTINS; 6805 6806 arg = next_const_call_expr_arg (&iter); 6807 argtype = TREE_TYPE (arg); 6808 6809 if (SCALAR_FLOAT_TYPE_P (parmtype)) 6810 { 6811 if (! SCALAR_FLOAT_TYPE_P (argtype)) 6812 return END_BUILTINS; 6813 } 6814 else if (COMPLEX_FLOAT_TYPE_P (parmtype)) 6815 { 6816 if (! COMPLEX_FLOAT_TYPE_P (argtype)) 6817 return END_BUILTINS; 6818 } 6819 else if (POINTER_TYPE_P (parmtype)) 6820 { 6821 if (! POINTER_TYPE_P (argtype)) 6822 return END_BUILTINS; 6823 } 6824 else if (INTEGRAL_TYPE_P (parmtype)) 6825 { 6826 if (! INTEGRAL_TYPE_P (argtype)) 6827 return END_BUILTINS; 6828 } 6829 else 6830 return END_BUILTINS; 6831 } 6832 6833 /* Variable-length argument list. */ 6834 return DECL_FUNCTION_CODE (fndecl); 6835 } 6836 6837 /* Fold a call to __builtin_constant_p, if we know its argument ARG will 6838 evaluate to a constant. */ 6839 6840 static tree 6841 fold_builtin_constant_p (tree arg) 6842 { 6843 /* We return 1 for a numeric type that's known to be a constant 6844 value at compile-time or for an aggregate type that's a 6845 literal constant. */ 6846 STRIP_NOPS (arg); 6847 6848 /* If we know this is a constant, emit the constant of one. */ 6849 if (CONSTANT_CLASS_P (arg) 6850 || (TREE_CODE (arg) == CONSTRUCTOR 6851 && TREE_CONSTANT (arg))) 6852 return integer_one_node; 6853 if (TREE_CODE (arg) == ADDR_EXPR) 6854 { 6855 tree op = TREE_OPERAND (arg, 0); 6856 if (TREE_CODE (op) == STRING_CST 6857 || (TREE_CODE (op) == ARRAY_REF 6858 && integer_zerop (TREE_OPERAND (op, 1)) 6859 && TREE_CODE (TREE_OPERAND (op, 0)) == STRING_CST)) 6860 return integer_one_node; 6861 } 6862 6863 /* If this expression has side effects, show we don't know it to be a 6864 constant. Likewise if it's a pointer or aggregate type since in 6865 those case we only want literals, since those are only optimized 6866 when generating RTL, not later. 6867 And finally, if we are compiling an initializer, not code, we 6868 need to return a definite result now; there's not going to be any 6869 more optimization done. */ 6870 if (TREE_SIDE_EFFECTS (arg) 6871 || AGGREGATE_TYPE_P (TREE_TYPE (arg)) 6872 || POINTER_TYPE_P (TREE_TYPE (arg)) 6873 || cfun == 0 6874 || folding_initializer 6875 || force_folding_builtin_constant_p) 6876 return integer_zero_node; 6877 6878 return NULL_TREE; 6879 } 6880 6881 /* Create builtin_expect with PRED and EXPECTED as its arguments and 6882 return it as a truthvalue. */ 6883 6884 static tree 6885 build_builtin_expect_predicate (location_t loc, tree pred, tree expected, 6886 tree predictor) 6887 { 6888 tree fn, arg_types, pred_type, expected_type, call_expr, ret_type; 6889 6890 fn = builtin_decl_explicit (BUILT_IN_EXPECT); 6891 arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn)); 6892 ret_type = TREE_TYPE (TREE_TYPE (fn)); 6893 pred_type = TREE_VALUE (arg_types); 6894 expected_type = TREE_VALUE (TREE_CHAIN (arg_types)); 6895 6896 pred = fold_convert_loc (loc, pred_type, pred); 6897 expected = fold_convert_loc (loc, expected_type, expected); 6898 call_expr = build_call_expr_loc (loc, fn, predictor ? 3 : 2, pred, expected, 6899 predictor); 6900 6901 return build2 (NE_EXPR, TREE_TYPE (pred), call_expr, 6902 build_int_cst (ret_type, 0)); 6903 } 6904 6905 /* Fold a call to builtin_expect with arguments ARG0 and ARG1. Return 6906 NULL_TREE if no simplification is possible. */ 6907 6908 tree 6909 fold_builtin_expect (location_t loc, tree arg0, tree arg1, tree arg2) 6910 { 6911 tree inner, fndecl, inner_arg0; 6912 enum tree_code code; 6913 6914 /* Distribute the expected value over short-circuiting operators. 6915 See through the cast from truthvalue_type_node to long. */ 6916 inner_arg0 = arg0; 6917 while (CONVERT_EXPR_P (inner_arg0) 6918 && INTEGRAL_TYPE_P (TREE_TYPE (inner_arg0)) 6919 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (inner_arg0, 0)))) 6920 inner_arg0 = TREE_OPERAND (inner_arg0, 0); 6921 6922 /* If this is a builtin_expect within a builtin_expect keep the 6923 inner one. See through a comparison against a constant. It 6924 might have been added to create a thruthvalue. */ 6925 inner = inner_arg0; 6926 6927 if (COMPARISON_CLASS_P (inner) 6928 && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST) 6929 inner = TREE_OPERAND (inner, 0); 6930 6931 if (TREE_CODE (inner) == CALL_EXPR 6932 && (fndecl = get_callee_fndecl (inner)) 6933 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL 6934 && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_EXPECT) 6935 return arg0; 6936 6937 inner = inner_arg0; 6938 code = TREE_CODE (inner); 6939 if (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR) 6940 { 6941 tree op0 = TREE_OPERAND (inner, 0); 6942 tree op1 = TREE_OPERAND (inner, 1); 6943 6944 op0 = build_builtin_expect_predicate (loc, op0, arg1, arg2); 6945 op1 = build_builtin_expect_predicate (loc, op1, arg1, arg2); 6946 inner = build2 (code, TREE_TYPE (inner), op0, op1); 6947 6948 return fold_convert_loc (loc, TREE_TYPE (arg0), inner); 6949 } 6950 6951 /* If the argument isn't invariant then there's nothing else we can do. */ 6952 if (!TREE_CONSTANT (inner_arg0)) 6953 return NULL_TREE; 6954 6955 /* If we expect that a comparison against the argument will fold to 6956 a constant return the constant. In practice, this means a true 6957 constant or the address of a non-weak symbol. */ 6958 inner = inner_arg0; 6959 STRIP_NOPS (inner); 6960 if (TREE_CODE (inner) == ADDR_EXPR) 6961 { 6962 do 6963 { 6964 inner = TREE_OPERAND (inner, 0); 6965 } 6966 while (TREE_CODE (inner) == COMPONENT_REF 6967 || TREE_CODE (inner) == ARRAY_REF); 6968 if ((TREE_CODE (inner) == VAR_DECL 6969 || TREE_CODE (inner) == FUNCTION_DECL) 6970 && DECL_WEAK (inner)) 6971 return NULL_TREE; 6972 } 6973 6974 /* Otherwise, ARG0 already has the proper type for the return value. */ 6975 return arg0; 6976 } 6977 6978 /* Fold a call to __builtin_classify_type with argument ARG. */ 6979 6980 static tree 6981 fold_builtin_classify_type (tree arg) 6982 { 6983 if (arg == 0) 6984 return build_int_cst (integer_type_node, no_type_class); 6985 6986 return build_int_cst (integer_type_node, type_to_class (TREE_TYPE (arg))); 6987 } 6988 6989 /* Fold a call to __builtin_strlen with argument ARG. */ 6990 6991 static tree 6992 fold_builtin_strlen (location_t loc, tree type, tree arg) 6993 { 6994 if (!validate_arg (arg, POINTER_TYPE)) 6995 return NULL_TREE; 6996 else 6997 { 6998 tree len = c_strlen (arg, 0); 6999 7000 if (len) 7001 return fold_convert_loc (loc, type, len); 7002 7003 return NULL_TREE; 7004 } 7005 } 7006 7007 /* Fold a call to __builtin_inf or __builtin_huge_val. */ 7008 7009 static tree 7010 fold_builtin_inf (location_t loc, tree type, int warn) 7011 { 7012 REAL_VALUE_TYPE real; 7013 7014 /* __builtin_inff is intended to be usable to define INFINITY on all 7015 targets. If an infinity is not available, INFINITY expands "to a 7016 positive constant of type float that overflows at translation 7017 time", footnote "In this case, using INFINITY will violate the 7018 constraint in 6.4.4 and thus require a diagnostic." (C99 7.12#4). 7019 Thus we pedwarn to ensure this constraint violation is 7020 diagnosed. */ 7021 if (!MODE_HAS_INFINITIES (TYPE_MODE (type)) && warn) 7022 pedwarn (loc, 0, "target format does not support infinity"); 7023 7024 real_inf (&real); 7025 return build_real (type, real); 7026 } 7027 7028 /* Fold function call to builtin sincos, sincosf, or sincosl. Return 7029 NULL_TREE if no simplification can be made. */ 7030 7031 static tree 7032 fold_builtin_sincos (location_t loc, 7033 tree arg0, tree arg1, tree arg2) 7034 { 7035 tree type; 7036 tree fndecl, call = NULL_TREE; 7037 7038 if (!validate_arg (arg0, REAL_TYPE) 7039 || !validate_arg (arg1, POINTER_TYPE) 7040 || !validate_arg (arg2, POINTER_TYPE)) 7041 return NULL_TREE; 7042 7043 type = TREE_TYPE (arg0); 7044 7045 /* Calculate the result when the argument is a constant. */ 7046 built_in_function fn = mathfn_built_in_2 (type, CFN_BUILT_IN_CEXPI); 7047 if (fn == END_BUILTINS) 7048 return NULL_TREE; 7049 7050 /* Canonicalize sincos to cexpi. */ 7051 if (TREE_CODE (arg0) == REAL_CST) 7052 { 7053 tree complex_type = build_complex_type (type); 7054 call = fold_const_call (as_combined_fn (fn), complex_type, arg0); 7055 } 7056 if (!call) 7057 { 7058 if (!targetm.libc_has_function (function_c99_math_complex) 7059 || !builtin_decl_implicit_p (fn)) 7060 return NULL_TREE; 7061 fndecl = builtin_decl_explicit (fn); 7062 call = build_call_expr_loc (loc, fndecl, 1, arg0); 7063 call = builtin_save_expr (call); 7064 } 7065 7066 return build2 (COMPOUND_EXPR, void_type_node, 7067 build2 (MODIFY_EXPR, void_type_node, 7068 build_fold_indirect_ref_loc (loc, arg1), 7069 fold_build1_loc (loc, IMAGPART_EXPR, type, call)), 7070 build2 (MODIFY_EXPR, void_type_node, 7071 build_fold_indirect_ref_loc (loc, arg2), 7072 fold_build1_loc (loc, REALPART_EXPR, type, call))); 7073 } 7074 7075 /* Fold function call to builtin memchr. ARG1, ARG2 and LEN are the 7076 arguments to the call, and TYPE is its return type. 7077 Return NULL_TREE if no simplification can be made. */ 7078 7079 static tree 7080 fold_builtin_memchr (location_t loc, tree arg1, tree arg2, tree len, tree type) 7081 { 7082 if (!validate_arg (arg1, POINTER_TYPE) 7083 || !validate_arg (arg2, INTEGER_TYPE) 7084 || !validate_arg (len, INTEGER_TYPE)) 7085 return NULL_TREE; 7086 else 7087 { 7088 const char *p1; 7089 7090 if (TREE_CODE (arg2) != INTEGER_CST 7091 || !tree_fits_uhwi_p (len)) 7092 return NULL_TREE; 7093 7094 p1 = c_getstr (arg1); 7095 if (p1 && compare_tree_int (len, strlen (p1) + 1) <= 0) 7096 { 7097 char c; 7098 const char *r; 7099 tree tem; 7100 7101 if (target_char_cast (arg2, &c)) 7102 return NULL_TREE; 7103 7104 r = (const char *) memchr (p1, c, tree_to_uhwi (len)); 7105 7106 if (r == NULL) 7107 return build_int_cst (TREE_TYPE (arg1), 0); 7108 7109 tem = fold_build_pointer_plus_hwi_loc (loc, arg1, r - p1); 7110 return fold_convert_loc (loc, type, tem); 7111 } 7112 return NULL_TREE; 7113 } 7114 } 7115 7116 /* Fold function call to builtin memcmp with arguments ARG1 and ARG2. 7117 Return NULL_TREE if no simplification can be made. */ 7118 7119 static tree 7120 fold_builtin_memcmp (location_t loc, tree arg1, tree arg2, tree len) 7121 { 7122 if (!validate_arg (arg1, POINTER_TYPE) 7123 || !validate_arg (arg2, POINTER_TYPE) 7124 || !validate_arg (len, INTEGER_TYPE)) 7125 return NULL_TREE; 7126 7127 /* If the LEN parameter is zero, return zero. */ 7128 if (integer_zerop (len)) 7129 return omit_two_operands_loc (loc, integer_type_node, integer_zero_node, 7130 arg1, arg2); 7131 7132 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */ 7133 if (operand_equal_p (arg1, arg2, 0)) 7134 return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len); 7135 7136 /* If len parameter is one, return an expression corresponding to 7137 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */ 7138 if (tree_fits_uhwi_p (len) && tree_to_uhwi (len) == 1) 7139 { 7140 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0); 7141 tree cst_uchar_ptr_node 7142 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true); 7143 7144 tree ind1 7145 = fold_convert_loc (loc, integer_type_node, 7146 build1 (INDIRECT_REF, cst_uchar_node, 7147 fold_convert_loc (loc, 7148 cst_uchar_ptr_node, 7149 arg1))); 7150 tree ind2 7151 = fold_convert_loc (loc, integer_type_node, 7152 build1 (INDIRECT_REF, cst_uchar_node, 7153 fold_convert_loc (loc, 7154 cst_uchar_ptr_node, 7155 arg2))); 7156 return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2); 7157 } 7158 7159 return NULL_TREE; 7160 } 7161 7162 /* Fold function call to builtin strcmp with arguments ARG1 and ARG2. 7163 Return NULL_TREE if no simplification can be made. */ 7164 7165 static tree 7166 fold_builtin_strcmp (location_t loc, tree arg1, tree arg2) 7167 { 7168 if (!validate_arg (arg1, POINTER_TYPE) 7169 || !validate_arg (arg2, POINTER_TYPE)) 7170 return NULL_TREE; 7171 7172 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */ 7173 if (operand_equal_p (arg1, arg2, 0)) 7174 return integer_zero_node; 7175 7176 /* If the second arg is "", return *(const unsigned char*)arg1. */ 7177 const char *p2 = c_getstr (arg2); 7178 if (p2 && *p2 == '\0') 7179 { 7180 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0); 7181 tree cst_uchar_ptr_node 7182 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true); 7183 7184 return fold_convert_loc (loc, integer_type_node, 7185 build1 (INDIRECT_REF, cst_uchar_node, 7186 fold_convert_loc (loc, 7187 cst_uchar_ptr_node, 7188 arg1))); 7189 } 7190 7191 /* If the first arg is "", return -*(const unsigned char*)arg2. */ 7192 const char *p1 = c_getstr (arg1); 7193 if (p1 && *p1 == '\0') 7194 { 7195 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0); 7196 tree cst_uchar_ptr_node 7197 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true); 7198 7199 tree temp 7200 = fold_convert_loc (loc, integer_type_node, 7201 build1 (INDIRECT_REF, cst_uchar_node, 7202 fold_convert_loc (loc, 7203 cst_uchar_ptr_node, 7204 arg2))); 7205 return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp); 7206 } 7207 7208 return NULL_TREE; 7209 } 7210 7211 /* Fold function call to builtin strncmp with arguments ARG1, ARG2, and LEN. 7212 Return NULL_TREE if no simplification can be made. */ 7213 7214 static tree 7215 fold_builtin_strncmp (location_t loc, tree arg1, tree arg2, tree len) 7216 { 7217 if (!validate_arg (arg1, POINTER_TYPE) 7218 || !validate_arg (arg2, POINTER_TYPE) 7219 || !validate_arg (len, INTEGER_TYPE)) 7220 return NULL_TREE; 7221 7222 /* If the LEN parameter is zero, return zero. */ 7223 if (integer_zerop (len)) 7224 return omit_two_operands_loc (loc, integer_type_node, integer_zero_node, 7225 arg1, arg2); 7226 7227 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */ 7228 if (operand_equal_p (arg1, arg2, 0)) 7229 return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len); 7230 7231 /* If the second arg is "", and the length is greater than zero, 7232 return *(const unsigned char*)arg1. */ 7233 const char *p2 = c_getstr (arg2); 7234 if (p2 && *p2 == '\0' 7235 && TREE_CODE (len) == INTEGER_CST 7236 && tree_int_cst_sgn (len) == 1) 7237 { 7238 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0); 7239 tree cst_uchar_ptr_node 7240 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true); 7241 7242 return fold_convert_loc (loc, integer_type_node, 7243 build1 (INDIRECT_REF, cst_uchar_node, 7244 fold_convert_loc (loc, 7245 cst_uchar_ptr_node, 7246 arg1))); 7247 } 7248 7249 /* If the first arg is "", and the length is greater than zero, 7250 return -*(const unsigned char*)arg2. */ 7251 const char *p1 = c_getstr (arg1); 7252 if (p1 && *p1 == '\0' 7253 && TREE_CODE (len) == INTEGER_CST 7254 && tree_int_cst_sgn (len) == 1) 7255 { 7256 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0); 7257 tree cst_uchar_ptr_node 7258 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true); 7259 7260 tree temp = fold_convert_loc (loc, integer_type_node, 7261 build1 (INDIRECT_REF, cst_uchar_node, 7262 fold_convert_loc (loc, 7263 cst_uchar_ptr_node, 7264 arg2))); 7265 return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp); 7266 } 7267 7268 /* If len parameter is one, return an expression corresponding to 7269 (*(const unsigned char*)arg1 - (const unsigned char*)arg2). */ 7270 if (tree_fits_uhwi_p (len) && tree_to_uhwi (len) == 1) 7271 { 7272 tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0); 7273 tree cst_uchar_ptr_node 7274 = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true); 7275 7276 tree ind1 = fold_convert_loc (loc, integer_type_node, 7277 build1 (INDIRECT_REF, cst_uchar_node, 7278 fold_convert_loc (loc, 7279 cst_uchar_ptr_node, 7280 arg1))); 7281 tree ind2 = fold_convert_loc (loc, integer_type_node, 7282 build1 (INDIRECT_REF, cst_uchar_node, 7283 fold_convert_loc (loc, 7284 cst_uchar_ptr_node, 7285 arg2))); 7286 return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2); 7287 } 7288 7289 return NULL_TREE; 7290 } 7291 7292 /* Fold a call to builtin isascii with argument ARG. */ 7293 7294 static tree 7295 fold_builtin_isascii (location_t loc, tree arg) 7296 { 7297 if (!validate_arg (arg, INTEGER_TYPE)) 7298 return NULL_TREE; 7299 else 7300 { 7301 /* Transform isascii(c) -> ((c & ~0x7f) == 0). */ 7302 arg = fold_build2 (BIT_AND_EXPR, integer_type_node, arg, 7303 build_int_cst (integer_type_node, 7304 ~ (unsigned HOST_WIDE_INT) 0x7f)); 7305 return fold_build2_loc (loc, EQ_EXPR, integer_type_node, 7306 arg, integer_zero_node); 7307 } 7308 } 7309 7310 /* Fold a call to builtin toascii with argument ARG. */ 7311 7312 static tree 7313 fold_builtin_toascii (location_t loc, tree arg) 7314 { 7315 if (!validate_arg (arg, INTEGER_TYPE)) 7316 return NULL_TREE; 7317 7318 /* Transform toascii(c) -> (c & 0x7f). */ 7319 return fold_build2_loc (loc, BIT_AND_EXPR, integer_type_node, arg, 7320 build_int_cst (integer_type_node, 0x7f)); 7321 } 7322 7323 /* Fold a call to builtin isdigit with argument ARG. */ 7324 7325 static tree 7326 fold_builtin_isdigit (location_t loc, tree arg) 7327 { 7328 if (!validate_arg (arg, INTEGER_TYPE)) 7329 return NULL_TREE; 7330 else 7331 { 7332 /* Transform isdigit(c) -> (unsigned)(c) - '0' <= 9. */ 7333 /* According to the C standard, isdigit is unaffected by locale. 7334 However, it definitely is affected by the target character set. */ 7335 unsigned HOST_WIDE_INT target_digit0 7336 = lang_hooks.to_target_charset ('0'); 7337 7338 if (target_digit0 == 0) 7339 return NULL_TREE; 7340 7341 arg = fold_convert_loc (loc, unsigned_type_node, arg); 7342 arg = fold_build2 (MINUS_EXPR, unsigned_type_node, arg, 7343 build_int_cst (unsigned_type_node, target_digit0)); 7344 return fold_build2_loc (loc, LE_EXPR, integer_type_node, arg, 7345 build_int_cst (unsigned_type_node, 9)); 7346 } 7347 } 7348 7349 /* Fold a call to fabs, fabsf or fabsl with argument ARG. */ 7350 7351 static tree 7352 fold_builtin_fabs (location_t loc, tree arg, tree type) 7353 { 7354 if (!validate_arg (arg, REAL_TYPE)) 7355 return NULL_TREE; 7356 7357 arg = fold_convert_loc (loc, type, arg); 7358 return fold_build1_loc (loc, ABS_EXPR, type, arg); 7359 } 7360 7361 /* Fold a call to abs, labs, llabs or imaxabs with argument ARG. */ 7362 7363 static tree 7364 fold_builtin_abs (location_t loc, tree arg, tree type) 7365 { 7366 if (!validate_arg (arg, INTEGER_TYPE)) 7367 return NULL_TREE; 7368 7369 arg = fold_convert_loc (loc, type, arg); 7370 return fold_build1_loc (loc, ABS_EXPR, type, arg); 7371 } 7372 7373 /* Fold a call to fma, fmaf, or fmal with arguments ARG[012]. */ 7374 7375 static tree 7376 fold_builtin_fma (location_t loc, tree arg0, tree arg1, tree arg2, tree type) 7377 { 7378 /* ??? Only expand to FMA_EXPR if it's directly supported. */ 7379 if (validate_arg (arg0, REAL_TYPE) 7380 && validate_arg (arg1, REAL_TYPE) 7381 && validate_arg (arg2, REAL_TYPE) 7382 && optab_handler (fma_optab, TYPE_MODE (type)) != CODE_FOR_nothing) 7383 return fold_build3_loc (loc, FMA_EXPR, type, arg0, arg1, arg2); 7384 7385 return NULL_TREE; 7386 } 7387 7388 /* Fold a call to builtin carg(a+bi) -> atan2(b,a). */ 7389 7390 static tree 7391 fold_builtin_carg (location_t loc, tree arg, tree type) 7392 { 7393 if (validate_arg (arg, COMPLEX_TYPE) 7394 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE) 7395 { 7396 tree atan2_fn = mathfn_built_in (type, BUILT_IN_ATAN2); 7397 7398 if (atan2_fn) 7399 { 7400 tree new_arg = builtin_save_expr (arg); 7401 tree r_arg = fold_build1_loc (loc, REALPART_EXPR, type, new_arg); 7402 tree i_arg = fold_build1_loc (loc, IMAGPART_EXPR, type, new_arg); 7403 return build_call_expr_loc (loc, atan2_fn, 2, i_arg, r_arg); 7404 } 7405 } 7406 7407 return NULL_TREE; 7408 } 7409 7410 /* Fold a call to builtin frexp, we can assume the base is 2. */ 7411 7412 static tree 7413 fold_builtin_frexp (location_t loc, tree arg0, tree arg1, tree rettype) 7414 { 7415 if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE)) 7416 return NULL_TREE; 7417 7418 STRIP_NOPS (arg0); 7419 7420 if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0))) 7421 return NULL_TREE; 7422 7423 arg1 = build_fold_indirect_ref_loc (loc, arg1); 7424 7425 /* Proceed if a valid pointer type was passed in. */ 7426 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == integer_type_node) 7427 { 7428 const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0); 7429 tree frac, exp; 7430 7431 switch (value->cl) 7432 { 7433 case rvc_zero: 7434 /* For +-0, return (*exp = 0, +-0). */ 7435 exp = integer_zero_node; 7436 frac = arg0; 7437 break; 7438 case rvc_nan: 7439 case rvc_inf: 7440 /* For +-NaN or +-Inf, *exp is unspecified, return arg0. */ 7441 return omit_one_operand_loc (loc, rettype, arg0, arg1); 7442 case rvc_normal: 7443 { 7444 /* Since the frexp function always expects base 2, and in 7445 GCC normalized significands are already in the range 7446 [0.5, 1.0), we have exactly what frexp wants. */ 7447 REAL_VALUE_TYPE frac_rvt = *value; 7448 SET_REAL_EXP (&frac_rvt, 0); 7449 frac = build_real (rettype, frac_rvt); 7450 exp = build_int_cst (integer_type_node, REAL_EXP (value)); 7451 } 7452 break; 7453 default: 7454 gcc_unreachable (); 7455 } 7456 7457 /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */ 7458 arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1, exp); 7459 TREE_SIDE_EFFECTS (arg1) = 1; 7460 return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1, frac); 7461 } 7462 7463 return NULL_TREE; 7464 } 7465 7466 /* Fold a call to builtin modf. */ 7467 7468 static tree 7469 fold_builtin_modf (location_t loc, tree arg0, tree arg1, tree rettype) 7470 { 7471 if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE)) 7472 return NULL_TREE; 7473 7474 STRIP_NOPS (arg0); 7475 7476 if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0))) 7477 return NULL_TREE; 7478 7479 arg1 = build_fold_indirect_ref_loc (loc, arg1); 7480 7481 /* Proceed if a valid pointer type was passed in. */ 7482 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == TYPE_MAIN_VARIANT (rettype)) 7483 { 7484 const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0); 7485 REAL_VALUE_TYPE trunc, frac; 7486 7487 switch (value->cl) 7488 { 7489 case rvc_nan: 7490 case rvc_zero: 7491 /* For +-NaN or +-0, return (*arg1 = arg0, arg0). */ 7492 trunc = frac = *value; 7493 break; 7494 case rvc_inf: 7495 /* For +-Inf, return (*arg1 = arg0, +-0). */ 7496 frac = dconst0; 7497 frac.sign = value->sign; 7498 trunc = *value; 7499 break; 7500 case rvc_normal: 7501 /* Return (*arg1 = trunc(arg0), arg0-trunc(arg0)). */ 7502 real_trunc (&trunc, VOIDmode, value); 7503 real_arithmetic (&frac, MINUS_EXPR, value, &trunc); 7504 /* If the original number was negative and already 7505 integral, then the fractional part is -0.0. */ 7506 if (value->sign && frac.cl == rvc_zero) 7507 frac.sign = value->sign; 7508 break; 7509 } 7510 7511 /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */ 7512 arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1, 7513 build_real (rettype, trunc)); 7514 TREE_SIDE_EFFECTS (arg1) = 1; 7515 return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1, 7516 build_real (rettype, frac)); 7517 } 7518 7519 return NULL_TREE; 7520 } 7521 7522 /* Given a location LOC, an interclass builtin function decl FNDECL 7523 and its single argument ARG, return an folded expression computing 7524 the same, or NULL_TREE if we either couldn't or didn't want to fold 7525 (the latter happen if there's an RTL instruction available). */ 7526 7527 static tree 7528 fold_builtin_interclass_mathfn (location_t loc, tree fndecl, tree arg) 7529 { 7530 machine_mode mode; 7531 7532 if (!validate_arg (arg, REAL_TYPE)) 7533 return NULL_TREE; 7534 7535 if (interclass_mathfn_icode (arg, fndecl) != CODE_FOR_nothing) 7536 return NULL_TREE; 7537 7538 mode = TYPE_MODE (TREE_TYPE (arg)); 7539 7540 bool is_ibm_extended = MODE_COMPOSITE_P (mode); 7541 7542 /* If there is no optab, try generic code. */ 7543 switch (DECL_FUNCTION_CODE (fndecl)) 7544 { 7545 tree result; 7546 7547 CASE_FLT_FN (BUILT_IN_ISINF): 7548 { 7549 /* isinf(x) -> isgreater(fabs(x),DBL_MAX). */ 7550 tree const isgr_fn = builtin_decl_explicit (BUILT_IN_ISGREATER); 7551 tree type = TREE_TYPE (arg); 7552 REAL_VALUE_TYPE r; 7553 char buf[128]; 7554 7555 if (is_ibm_extended) 7556 { 7557 /* NaN and Inf are encoded in the high-order double value 7558 only. The low-order value is not significant. */ 7559 type = double_type_node; 7560 mode = DFmode; 7561 arg = fold_build1_loc (loc, NOP_EXPR, type, arg); 7562 } 7563 get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf)); 7564 real_from_string (&r, buf); 7565 result = build_call_expr (isgr_fn, 2, 7566 fold_build1_loc (loc, ABS_EXPR, type, arg), 7567 build_real (type, r)); 7568 return result; 7569 } 7570 CASE_FLT_FN (BUILT_IN_FINITE): 7571 case BUILT_IN_ISFINITE: 7572 { 7573 /* isfinite(x) -> islessequal(fabs(x),DBL_MAX). */ 7574 tree const isle_fn = builtin_decl_explicit (BUILT_IN_ISLESSEQUAL); 7575 tree type = TREE_TYPE (arg); 7576 REAL_VALUE_TYPE r; 7577 char buf[128]; 7578 7579 if (is_ibm_extended) 7580 { 7581 /* NaN and Inf are encoded in the high-order double value 7582 only. The low-order value is not significant. */ 7583 type = double_type_node; 7584 mode = DFmode; 7585 arg = fold_build1_loc (loc, NOP_EXPR, type, arg); 7586 } 7587 get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf)); 7588 real_from_string (&r, buf); 7589 result = build_call_expr (isle_fn, 2, 7590 fold_build1_loc (loc, ABS_EXPR, type, arg), 7591 build_real (type, r)); 7592 /*result = fold_build2_loc (loc, UNGT_EXPR, 7593 TREE_TYPE (TREE_TYPE (fndecl)), 7594 fold_build1_loc (loc, ABS_EXPR, type, arg), 7595 build_real (type, r)); 7596 result = fold_build1_loc (loc, TRUTH_NOT_EXPR, 7597 TREE_TYPE (TREE_TYPE (fndecl)), 7598 result);*/ 7599 return result; 7600 } 7601 case BUILT_IN_ISNORMAL: 7602 { 7603 /* isnormal(x) -> isgreaterequal(fabs(x),DBL_MIN) & 7604 islessequal(fabs(x),DBL_MAX). */ 7605 tree const isle_fn = builtin_decl_explicit (BUILT_IN_ISLESSEQUAL); 7606 tree type = TREE_TYPE (arg); 7607 tree orig_arg, max_exp, min_exp; 7608 machine_mode orig_mode = mode; 7609 REAL_VALUE_TYPE rmax, rmin; 7610 char buf[128]; 7611 7612 orig_arg = arg = builtin_save_expr (arg); 7613 if (is_ibm_extended) 7614 { 7615 /* Use double to test the normal range of IBM extended 7616 precision. Emin for IBM extended precision is 7617 different to emin for IEEE double, being 53 higher 7618 since the low double exponent is at least 53 lower 7619 than the high double exponent. */ 7620 type = double_type_node; 7621 mode = DFmode; 7622 arg = fold_build1_loc (loc, NOP_EXPR, type, arg); 7623 } 7624 arg = fold_build1_loc (loc, ABS_EXPR, type, arg); 7625 7626 get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf)); 7627 real_from_string (&rmax, buf); 7628 sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (orig_mode)->emin - 1); 7629 real_from_string (&rmin, buf); 7630 max_exp = build_real (type, rmax); 7631 min_exp = build_real (type, rmin); 7632 7633 max_exp = build_call_expr (isle_fn, 2, arg, max_exp); 7634 if (is_ibm_extended) 7635 { 7636 /* Testing the high end of the range is done just using 7637 the high double, using the same test as isfinite(). 7638 For the subnormal end of the range we first test the 7639 high double, then if its magnitude is equal to the 7640 limit of 0x1p-969, we test whether the low double is 7641 non-zero and opposite sign to the high double. */ 7642 tree const islt_fn = builtin_decl_explicit (BUILT_IN_ISLESS); 7643 tree const isgt_fn = builtin_decl_explicit (BUILT_IN_ISGREATER); 7644 tree gt_min = build_call_expr (isgt_fn, 2, arg, min_exp); 7645 tree eq_min = fold_build2 (EQ_EXPR, integer_type_node, 7646 arg, min_exp); 7647 tree as_complex = build1 (VIEW_CONVERT_EXPR, 7648 complex_double_type_node, orig_arg); 7649 tree hi_dbl = build1 (REALPART_EXPR, type, as_complex); 7650 tree lo_dbl = build1 (IMAGPART_EXPR, type, as_complex); 7651 tree zero = build_real (type, dconst0); 7652 tree hilt = build_call_expr (islt_fn, 2, hi_dbl, zero); 7653 tree lolt = build_call_expr (islt_fn, 2, lo_dbl, zero); 7654 tree logt = build_call_expr (isgt_fn, 2, lo_dbl, zero); 7655 tree ok_lo = fold_build1 (TRUTH_NOT_EXPR, integer_type_node, 7656 fold_build3 (COND_EXPR, 7657 integer_type_node, 7658 hilt, logt, lolt)); 7659 eq_min = fold_build2 (TRUTH_ANDIF_EXPR, integer_type_node, 7660 eq_min, ok_lo); 7661 min_exp = fold_build2 (TRUTH_ORIF_EXPR, integer_type_node, 7662 gt_min, eq_min); 7663 } 7664 else 7665 { 7666 tree const isge_fn 7667 = builtin_decl_explicit (BUILT_IN_ISGREATEREQUAL); 7668 min_exp = build_call_expr (isge_fn, 2, arg, min_exp); 7669 } 7670 result = fold_build2 (BIT_AND_EXPR, integer_type_node, 7671 max_exp, min_exp); 7672 return result; 7673 } 7674 default: 7675 break; 7676 } 7677 7678 return NULL_TREE; 7679 } 7680 7681 /* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite. 7682 ARG is the argument for the call. */ 7683 7684 static tree 7685 fold_builtin_classify (location_t loc, tree fndecl, tree arg, int builtin_index) 7686 { 7687 tree type = TREE_TYPE (TREE_TYPE (fndecl)); 7688 7689 if (!validate_arg (arg, REAL_TYPE)) 7690 return NULL_TREE; 7691 7692 switch (builtin_index) 7693 { 7694 case BUILT_IN_ISINF: 7695 if (!HONOR_INFINITIES (arg)) 7696 return omit_one_operand_loc (loc, type, integer_zero_node, arg); 7697 7698 return NULL_TREE; 7699 7700 case BUILT_IN_ISINF_SIGN: 7701 { 7702 /* isinf_sign(x) -> isinf(x) ? (signbit(x) ? -1 : 1) : 0 */ 7703 /* In a boolean context, GCC will fold the inner COND_EXPR to 7704 1. So e.g. "if (isinf_sign(x))" would be folded to just 7705 "if (isinf(x) ? 1 : 0)" which becomes "if (isinf(x))". */ 7706 tree signbit_fn = mathfn_built_in_1 7707 (TREE_TYPE (arg), CFN_BUILT_IN_SIGNBIT, 0); 7708 tree isinf_fn = builtin_decl_explicit (BUILT_IN_ISINF); 7709 tree tmp = NULL_TREE; 7710 7711 arg = builtin_save_expr (arg); 7712 7713 if (signbit_fn && isinf_fn) 7714 { 7715 tree signbit_call = build_call_expr_loc (loc, signbit_fn, 1, arg); 7716 tree isinf_call = build_call_expr_loc (loc, isinf_fn, 1, arg); 7717 7718 signbit_call = fold_build2_loc (loc, NE_EXPR, integer_type_node, 7719 signbit_call, integer_zero_node); 7720 isinf_call = fold_build2_loc (loc, NE_EXPR, integer_type_node, 7721 isinf_call, integer_zero_node); 7722 7723 tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node, signbit_call, 7724 integer_minus_one_node, integer_one_node); 7725 tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node, 7726 isinf_call, tmp, 7727 integer_zero_node); 7728 } 7729 7730 return tmp; 7731 } 7732 7733 case BUILT_IN_ISFINITE: 7734 if (!HONOR_NANS (arg) 7735 && !HONOR_INFINITIES (arg)) 7736 return omit_one_operand_loc (loc, type, integer_one_node, arg); 7737 7738 return NULL_TREE; 7739 7740 case BUILT_IN_ISNAN: 7741 if (!HONOR_NANS (arg)) 7742 return omit_one_operand_loc (loc, type, integer_zero_node, arg); 7743 7744 { 7745 bool is_ibm_extended = MODE_COMPOSITE_P (TYPE_MODE (TREE_TYPE (arg))); 7746 if (is_ibm_extended) 7747 { 7748 /* NaN and Inf are encoded in the high-order double value 7749 only. The low-order value is not significant. */ 7750 arg = fold_build1_loc (loc, NOP_EXPR, double_type_node, arg); 7751 } 7752 } 7753 arg = builtin_save_expr (arg); 7754 return fold_build2_loc (loc, UNORDERED_EXPR, type, arg, arg); 7755 7756 default: 7757 gcc_unreachable (); 7758 } 7759 } 7760 7761 /* Fold a call to __builtin_fpclassify(int, int, int, int, int, ...). 7762 This builtin will generate code to return the appropriate floating 7763 point classification depending on the value of the floating point 7764 number passed in. The possible return values must be supplied as 7765 int arguments to the call in the following order: FP_NAN, FP_INFINITE, 7766 FP_NORMAL, FP_SUBNORMAL and FP_ZERO. The ellipses is for exactly 7767 one floating point argument which is "type generic". */ 7768 7769 static tree 7770 fold_builtin_fpclassify (location_t loc, tree *args, int nargs) 7771 { 7772 tree fp_nan, fp_infinite, fp_normal, fp_subnormal, fp_zero, 7773 arg, type, res, tmp; 7774 machine_mode mode; 7775 REAL_VALUE_TYPE r; 7776 char buf[128]; 7777 7778 /* Verify the required arguments in the original call. */ 7779 if (nargs != 6 7780 || !validate_arg (args[0], INTEGER_TYPE) 7781 || !validate_arg (args[1], INTEGER_TYPE) 7782 || !validate_arg (args[2], INTEGER_TYPE) 7783 || !validate_arg (args[3], INTEGER_TYPE) 7784 || !validate_arg (args[4], INTEGER_TYPE) 7785 || !validate_arg (args[5], REAL_TYPE)) 7786 return NULL_TREE; 7787 7788 fp_nan = args[0]; 7789 fp_infinite = args[1]; 7790 fp_normal = args[2]; 7791 fp_subnormal = args[3]; 7792 fp_zero = args[4]; 7793 arg = args[5]; 7794 type = TREE_TYPE (arg); 7795 mode = TYPE_MODE (type); 7796 arg = builtin_save_expr (fold_build1_loc (loc, ABS_EXPR, type, arg)); 7797 7798 /* fpclassify(x) -> 7799 isnan(x) ? FP_NAN : 7800 (fabs(x) == Inf ? FP_INFINITE : 7801 (fabs(x) >= DBL_MIN ? FP_NORMAL : 7802 (x == 0 ? FP_ZERO : FP_SUBNORMAL))). */ 7803 7804 tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg, 7805 build_real (type, dconst0)); 7806 res = fold_build3_loc (loc, COND_EXPR, integer_type_node, 7807 tmp, fp_zero, fp_subnormal); 7808 7809 sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1); 7810 real_from_string (&r, buf); 7811 tmp = fold_build2_loc (loc, GE_EXPR, integer_type_node, 7812 arg, build_real (type, r)); 7813 res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, fp_normal, res); 7814 7815 if (HONOR_INFINITIES (mode)) 7816 { 7817 real_inf (&r); 7818 tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg, 7819 build_real (type, r)); 7820 res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, 7821 fp_infinite, res); 7822 } 7823 7824 if (HONOR_NANS (mode)) 7825 { 7826 tmp = fold_build2_loc (loc, ORDERED_EXPR, integer_type_node, arg, arg); 7827 res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, res, fp_nan); 7828 } 7829 7830 return res; 7831 } 7832 7833 /* Fold a call to an unordered comparison function such as 7834 __builtin_isgreater(). FNDECL is the FUNCTION_DECL for the function 7835 being called and ARG0 and ARG1 are the arguments for the call. 7836 UNORDERED_CODE and ORDERED_CODE are comparison codes that give 7837 the opposite of the desired result. UNORDERED_CODE is used 7838 for modes that can hold NaNs and ORDERED_CODE is used for 7839 the rest. */ 7840 7841 static tree 7842 fold_builtin_unordered_cmp (location_t loc, tree fndecl, tree arg0, tree arg1, 7843 enum tree_code unordered_code, 7844 enum tree_code ordered_code) 7845 { 7846 tree type = TREE_TYPE (TREE_TYPE (fndecl)); 7847 enum tree_code code; 7848 tree type0, type1; 7849 enum tree_code code0, code1; 7850 tree cmp_type = NULL_TREE; 7851 7852 type0 = TREE_TYPE (arg0); 7853 type1 = TREE_TYPE (arg1); 7854 7855 code0 = TREE_CODE (type0); 7856 code1 = TREE_CODE (type1); 7857 7858 if (code0 == REAL_TYPE && code1 == REAL_TYPE) 7859 /* Choose the wider of two real types. */ 7860 cmp_type = TYPE_PRECISION (type0) >= TYPE_PRECISION (type1) 7861 ? type0 : type1; 7862 else if (code0 == REAL_TYPE && code1 == INTEGER_TYPE) 7863 cmp_type = type0; 7864 else if (code0 == INTEGER_TYPE && code1 == REAL_TYPE) 7865 cmp_type = type1; 7866 7867 arg0 = fold_convert_loc (loc, cmp_type, arg0); 7868 arg1 = fold_convert_loc (loc, cmp_type, arg1); 7869 7870 if (unordered_code == UNORDERED_EXPR) 7871 { 7872 if (!HONOR_NANS (arg0)) 7873 return omit_two_operands_loc (loc, type, integer_zero_node, arg0, arg1); 7874 return fold_build2_loc (loc, UNORDERED_EXPR, type, arg0, arg1); 7875 } 7876 7877 code = HONOR_NANS (arg0) ? unordered_code : ordered_code; 7878 return fold_build1_loc (loc, TRUTH_NOT_EXPR, type, 7879 fold_build2_loc (loc, code, type, arg0, arg1)); 7880 } 7881 7882 /* Fold __builtin_{,s,u}{add,sub,mul}{,l,ll}_overflow, either into normal 7883 arithmetics if it can never overflow, or into internal functions that 7884 return both result of arithmetics and overflowed boolean flag in 7885 a complex integer result, or some other check for overflow. */ 7886 7887 static tree 7888 fold_builtin_arith_overflow (location_t loc, enum built_in_function fcode, 7889 tree arg0, tree arg1, tree arg2) 7890 { 7891 enum internal_fn ifn = IFN_LAST; 7892 tree type = TREE_TYPE (TREE_TYPE (arg2)); 7893 tree mem_arg2 = build_fold_indirect_ref_loc (loc, arg2); 7894 switch (fcode) 7895 { 7896 case BUILT_IN_ADD_OVERFLOW: 7897 case BUILT_IN_SADD_OVERFLOW: 7898 case BUILT_IN_SADDL_OVERFLOW: 7899 case BUILT_IN_SADDLL_OVERFLOW: 7900 case BUILT_IN_UADD_OVERFLOW: 7901 case BUILT_IN_UADDL_OVERFLOW: 7902 case BUILT_IN_UADDLL_OVERFLOW: 7903 ifn = IFN_ADD_OVERFLOW; 7904 break; 7905 case BUILT_IN_SUB_OVERFLOW: 7906 case BUILT_IN_SSUB_OVERFLOW: 7907 case BUILT_IN_SSUBL_OVERFLOW: 7908 case BUILT_IN_SSUBLL_OVERFLOW: 7909 case BUILT_IN_USUB_OVERFLOW: 7910 case BUILT_IN_USUBL_OVERFLOW: 7911 case BUILT_IN_USUBLL_OVERFLOW: 7912 ifn = IFN_SUB_OVERFLOW; 7913 break; 7914 case BUILT_IN_MUL_OVERFLOW: 7915 case BUILT_IN_SMUL_OVERFLOW: 7916 case BUILT_IN_SMULL_OVERFLOW: 7917 case BUILT_IN_SMULLL_OVERFLOW: 7918 case BUILT_IN_UMUL_OVERFLOW: 7919 case BUILT_IN_UMULL_OVERFLOW: 7920 case BUILT_IN_UMULLL_OVERFLOW: 7921 ifn = IFN_MUL_OVERFLOW; 7922 break; 7923 default: 7924 gcc_unreachable (); 7925 } 7926 tree ctype = build_complex_type (type); 7927 tree call = build_call_expr_internal_loc (loc, ifn, ctype, 7928 2, arg0, arg1); 7929 tree tgt = save_expr (call); 7930 tree intres = build1_loc (loc, REALPART_EXPR, type, tgt); 7931 tree ovfres = build1_loc (loc, IMAGPART_EXPR, type, tgt); 7932 ovfres = fold_convert_loc (loc, boolean_type_node, ovfres); 7933 tree store 7934 = fold_build2_loc (loc, MODIFY_EXPR, void_type_node, mem_arg2, intres); 7935 return build2_loc (loc, COMPOUND_EXPR, boolean_type_node, store, ovfres); 7936 } 7937 7938 /* Fold a call to built-in function FNDECL with 0 arguments. 7939 This function returns NULL_TREE if no simplification was possible. */ 7940 7941 static tree 7942 fold_builtin_0 (location_t loc, tree fndecl) 7943 { 7944 tree type = TREE_TYPE (TREE_TYPE (fndecl)); 7945 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl); 7946 switch (fcode) 7947 { 7948 CASE_FLT_FN (BUILT_IN_INF): 7949 case BUILT_IN_INFD32: 7950 case BUILT_IN_INFD64: 7951 case BUILT_IN_INFD128: 7952 return fold_builtin_inf (loc, type, true); 7953 7954 CASE_FLT_FN (BUILT_IN_HUGE_VAL): 7955 return fold_builtin_inf (loc, type, false); 7956 7957 case BUILT_IN_CLASSIFY_TYPE: 7958 return fold_builtin_classify_type (NULL_TREE); 7959 7960 default: 7961 break; 7962 } 7963 return NULL_TREE; 7964 } 7965 7966 /* Fold a call to built-in function FNDECL with 1 argument, ARG0. 7967 This function returns NULL_TREE if no simplification was possible. */ 7968 7969 static tree 7970 fold_builtin_1 (location_t loc, tree fndecl, tree arg0) 7971 { 7972 tree type = TREE_TYPE (TREE_TYPE (fndecl)); 7973 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl); 7974 7975 if (TREE_CODE (arg0) == ERROR_MARK) 7976 return NULL_TREE; 7977 7978 if (tree ret = fold_const_call (as_combined_fn (fcode), type, arg0)) 7979 return ret; 7980 7981 switch (fcode) 7982 { 7983 case BUILT_IN_CONSTANT_P: 7984 { 7985 tree val = fold_builtin_constant_p (arg0); 7986 7987 /* Gimplification will pull the CALL_EXPR for the builtin out of 7988 an if condition. When not optimizing, we'll not CSE it back. 7989 To avoid link error types of regressions, return false now. */ 7990 if (!val && !optimize) 7991 val = integer_zero_node; 7992 7993 return val; 7994 } 7995 7996 case BUILT_IN_CLASSIFY_TYPE: 7997 return fold_builtin_classify_type (arg0); 7998 7999 case BUILT_IN_STRLEN: 8000 return fold_builtin_strlen (loc, type, arg0); 8001 8002 CASE_FLT_FN (BUILT_IN_FABS): 8003 case BUILT_IN_FABSD32: 8004 case BUILT_IN_FABSD64: 8005 case BUILT_IN_FABSD128: 8006 return fold_builtin_fabs (loc, arg0, type); 8007 8008 case BUILT_IN_ABS: 8009 case BUILT_IN_LABS: 8010 case BUILT_IN_LLABS: 8011 case BUILT_IN_IMAXABS: 8012 return fold_builtin_abs (loc, arg0, type); 8013 8014 CASE_FLT_FN (BUILT_IN_CONJ): 8015 if (validate_arg (arg0, COMPLEX_TYPE) 8016 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE) 8017 return fold_build1_loc (loc, CONJ_EXPR, type, arg0); 8018 break; 8019 8020 CASE_FLT_FN (BUILT_IN_CREAL): 8021 if (validate_arg (arg0, COMPLEX_TYPE) 8022 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE) 8023 return non_lvalue_loc (loc, fold_build1_loc (loc, REALPART_EXPR, type, arg0)); 8024 break; 8025 8026 CASE_FLT_FN (BUILT_IN_CIMAG): 8027 if (validate_arg (arg0, COMPLEX_TYPE) 8028 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE) 8029 return non_lvalue_loc (loc, fold_build1_loc (loc, IMAGPART_EXPR, type, arg0)); 8030 break; 8031 8032 CASE_FLT_FN (BUILT_IN_CARG): 8033 return fold_builtin_carg (loc, arg0, type); 8034 8035 case BUILT_IN_ISASCII: 8036 return fold_builtin_isascii (loc, arg0); 8037 8038 case BUILT_IN_TOASCII: 8039 return fold_builtin_toascii (loc, arg0); 8040 8041 case BUILT_IN_ISDIGIT: 8042 return fold_builtin_isdigit (loc, arg0); 8043 8044 CASE_FLT_FN (BUILT_IN_FINITE): 8045 case BUILT_IN_FINITED32: 8046 case BUILT_IN_FINITED64: 8047 case BUILT_IN_FINITED128: 8048 case BUILT_IN_ISFINITE: 8049 { 8050 tree ret = fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISFINITE); 8051 if (ret) 8052 return ret; 8053 return fold_builtin_interclass_mathfn (loc, fndecl, arg0); 8054 } 8055 8056 CASE_FLT_FN (BUILT_IN_ISINF): 8057 case BUILT_IN_ISINFD32: 8058 case BUILT_IN_ISINFD64: 8059 case BUILT_IN_ISINFD128: 8060 { 8061 tree ret = fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF); 8062 if (ret) 8063 return ret; 8064 return fold_builtin_interclass_mathfn (loc, fndecl, arg0); 8065 } 8066 8067 case BUILT_IN_ISNORMAL: 8068 return fold_builtin_interclass_mathfn (loc, fndecl, arg0); 8069 8070 case BUILT_IN_ISINF_SIGN: 8071 return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF_SIGN); 8072 8073 CASE_FLT_FN (BUILT_IN_ISNAN): 8074 case BUILT_IN_ISNAND32: 8075 case BUILT_IN_ISNAND64: 8076 case BUILT_IN_ISNAND128: 8077 return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISNAN); 8078 8079 case BUILT_IN_FREE: 8080 if (integer_zerop (arg0)) 8081 return build_empty_stmt (loc); 8082 break; 8083 8084 default: 8085 break; 8086 } 8087 8088 return NULL_TREE; 8089 8090 } 8091 8092 /* Fold a call to built-in function FNDECL with 2 arguments, ARG0 and ARG1. 8093 This function returns NULL_TREE if no simplification was possible. */ 8094 8095 static tree 8096 fold_builtin_2 (location_t loc, tree fndecl, tree arg0, tree arg1) 8097 { 8098 tree type = TREE_TYPE (TREE_TYPE (fndecl)); 8099 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl); 8100 8101 if (TREE_CODE (arg0) == ERROR_MARK 8102 || TREE_CODE (arg1) == ERROR_MARK) 8103 return NULL_TREE; 8104 8105 if (tree ret = fold_const_call (as_combined_fn (fcode), type, arg0, arg1)) 8106 return ret; 8107 8108 switch (fcode) 8109 { 8110 CASE_FLT_FN_REENT (BUILT_IN_GAMMA): /* GAMMA_R */ 8111 CASE_FLT_FN_REENT (BUILT_IN_LGAMMA): /* LGAMMA_R */ 8112 if (validate_arg (arg0, REAL_TYPE) 8113 && validate_arg (arg1, POINTER_TYPE)) 8114 return do_mpfr_lgamma_r (arg0, arg1, type); 8115 break; 8116 8117 CASE_FLT_FN (BUILT_IN_FREXP): 8118 return fold_builtin_frexp (loc, arg0, arg1, type); 8119 8120 CASE_FLT_FN (BUILT_IN_MODF): 8121 return fold_builtin_modf (loc, arg0, arg1, type); 8122 8123 case BUILT_IN_STRSTR: 8124 return fold_builtin_strstr (loc, arg0, arg1, type); 8125 8126 case BUILT_IN_STRSPN: 8127 return fold_builtin_strspn (loc, arg0, arg1); 8128 8129 case BUILT_IN_STRCSPN: 8130 return fold_builtin_strcspn (loc, arg0, arg1); 8131 8132 case BUILT_IN_STRCHR: 8133 case BUILT_IN_INDEX: 8134 return fold_builtin_strchr (loc, arg0, arg1, type); 8135 8136 case BUILT_IN_STRRCHR: 8137 case BUILT_IN_RINDEX: 8138 return fold_builtin_strrchr (loc, arg0, arg1, type); 8139 8140 case BUILT_IN_STRCMP: 8141 return fold_builtin_strcmp (loc, arg0, arg1); 8142 8143 case BUILT_IN_STRPBRK: 8144 return fold_builtin_strpbrk (loc, arg0, arg1, type); 8145 8146 case BUILT_IN_EXPECT: 8147 return fold_builtin_expect (loc, arg0, arg1, NULL_TREE); 8148 8149 case BUILT_IN_ISGREATER: 8150 return fold_builtin_unordered_cmp (loc, fndecl, 8151 arg0, arg1, UNLE_EXPR, LE_EXPR); 8152 case BUILT_IN_ISGREATEREQUAL: 8153 return fold_builtin_unordered_cmp (loc, fndecl, 8154 arg0, arg1, UNLT_EXPR, LT_EXPR); 8155 case BUILT_IN_ISLESS: 8156 return fold_builtin_unordered_cmp (loc, fndecl, 8157 arg0, arg1, UNGE_EXPR, GE_EXPR); 8158 case BUILT_IN_ISLESSEQUAL: 8159 return fold_builtin_unordered_cmp (loc, fndecl, 8160 arg0, arg1, UNGT_EXPR, GT_EXPR); 8161 case BUILT_IN_ISLESSGREATER: 8162 return fold_builtin_unordered_cmp (loc, fndecl, 8163 arg0, arg1, UNEQ_EXPR, EQ_EXPR); 8164 case BUILT_IN_ISUNORDERED: 8165 return fold_builtin_unordered_cmp (loc, fndecl, 8166 arg0, arg1, UNORDERED_EXPR, 8167 NOP_EXPR); 8168 8169 /* We do the folding for va_start in the expander. */ 8170 case BUILT_IN_VA_START: 8171 break; 8172 8173 case BUILT_IN_OBJECT_SIZE: 8174 return fold_builtin_object_size (arg0, arg1); 8175 8176 case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE: 8177 return fold_builtin_atomic_always_lock_free (arg0, arg1); 8178 8179 case BUILT_IN_ATOMIC_IS_LOCK_FREE: 8180 return fold_builtin_atomic_is_lock_free (arg0, arg1); 8181 8182 default: 8183 break; 8184 } 8185 return NULL_TREE; 8186 } 8187 8188 /* Fold a call to built-in function FNDECL with 3 arguments, ARG0, ARG1, 8189 and ARG2. 8190 This function returns NULL_TREE if no simplification was possible. */ 8191 8192 static tree 8193 fold_builtin_3 (location_t loc, tree fndecl, 8194 tree arg0, tree arg1, tree arg2) 8195 { 8196 tree type = TREE_TYPE (TREE_TYPE (fndecl)); 8197 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl); 8198 8199 if (TREE_CODE (arg0) == ERROR_MARK 8200 || TREE_CODE (arg1) == ERROR_MARK 8201 || TREE_CODE (arg2) == ERROR_MARK) 8202 return NULL_TREE; 8203 8204 if (tree ret = fold_const_call (as_combined_fn (fcode), type, 8205 arg0, arg1, arg2)) 8206 return ret; 8207 8208 switch (fcode) 8209 { 8210 8211 CASE_FLT_FN (BUILT_IN_SINCOS): 8212 return fold_builtin_sincos (loc, arg0, arg1, arg2); 8213 8214 CASE_FLT_FN (BUILT_IN_FMA): 8215 return fold_builtin_fma (loc, arg0, arg1, arg2, type); 8216 8217 CASE_FLT_FN (BUILT_IN_REMQUO): 8218 if (validate_arg (arg0, REAL_TYPE) 8219 && validate_arg (arg1, REAL_TYPE) 8220 && validate_arg (arg2, POINTER_TYPE)) 8221 return do_mpfr_remquo (arg0, arg1, arg2); 8222 break; 8223 8224 case BUILT_IN_STRNCMP: 8225 return fold_builtin_strncmp (loc, arg0, arg1, arg2); 8226 8227 case BUILT_IN_MEMCHR: 8228 return fold_builtin_memchr (loc, arg0, arg1, arg2, type); 8229 8230 case BUILT_IN_BCMP: 8231 case BUILT_IN_MEMCMP: 8232 return fold_builtin_memcmp (loc, arg0, arg1, arg2);; 8233 8234 case BUILT_IN_EXPECT: 8235 return fold_builtin_expect (loc, arg0, arg1, arg2); 8236 8237 case BUILT_IN_ADD_OVERFLOW: 8238 case BUILT_IN_SUB_OVERFLOW: 8239 case BUILT_IN_MUL_OVERFLOW: 8240 case BUILT_IN_SADD_OVERFLOW: 8241 case BUILT_IN_SADDL_OVERFLOW: 8242 case BUILT_IN_SADDLL_OVERFLOW: 8243 case BUILT_IN_SSUB_OVERFLOW: 8244 case BUILT_IN_SSUBL_OVERFLOW: 8245 case BUILT_IN_SSUBLL_OVERFLOW: 8246 case BUILT_IN_SMUL_OVERFLOW: 8247 case BUILT_IN_SMULL_OVERFLOW: 8248 case BUILT_IN_SMULLL_OVERFLOW: 8249 case BUILT_IN_UADD_OVERFLOW: 8250 case BUILT_IN_UADDL_OVERFLOW: 8251 case BUILT_IN_UADDLL_OVERFLOW: 8252 case BUILT_IN_USUB_OVERFLOW: 8253 case BUILT_IN_USUBL_OVERFLOW: 8254 case BUILT_IN_USUBLL_OVERFLOW: 8255 case BUILT_IN_UMUL_OVERFLOW: 8256 case BUILT_IN_UMULL_OVERFLOW: 8257 case BUILT_IN_UMULLL_OVERFLOW: 8258 return fold_builtin_arith_overflow (loc, fcode, arg0, arg1, arg2); 8259 8260 default: 8261 break; 8262 } 8263 return NULL_TREE; 8264 } 8265 8266 /* Fold a call to built-in function FNDECL. ARGS is an array of NARGS 8267 arguments. IGNORE is true if the result of the 8268 function call is ignored. This function returns NULL_TREE if no 8269 simplification was possible. */ 8270 8271 tree 8272 fold_builtin_n (location_t loc, tree fndecl, tree *args, int nargs, bool) 8273 { 8274 tree ret = NULL_TREE; 8275 8276 switch (nargs) 8277 { 8278 case 0: 8279 ret = fold_builtin_0 (loc, fndecl); 8280 break; 8281 case 1: 8282 ret = fold_builtin_1 (loc, fndecl, args[0]); 8283 break; 8284 case 2: 8285 ret = fold_builtin_2 (loc, fndecl, args[0], args[1]); 8286 break; 8287 case 3: 8288 ret = fold_builtin_3 (loc, fndecl, args[0], args[1], args[2]); 8289 break; 8290 default: 8291 ret = fold_builtin_varargs (loc, fndecl, args, nargs); 8292 break; 8293 } 8294 if (ret) 8295 { 8296 ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret); 8297 SET_EXPR_LOCATION (ret, loc); 8298 TREE_NO_WARNING (ret) = 1; 8299 return ret; 8300 } 8301 return NULL_TREE; 8302 } 8303 8304 /* Construct a new CALL_EXPR to FNDECL using the tail of the argument 8305 list ARGS along with N new arguments in NEWARGS. SKIP is the number 8306 of arguments in ARGS to be omitted. OLDNARGS is the number of 8307 elements in ARGS. */ 8308 8309 static tree 8310 rewrite_call_expr_valist (location_t loc, int oldnargs, tree *args, 8311 int skip, tree fndecl, int n, va_list newargs) 8312 { 8313 int nargs = oldnargs - skip + n; 8314 tree *buffer; 8315 8316 if (n > 0) 8317 { 8318 int i, j; 8319 8320 buffer = XALLOCAVEC (tree, nargs); 8321 for (i = 0; i < n; i++) 8322 buffer[i] = va_arg (newargs, tree); 8323 for (j = skip; j < oldnargs; j++, i++) 8324 buffer[i] = args[j]; 8325 } 8326 else 8327 buffer = args + skip; 8328 8329 return build_call_expr_loc_array (loc, fndecl, nargs, buffer); 8330 } 8331 8332 /* Return true if FNDECL shouldn't be folded right now. 8333 If a built-in function has an inline attribute always_inline 8334 wrapper, defer folding it after always_inline functions have 8335 been inlined, otherwise e.g. -D_FORTIFY_SOURCE checking 8336 might not be performed. */ 8337 8338 bool 8339 avoid_folding_inline_builtin (tree fndecl) 8340 { 8341 return (DECL_DECLARED_INLINE_P (fndecl) 8342 && DECL_DISREGARD_INLINE_LIMITS (fndecl) 8343 && cfun 8344 && !cfun->always_inline_functions_inlined 8345 && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fndecl))); 8346 } 8347 8348 /* A wrapper function for builtin folding that prevents warnings for 8349 "statement without effect" and the like, caused by removing the 8350 call node earlier than the warning is generated. */ 8351 8352 tree 8353 fold_call_expr (location_t loc, tree exp, bool ignore) 8354 { 8355 tree ret = NULL_TREE; 8356 tree fndecl = get_callee_fndecl (exp); 8357 if (fndecl 8358 && TREE_CODE (fndecl) == FUNCTION_DECL 8359 && DECL_BUILT_IN (fndecl) 8360 /* If CALL_EXPR_VA_ARG_PACK is set, the arguments aren't finalized 8361 yet. Defer folding until we see all the arguments 8362 (after inlining). */ 8363 && !CALL_EXPR_VA_ARG_PACK (exp)) 8364 { 8365 int nargs = call_expr_nargs (exp); 8366 8367 /* Before gimplification CALL_EXPR_VA_ARG_PACK is not set, but 8368 instead last argument is __builtin_va_arg_pack (). Defer folding 8369 even in that case, until arguments are finalized. */ 8370 if (nargs && TREE_CODE (CALL_EXPR_ARG (exp, nargs - 1)) == CALL_EXPR) 8371 { 8372 tree fndecl2 = get_callee_fndecl (CALL_EXPR_ARG (exp, nargs - 1)); 8373 if (fndecl2 8374 && TREE_CODE (fndecl2) == FUNCTION_DECL 8375 && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL 8376 && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK) 8377 return NULL_TREE; 8378 } 8379 8380 if (avoid_folding_inline_builtin (fndecl)) 8381 return NULL_TREE; 8382 8383 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD) 8384 return targetm.fold_builtin (fndecl, call_expr_nargs (exp), 8385 CALL_EXPR_ARGP (exp), ignore); 8386 else 8387 { 8388 tree *args = CALL_EXPR_ARGP (exp); 8389 ret = fold_builtin_n (loc, fndecl, args, nargs, ignore); 8390 if (ret) 8391 return ret; 8392 } 8393 } 8394 return NULL_TREE; 8395 } 8396 8397 /* Fold a CALL_EXPR with type TYPE with FN as the function expression. 8398 N arguments are passed in the array ARGARRAY. Return a folded 8399 expression or NULL_TREE if no simplification was possible. */ 8400 8401 tree 8402 fold_builtin_call_array (location_t loc, tree, 8403 tree fn, 8404 int n, 8405 tree *argarray) 8406 { 8407 if (TREE_CODE (fn) != ADDR_EXPR) 8408 return NULL_TREE; 8409 8410 tree fndecl = TREE_OPERAND (fn, 0); 8411 if (TREE_CODE (fndecl) == FUNCTION_DECL 8412 && DECL_BUILT_IN (fndecl)) 8413 { 8414 /* If last argument is __builtin_va_arg_pack (), arguments to this 8415 function are not finalized yet. Defer folding until they are. */ 8416 if (n && TREE_CODE (argarray[n - 1]) == CALL_EXPR) 8417 { 8418 tree fndecl2 = get_callee_fndecl (argarray[n - 1]); 8419 if (fndecl2 8420 && TREE_CODE (fndecl2) == FUNCTION_DECL 8421 && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL 8422 && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK) 8423 return NULL_TREE; 8424 } 8425 if (avoid_folding_inline_builtin (fndecl)) 8426 return NULL_TREE; 8427 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD) 8428 return targetm.fold_builtin (fndecl, n, argarray, false); 8429 else 8430 return fold_builtin_n (loc, fndecl, argarray, n, false); 8431 } 8432 8433 return NULL_TREE; 8434 } 8435 8436 /* Construct a new CALL_EXPR using the tail of the argument list of EXP 8437 along with N new arguments specified as the "..." parameters. SKIP 8438 is the number of arguments in EXP to be omitted. This function is used 8439 to do varargs-to-varargs transformations. */ 8440 8441 static tree 8442 rewrite_call_expr (location_t loc, tree exp, int skip, tree fndecl, int n, ...) 8443 { 8444 va_list ap; 8445 tree t; 8446 8447 va_start (ap, n); 8448 t = rewrite_call_expr_valist (loc, call_expr_nargs (exp), 8449 CALL_EXPR_ARGP (exp), skip, fndecl, n, ap); 8450 va_end (ap); 8451 8452 return t; 8453 } 8454 8455 /* Validate a single argument ARG against a tree code CODE representing 8456 a type. */ 8457 8458 static bool 8459 validate_arg (const_tree arg, enum tree_code code) 8460 { 8461 if (!arg) 8462 return false; 8463 else if (code == POINTER_TYPE) 8464 return POINTER_TYPE_P (TREE_TYPE (arg)); 8465 else if (code == INTEGER_TYPE) 8466 return INTEGRAL_TYPE_P (TREE_TYPE (arg)); 8467 return code == TREE_CODE (TREE_TYPE (arg)); 8468 } 8469 8470 /* This function validates the types of a function call argument list 8471 against a specified list of tree_codes. If the last specifier is a 0, 8472 that represents an ellipses, otherwise the last specifier must be a 8473 VOID_TYPE. 8474 8475 This is the GIMPLE version of validate_arglist. Eventually we want to 8476 completely convert builtins.c to work from GIMPLEs and the tree based 8477 validate_arglist will then be removed. */ 8478 8479 bool 8480 validate_gimple_arglist (const gcall *call, ...) 8481 { 8482 enum tree_code code; 8483 bool res = 0; 8484 va_list ap; 8485 const_tree arg; 8486 size_t i; 8487 8488 va_start (ap, call); 8489 i = 0; 8490 8491 do 8492 { 8493 code = (enum tree_code) va_arg (ap, int); 8494 switch (code) 8495 { 8496 case 0: 8497 /* This signifies an ellipses, any further arguments are all ok. */ 8498 res = true; 8499 goto end; 8500 case VOID_TYPE: 8501 /* This signifies an endlink, if no arguments remain, return 8502 true, otherwise return false. */ 8503 res = (i == gimple_call_num_args (call)); 8504 goto end; 8505 default: 8506 /* If no parameters remain or the parameter's code does not 8507 match the specified code, return false. Otherwise continue 8508 checking any remaining arguments. */ 8509 arg = gimple_call_arg (call, i++); 8510 if (!validate_arg (arg, code)) 8511 goto end; 8512 break; 8513 } 8514 } 8515 while (1); 8516 8517 /* We need gotos here since we can only have one VA_CLOSE in a 8518 function. */ 8519 end: ; 8520 va_end (ap); 8521 8522 return res; 8523 } 8524 8525 /* Default target-specific builtin expander that does nothing. */ 8526 8527 rtx 8528 default_expand_builtin (tree exp ATTRIBUTE_UNUSED, 8529 rtx target ATTRIBUTE_UNUSED, 8530 rtx subtarget ATTRIBUTE_UNUSED, 8531 machine_mode mode ATTRIBUTE_UNUSED, 8532 int ignore ATTRIBUTE_UNUSED) 8533 { 8534 return NULL_RTX; 8535 } 8536 8537 /* Returns true is EXP represents data that would potentially reside 8538 in a readonly section. */ 8539 8540 bool 8541 readonly_data_expr (tree exp) 8542 { 8543 STRIP_NOPS (exp); 8544 8545 if (TREE_CODE (exp) != ADDR_EXPR) 8546 return false; 8547 8548 exp = get_base_address (TREE_OPERAND (exp, 0)); 8549 if (!exp) 8550 return false; 8551 8552 /* Make sure we call decl_readonly_section only for trees it 8553 can handle (since it returns true for everything it doesn't 8554 understand). */ 8555 if (TREE_CODE (exp) == STRING_CST 8556 || TREE_CODE (exp) == CONSTRUCTOR 8557 || (TREE_CODE (exp) == VAR_DECL && TREE_STATIC (exp))) 8558 return decl_readonly_section (exp, 0); 8559 else 8560 return false; 8561 } 8562 8563 /* Simplify a call to the strstr builtin. S1 and S2 are the arguments 8564 to the call, and TYPE is its return type. 8565 8566 Return NULL_TREE if no simplification was possible, otherwise return the 8567 simplified form of the call as a tree. 8568 8569 The simplified form may be a constant or other expression which 8570 computes the same value, but in a more efficient manner (including 8571 calls to other builtin functions). 8572 8573 The call may contain arguments which need to be evaluated, but 8574 which are not useful to determine the result of the call. In 8575 this case we return a chain of COMPOUND_EXPRs. The LHS of each 8576 COMPOUND_EXPR will be an argument which must be evaluated. 8577 COMPOUND_EXPRs are chained through their RHS. The RHS of the last 8578 COMPOUND_EXPR in the chain will contain the tree for the simplified 8579 form of the builtin function call. */ 8580 8581 static tree 8582 fold_builtin_strstr (location_t loc, tree s1, tree s2, tree type) 8583 { 8584 if (!validate_arg (s1, POINTER_TYPE) 8585 || !validate_arg (s2, POINTER_TYPE)) 8586 return NULL_TREE; 8587 else 8588 { 8589 tree fn; 8590 const char *p1, *p2; 8591 8592 p2 = c_getstr (s2); 8593 if (p2 == NULL) 8594 return NULL_TREE; 8595 8596 p1 = c_getstr (s1); 8597 if (p1 != NULL) 8598 { 8599 const char *r = strstr (p1, p2); 8600 tree tem; 8601 8602 if (r == NULL) 8603 return build_int_cst (TREE_TYPE (s1), 0); 8604 8605 /* Return an offset into the constant string argument. */ 8606 tem = fold_build_pointer_plus_hwi_loc (loc, s1, r - p1); 8607 return fold_convert_loc (loc, type, tem); 8608 } 8609 8610 /* The argument is const char *, and the result is char *, so we need 8611 a type conversion here to avoid a warning. */ 8612 if (p2[0] == '\0') 8613 return fold_convert_loc (loc, type, s1); 8614 8615 if (p2[1] != '\0') 8616 return NULL_TREE; 8617 8618 fn = builtin_decl_implicit (BUILT_IN_STRCHR); 8619 if (!fn) 8620 return NULL_TREE; 8621 8622 /* New argument list transforming strstr(s1, s2) to 8623 strchr(s1, s2[0]). */ 8624 return build_call_expr_loc (loc, fn, 2, s1, 8625 build_int_cst (integer_type_node, p2[0])); 8626 } 8627 } 8628 8629 /* Simplify a call to the strchr builtin. S1 and S2 are the arguments to 8630 the call, and TYPE is its return type. 8631 8632 Return NULL_TREE if no simplification was possible, otherwise return the 8633 simplified form of the call as a tree. 8634 8635 The simplified form may be a constant or other expression which 8636 computes the same value, but in a more efficient manner (including 8637 calls to other builtin functions). 8638 8639 The call may contain arguments which need to be evaluated, but 8640 which are not useful to determine the result of the call. In 8641 this case we return a chain of COMPOUND_EXPRs. The LHS of each 8642 COMPOUND_EXPR will be an argument which must be evaluated. 8643 COMPOUND_EXPRs are chained through their RHS. The RHS of the last 8644 COMPOUND_EXPR in the chain will contain the tree for the simplified 8645 form of the builtin function call. */ 8646 8647 static tree 8648 fold_builtin_strchr (location_t loc, tree s1, tree s2, tree type) 8649 { 8650 if (!validate_arg (s1, POINTER_TYPE) 8651 || !validate_arg (s2, INTEGER_TYPE)) 8652 return NULL_TREE; 8653 else 8654 { 8655 const char *p1; 8656 8657 if (TREE_CODE (s2) != INTEGER_CST) 8658 return NULL_TREE; 8659 8660 p1 = c_getstr (s1); 8661 if (p1 != NULL) 8662 { 8663 char c; 8664 const char *r; 8665 tree tem; 8666 8667 if (target_char_cast (s2, &c)) 8668 return NULL_TREE; 8669 8670 r = strchr (p1, c); 8671 8672 if (r == NULL) 8673 return build_int_cst (TREE_TYPE (s1), 0); 8674 8675 /* Return an offset into the constant string argument. */ 8676 tem = fold_build_pointer_plus_hwi_loc (loc, s1, r - p1); 8677 return fold_convert_loc (loc, type, tem); 8678 } 8679 return NULL_TREE; 8680 } 8681 } 8682 8683 /* Simplify a call to the strrchr builtin. S1 and S2 are the arguments to 8684 the call, and TYPE is its return type. 8685 8686 Return NULL_TREE if no simplification was possible, otherwise return the 8687 simplified form of the call as a tree. 8688 8689 The simplified form may be a constant or other expression which 8690 computes the same value, but in a more efficient manner (including 8691 calls to other builtin functions). 8692 8693 The call may contain arguments which need to be evaluated, but 8694 which are not useful to determine the result of the call. In 8695 this case we return a chain of COMPOUND_EXPRs. The LHS of each 8696 COMPOUND_EXPR will be an argument which must be evaluated. 8697 COMPOUND_EXPRs are chained through their RHS. The RHS of the last 8698 COMPOUND_EXPR in the chain will contain the tree for the simplified 8699 form of the builtin function call. */ 8700 8701 static tree 8702 fold_builtin_strrchr (location_t loc, tree s1, tree s2, tree type) 8703 { 8704 if (!validate_arg (s1, POINTER_TYPE) 8705 || !validate_arg (s2, INTEGER_TYPE)) 8706 return NULL_TREE; 8707 else 8708 { 8709 tree fn; 8710 const char *p1; 8711 8712 if (TREE_CODE (s2) != INTEGER_CST) 8713 return NULL_TREE; 8714 8715 p1 = c_getstr (s1); 8716 if (p1 != NULL) 8717 { 8718 char c; 8719 const char *r; 8720 tree tem; 8721 8722 if (target_char_cast (s2, &c)) 8723 return NULL_TREE; 8724 8725 r = strrchr (p1, c); 8726 8727 if (r == NULL) 8728 return build_int_cst (TREE_TYPE (s1), 0); 8729 8730 /* Return an offset into the constant string argument. */ 8731 tem = fold_build_pointer_plus_hwi_loc (loc, s1, r - p1); 8732 return fold_convert_loc (loc, type, tem); 8733 } 8734 8735 if (! integer_zerop (s2)) 8736 return NULL_TREE; 8737 8738 fn = builtin_decl_implicit (BUILT_IN_STRCHR); 8739 if (!fn) 8740 return NULL_TREE; 8741 8742 /* Transform strrchr(s1, '\0') to strchr(s1, '\0'). */ 8743 return build_call_expr_loc (loc, fn, 2, s1, s2); 8744 } 8745 } 8746 8747 /* Simplify a call to the strpbrk builtin. S1 and S2 are the arguments 8748 to the call, and TYPE is its return type. 8749 8750 Return NULL_TREE if no simplification was possible, otherwise return the 8751 simplified form of the call as a tree. 8752 8753 The simplified form may be a constant or other expression which 8754 computes the same value, but in a more efficient manner (including 8755 calls to other builtin functions). 8756 8757 The call may contain arguments which need to be evaluated, but 8758 which are not useful to determine the result of the call. In 8759 this case we return a chain of COMPOUND_EXPRs. The LHS of each 8760 COMPOUND_EXPR will be an argument which must be evaluated. 8761 COMPOUND_EXPRs are chained through their RHS. The RHS of the last 8762 COMPOUND_EXPR in the chain will contain the tree for the simplified 8763 form of the builtin function call. */ 8764 8765 static tree 8766 fold_builtin_strpbrk (location_t loc, tree s1, tree s2, tree type) 8767 { 8768 if (!validate_arg (s1, POINTER_TYPE) 8769 || !validate_arg (s2, POINTER_TYPE)) 8770 return NULL_TREE; 8771 else 8772 { 8773 tree fn; 8774 const char *p1, *p2; 8775 8776 p2 = c_getstr (s2); 8777 if (p2 == NULL) 8778 return NULL_TREE; 8779 8780 p1 = c_getstr (s1); 8781 if (p1 != NULL) 8782 { 8783 const char *r = strpbrk (p1, p2); 8784 tree tem; 8785 8786 if (r == NULL) 8787 return build_int_cst (TREE_TYPE (s1), 0); 8788 8789 /* Return an offset into the constant string argument. */ 8790 tem = fold_build_pointer_plus_hwi_loc (loc, s1, r - p1); 8791 return fold_convert_loc (loc, type, tem); 8792 } 8793 8794 if (p2[0] == '\0') 8795 /* strpbrk(x, "") == NULL. 8796 Evaluate and ignore s1 in case it had side-effects. */ 8797 return omit_one_operand_loc (loc, type, integer_zero_node, s1); 8798 8799 if (p2[1] != '\0') 8800 return NULL_TREE; /* Really call strpbrk. */ 8801 8802 fn = builtin_decl_implicit (BUILT_IN_STRCHR); 8803 if (!fn) 8804 return NULL_TREE; 8805 8806 /* New argument list transforming strpbrk(s1, s2) to 8807 strchr(s1, s2[0]). */ 8808 return build_call_expr_loc (loc, fn, 2, s1, 8809 build_int_cst (integer_type_node, p2[0])); 8810 } 8811 } 8812 8813 /* Simplify a call to the strspn builtin. S1 and S2 are the arguments 8814 to the call. 8815 8816 Return NULL_TREE if no simplification was possible, otherwise return the 8817 simplified form of the call as a tree. 8818 8819 The simplified form may be a constant or other expression which 8820 computes the same value, but in a more efficient manner (including 8821 calls to other builtin functions). 8822 8823 The call may contain arguments which need to be evaluated, but 8824 which are not useful to determine the result of the call. In 8825 this case we return a chain of COMPOUND_EXPRs. The LHS of each 8826 COMPOUND_EXPR will be an argument which must be evaluated. 8827 COMPOUND_EXPRs are chained through their RHS. The RHS of the last 8828 COMPOUND_EXPR in the chain will contain the tree for the simplified 8829 form of the builtin function call. */ 8830 8831 static tree 8832 fold_builtin_strspn (location_t loc, tree s1, tree s2) 8833 { 8834 if (!validate_arg (s1, POINTER_TYPE) 8835 || !validate_arg (s2, POINTER_TYPE)) 8836 return NULL_TREE; 8837 else 8838 { 8839 const char *p1 = c_getstr (s1), *p2 = c_getstr (s2); 8840 8841 /* If either argument is "", return NULL_TREE. */ 8842 if ((p1 && *p1 == '\0') || (p2 && *p2 == '\0')) 8843 /* Evaluate and ignore both arguments in case either one has 8844 side-effects. */ 8845 return omit_two_operands_loc (loc, size_type_node, size_zero_node, 8846 s1, s2); 8847 return NULL_TREE; 8848 } 8849 } 8850 8851 /* Simplify a call to the strcspn builtin. S1 and S2 are the arguments 8852 to the call. 8853 8854 Return NULL_TREE if no simplification was possible, otherwise return the 8855 simplified form of the call as a tree. 8856 8857 The simplified form may be a constant or other expression which 8858 computes the same value, but in a more efficient manner (including 8859 calls to other builtin functions). 8860 8861 The call may contain arguments which need to be evaluated, but 8862 which are not useful to determine the result of the call. In 8863 this case we return a chain of COMPOUND_EXPRs. The LHS of each 8864 COMPOUND_EXPR will be an argument which must be evaluated. 8865 COMPOUND_EXPRs are chained through their RHS. The RHS of the last 8866 COMPOUND_EXPR in the chain will contain the tree for the simplified 8867 form of the builtin function call. */ 8868 8869 static tree 8870 fold_builtin_strcspn (location_t loc, tree s1, tree s2) 8871 { 8872 if (!validate_arg (s1, POINTER_TYPE) 8873 || !validate_arg (s2, POINTER_TYPE)) 8874 return NULL_TREE; 8875 else 8876 { 8877 /* If the first argument is "", return NULL_TREE. */ 8878 const char *p1 = c_getstr (s1); 8879 if (p1 && *p1 == '\0') 8880 { 8881 /* Evaluate and ignore argument s2 in case it has 8882 side-effects. */ 8883 return omit_one_operand_loc (loc, size_type_node, 8884 size_zero_node, s2); 8885 } 8886 8887 /* If the second argument is "", return __builtin_strlen(s1). */ 8888 const char *p2 = c_getstr (s2); 8889 if (p2 && *p2 == '\0') 8890 { 8891 tree fn = builtin_decl_implicit (BUILT_IN_STRLEN); 8892 8893 /* If the replacement _DECL isn't initialized, don't do the 8894 transformation. */ 8895 if (!fn) 8896 return NULL_TREE; 8897 8898 return build_call_expr_loc (loc, fn, 1, s1); 8899 } 8900 return NULL_TREE; 8901 } 8902 } 8903 8904 /* Fold the next_arg or va_start call EXP. Returns true if there was an error 8905 produced. False otherwise. This is done so that we don't output the error 8906 or warning twice or three times. */ 8907 8908 bool 8909 fold_builtin_next_arg (tree exp, bool va_start_p) 8910 { 8911 tree fntype = TREE_TYPE (current_function_decl); 8912 int nargs = call_expr_nargs (exp); 8913 tree arg; 8914 /* There is good chance the current input_location points inside the 8915 definition of the va_start macro (perhaps on the token for 8916 builtin) in a system header, so warnings will not be emitted. 8917 Use the location in real source code. */ 8918 source_location current_location = 8919 linemap_unwind_to_first_non_reserved_loc (line_table, input_location, 8920 NULL); 8921 8922 if (!stdarg_p (fntype)) 8923 { 8924 error ("%<va_start%> used in function with fixed args"); 8925 return true; 8926 } 8927 8928 if (va_start_p) 8929 { 8930 if (va_start_p && (nargs != 2)) 8931 { 8932 error ("wrong number of arguments to function %<va_start%>"); 8933 return true; 8934 } 8935 arg = CALL_EXPR_ARG (exp, 1); 8936 } 8937 /* We use __builtin_va_start (ap, 0, 0) or __builtin_next_arg (0, 0) 8938 when we checked the arguments and if needed issued a warning. */ 8939 else 8940 { 8941 if (nargs == 0) 8942 { 8943 /* Evidently an out of date version of <stdarg.h>; can't validate 8944 va_start's second argument, but can still work as intended. */ 8945 warning_at (current_location, 8946 OPT_Wvarargs, 8947 "%<__builtin_next_arg%> called without an argument"); 8948 return true; 8949 } 8950 else if (nargs > 1) 8951 { 8952 error ("wrong number of arguments to function %<__builtin_next_arg%>"); 8953 return true; 8954 } 8955 arg = CALL_EXPR_ARG (exp, 0); 8956 } 8957 8958 if (TREE_CODE (arg) == SSA_NAME) 8959 arg = SSA_NAME_VAR (arg); 8960 8961 /* We destructively modify the call to be __builtin_va_start (ap, 0) 8962 or __builtin_next_arg (0) the first time we see it, after checking 8963 the arguments and if needed issuing a warning. */ 8964 if (!integer_zerop (arg)) 8965 { 8966 tree last_parm = tree_last (DECL_ARGUMENTS (current_function_decl)); 8967 8968 /* Strip off all nops for the sake of the comparison. This 8969 is not quite the same as STRIP_NOPS. It does more. 8970 We must also strip off INDIRECT_EXPR for C++ reference 8971 parameters. */ 8972 while (CONVERT_EXPR_P (arg) 8973 || TREE_CODE (arg) == INDIRECT_REF) 8974 arg = TREE_OPERAND (arg, 0); 8975 if (arg != last_parm) 8976 { 8977 /* FIXME: Sometimes with the tree optimizers we can get the 8978 not the last argument even though the user used the last 8979 argument. We just warn and set the arg to be the last 8980 argument so that we will get wrong-code because of 8981 it. */ 8982 warning_at (current_location, 8983 OPT_Wvarargs, 8984 "second parameter of %<va_start%> not last named argument"); 8985 } 8986 8987 /* Undefined by C99 7.15.1.4p4 (va_start): 8988 "If the parameter parmN is declared with the register storage 8989 class, with a function or array type, or with a type that is 8990 not compatible with the type that results after application of 8991 the default argument promotions, the behavior is undefined." 8992 */ 8993 else if (DECL_REGISTER (arg)) 8994 { 8995 warning_at (current_location, 8996 OPT_Wvarargs, 8997 "undefined behavior when second parameter of " 8998 "%<va_start%> is declared with %<register%> storage"); 8999 } 9000 9001 /* We want to verify the second parameter just once before the tree 9002 optimizers are run and then avoid keeping it in the tree, 9003 as otherwise we could warn even for correct code like: 9004 void foo (int i, ...) 9005 { va_list ap; i++; va_start (ap, i); va_end (ap); } */ 9006 if (va_start_p) 9007 CALL_EXPR_ARG (exp, 1) = integer_zero_node; 9008 else 9009 CALL_EXPR_ARG (exp, 0) = integer_zero_node; 9010 } 9011 return false; 9012 } 9013 9014 9015 /* Expand a call EXP to __builtin_object_size. */ 9016 9017 static rtx 9018 expand_builtin_object_size (tree exp) 9019 { 9020 tree ost; 9021 int object_size_type; 9022 tree fndecl = get_callee_fndecl (exp); 9023 9024 if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE)) 9025 { 9026 error ("%Kfirst argument of %D must be a pointer, second integer constant", 9027 exp, fndecl); 9028 expand_builtin_trap (); 9029 return const0_rtx; 9030 } 9031 9032 ost = CALL_EXPR_ARG (exp, 1); 9033 STRIP_NOPS (ost); 9034 9035 if (TREE_CODE (ost) != INTEGER_CST 9036 || tree_int_cst_sgn (ost) < 0 9037 || compare_tree_int (ost, 3) > 0) 9038 { 9039 error ("%Klast argument of %D is not integer constant between 0 and 3", 9040 exp, fndecl); 9041 expand_builtin_trap (); 9042 return const0_rtx; 9043 } 9044 9045 object_size_type = tree_to_shwi (ost); 9046 9047 return object_size_type < 2 ? constm1_rtx : const0_rtx; 9048 } 9049 9050 /* Expand EXP, a call to the __mem{cpy,pcpy,move,set}_chk builtin. 9051 FCODE is the BUILT_IN_* to use. 9052 Return NULL_RTX if we failed; the caller should emit a normal call, 9053 otherwise try to get the result in TARGET, if convenient (and in 9054 mode MODE if that's convenient). */ 9055 9056 static rtx 9057 expand_builtin_memory_chk (tree exp, rtx target, machine_mode mode, 9058 enum built_in_function fcode) 9059 { 9060 tree dest, src, len, size; 9061 9062 if (!validate_arglist (exp, 9063 POINTER_TYPE, 9064 fcode == BUILT_IN_MEMSET_CHK 9065 ? INTEGER_TYPE : POINTER_TYPE, 9066 INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE)) 9067 return NULL_RTX; 9068 9069 dest = CALL_EXPR_ARG (exp, 0); 9070 src = CALL_EXPR_ARG (exp, 1); 9071 len = CALL_EXPR_ARG (exp, 2); 9072 size = CALL_EXPR_ARG (exp, 3); 9073 9074 if (! tree_fits_uhwi_p (size)) 9075 return NULL_RTX; 9076 9077 if (tree_fits_uhwi_p (len) || integer_all_onesp (size)) 9078 { 9079 tree fn; 9080 9081 if (! integer_all_onesp (size) && tree_int_cst_lt (size, len)) 9082 { 9083 warning_at (tree_nonartificial_location (exp), 9084 0, "%Kcall to %D will always overflow destination buffer", 9085 exp, get_callee_fndecl (exp)); 9086 return NULL_RTX; 9087 } 9088 9089 fn = NULL_TREE; 9090 /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume 9091 mem{cpy,pcpy,move,set} is available. */ 9092 switch (fcode) 9093 { 9094 case BUILT_IN_MEMCPY_CHK: 9095 fn = builtin_decl_explicit (BUILT_IN_MEMCPY); 9096 break; 9097 case BUILT_IN_MEMPCPY_CHK: 9098 fn = builtin_decl_explicit (BUILT_IN_MEMPCPY); 9099 break; 9100 case BUILT_IN_MEMMOVE_CHK: 9101 fn = builtin_decl_explicit (BUILT_IN_MEMMOVE); 9102 break; 9103 case BUILT_IN_MEMSET_CHK: 9104 fn = builtin_decl_explicit (BUILT_IN_MEMSET); 9105 break; 9106 default: 9107 break; 9108 } 9109 9110 if (! fn) 9111 return NULL_RTX; 9112 9113 fn = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 3, dest, src, len); 9114 gcc_assert (TREE_CODE (fn) == CALL_EXPR); 9115 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp); 9116 return expand_expr (fn, target, mode, EXPAND_NORMAL); 9117 } 9118 else if (fcode == BUILT_IN_MEMSET_CHK) 9119 return NULL_RTX; 9120 else 9121 { 9122 unsigned int dest_align = get_pointer_alignment (dest); 9123 9124 /* If DEST is not a pointer type, call the normal function. */ 9125 if (dest_align == 0) 9126 return NULL_RTX; 9127 9128 /* If SRC and DEST are the same (and not volatile), do nothing. */ 9129 if (operand_equal_p (src, dest, 0)) 9130 { 9131 tree expr; 9132 9133 if (fcode != BUILT_IN_MEMPCPY_CHK) 9134 { 9135 /* Evaluate and ignore LEN in case it has side-effects. */ 9136 expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL); 9137 return expand_expr (dest, target, mode, EXPAND_NORMAL); 9138 } 9139 9140 expr = fold_build_pointer_plus (dest, len); 9141 return expand_expr (expr, target, mode, EXPAND_NORMAL); 9142 } 9143 9144 /* __memmove_chk special case. */ 9145 if (fcode == BUILT_IN_MEMMOVE_CHK) 9146 { 9147 unsigned int src_align = get_pointer_alignment (src); 9148 9149 if (src_align == 0) 9150 return NULL_RTX; 9151 9152 /* If src is categorized for a readonly section we can use 9153 normal __memcpy_chk. */ 9154 if (readonly_data_expr (src)) 9155 { 9156 tree fn = builtin_decl_explicit (BUILT_IN_MEMCPY_CHK); 9157 if (!fn) 9158 return NULL_RTX; 9159 fn = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 4, 9160 dest, src, len, size); 9161 gcc_assert (TREE_CODE (fn) == CALL_EXPR); 9162 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp); 9163 return expand_expr (fn, target, mode, EXPAND_NORMAL); 9164 } 9165 } 9166 return NULL_RTX; 9167 } 9168 } 9169 9170 /* Emit warning if a buffer overflow is detected at compile time. */ 9171 9172 static void 9173 maybe_emit_chk_warning (tree exp, enum built_in_function fcode) 9174 { 9175 int is_strlen = 0; 9176 tree len, size; 9177 location_t loc = tree_nonartificial_location (exp); 9178 9179 switch (fcode) 9180 { 9181 case BUILT_IN_STRCPY_CHK: 9182 case BUILT_IN_STPCPY_CHK: 9183 /* For __strcat_chk the warning will be emitted only if overflowing 9184 by at least strlen (dest) + 1 bytes. */ 9185 case BUILT_IN_STRCAT_CHK: 9186 len = CALL_EXPR_ARG (exp, 1); 9187 size = CALL_EXPR_ARG (exp, 2); 9188 is_strlen = 1; 9189 break; 9190 case BUILT_IN_STRNCAT_CHK: 9191 case BUILT_IN_STRNCPY_CHK: 9192 case BUILT_IN_STPNCPY_CHK: 9193 len = CALL_EXPR_ARG (exp, 2); 9194 size = CALL_EXPR_ARG (exp, 3); 9195 break; 9196 case BUILT_IN_SNPRINTF_CHK: 9197 case BUILT_IN_VSNPRINTF_CHK: 9198 len = CALL_EXPR_ARG (exp, 1); 9199 size = CALL_EXPR_ARG (exp, 3); 9200 break; 9201 default: 9202 gcc_unreachable (); 9203 } 9204 9205 if (!len || !size) 9206 return; 9207 9208 if (! tree_fits_uhwi_p (size) || integer_all_onesp (size)) 9209 return; 9210 9211 if (is_strlen) 9212 { 9213 len = c_strlen (len, 1); 9214 if (! len || ! tree_fits_uhwi_p (len) || tree_int_cst_lt (len, size)) 9215 return; 9216 } 9217 else if (fcode == BUILT_IN_STRNCAT_CHK) 9218 { 9219 tree src = CALL_EXPR_ARG (exp, 1); 9220 if (! src || ! tree_fits_uhwi_p (len) || tree_int_cst_lt (len, size)) 9221 return; 9222 src = c_strlen (src, 1); 9223 if (! src || ! tree_fits_uhwi_p (src)) 9224 { 9225 warning_at (loc, 0, "%Kcall to %D might overflow destination buffer", 9226 exp, get_callee_fndecl (exp)); 9227 return; 9228 } 9229 else if (tree_int_cst_lt (src, size)) 9230 return; 9231 } 9232 else if (! tree_fits_uhwi_p (len) || ! tree_int_cst_lt (size, len)) 9233 return; 9234 9235 warning_at (loc, 0, "%Kcall to %D will always overflow destination buffer", 9236 exp, get_callee_fndecl (exp)); 9237 } 9238 9239 /* Emit warning if a buffer overflow is detected at compile time 9240 in __sprintf_chk/__vsprintf_chk calls. */ 9241 9242 static void 9243 maybe_emit_sprintf_chk_warning (tree exp, enum built_in_function fcode) 9244 { 9245 tree size, len, fmt; 9246 const char *fmt_str; 9247 int nargs = call_expr_nargs (exp); 9248 9249 /* Verify the required arguments in the original call. */ 9250 9251 if (nargs < 4) 9252 return; 9253 size = CALL_EXPR_ARG (exp, 2); 9254 fmt = CALL_EXPR_ARG (exp, 3); 9255 9256 if (! tree_fits_uhwi_p (size) || integer_all_onesp (size)) 9257 return; 9258 9259 /* Check whether the format is a literal string constant. */ 9260 fmt_str = c_getstr (fmt); 9261 if (fmt_str == NULL) 9262 return; 9263 9264 if (!init_target_chars ()) 9265 return; 9266 9267 /* If the format doesn't contain % args or %%, we know its size. */ 9268 if (strchr (fmt_str, target_percent) == 0) 9269 len = build_int_cstu (size_type_node, strlen (fmt_str)); 9270 /* If the format is "%s" and first ... argument is a string literal, 9271 we know it too. */ 9272 else if (fcode == BUILT_IN_SPRINTF_CHK 9273 && strcmp (fmt_str, target_percent_s) == 0) 9274 { 9275 tree arg; 9276 9277 if (nargs < 5) 9278 return; 9279 arg = CALL_EXPR_ARG (exp, 4); 9280 if (! POINTER_TYPE_P (TREE_TYPE (arg))) 9281 return; 9282 9283 len = c_strlen (arg, 1); 9284 if (!len || ! tree_fits_uhwi_p (len)) 9285 return; 9286 } 9287 else 9288 return; 9289 9290 if (! tree_int_cst_lt (len, size)) 9291 warning_at (tree_nonartificial_location (exp), 9292 0, "%Kcall to %D will always overflow destination buffer", 9293 exp, get_callee_fndecl (exp)); 9294 } 9295 9296 /* Emit warning if a free is called with address of a variable. */ 9297 9298 static void 9299 maybe_emit_free_warning (tree exp) 9300 { 9301 tree arg = CALL_EXPR_ARG (exp, 0); 9302 9303 STRIP_NOPS (arg); 9304 if (TREE_CODE (arg) != ADDR_EXPR) 9305 return; 9306 9307 arg = get_base_address (TREE_OPERAND (arg, 0)); 9308 if (arg == NULL || INDIRECT_REF_P (arg) || TREE_CODE (arg) == MEM_REF) 9309 return; 9310 9311 if (SSA_VAR_P (arg)) 9312 warning_at (tree_nonartificial_location (exp), OPT_Wfree_nonheap_object, 9313 "%Kattempt to free a non-heap object %qD", exp, arg); 9314 else 9315 warning_at (tree_nonartificial_location (exp), OPT_Wfree_nonheap_object, 9316 "%Kattempt to free a non-heap object", exp); 9317 } 9318 9319 /* Fold a call to __builtin_object_size with arguments PTR and OST, 9320 if possible. */ 9321 9322 static tree 9323 fold_builtin_object_size (tree ptr, tree ost) 9324 { 9325 unsigned HOST_WIDE_INT bytes; 9326 int object_size_type; 9327 9328 if (!validate_arg (ptr, POINTER_TYPE) 9329 || !validate_arg (ost, INTEGER_TYPE)) 9330 return NULL_TREE; 9331 9332 STRIP_NOPS (ost); 9333 9334 if (TREE_CODE (ost) != INTEGER_CST 9335 || tree_int_cst_sgn (ost) < 0 9336 || compare_tree_int (ost, 3) > 0) 9337 return NULL_TREE; 9338 9339 object_size_type = tree_to_shwi (ost); 9340 9341 /* __builtin_object_size doesn't evaluate side-effects in its arguments; 9342 if there are any side-effects, it returns (size_t) -1 for types 0 and 1 9343 and (size_t) 0 for types 2 and 3. */ 9344 if (TREE_SIDE_EFFECTS (ptr)) 9345 return build_int_cst_type (size_type_node, object_size_type < 2 ? -1 : 0); 9346 9347 if (TREE_CODE (ptr) == ADDR_EXPR) 9348 { 9349 bytes = compute_builtin_object_size (ptr, object_size_type); 9350 if (wi::fits_to_tree_p (bytes, size_type_node)) 9351 return build_int_cstu (size_type_node, bytes); 9352 } 9353 else if (TREE_CODE (ptr) == SSA_NAME) 9354 { 9355 /* If object size is not known yet, delay folding until 9356 later. Maybe subsequent passes will help determining 9357 it. */ 9358 bytes = compute_builtin_object_size (ptr, object_size_type); 9359 if (bytes != (unsigned HOST_WIDE_INT) (object_size_type < 2 ? -1 : 0) 9360 && wi::fits_to_tree_p (bytes, size_type_node)) 9361 return build_int_cstu (size_type_node, bytes); 9362 } 9363 9364 return NULL_TREE; 9365 } 9366 9367 /* Builtins with folding operations that operate on "..." arguments 9368 need special handling; we need to store the arguments in a convenient 9369 data structure before attempting any folding. Fortunately there are 9370 only a few builtins that fall into this category. FNDECL is the 9371 function, EXP is the CALL_EXPR for the call. */ 9372 9373 static tree 9374 fold_builtin_varargs (location_t loc, tree fndecl, tree *args, int nargs) 9375 { 9376 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl); 9377 tree ret = NULL_TREE; 9378 9379 switch (fcode) 9380 { 9381 case BUILT_IN_FPCLASSIFY: 9382 ret = fold_builtin_fpclassify (loc, args, nargs); 9383 break; 9384 9385 default: 9386 break; 9387 } 9388 if (ret) 9389 { 9390 ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret); 9391 SET_EXPR_LOCATION (ret, loc); 9392 TREE_NO_WARNING (ret) = 1; 9393 return ret; 9394 } 9395 return NULL_TREE; 9396 } 9397 9398 /* Initialize format string characters in the target charset. */ 9399 9400 bool 9401 init_target_chars (void) 9402 { 9403 static bool init; 9404 if (!init) 9405 { 9406 target_newline = lang_hooks.to_target_charset ('\n'); 9407 target_percent = lang_hooks.to_target_charset ('%'); 9408 target_c = lang_hooks.to_target_charset ('c'); 9409 target_s = lang_hooks.to_target_charset ('s'); 9410 if (target_newline == 0 || target_percent == 0 || target_c == 0 9411 || target_s == 0) 9412 return false; 9413 9414 target_percent_c[0] = target_percent; 9415 target_percent_c[1] = target_c; 9416 target_percent_c[2] = '\0'; 9417 9418 target_percent_s[0] = target_percent; 9419 target_percent_s[1] = target_s; 9420 target_percent_s[2] = '\0'; 9421 9422 target_percent_s_newline[0] = target_percent; 9423 target_percent_s_newline[1] = target_s; 9424 target_percent_s_newline[2] = target_newline; 9425 target_percent_s_newline[3] = '\0'; 9426 9427 init = true; 9428 } 9429 return true; 9430 } 9431 9432 /* Helper function for do_mpfr_arg*(). Ensure M is a normal number 9433 and no overflow/underflow occurred. INEXACT is true if M was not 9434 exactly calculated. TYPE is the tree type for the result. This 9435 function assumes that you cleared the MPFR flags and then 9436 calculated M to see if anything subsequently set a flag prior to 9437 entering this function. Return NULL_TREE if any checks fail. */ 9438 9439 static tree 9440 do_mpfr_ckconv (mpfr_srcptr m, tree type, int inexact) 9441 { 9442 /* Proceed iff we get a normal number, i.e. not NaN or Inf and no 9443 overflow/underflow occurred. If -frounding-math, proceed iff the 9444 result of calling FUNC was exact. */ 9445 if (mpfr_number_p (m) && !mpfr_overflow_p () && !mpfr_underflow_p () 9446 && (!flag_rounding_math || !inexact)) 9447 { 9448 REAL_VALUE_TYPE rr; 9449 9450 real_from_mpfr (&rr, m, type, GMP_RNDN); 9451 /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR value, 9452 check for overflow/underflow. If the REAL_VALUE_TYPE is zero 9453 but the mpft_t is not, then we underflowed in the 9454 conversion. */ 9455 if (real_isfinite (&rr) 9456 && (rr.cl == rvc_zero) == (mpfr_zero_p (m) != 0)) 9457 { 9458 REAL_VALUE_TYPE rmode; 9459 9460 real_convert (&rmode, TYPE_MODE (type), &rr); 9461 /* Proceed iff the specified mode can hold the value. */ 9462 if (real_identical (&rmode, &rr)) 9463 return build_real (type, rmode); 9464 } 9465 } 9466 return NULL_TREE; 9467 } 9468 9469 /* Helper function for do_mpc_arg*(). Ensure M is a normal complex 9470 number and no overflow/underflow occurred. INEXACT is true if M 9471 was not exactly calculated. TYPE is the tree type for the result. 9472 This function assumes that you cleared the MPFR flags and then 9473 calculated M to see if anything subsequently set a flag prior to 9474 entering this function. Return NULL_TREE if any checks fail, if 9475 FORCE_CONVERT is true, then bypass the checks. */ 9476 9477 static tree 9478 do_mpc_ckconv (mpc_srcptr m, tree type, int inexact, int force_convert) 9479 { 9480 /* Proceed iff we get a normal number, i.e. not NaN or Inf and no 9481 overflow/underflow occurred. If -frounding-math, proceed iff the 9482 result of calling FUNC was exact. */ 9483 if (force_convert 9484 || (mpfr_number_p (mpc_realref (m)) && mpfr_number_p (mpc_imagref (m)) 9485 && !mpfr_overflow_p () && !mpfr_underflow_p () 9486 && (!flag_rounding_math || !inexact))) 9487 { 9488 REAL_VALUE_TYPE re, im; 9489 9490 real_from_mpfr (&re, mpc_realref (m), TREE_TYPE (type), GMP_RNDN); 9491 real_from_mpfr (&im, mpc_imagref (m), TREE_TYPE (type), GMP_RNDN); 9492 /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR values, 9493 check for overflow/underflow. If the REAL_VALUE_TYPE is zero 9494 but the mpft_t is not, then we underflowed in the 9495 conversion. */ 9496 if (force_convert 9497 || (real_isfinite (&re) && real_isfinite (&im) 9498 && (re.cl == rvc_zero) == (mpfr_zero_p (mpc_realref (m)) != 0) 9499 && (im.cl == rvc_zero) == (mpfr_zero_p (mpc_imagref (m)) != 0))) 9500 { 9501 REAL_VALUE_TYPE re_mode, im_mode; 9502 9503 real_convert (&re_mode, TYPE_MODE (TREE_TYPE (type)), &re); 9504 real_convert (&im_mode, TYPE_MODE (TREE_TYPE (type)), &im); 9505 /* Proceed iff the specified mode can hold the value. */ 9506 if (force_convert 9507 || (real_identical (&re_mode, &re) 9508 && real_identical (&im_mode, &im))) 9509 return build_complex (type, build_real (TREE_TYPE (type), re_mode), 9510 build_real (TREE_TYPE (type), im_mode)); 9511 } 9512 } 9513 return NULL_TREE; 9514 } 9515 9516 /* If arguments ARG0 and ARG1 are REAL_CSTs, call mpfr_remquo() to set 9517 the pointer *(ARG_QUO) and return the result. The type is taken 9518 from the type of ARG0 and is used for setting the precision of the 9519 calculation and results. */ 9520 9521 static tree 9522 do_mpfr_remquo (tree arg0, tree arg1, tree arg_quo) 9523 { 9524 tree const type = TREE_TYPE (arg0); 9525 tree result = NULL_TREE; 9526 9527 STRIP_NOPS (arg0); 9528 STRIP_NOPS (arg1); 9529 9530 /* To proceed, MPFR must exactly represent the target floating point 9531 format, which only happens when the target base equals two. */ 9532 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2 9533 && TREE_CODE (arg0) == REAL_CST && !TREE_OVERFLOW (arg0) 9534 && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1)) 9535 { 9536 const REAL_VALUE_TYPE *const ra0 = TREE_REAL_CST_PTR (arg0); 9537 const REAL_VALUE_TYPE *const ra1 = TREE_REAL_CST_PTR (arg1); 9538 9539 if (real_isfinite (ra0) && real_isfinite (ra1)) 9540 { 9541 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type)); 9542 const int prec = fmt->p; 9543 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN; 9544 tree result_rem; 9545 long integer_quo; 9546 mpfr_t m0, m1; 9547 9548 mpfr_inits2 (prec, m0, m1, NULL); 9549 mpfr_from_real (m0, ra0, GMP_RNDN); 9550 mpfr_from_real (m1, ra1, GMP_RNDN); 9551 mpfr_clear_flags (); 9552 mpfr_remquo (m0, &integer_quo, m0, m1, rnd); 9553 /* Remquo is independent of the rounding mode, so pass 9554 inexact=0 to do_mpfr_ckconv(). */ 9555 result_rem = do_mpfr_ckconv (m0, type, /*inexact=*/ 0); 9556 mpfr_clears (m0, m1, NULL); 9557 if (result_rem) 9558 { 9559 /* MPFR calculates quo in the host's long so it may 9560 return more bits in quo than the target int can hold 9561 if sizeof(host long) > sizeof(target int). This can 9562 happen even for native compilers in LP64 mode. In 9563 these cases, modulo the quo value with the largest 9564 number that the target int can hold while leaving one 9565 bit for the sign. */ 9566 if (sizeof (integer_quo) * CHAR_BIT > INT_TYPE_SIZE) 9567 integer_quo %= (long)(1UL << (INT_TYPE_SIZE - 1)); 9568 9569 /* Dereference the quo pointer argument. */ 9570 arg_quo = build_fold_indirect_ref (arg_quo); 9571 /* Proceed iff a valid pointer type was passed in. */ 9572 if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_quo)) == integer_type_node) 9573 { 9574 /* Set the value. */ 9575 tree result_quo 9576 = fold_build2 (MODIFY_EXPR, TREE_TYPE (arg_quo), arg_quo, 9577 build_int_cst (TREE_TYPE (arg_quo), 9578 integer_quo)); 9579 TREE_SIDE_EFFECTS (result_quo) = 1; 9580 /* Combine the quo assignment with the rem. */ 9581 result = non_lvalue (fold_build2 (COMPOUND_EXPR, type, 9582 result_quo, result_rem)); 9583 } 9584 } 9585 } 9586 } 9587 return result; 9588 } 9589 9590 /* If ARG is a REAL_CST, call mpfr_lgamma() on it and return the 9591 resulting value as a tree with type TYPE. The mpfr precision is 9592 set to the precision of TYPE. We assume that this mpfr function 9593 returns zero if the result could be calculated exactly within the 9594 requested precision. In addition, the integer pointer represented 9595 by ARG_SG will be dereferenced and set to the appropriate signgam 9596 (-1,1) value. */ 9597 9598 static tree 9599 do_mpfr_lgamma_r (tree arg, tree arg_sg, tree type) 9600 { 9601 tree result = NULL_TREE; 9602 9603 STRIP_NOPS (arg); 9604 9605 /* To proceed, MPFR must exactly represent the target floating point 9606 format, which only happens when the target base equals two. Also 9607 verify ARG is a constant and that ARG_SG is an int pointer. */ 9608 if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2 9609 && TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg) 9610 && TREE_CODE (TREE_TYPE (arg_sg)) == POINTER_TYPE 9611 && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (arg_sg))) == integer_type_node) 9612 { 9613 const REAL_VALUE_TYPE *const ra = TREE_REAL_CST_PTR (arg); 9614 9615 /* In addition to NaN and Inf, the argument cannot be zero or a 9616 negative integer. */ 9617 if (real_isfinite (ra) 9618 && ra->cl != rvc_zero 9619 && !(real_isneg (ra) && real_isinteger (ra, TYPE_MODE (type)))) 9620 { 9621 const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type)); 9622 const int prec = fmt->p; 9623 const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN; 9624 int inexact, sg; 9625 mpfr_t m; 9626 tree result_lg; 9627 9628 mpfr_init2 (m, prec); 9629 mpfr_from_real (m, ra, GMP_RNDN); 9630 mpfr_clear_flags (); 9631 inexact = mpfr_lgamma (m, &sg, m, rnd); 9632 result_lg = do_mpfr_ckconv (m, type, inexact); 9633 mpfr_clear (m); 9634 if (result_lg) 9635 { 9636 tree result_sg; 9637 9638 /* Dereference the arg_sg pointer argument. */ 9639 arg_sg = build_fold_indirect_ref (arg_sg); 9640 /* Assign the signgam value into *arg_sg. */ 9641 result_sg = fold_build2 (MODIFY_EXPR, 9642 TREE_TYPE (arg_sg), arg_sg, 9643 build_int_cst (TREE_TYPE (arg_sg), sg)); 9644 TREE_SIDE_EFFECTS (result_sg) = 1; 9645 /* Combine the signgam assignment with the lgamma result. */ 9646 result = non_lvalue (fold_build2 (COMPOUND_EXPR, type, 9647 result_sg, result_lg)); 9648 } 9649 } 9650 } 9651 9652 return result; 9653 } 9654 9655 /* If arguments ARG0 and ARG1 are a COMPLEX_CST, call the two-argument 9656 mpc function FUNC on it and return the resulting value as a tree 9657 with type TYPE. The mpfr precision is set to the precision of 9658 TYPE. We assume that function FUNC returns zero if the result 9659 could be calculated exactly within the requested precision. If 9660 DO_NONFINITE is true, then fold expressions containing Inf or NaN 9661 in the arguments and/or results. */ 9662 9663 tree 9664 do_mpc_arg2 (tree arg0, tree arg1, tree type, int do_nonfinite, 9665 int (*func)(mpc_ptr, mpc_srcptr, mpc_srcptr, mpc_rnd_t)) 9666 { 9667 tree result = NULL_TREE; 9668 9669 STRIP_NOPS (arg0); 9670 STRIP_NOPS (arg1); 9671 9672 /* To proceed, MPFR must exactly represent the target floating point 9673 format, which only happens when the target base equals two. */ 9674 if (TREE_CODE (arg0) == COMPLEX_CST && !TREE_OVERFLOW (arg0) 9675 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE 9676 && TREE_CODE (arg1) == COMPLEX_CST && !TREE_OVERFLOW (arg1) 9677 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == REAL_TYPE 9678 && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg0))))->b == 2) 9679 { 9680 const REAL_VALUE_TYPE *const re0 = TREE_REAL_CST_PTR (TREE_REALPART (arg0)); 9681 const REAL_VALUE_TYPE *const im0 = TREE_REAL_CST_PTR (TREE_IMAGPART (arg0)); 9682 const REAL_VALUE_TYPE *const re1 = TREE_REAL_CST_PTR (TREE_REALPART (arg1)); 9683 const REAL_VALUE_TYPE *const im1 = TREE_REAL_CST_PTR (TREE_IMAGPART (arg1)); 9684 9685 if (do_nonfinite 9686 || (real_isfinite (re0) && real_isfinite (im0) 9687 && real_isfinite (re1) && real_isfinite (im1))) 9688 { 9689 const struct real_format *const fmt = 9690 REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type))); 9691 const int prec = fmt->p; 9692 const mp_rnd_t rnd = fmt->round_towards_zero ? GMP_RNDZ : GMP_RNDN; 9693 const mpc_rnd_t crnd = fmt->round_towards_zero ? MPC_RNDZZ : MPC_RNDNN; 9694 int inexact; 9695 mpc_t m0, m1; 9696 9697 mpc_init2 (m0, prec); 9698 mpc_init2 (m1, prec); 9699 mpfr_from_real (mpc_realref (m0), re0, rnd); 9700 mpfr_from_real (mpc_imagref (m0), im0, rnd); 9701 mpfr_from_real (mpc_realref (m1), re1, rnd); 9702 mpfr_from_real (mpc_imagref (m1), im1, rnd); 9703 mpfr_clear_flags (); 9704 inexact = func (m0, m0, m1, crnd); 9705 result = do_mpc_ckconv (m0, type, inexact, do_nonfinite); 9706 mpc_clear (m0); 9707 mpc_clear (m1); 9708 } 9709 } 9710 9711 return result; 9712 } 9713 9714 /* A wrapper function for builtin folding that prevents warnings for 9715 "statement without effect" and the like, caused by removing the 9716 call node earlier than the warning is generated. */ 9717 9718 tree 9719 fold_call_stmt (gcall *stmt, bool ignore) 9720 { 9721 tree ret = NULL_TREE; 9722 tree fndecl = gimple_call_fndecl (stmt); 9723 location_t loc = gimple_location (stmt); 9724 if (fndecl 9725 && TREE_CODE (fndecl) == FUNCTION_DECL 9726 && DECL_BUILT_IN (fndecl) 9727 && !gimple_call_va_arg_pack_p (stmt)) 9728 { 9729 int nargs = gimple_call_num_args (stmt); 9730 tree *args = (nargs > 0 9731 ? gimple_call_arg_ptr (stmt, 0) 9732 : &error_mark_node); 9733 9734 if (avoid_folding_inline_builtin (fndecl)) 9735 return NULL_TREE; 9736 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD) 9737 { 9738 return targetm.fold_builtin (fndecl, nargs, args, ignore); 9739 } 9740 else 9741 { 9742 ret = fold_builtin_n (loc, fndecl, args, nargs, ignore); 9743 if (ret) 9744 { 9745 /* Propagate location information from original call to 9746 expansion of builtin. Otherwise things like 9747 maybe_emit_chk_warning, that operate on the expansion 9748 of a builtin, will use the wrong location information. */ 9749 if (gimple_has_location (stmt)) 9750 { 9751 tree realret = ret; 9752 if (TREE_CODE (ret) == NOP_EXPR) 9753 realret = TREE_OPERAND (ret, 0); 9754 if (CAN_HAVE_LOCATION_P (realret) 9755 && !EXPR_HAS_LOCATION (realret)) 9756 SET_EXPR_LOCATION (realret, loc); 9757 return realret; 9758 } 9759 return ret; 9760 } 9761 } 9762 } 9763 return NULL_TREE; 9764 } 9765 9766 /* Look up the function in builtin_decl that corresponds to DECL 9767 and set ASMSPEC as its user assembler name. DECL must be a 9768 function decl that declares a builtin. */ 9769 9770 void 9771 set_builtin_user_assembler_name (tree decl, const char *asmspec) 9772 { 9773 tree builtin; 9774 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL 9775 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL 9776 && asmspec != 0); 9777 9778 builtin = builtin_decl_explicit (DECL_FUNCTION_CODE (decl)); 9779 set_user_assembler_name (builtin, asmspec); 9780 switch (DECL_FUNCTION_CODE (decl)) 9781 { 9782 case BUILT_IN_MEMCPY: 9783 init_block_move_fn (asmspec); 9784 memcpy_libfunc = set_user_assembler_libfunc ("memcpy", asmspec); 9785 break; 9786 case BUILT_IN_MEMSET: 9787 init_block_clear_fn (asmspec); 9788 memset_libfunc = set_user_assembler_libfunc ("memset", asmspec); 9789 break; 9790 case BUILT_IN_MEMMOVE: 9791 memmove_libfunc = set_user_assembler_libfunc ("memmove", asmspec); 9792 break; 9793 case BUILT_IN_MEMCMP: 9794 memcmp_libfunc = set_user_assembler_libfunc ("memcmp", asmspec); 9795 break; 9796 case BUILT_IN_ABORT: 9797 abort_libfunc = set_user_assembler_libfunc ("abort", asmspec); 9798 break; 9799 case BUILT_IN_FFS: 9800 if (INT_TYPE_SIZE < BITS_PER_WORD) 9801 { 9802 set_user_assembler_libfunc ("ffs", asmspec); 9803 set_optab_libfunc (ffs_optab, mode_for_size (INT_TYPE_SIZE, 9804 MODE_INT, 0), "ffs"); 9805 } 9806 break; 9807 default: 9808 break; 9809 } 9810 } 9811 9812 /* Return true if DECL is a builtin that expands to a constant or similarly 9813 simple code. */ 9814 bool 9815 is_simple_builtin (tree decl) 9816 { 9817 if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL) 9818 switch (DECL_FUNCTION_CODE (decl)) 9819 { 9820 /* Builtins that expand to constants. */ 9821 case BUILT_IN_CONSTANT_P: 9822 case BUILT_IN_EXPECT: 9823 case BUILT_IN_OBJECT_SIZE: 9824 case BUILT_IN_UNREACHABLE: 9825 /* Simple register moves or loads from stack. */ 9826 case BUILT_IN_ASSUME_ALIGNED: 9827 case BUILT_IN_RETURN_ADDRESS: 9828 case BUILT_IN_EXTRACT_RETURN_ADDR: 9829 case BUILT_IN_FROB_RETURN_ADDR: 9830 case BUILT_IN_RETURN: 9831 case BUILT_IN_AGGREGATE_INCOMING_ADDRESS: 9832 case BUILT_IN_FRAME_ADDRESS: 9833 case BUILT_IN_VA_END: 9834 case BUILT_IN_STACK_SAVE: 9835 case BUILT_IN_STACK_RESTORE: 9836 /* Exception state returns or moves registers around. */ 9837 case BUILT_IN_EH_FILTER: 9838 case BUILT_IN_EH_POINTER: 9839 case BUILT_IN_EH_COPY_VALUES: 9840 return true; 9841 9842 default: 9843 return false; 9844 } 9845 9846 return false; 9847 } 9848 9849 /* Return true if DECL is a builtin that is not expensive, i.e., they are 9850 most probably expanded inline into reasonably simple code. This is a 9851 superset of is_simple_builtin. */ 9852 bool 9853 is_inexpensive_builtin (tree decl) 9854 { 9855 if (!decl) 9856 return false; 9857 else if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_MD) 9858 return true; 9859 else if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL) 9860 switch (DECL_FUNCTION_CODE (decl)) 9861 { 9862 case BUILT_IN_ABS: 9863 case BUILT_IN_ALLOCA: 9864 case BUILT_IN_ALLOCA_WITH_ALIGN: 9865 case BUILT_IN_BSWAP16: 9866 case BUILT_IN_BSWAP32: 9867 case BUILT_IN_BSWAP64: 9868 case BUILT_IN_CLZ: 9869 case BUILT_IN_CLZIMAX: 9870 case BUILT_IN_CLZL: 9871 case BUILT_IN_CLZLL: 9872 case BUILT_IN_CTZ: 9873 case BUILT_IN_CTZIMAX: 9874 case BUILT_IN_CTZL: 9875 case BUILT_IN_CTZLL: 9876 case BUILT_IN_FFS: 9877 case BUILT_IN_FFSIMAX: 9878 case BUILT_IN_FFSL: 9879 case BUILT_IN_FFSLL: 9880 case BUILT_IN_IMAXABS: 9881 case BUILT_IN_FINITE: 9882 case BUILT_IN_FINITEF: 9883 case BUILT_IN_FINITEL: 9884 case BUILT_IN_FINITED32: 9885 case BUILT_IN_FINITED64: 9886 case BUILT_IN_FINITED128: 9887 case BUILT_IN_FPCLASSIFY: 9888 case BUILT_IN_ISFINITE: 9889 case BUILT_IN_ISINF_SIGN: 9890 case BUILT_IN_ISINF: 9891 case BUILT_IN_ISINFF: 9892 case BUILT_IN_ISINFL: 9893 case BUILT_IN_ISINFD32: 9894 case BUILT_IN_ISINFD64: 9895 case BUILT_IN_ISINFD128: 9896 case BUILT_IN_ISNAN: 9897 case BUILT_IN_ISNANF: 9898 case BUILT_IN_ISNANL: 9899 case BUILT_IN_ISNAND32: 9900 case BUILT_IN_ISNAND64: 9901 case BUILT_IN_ISNAND128: 9902 case BUILT_IN_ISNORMAL: 9903 case BUILT_IN_ISGREATER: 9904 case BUILT_IN_ISGREATEREQUAL: 9905 case BUILT_IN_ISLESS: 9906 case BUILT_IN_ISLESSEQUAL: 9907 case BUILT_IN_ISLESSGREATER: 9908 case BUILT_IN_ISUNORDERED: 9909 case BUILT_IN_VA_ARG_PACK: 9910 case BUILT_IN_VA_ARG_PACK_LEN: 9911 case BUILT_IN_VA_COPY: 9912 case BUILT_IN_TRAP: 9913 case BUILT_IN_SAVEREGS: 9914 case BUILT_IN_POPCOUNTL: 9915 case BUILT_IN_POPCOUNTLL: 9916 case BUILT_IN_POPCOUNTIMAX: 9917 case BUILT_IN_POPCOUNT: 9918 case BUILT_IN_PARITYL: 9919 case BUILT_IN_PARITYLL: 9920 case BUILT_IN_PARITYIMAX: 9921 case BUILT_IN_PARITY: 9922 case BUILT_IN_LABS: 9923 case BUILT_IN_LLABS: 9924 case BUILT_IN_PREFETCH: 9925 case BUILT_IN_ACC_ON_DEVICE: 9926 return true; 9927 9928 default: 9929 return is_simple_builtin (decl); 9930 } 9931 9932 return false; 9933 } 9934