gcc/targhooks.c

   1 /* Default target hook functions.
   2    Copyright (C) 2003, 2004, 2005, 2007 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 /* The migration of target macros to target hooks works as follows:
  21
  22    1. Create a target hook that uses the existing target macros to
  23       implement the same functionality.
  24
  25    2. Convert all the MI files to use the hook instead of the macro.
  26
  27    3. Repeat for a majority of the remaining target macros.  This will
  28       take some time.
  29
  30    4. Tell target maintainers to start migrating.
  31
  32    5. Eventually convert the backends to override the hook instead of
  33       defining the macros.  This will take some time too.
  34
  35    6. TBD when, poison the macros.  Unmigrated targets will break at
  36       this point.
  37
  38    Note that we expect steps 1-3 to be done by the people that
  39    understand what the MI does with each macro, and step 5 to be done
  40    by the target maintainers for their respective targets.
  41
  42    Note that steps 1 and 2 don't have to be done together, but no
  43    target can override the new hook until step 2 is complete for it.
  44
  45    Once the macros are poisoned, we will revert to the old migration
  46    rules - migrate the macro, callers, and targets all at once.  This
  47    comment can thus be removed at that point.  */
  48
  49 #include "config.h"
  50 #include "system.h"
  51 #include "coretypes.h"
  52 #include "tm.h"
  53 #include "machmode.h"
  54 #include "rtl.h"
  55 #include "tree.h"
  56 #include "expr.h"
  57 #include "output.h"
  58 #include "toplev.h"
  59 #include "function.h"
  60 #include "target.h"
  61 #include "tm_p.h"
  62 #include "target-def.h"
  63 #include "ggc.h"
  64 #include "hard-reg-set.h"
  65 #include "reload.h"
  66 #include "optabs.h"
  67 #include "recog.h"
  68
  69
  70 void
  71 default_external_libcall (rtx fun ATTRIBUTE_UNUSED)
  72 {
  73 #ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
  74   ASM_OUTPUT_EXTERNAL_LIBCALL(asm_out_file, fun);
  75 #endif
  76 }
  77
  78 enum machine_mode
  79 default_cc_modes_compatible (enum machine_mode m1, enum machine_mode m2)
  80 {
  81   if (m1 == m2)
  82     return m1;
  83   return VOIDmode;
  84 }
  85
  86 bool
  87 default_return_in_memory (const_tree type,
  88                           const_tree fntype ATTRIBUTE_UNUSED)
  89 {
  90 #ifndef RETURN_IN_MEMORY
  91   return (TYPE_MODE (type) == BLKmode);
  92 #else
  93   return RETURN_IN_MEMORY (type);
  94 #endif
  95 }
  96
  97 rtx
  98 default_expand_builtin_saveregs (void)
  99 {
 100   error ("__builtin_saveregs not supported by this target");
 101   return const0_rtx;
 102 }
 103
 104 void
 105 default_setup_incoming_varargs (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
 106                                 enum machine_mode mode ATTRIBUTE_UNUSED,
 107                                 tree type ATTRIBUTE_UNUSED,
 108                                 int *pretend_arg_size ATTRIBUTE_UNUSED,
 109                                 int second_time ATTRIBUTE_UNUSED)
 110 {
 111 }
 112
 113 /* The default implementation of TARGET_BUILTIN_SETJMP_FRAME_VALUE.  */
 114
 115 rtx
 116 default_builtin_setjmp_frame_value (void)
 117 {
 118   return virtual_stack_vars_rtx;
 119 }
 120
 121 /* Generic hook that takes a CUMULATIVE_ARGS pointer and returns false.  */
 122
 123 bool
 124 hook_bool_CUMULATIVE_ARGS_false (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED)
 125 {
 126   return false;
 127 }
 128
 129 bool
 130 default_pretend_outgoing_varargs_named (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED)
 131 {
 132   return (targetm.calls.setup_incoming_varargs
 133           != default_setup_incoming_varargs);
 134 }
 135
 136 enum machine_mode
 137 default_eh_return_filter_mode (void)
 138 {
 139   return word_mode;
 140 }
 141
 142 enum machine_mode
 143 default_libgcc_cmp_return_mode (void)
 144 {
 145   return word_mode;
 146 }
 147
 148 enum machine_mode
 149 default_libgcc_shift_count_mode (void)
 150 {
 151   return word_mode;
 152 }
 153
 154 /* The default implementation of TARGET_SHIFT_TRUNCATION_MASK.  */
 155
 156 unsigned HOST_WIDE_INT
 157 default_shift_truncation_mask (enum machine_mode mode)
 158 {
 159   return SHIFT_COUNT_TRUNCATED ? GET_MODE_BITSIZE (mode) - 1 : 0;
 160 }
 161
 162 /* The default implementation of TARGET_MIN_DIVISIONS_FOR_RECIP_MUL.  */
 163
 164 unsigned int
 165 default_min_divisions_for_recip_mul (enum machine_mode mode ATTRIBUTE_UNUSED)
 166 {
 167   return have_insn_for (DIV, mode) ? 3 : 2;
 168 }
 169
 170 /* The default implementation of TARGET_MODE_REP_EXTENDED.  */
 171
 172 int
 173 default_mode_rep_extended (enum machine_mode mode ATTRIBUTE_UNUSED,
 174                            enum machine_mode mode_rep ATTRIBUTE_UNUSED)
 175 {
 176   return UNKNOWN;
 177 }
 178
 179 /* Generic hook that takes a CUMULATIVE_ARGS pointer and returns true.  */
 180
 181 bool
 182 hook_bool_CUMULATIVE_ARGS_true (CUMULATIVE_ARGS * a ATTRIBUTE_UNUSED)
 183 {
 184   return true;
 185 }
 186
 187 /* Return machine mode for non-standard suffix
 188    or VOIDmode if non-standard suffixes are unsupported.  */
 189 enum machine_mode
 190 default_mode_for_suffix (char suffix ATTRIBUTE_UNUSED)
 191 {
 192   return VOIDmode;
 193 }
 194
 195 /* The generic C++ ABI specifies this is a 64-bit value.  */
 196 tree
 197 default_cxx_guard_type (void)
 198 {
 199   return long_long_integer_type_node;
 200 }
 201
 202
 203 /* Returns the size of the cookie to use when allocating an array
 204    whose elements have the indicated TYPE.  Assumes that it is already
 205    known that a cookie is needed.  */
 206
 207 tree
 208 default_cxx_get_cookie_size (tree type)
 209 {
 210   tree cookie_size;
 211
 212   /* We need to allocate an additional max (sizeof (size_t), alignof
 213      (true_type)) bytes.  */
 214   tree sizetype_size;
 215   tree type_align;
 216
 217   sizetype_size = size_in_bytes (sizetype);
 218   type_align = size_int (TYPE_ALIGN_UNIT (type));
 219   if (INT_CST_LT_UNSIGNED (type_align, sizetype_size))
 220     cookie_size = sizetype_size;
 221   else
 222     cookie_size = type_align;
 223
 224   return cookie_size;
 225 }
 226
 227 /* Return true if a parameter must be passed by reference.  This version
 228    of the TARGET_PASS_BY_REFERENCE hook uses just MUST_PASS_IN_STACK.  */
 229
 230 bool
 231 hook_pass_by_reference_must_pass_in_stack (CUMULATIVE_ARGS *c ATTRIBUTE_UNUSED,
 232         enum machine_mode mode ATTRIBUTE_UNUSED, const_tree type ATTRIBUTE_UNUSED,
 233         bool named_arg ATTRIBUTE_UNUSED)
 234 {
 235   return targetm.calls.must_pass_in_stack (mode, type);
 236 }
 237
 238 /* Return true if a parameter follows callee copies conventions.  This
 239    version of the hook is true for all named arguments.  */
 240
 241 bool
 242 hook_callee_copies_named (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
 243                           enum machine_mode mode ATTRIBUTE_UNUSED,
 244                           const_tree type ATTRIBUTE_UNUSED, bool named)
 245 {
 246   return named;
 247 }
 248
 249 /* Emit any directives required to unwind this instruction.  */
 250
 251 void
 252 default_unwind_emit (FILE * stream ATTRIBUTE_UNUSED,
 253                      rtx insn ATTRIBUTE_UNUSED)
 254 {
 255   /* Should never happen.  */
 256   gcc_unreachable ();
 257 }
 258
 259 /* True if MODE is valid for the target.  By "valid", we mean able to
 260    be manipulated in non-trivial ways.  In particular, this means all
 261    the arithmetic is supported.
 262
 263    By default we guess this means that any C type is supported.  If
 264    we can't map the mode back to a type that would be available in C,
 265    then reject it.  Special case, here, is the double-word arithmetic
 266    supported by optabs.c.  */
 267
 268 bool
 269 default_scalar_mode_supported_p (enum machine_mode mode)
 270 {
 271   int precision = GET_MODE_PRECISION (mode);
 272
 273   switch (GET_MODE_CLASS (mode))
 274     {
 275     case MODE_PARTIAL_INT:
 276     case MODE_INT:
 277       if (precision == CHAR_TYPE_SIZE)
 278         return true;
 279       if (precision == SHORT_TYPE_SIZE)
 280         return true;
 281       if (precision == INT_TYPE_SIZE)
 282         return true;
 283       if (precision == LONG_TYPE_SIZE)
 284         return true;
 285       if (precision == LONG_LONG_TYPE_SIZE)
 286         return true;
 287       if (precision == 2 * BITS_PER_WORD)
 288         return true;
 289       return false;
 290
 291     case MODE_FLOAT:
 292       if (precision == FLOAT_TYPE_SIZE)
 293         return true;
 294       if (precision == DOUBLE_TYPE_SIZE)
 295         return true;
 296       if (precision == LONG_DOUBLE_TYPE_SIZE)
 297         return true;
 298       return false;
 299
 300     case MODE_DECIMAL_FLOAT:
 301     case MODE_FRACT:
 302     case MODE_UFRACT:
 303     case MODE_ACCUM:
 304     case MODE_UACCUM:
 305       return false;
 306
 307     default:
 308       gcc_unreachable ();
 309     }
 310 }
 311
 312 /* True if the target supports decimal floating point.  */
 313
 314 bool
 315 default_decimal_float_supported_p (void)
 316 {
 317   return ENABLE_DECIMAL_FLOAT;
 318 }
 319
 320 /* True if the target supports fixed-point arithmetic.  */
 321
 322 bool
 323 default_fixed_point_supported_p (void)
 324 {
 325   return ENABLE_FIXED_POINT;
 326 }
 327
 328 /* NULL if INSN insn is valid within a low-overhead loop, otherwise returns
 329    an error message.
 330
 331    This function checks whether a given INSN is valid within a low-overhead
 332    loop.  If INSN is invalid it returns the reason for that, otherwise it
 333    returns NULL. A called function may clobber any special registers required
 334    for low-overhead looping. Additionally, some targets (eg, PPC) use the count
 335    register for branch on table instructions. We reject the doloop pattern in
 336    these cases.  */
 337
 338 const char *
 339 default_invalid_within_doloop (const_rtx insn)
 340 {
 341   if (CALL_P (insn))
 342     return "Function call in loop.";
 343
 344   if (JUMP_P (insn)
 345       && (GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC
 346           || GET_CODE (PATTERN (insn)) == ADDR_VEC))
 347     return "Computed branch in the loop.";
 348
 349   return NULL;
 350 }
 351
 352 /* Mapping of builtin functions to vectorized variants.  */
 353
 354 tree
 355 default_builtin_vectorized_function (enum built_in_function fn ATTRIBUTE_UNUSED,
 356                                      tree type_out ATTRIBUTE_UNUSED,
 357                                      tree type_in ATTRIBUTE_UNUSED)
 358 {
 359   return NULL_TREE;
 360 }
 361
 362 /* Vectorized conversion.  */
 363
 364 tree
 365 default_builtin_vectorized_conversion (enum tree_code code ATTRIBUTE_UNUSED,
 366                                        tree type ATTRIBUTE_UNUSED)
 367 {
 368   return NULL_TREE;
 369 }
 370
 371 /* Reciprocal.  */
 372
 373 tree
 374 default_builtin_reciprocal (enum built_in_function fn ATTRIBUTE_UNUSED,
 375                             bool md_fn ATTRIBUTE_UNUSED,
 376                             bool sqrt ATTRIBUTE_UNUSED)
 377 {
 378   return NULL_TREE;
 379 }
 380
 381 bool
 382 hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false (
 383         CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
 384         enum machine_mode mode ATTRIBUTE_UNUSED,
 385         const_tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
 386 {
 387   return false;
 388 }
 389
 390 bool
 391 hook_bool_CUMULATIVE_ARGS_mode_tree_bool_true (
 392         CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
 393         enum machine_mode mode ATTRIBUTE_UNUSED,
 394         const_tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
 395 {
 396   return true;
 397 }
 398
 399 int
 400 hook_int_CUMULATIVE_ARGS_mode_tree_bool_0 (
 401         CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
 402         enum machine_mode mode ATTRIBUTE_UNUSED,
 403         tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
 404 {
 405   return 0;
 406 }
 407
 408 void
 409 hook_void_bitmap (bitmap regs ATTRIBUTE_UNUSED)
 410 {
 411 }
 412
 413 const char *
 414 hook_invalid_arg_for_unprototyped_fn (
 415         const_tree typelist ATTRIBUTE_UNUSED,
 416         const_tree funcdecl ATTRIBUTE_UNUSED,
 417         const_tree val ATTRIBUTE_UNUSED)
 418 {
 419   return NULL;
 420 }
 421
 422 /* Initialize the stack protection decls.  */
 423
 424 /* Stack protection related decls living in libgcc.  */
 425 static GTY(()) tree stack_chk_guard_decl;
 426
 427 tree
 428 default_stack_protect_guard (void)
 429 {
 430   tree t = stack_chk_guard_decl;
 431
 432   if (t == NULL)
 433     {
 434       t = build_decl (VAR_DECL, get_identifier ("__stack_chk_guard"),
 435                       ptr_type_node);
 436       TREE_STATIC (t) = 1;
 437       TREE_PUBLIC (t) = 1;
 438       DECL_EXTERNAL (t) = 1;
 439       TREE_USED (t) = 1;
 440       TREE_THIS_VOLATILE (t) = 1;
 441       DECL_ARTIFICIAL (t) = 1;
 442       DECL_IGNORED_P (t) = 1;
 443
 444       stack_chk_guard_decl = t;
 445     }
 446
 447   return t;
 448 }
 449
 450 static GTY(()) tree stack_chk_fail_decl;
 451
 452 tree
 453 default_external_stack_protect_fail (void)
 454 {
 455   tree t = stack_chk_fail_decl;
 456
 457   if (t == NULL_TREE)
 458     {
 459       t = build_function_type_list (void_type_node, NULL_TREE);
 460       t = build_decl (FUNCTION_DECL, get_identifier ("__stack_chk_fail"), t);
 461       TREE_STATIC (t) = 1;
 462       TREE_PUBLIC (t) = 1;
 463       DECL_EXTERNAL (t) = 1;
 464       TREE_USED (t) = 1;
 465       TREE_THIS_VOLATILE (t) = 1;
 466       TREE_NOTHROW (t) = 1;
 467       DECL_ARTIFICIAL (t) = 1;
 468       DECL_IGNORED_P (t) = 1;
 469       DECL_VISIBILITY (t) = VISIBILITY_DEFAULT;
 470       DECL_VISIBILITY_SPECIFIED (t) = 1;
 471
 472       stack_chk_fail_decl = t;
 473     }
 474
 475   return build_call_expr (t, 0);
 476 }
 477
 478 tree
 479 default_hidden_stack_protect_fail (void)
 480 {
 481 #ifndef HAVE_GAS_HIDDEN
 482   return default_external_stack_protect_fail ();
 483 #else
 484   tree t = stack_chk_fail_decl;
 485
 486   if (!flag_pic)
 487     return default_external_stack_protect_fail ();
 488
 489   if (t == NULL_TREE)
 490     {
 491       t = build_function_type_list (void_type_node, NULL_TREE);
 492       t = build_decl (FUNCTION_DECL,
 493                       get_identifier ("__stack_chk_fail_local"), t);
 494       TREE_STATIC (t) = 1;
 495       TREE_PUBLIC (t) = 1;
 496       DECL_EXTERNAL (t) = 1;
 497       TREE_USED (t) = 1;
 498       TREE_THIS_VOLATILE (t) = 1;
 499       TREE_NOTHROW (t) = 1;
 500       DECL_ARTIFICIAL (t) = 1;
 501       DECL_IGNORED_P (t) = 1;
 502       DECL_VISIBILITY_SPECIFIED (t) = 1;
 503       DECL_VISIBILITY (t) = VISIBILITY_HIDDEN;
 504
 505       stack_chk_fail_decl = t;
 506     }
 507
 508   return build_call_expr (t, 0);
 509 #endif
 510 }
 511
 512 bool
 513 hook_bool_const_rtx_commutative_p (const_rtx x,
 514                                    int outer_code ATTRIBUTE_UNUSED)
 515 {
 516   return COMMUTATIVE_P (x);
 517 }
 518
 519 rtx
 520 default_function_value (const_tree ret_type ATTRIBUTE_UNUSED,
 521                         const_tree fn_decl_or_type,
 522                         bool outgoing ATTRIBUTE_UNUSED)
 523 {
 524   /* The old interface doesn't handle receiving the function type.  */
 525   if (fn_decl_or_type
 526       && !DECL_P (fn_decl_or_type))
 527     fn_decl_or_type = NULL;
 528
 529 #ifdef FUNCTION_OUTGOING_VALUE
 530   if (outgoing)
 531     return FUNCTION_OUTGOING_VALUE (ret_type, fn_decl_or_type);
 532 #endif
 533
 534 #ifdef FUNCTION_VALUE
 535   return FUNCTION_VALUE (ret_type, fn_decl_or_type);
 536 #else
 537   return NULL_RTX;
 538 #endif
 539 }
 540
 541 rtx
 542 default_internal_arg_pointer (void)
 543 {
 544   /* If the reg that the virtual arg pointer will be translated into is
 545      not a fixed reg or is the stack pointer, make a copy of the virtual
 546      arg pointer, and address parms via the copy.  The frame pointer is
 547      considered fixed even though it is not marked as such.  */
 548   if ((ARG_POINTER_REGNUM == STACK_POINTER_REGNUM
 549        || ! (fixed_regs[ARG_POINTER_REGNUM]
 550              || ARG_POINTER_REGNUM == FRAME_POINTER_REGNUM)))
 551     return copy_to_reg (virtual_incoming_args_rtx);
 552   else
 553     return virtual_incoming_args_rtx;
 554 }
 555
 556 enum reg_class
 557 default_secondary_reload (bool in_p ATTRIBUTE_UNUSED, rtx x ATTRIBUTE_UNUSED,
 558                           enum reg_class reload_class ATTRIBUTE_UNUSED,
 559                           enum machine_mode reload_mode ATTRIBUTE_UNUSED,
 560                           secondary_reload_info *sri)
 561 {
 562   enum reg_class class = NO_REGS;
 563
 564   if (sri->prev_sri && sri->prev_sri->t_icode != CODE_FOR_nothing)
 565     {
 566       sri->icode = sri->prev_sri->t_icode;
 567       return NO_REGS;
 568     }
 569 #ifdef SECONDARY_INPUT_RELOAD_CLASS
 570   if (in_p)
 571     class = SECONDARY_INPUT_RELOAD_CLASS (reload_class, reload_mode, x);
 572 #endif
 573 #ifdef SECONDARY_OUTPUT_RELOAD_CLASS
 574   if (! in_p)
 575     class = SECONDARY_OUTPUT_RELOAD_CLASS (reload_class, reload_mode, x);
 576 #endif
 577   if (class != NO_REGS)
 578     {
 579       enum insn_code icode = (in_p ? reload_in_optab[(int) reload_mode]
 580                               : reload_out_optab[(int) reload_mode]);
 581
 582       if (icode != CODE_FOR_nothing
 583           && insn_data[(int) icode].operand[in_p].predicate
 584           && ! insn_data[(int) icode].operand[in_p].predicate (x, reload_mode))
 585         icode = CODE_FOR_nothing;
 586       else if (icode != CODE_FOR_nothing)
 587         {
 588           const char *insn_constraint, *scratch_constraint;
 589           char insn_letter, scratch_letter;
 590           enum reg_class insn_class, scratch_class;
 591
 592           gcc_assert (insn_data[(int) icode].n_operands == 3);
 593           insn_constraint = insn_data[(int) icode].operand[!in_p].constraint;
 594           if (!*insn_constraint)
 595             insn_class = ALL_REGS;
 596           else
 597             {
 598               if (in_p)
 599                 {
 600                   gcc_assert (*insn_constraint == '=');
 601                   insn_constraint++;
 602                 }
 603               insn_letter = *insn_constraint;
 604               insn_class
 605                 = (insn_letter == 'r' ? GENERAL_REGS
 606                    : REG_CLASS_FROM_CONSTRAINT ((unsigned char) insn_letter,
 607                                                 insn_constraint));
 608               gcc_assert (insn_class != NO_REGS);
 609             }
 610
 611           scratch_constraint = insn_data[(int) icode].operand[2].constraint;
 612           /* The scratch register's constraint must start with "=&",
 613              except for an input reload, where only "=" is necessary,
 614              and where it might be beneficial to re-use registers from
 615              the input.  */
 616           gcc_assert (scratch_constraint[0] == '='
 617                       && (in_p || scratch_constraint[1] == '&'));
 618           scratch_constraint++;
 619           if (*scratch_constraint == '&')
 620             scratch_constraint++;
 621           scratch_letter = *scratch_constraint;
 622           scratch_class
 623             = (scratch_letter == 'r' ? GENERAL_REGS
 624                : REG_CLASS_FROM_CONSTRAINT ((unsigned char) scratch_letter,
 625                                             scratch_constraint));
 626
 627           if (reg_class_subset_p (reload_class, insn_class))
 628             {
 629               gcc_assert (scratch_class == class);
 630               class = NO_REGS;
 631             }
 632           else
 633             class = insn_class;
 634
 635         }
 636       if (class == NO_REGS)
 637         sri->icode = icode;
 638       else
 639         sri->t_icode = icode;
 640     }
 641   return class;
 642 }
 643
 644 bool
 645 default_handle_c_option (size_t code ATTRIBUTE_UNUSED,
 646                          const char *arg ATTRIBUTE_UNUSED,
 647                          int value ATTRIBUTE_UNUSED)
 648 {
 649   return false;
 650 }
 651
 652 /* By default, if flag_pic is true, then neither local nor global relocs
 653    should be placed in readonly memory.  */
 654
 655 int
 656 default_reloc_rw_mask (void)
 657 {
 658   return flag_pic ? 3 : 0;
 659 }
 660
 661 /* By default, do no modification. */
 662 tree default_mangle_decl_assembler_name (tree decl ATTRIBUTE_UNUSED,
 663                                          tree id)
 664 {
 665    return id;
 666 }
 667
 668 bool
 669 default_builtin_vector_alignment_reachable (const_tree type, bool is_packed)
 670 {
 671   if (is_packed)
 672     return false;
 673
 674   /* Assuming that types whose size is > pointer-size are not guaranteed to be
 675      naturally aligned.  */
 676   if (tree_int_cst_compare (TYPE_SIZE (type), bitsize_int (POINTER_SIZE)) > 0)
 677     return false;
 678
 679   /* Assuming that types whose size is <= pointer-size
 680      are naturally aligned.  */
 681   return true;
 682 }
 683
 684 #include "gt-targhooks.h"