OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [targhooks.c] - Blame information for rev 774

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 684 jeremybenn
/* Default target hook functions.
2
   Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
3
   Free Software Foundation, Inc.
4
 
5
This file is part of GCC.
6
 
7
GCC is free software; you can redistribute it and/or modify it under
8
the terms of the GNU General Public License as published by the Free
9
Software Foundation; either version 3, or (at your option) any later
10
version.
11
 
12
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13
WARRANTY; without even the implied warranty of MERCHANTABILITY or
14
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15
for more details.
16
 
17
You should have received a copy of the GNU General Public License
18
along with GCC; see the file COPYING3.  If not see
19
<http://www.gnu.org/licenses/>.  */
20
 
21
/* The migration of target macros to target hooks works as follows:
22
 
23
   1. Create a target hook that uses the existing target macros to
24
      implement the same functionality.
25
 
26
   2. Convert all the MI files to use the hook instead of the macro.
27
 
28
   3. Repeat for a majority of the remaining target macros.  This will
29
      take some time.
30
 
31
   4. Tell target maintainers to start migrating.
32
 
33
   5. Eventually convert the backends to override the hook instead of
34
      defining the macros.  This will take some time too.
35
 
36
   6. TBD when, poison the macros.  Unmigrated targets will break at
37
      this point.
38
 
39
   Note that we expect steps 1-3 to be done by the people that
40
   understand what the MI does with each macro, and step 5 to be done
41
   by the target maintainers for their respective targets.
42
 
43
   Note that steps 1 and 2 don't have to be done together, but no
44
   target can override the new hook until step 2 is complete for it.
45
 
46
   Once the macros are poisoned, we will revert to the old migration
47
   rules - migrate the macro, callers, and targets all at once.  This
48
   comment can thus be removed at that point.  */
49
 
50
#include "config.h"
51
#include "system.h"
52
#include "coretypes.h"
53
#include "tm.h"
54
#include "machmode.h"
55
#include "rtl.h"
56
#include "tree.h"
57
#include "expr.h"
58
#include "output.h"
59
#include "diagnostic-core.h"
60
#include "function.h"
61
#include "target.h"
62
#include "tm_p.h"
63
#include "target-def.h"
64
#include "ggc.h"
65
#include "hard-reg-set.h"
66
#include "regs.h"
67
#include "reload.h"
68
#include "optabs.h"
69
#include "recog.h"
70
#include "intl.h"
71
#include "opts.h"
72
#include "tree-flow.h"
73
#include "tree-ssa-alias.h"
74
 
75
 
76
bool
77
default_legitimate_address_p (enum machine_mode mode ATTRIBUTE_UNUSED,
78
                              rtx addr ATTRIBUTE_UNUSED,
79
                              bool strict ATTRIBUTE_UNUSED)
80
{
81
#ifdef GO_IF_LEGITIMATE_ADDRESS
82
  /* Defer to the old implementation using a goto.  */
83
  if (strict)
84
    return strict_memory_address_p (mode, addr);
85
  else
86
    return memory_address_p (mode, addr);
87
#else
88
  gcc_unreachable ();
89
#endif
90
}
91
 
92
void
93
default_external_libcall (rtx fun ATTRIBUTE_UNUSED)
94
{
95
#ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
96
  ASM_OUTPUT_EXTERNAL_LIBCALL(asm_out_file, fun);
97
#endif
98
}
99
 
100
int
101
default_unspec_may_trap_p (const_rtx x, unsigned flags)
102
{
103
  int i;
104
 
105
  if (GET_CODE (x) == UNSPEC_VOLATILE
106
      /* Any floating arithmetic may trap.  */
107
      || (SCALAR_FLOAT_MODE_P (GET_MODE (x))
108
          && flag_trapping_math))
109
    return 1;
110
 
111
  for (i = 0; i < XVECLEN (x, 0); ++i)
112
    {
113
      if (may_trap_p_1 (XVECEXP (x, 0, i), flags))
114
        return 1;
115
    }
116
 
117
  return 0;
118
}
119
 
120
enum machine_mode
121
default_promote_function_mode (const_tree type ATTRIBUTE_UNUSED,
122
                               enum machine_mode mode,
123
                               int *punsignedp ATTRIBUTE_UNUSED,
124
                               const_tree funtype ATTRIBUTE_UNUSED,
125
                               int for_return ATTRIBUTE_UNUSED)
126
{
127
  if (type != NULL_TREE && for_return == 2)
128
    return promote_mode (type, mode, punsignedp);
129
  return mode;
130
}
131
 
132
enum machine_mode
133
default_promote_function_mode_always_promote (const_tree type,
134
                                              enum machine_mode mode,
135
                                              int *punsignedp,
136
                                              const_tree funtype ATTRIBUTE_UNUSED,
137
                                              int for_return ATTRIBUTE_UNUSED)
138
{
139
  return promote_mode (type, mode, punsignedp);
140
}
141
 
142
 
143
enum machine_mode
144
default_cc_modes_compatible (enum machine_mode m1, enum machine_mode m2)
145
{
146
  if (m1 == m2)
147
    return m1;
148
  return VOIDmode;
149
}
150
 
151
bool
152
default_return_in_memory (const_tree type,
153
                          const_tree fntype ATTRIBUTE_UNUSED)
154
{
155
  return (TYPE_MODE (type) == BLKmode);
156
}
157
 
158
rtx
159
default_legitimize_address (rtx x, rtx orig_x ATTRIBUTE_UNUSED,
160
                            enum machine_mode mode ATTRIBUTE_UNUSED)
161
{
162
  return x;
163
}
164
 
165
rtx
166
default_expand_builtin_saveregs (void)
167
{
168
  error ("__builtin_saveregs not supported by this target");
169
  return const0_rtx;
170
}
171
 
172
void
173
default_setup_incoming_varargs (cumulative_args_t ca ATTRIBUTE_UNUSED,
174
                                enum machine_mode mode ATTRIBUTE_UNUSED,
175
                                tree type ATTRIBUTE_UNUSED,
176
                                int *pretend_arg_size ATTRIBUTE_UNUSED,
177
                                int second_time ATTRIBUTE_UNUSED)
178
{
179
}
180
 
181
/* The default implementation of TARGET_BUILTIN_SETJMP_FRAME_VALUE.  */
182
 
183
rtx
184
default_builtin_setjmp_frame_value (void)
185
{
186
  return virtual_stack_vars_rtx;
187
}
188
 
189
/* Generic hook that takes a CUMULATIVE_ARGS pointer and returns false.  */
190
 
191
bool
192
hook_bool_CUMULATIVE_ARGS_false (cumulative_args_t ca ATTRIBUTE_UNUSED)
193
{
194
  return false;
195
}
196
 
197
bool
198
default_pretend_outgoing_varargs_named (cumulative_args_t ca ATTRIBUTE_UNUSED)
199
{
200
  return (targetm.calls.setup_incoming_varargs
201
          != default_setup_incoming_varargs);
202
}
203
 
204
enum machine_mode
205
default_eh_return_filter_mode (void)
206
{
207
  return targetm.unwind_word_mode ();
208
}
209
 
210
enum machine_mode
211
default_libgcc_cmp_return_mode (void)
212
{
213
  return word_mode;
214
}
215
 
216
enum machine_mode
217
default_libgcc_shift_count_mode (void)
218
{
219
  return word_mode;
220
}
221
 
222
enum machine_mode
223
default_unwind_word_mode (void)
224
{
225
  return word_mode;
226
}
227
 
228
/* The default implementation of TARGET_SHIFT_TRUNCATION_MASK.  */
229
 
230
unsigned HOST_WIDE_INT
231
default_shift_truncation_mask (enum machine_mode mode)
232
{
233
  return SHIFT_COUNT_TRUNCATED ? GET_MODE_BITSIZE (mode) - 1 : 0;
234
}
235
 
236
/* The default implementation of TARGET_MIN_DIVISIONS_FOR_RECIP_MUL.  */
237
 
238
unsigned int
239
default_min_divisions_for_recip_mul (enum machine_mode mode ATTRIBUTE_UNUSED)
240
{
241
  return have_insn_for (DIV, mode) ? 3 : 2;
242
}
243
 
244
/* The default implementation of TARGET_MODE_REP_EXTENDED.  */
245
 
246
int
247
default_mode_rep_extended (enum machine_mode mode ATTRIBUTE_UNUSED,
248
                           enum machine_mode mode_rep ATTRIBUTE_UNUSED)
249
{
250
  return UNKNOWN;
251
}
252
 
253
/* Generic hook that takes a CUMULATIVE_ARGS pointer and returns true.  */
254
 
255
bool
256
hook_bool_CUMULATIVE_ARGS_true (cumulative_args_t a ATTRIBUTE_UNUSED)
257
{
258
  return true;
259
}
260
 
261
/* Return machine mode for non-standard suffix
262
   or VOIDmode if non-standard suffixes are unsupported.  */
263
enum machine_mode
264
default_mode_for_suffix (char suffix ATTRIBUTE_UNUSED)
265
{
266
  return VOIDmode;
267
}
268
 
269
/* The generic C++ ABI specifies this is a 64-bit value.  */
270
tree
271
default_cxx_guard_type (void)
272
{
273
  return long_long_integer_type_node;
274
}
275
 
276
 
277
/* Returns the size of the cookie to use when allocating an array
278
   whose elements have the indicated TYPE.  Assumes that it is already
279
   known that a cookie is needed.  */
280
 
281
tree
282
default_cxx_get_cookie_size (tree type)
283
{
284
  tree cookie_size;
285
 
286
  /* We need to allocate an additional max (sizeof (size_t), alignof
287
     (true_type)) bytes.  */
288
  tree sizetype_size;
289
  tree type_align;
290
 
291
  sizetype_size = size_in_bytes (sizetype);
292
  type_align = size_int (TYPE_ALIGN_UNIT (type));
293
  if (INT_CST_LT_UNSIGNED (type_align, sizetype_size))
294
    cookie_size = sizetype_size;
295
  else
296
    cookie_size = type_align;
297
 
298
  return cookie_size;
299
}
300
 
301
/* Return true if a parameter must be passed by reference.  This version
302
   of the TARGET_PASS_BY_REFERENCE hook uses just MUST_PASS_IN_STACK.  */
303
 
304
bool
305
hook_pass_by_reference_must_pass_in_stack (cumulative_args_t c ATTRIBUTE_UNUSED,
306
        enum machine_mode mode ATTRIBUTE_UNUSED, const_tree type ATTRIBUTE_UNUSED,
307
        bool named_arg ATTRIBUTE_UNUSED)
308
{
309
  return targetm.calls.must_pass_in_stack (mode, type);
310
}
311
 
312
/* Return true if a parameter follows callee copies conventions.  This
313
   version of the hook is true for all named arguments.  */
314
 
315
bool
316
hook_callee_copies_named (cumulative_args_t ca ATTRIBUTE_UNUSED,
317
                          enum machine_mode mode ATTRIBUTE_UNUSED,
318
                          const_tree type ATTRIBUTE_UNUSED, bool named)
319
{
320
  return named;
321
}
322
 
323
/* Emit to STREAM the assembler syntax for insn operand X.  */
324
 
325
void
326
default_print_operand (FILE *stream ATTRIBUTE_UNUSED, rtx x ATTRIBUTE_UNUSED,
327
                       int code ATTRIBUTE_UNUSED)
328
{
329
#ifdef PRINT_OPERAND
330
  PRINT_OPERAND (stream, x, code);
331
#else
332
  gcc_unreachable ();
333
#endif
334
}
335
 
336
/* Emit to STREAM the assembler syntax for an insn operand whose memory
337
   address is X.  */
338
 
339
void
340
default_print_operand_address (FILE *stream ATTRIBUTE_UNUSED,
341
                               rtx x ATTRIBUTE_UNUSED)
342
{
343
#ifdef PRINT_OPERAND_ADDRESS
344
  PRINT_OPERAND_ADDRESS (stream, x);
345
#else
346
  gcc_unreachable ();
347
#endif
348
}
349
 
350
/* Return true if CODE is a valid punctuation character for the
351
   `print_operand' hook.  */
352
 
353
bool
354
default_print_operand_punct_valid_p (unsigned char code ATTRIBUTE_UNUSED)
355
{
356
#ifdef PRINT_OPERAND_PUNCT_VALID_P
357
  return PRINT_OPERAND_PUNCT_VALID_P (code);
358
#else
359
  return false;
360
#endif
361
}
362
 
363
/* The default implementation of TARGET_MANGLE_ASSEMBLER_NAME.  */
364
tree
365
default_mangle_assembler_name (const char *name ATTRIBUTE_UNUSED)
366
{
367
  const char *skipped = name + (*name == '*' ? 1 : 0);
368
  const char *stripped = targetm.strip_name_encoding (skipped);
369
  if (*name != '*' && user_label_prefix[0])
370
    stripped = ACONCAT ((user_label_prefix, stripped, NULL));
371
  return get_identifier (stripped);
372
}
373
 
374
/* True if MODE is valid for the target.  By "valid", we mean able to
375
   be manipulated in non-trivial ways.  In particular, this means all
376
   the arithmetic is supported.
377
 
378
   By default we guess this means that any C type is supported.  If
379
   we can't map the mode back to a type that would be available in C,
380
   then reject it.  Special case, here, is the double-word arithmetic
381
   supported by optabs.c.  */
382
 
383
bool
384
default_scalar_mode_supported_p (enum machine_mode mode)
385
{
386
  int precision = GET_MODE_PRECISION (mode);
387
 
388
  switch (GET_MODE_CLASS (mode))
389
    {
390
    case MODE_PARTIAL_INT:
391
    case MODE_INT:
392
      if (precision == CHAR_TYPE_SIZE)
393
        return true;
394
      if (precision == SHORT_TYPE_SIZE)
395
        return true;
396
      if (precision == INT_TYPE_SIZE)
397
        return true;
398
      if (precision == LONG_TYPE_SIZE)
399
        return true;
400
      if (precision == LONG_LONG_TYPE_SIZE)
401
        return true;
402
      if (precision == 2 * BITS_PER_WORD)
403
        return true;
404
      return false;
405
 
406
    case MODE_FLOAT:
407
      if (precision == FLOAT_TYPE_SIZE)
408
        return true;
409
      if (precision == DOUBLE_TYPE_SIZE)
410
        return true;
411
      if (precision == LONG_DOUBLE_TYPE_SIZE)
412
        return true;
413
      return false;
414
 
415
    case MODE_DECIMAL_FLOAT:
416
    case MODE_FRACT:
417
    case MODE_UFRACT:
418
    case MODE_ACCUM:
419
    case MODE_UACCUM:
420
      return false;
421
 
422
    default:
423
      gcc_unreachable ();
424
    }
425
}
426
 
427
/* Make some target macros useable by target-independent code.  */
428
bool
429
targhook_words_big_endian (void)
430
{
431
  return !!WORDS_BIG_ENDIAN;
432
}
433
 
434
bool
435
targhook_float_words_big_endian (void)
436
{
437
  return !!FLOAT_WORDS_BIG_ENDIAN;
438
}
439
 
440
/* True if the target supports decimal floating point.  */
441
 
442
bool
443
default_decimal_float_supported_p (void)
444
{
445
  return ENABLE_DECIMAL_FLOAT;
446
}
447
 
448
/* True if the target supports fixed-point arithmetic.  */
449
 
450
bool
451
default_fixed_point_supported_p (void)
452
{
453
  return ENABLE_FIXED_POINT;
454
}
455
 
456
/* NULL if INSN insn is valid within a low-overhead loop, otherwise returns
457
   an error message.
458
 
459
   This function checks whether a given INSN is valid within a low-overhead
460
   loop.  If INSN is invalid it returns the reason for that, otherwise it
461
   returns NULL. A called function may clobber any special registers required
462
   for low-overhead looping. Additionally, some targets (eg, PPC) use the count
463
   register for branch on table instructions. We reject the doloop pattern in
464
   these cases.  */
465
 
466
const char *
467
default_invalid_within_doloop (const_rtx insn)
468
{
469
  if (CALL_P (insn))
470
    return "Function call in loop.";
471
 
472
  if (JUMP_TABLE_DATA_P (insn))
473
    return "Computed branch in the loop.";
474
 
475
  return NULL;
476
}
477
 
478
/* Mapping of builtin functions to vectorized variants.  */
479
 
480
tree
481
default_builtin_vectorized_function (tree fndecl ATTRIBUTE_UNUSED,
482
                                     tree type_out ATTRIBUTE_UNUSED,
483
                                     tree type_in ATTRIBUTE_UNUSED)
484
{
485
  return NULL_TREE;
486
}
487
 
488
/* Vectorized conversion.  */
489
 
490
tree
491
default_builtin_vectorized_conversion (unsigned int code ATTRIBUTE_UNUSED,
492
                                       tree dest_type ATTRIBUTE_UNUSED,
493
                                       tree src_type ATTRIBUTE_UNUSED)
494
{
495
  return NULL_TREE;
496
}
497
 
498
/* Default vectorizer cost model values.  */
499
 
500
int
501
default_builtin_vectorization_cost (enum vect_cost_for_stmt type_of_cost,
502
                                    tree vectype ATTRIBUTE_UNUSED,
503
                                    int misalign ATTRIBUTE_UNUSED)
504
{
505
  switch (type_of_cost)
506
    {
507
      case scalar_stmt:
508
      case scalar_load:
509
      case scalar_store:
510
      case vector_stmt:
511
      case vector_load:
512
      case vector_store:
513
      case vec_to_scalar:
514
      case scalar_to_vec:
515
      case cond_branch_not_taken:
516
      case vec_perm:
517
      case vec_promote_demote:
518
        return 1;
519
 
520
      case unaligned_load:
521
      case unaligned_store:
522
        return 2;
523
 
524
      case cond_branch_taken:
525
        return 3;
526
 
527
      default:
528
        gcc_unreachable ();
529
    }
530
}
531
 
532
/* Reciprocal.  */
533
 
534
tree
535
default_builtin_reciprocal (unsigned int fn ATTRIBUTE_UNUSED,
536
                            bool md_fn ATTRIBUTE_UNUSED,
537
                            bool sqrt ATTRIBUTE_UNUSED)
538
{
539
  return NULL_TREE;
540
}
541
 
542
bool
543
hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false (
544
        cumulative_args_t ca ATTRIBUTE_UNUSED,
545
        enum machine_mode mode ATTRIBUTE_UNUSED,
546
        const_tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
547
{
548
  return false;
549
}
550
 
551
bool
552
hook_bool_CUMULATIVE_ARGS_mode_tree_bool_true (
553
        cumulative_args_t ca ATTRIBUTE_UNUSED,
554
        enum machine_mode mode ATTRIBUTE_UNUSED,
555
        const_tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
556
{
557
  return true;
558
}
559
 
560
int
561
hook_int_CUMULATIVE_ARGS_mode_tree_bool_0 (
562
        cumulative_args_t ca ATTRIBUTE_UNUSED,
563
        enum machine_mode mode ATTRIBUTE_UNUSED,
564
        tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED)
565
{
566
  return 0;
567
}
568
 
569
void
570
default_function_arg_advance (cumulative_args_t ca ATTRIBUTE_UNUSED,
571
                              enum machine_mode mode ATTRIBUTE_UNUSED,
572
                              const_tree type ATTRIBUTE_UNUSED,
573
                              bool named ATTRIBUTE_UNUSED)
574
{
575
  gcc_unreachable ();
576
}
577
 
578
rtx
579
default_function_arg (cumulative_args_t ca ATTRIBUTE_UNUSED,
580
                      enum machine_mode mode ATTRIBUTE_UNUSED,
581
                      const_tree type ATTRIBUTE_UNUSED,
582
                      bool named ATTRIBUTE_UNUSED)
583
{
584
  gcc_unreachable ();
585
}
586
 
587
rtx
588
default_function_incoming_arg (cumulative_args_t ca ATTRIBUTE_UNUSED,
589
                               enum machine_mode mode ATTRIBUTE_UNUSED,
590
                               const_tree type ATTRIBUTE_UNUSED,
591
                               bool named ATTRIBUTE_UNUSED)
592
{
593
  gcc_unreachable ();
594
}
595
 
596
unsigned int
597
default_function_arg_boundary (enum machine_mode mode ATTRIBUTE_UNUSED,
598
                               const_tree type ATTRIBUTE_UNUSED)
599
{
600
  return PARM_BOUNDARY;
601
}
602
 
603
unsigned int
604
default_function_arg_round_boundary (enum machine_mode mode ATTRIBUTE_UNUSED,
605
                                     const_tree type ATTRIBUTE_UNUSED)
606
{
607
  return PARM_BOUNDARY;
608
}
609
 
610
void
611
hook_void_bitmap (bitmap regs ATTRIBUTE_UNUSED)
612
{
613
}
614
 
615
const char *
616
hook_invalid_arg_for_unprototyped_fn (
617
        const_tree typelist ATTRIBUTE_UNUSED,
618
        const_tree funcdecl ATTRIBUTE_UNUSED,
619
        const_tree val ATTRIBUTE_UNUSED)
620
{
621
  return NULL;
622
}
623
 
624
/* Initialize the stack protection decls.  */
625
 
626
/* Stack protection related decls living in libgcc.  */
627
static GTY(()) tree stack_chk_guard_decl;
628
 
629
tree
630
default_stack_protect_guard (void)
631
{
632
  tree t = stack_chk_guard_decl;
633
 
634
  if (t == NULL)
635
    {
636
      rtx x;
637
 
638
      t = build_decl (UNKNOWN_LOCATION,
639
                      VAR_DECL, get_identifier ("__stack_chk_guard"),
640
                      ptr_type_node);
641
      TREE_STATIC (t) = 1;
642
      TREE_PUBLIC (t) = 1;
643
      DECL_EXTERNAL (t) = 1;
644
      TREE_USED (t) = 1;
645
      TREE_THIS_VOLATILE (t) = 1;
646
      DECL_ARTIFICIAL (t) = 1;
647
      DECL_IGNORED_P (t) = 1;
648
 
649
      /* Do not share RTL as the declaration is visible outside of
650
         current function.  */
651
      x = DECL_RTL (t);
652
      RTX_FLAG (x, used) = 1;
653
 
654
      stack_chk_guard_decl = t;
655
    }
656
 
657
  return t;
658
}
659
 
660
static GTY(()) tree stack_chk_fail_decl;
661
 
662
tree
663
default_external_stack_protect_fail (void)
664
{
665
  tree t = stack_chk_fail_decl;
666
 
667
  if (t == NULL_TREE)
668
    {
669
      t = build_function_type_list (void_type_node, NULL_TREE);
670
      t = build_decl (UNKNOWN_LOCATION,
671
                      FUNCTION_DECL, get_identifier ("__stack_chk_fail"), t);
672
      TREE_STATIC (t) = 1;
673
      TREE_PUBLIC (t) = 1;
674
      DECL_EXTERNAL (t) = 1;
675
      TREE_USED (t) = 1;
676
      TREE_THIS_VOLATILE (t) = 1;
677
      TREE_NOTHROW (t) = 1;
678
      DECL_ARTIFICIAL (t) = 1;
679
      DECL_IGNORED_P (t) = 1;
680
      DECL_VISIBILITY (t) = VISIBILITY_DEFAULT;
681
      DECL_VISIBILITY_SPECIFIED (t) = 1;
682
 
683
      stack_chk_fail_decl = t;
684
    }
685
 
686
  return build_call_expr (t, 0);
687
}
688
 
689
tree
690
default_hidden_stack_protect_fail (void)
691
{
692
#ifndef HAVE_GAS_HIDDEN
693
  return default_external_stack_protect_fail ();
694
#else
695
  tree t = stack_chk_fail_decl;
696
 
697
  if (!flag_pic)
698
    return default_external_stack_protect_fail ();
699
 
700
  if (t == NULL_TREE)
701
    {
702
      t = build_function_type_list (void_type_node, NULL_TREE);
703
      t = build_decl (UNKNOWN_LOCATION, FUNCTION_DECL,
704
                      get_identifier ("__stack_chk_fail_local"), t);
705
      TREE_STATIC (t) = 1;
706
      TREE_PUBLIC (t) = 1;
707
      DECL_EXTERNAL (t) = 1;
708
      TREE_USED (t) = 1;
709
      TREE_THIS_VOLATILE (t) = 1;
710
      TREE_NOTHROW (t) = 1;
711
      DECL_ARTIFICIAL (t) = 1;
712
      DECL_IGNORED_P (t) = 1;
713
      DECL_VISIBILITY_SPECIFIED (t) = 1;
714
      DECL_VISIBILITY (t) = VISIBILITY_HIDDEN;
715
 
716
      stack_chk_fail_decl = t;
717
    }
718
 
719
  return build_call_expr (t, 0);
720
#endif
721
}
722
 
723
bool
724
hook_bool_const_rtx_commutative_p (const_rtx x,
725
                                   int outer_code ATTRIBUTE_UNUSED)
726
{
727
  return COMMUTATIVE_P (x);
728
}
729
 
730
rtx
731
default_function_value (const_tree ret_type ATTRIBUTE_UNUSED,
732
                        const_tree fn_decl_or_type,
733
                        bool outgoing ATTRIBUTE_UNUSED)
734
{
735
  /* The old interface doesn't handle receiving the function type.  */
736
  if (fn_decl_or_type
737
      && !DECL_P (fn_decl_or_type))
738
    fn_decl_or_type = NULL;
739
 
740
#ifdef FUNCTION_VALUE
741
  return FUNCTION_VALUE (ret_type, fn_decl_or_type);
742
#else
743
  gcc_unreachable ();
744
#endif
745
}
746
 
747
rtx
748
default_libcall_value (enum machine_mode mode ATTRIBUTE_UNUSED,
749
                       const_rtx fun ATTRIBUTE_UNUSED)
750
{
751
#ifdef LIBCALL_VALUE
752
  return LIBCALL_VALUE (mode);
753
#else
754
  gcc_unreachable ();
755
#endif
756
}
757
 
758
/* The default hook for TARGET_FUNCTION_VALUE_REGNO_P.  */
759
 
760
bool
761
default_function_value_regno_p (const unsigned int regno ATTRIBUTE_UNUSED)
762
{
763
#ifdef FUNCTION_VALUE_REGNO_P
764
  return FUNCTION_VALUE_REGNO_P (regno);
765
#else
766
  gcc_unreachable ();
767
#endif
768
}
769
 
770
rtx
771
default_internal_arg_pointer (void)
772
{
773
  /* If the reg that the virtual arg pointer will be translated into is
774
     not a fixed reg or is the stack pointer, make a copy of the virtual
775
     arg pointer, and address parms via the copy.  The frame pointer is
776
     considered fixed even though it is not marked as such.  */
777
  if ((ARG_POINTER_REGNUM == STACK_POINTER_REGNUM
778
       || ! (fixed_regs[ARG_POINTER_REGNUM]
779
             || ARG_POINTER_REGNUM == FRAME_POINTER_REGNUM)))
780
    return copy_to_reg (virtual_incoming_args_rtx);
781
  else
782
    return virtual_incoming_args_rtx;
783
}
784
 
785
rtx
786
default_static_chain (const_tree fndecl, bool incoming_p)
787
{
788
  if (!DECL_STATIC_CHAIN (fndecl))
789
    return NULL;
790
 
791
  if (incoming_p)
792
    {
793
#ifdef STATIC_CHAIN_INCOMING_REGNUM
794
      return gen_rtx_REG (Pmode, STATIC_CHAIN_INCOMING_REGNUM);
795
#endif
796
    }
797
 
798
#ifdef STATIC_CHAIN_REGNUM
799
  return gen_rtx_REG (Pmode, STATIC_CHAIN_REGNUM);
800
#endif
801
 
802
  {
803
    static bool issued_error;
804
    if (!issued_error)
805
      {
806
        issued_error = true;
807
        sorry ("nested functions not supported on this target");
808
      }
809
 
810
    /* It really doesn't matter what we return here, so long at it
811
       doesn't cause the rest of the compiler to crash.  */
812
    return gen_rtx_MEM (Pmode, stack_pointer_rtx);
813
  }
814
}
815
 
816
void
817
default_trampoline_init (rtx ARG_UNUSED (m_tramp), tree ARG_UNUSED (t_func),
818
                         rtx ARG_UNUSED (r_chain))
819
{
820
  sorry ("nested function trampolines not supported on this target");
821
}
822
 
823
int
824
default_return_pops_args (tree fundecl ATTRIBUTE_UNUSED,
825
                          tree funtype ATTRIBUTE_UNUSED,
826
                          int size ATTRIBUTE_UNUSED)
827
{
828
  return 0;
829
}
830
 
831
reg_class_t
832
default_branch_target_register_class (void)
833
{
834
  return NO_REGS;
835
}
836
 
837
reg_class_t
838
default_secondary_reload (bool in_p ATTRIBUTE_UNUSED, rtx x ATTRIBUTE_UNUSED,
839
                          reg_class_t reload_class_i ATTRIBUTE_UNUSED,
840
                          enum machine_mode reload_mode ATTRIBUTE_UNUSED,
841
                          secondary_reload_info *sri)
842
{
843
  enum reg_class rclass = NO_REGS;
844
  enum reg_class reload_class = (enum reg_class) reload_class_i;
845
 
846
  if (sri->prev_sri && sri->prev_sri->t_icode != CODE_FOR_nothing)
847
    {
848
      sri->icode = sri->prev_sri->t_icode;
849
      return NO_REGS;
850
    }
851
#ifdef SECONDARY_INPUT_RELOAD_CLASS
852
  if (in_p)
853
    rclass = SECONDARY_INPUT_RELOAD_CLASS (reload_class, reload_mode, x);
854
#endif
855
#ifdef SECONDARY_OUTPUT_RELOAD_CLASS
856
  if (! in_p)
857
    rclass = SECONDARY_OUTPUT_RELOAD_CLASS (reload_class, reload_mode, x);
858
#endif
859
  if (rclass != NO_REGS)
860
    {
861
      enum insn_code icode
862
        = direct_optab_handler (in_p ? reload_in_optab : reload_out_optab,
863
                                reload_mode);
864
 
865
      if (icode != CODE_FOR_nothing
866
          && !insn_operand_matches (icode, in_p, x))
867
        icode = CODE_FOR_nothing;
868
      else if (icode != CODE_FOR_nothing)
869
        {
870
          const char *insn_constraint, *scratch_constraint;
871
          char insn_letter, scratch_letter;
872
          enum reg_class insn_class, scratch_class;
873
 
874
          gcc_assert (insn_data[(int) icode].n_operands == 3);
875
          insn_constraint = insn_data[(int) icode].operand[!in_p].constraint;
876
          if (!*insn_constraint)
877
            insn_class = ALL_REGS;
878
          else
879
            {
880
              if (in_p)
881
                {
882
                  gcc_assert (*insn_constraint == '=');
883
                  insn_constraint++;
884
                }
885
              insn_letter = *insn_constraint;
886
              insn_class
887
                = (insn_letter == 'r' ? GENERAL_REGS
888
                   : REG_CLASS_FROM_CONSTRAINT ((unsigned char) insn_letter,
889
                                                insn_constraint));
890
              gcc_assert (insn_class != NO_REGS);
891
            }
892
 
893
          scratch_constraint = insn_data[(int) icode].operand[2].constraint;
894
          /* The scratch register's constraint must start with "=&",
895
             except for an input reload, where only "=" is necessary,
896
             and where it might be beneficial to re-use registers from
897
             the input.  */
898
          gcc_assert (scratch_constraint[0] == '='
899
                      && (in_p || scratch_constraint[1] == '&'));
900
          scratch_constraint++;
901
          if (*scratch_constraint == '&')
902
            scratch_constraint++;
903
          scratch_letter = *scratch_constraint;
904
          scratch_class
905
            = (scratch_letter == 'r' ? GENERAL_REGS
906
               : REG_CLASS_FROM_CONSTRAINT ((unsigned char) scratch_letter,
907
                                            scratch_constraint));
908
 
909
          if (reg_class_subset_p (reload_class, insn_class))
910
            {
911
              gcc_assert (scratch_class == rclass);
912
              rclass = NO_REGS;
913
            }
914
          else
915
            rclass = insn_class;
916
 
917
        }
918
      if (rclass == NO_REGS)
919
        sri->icode = icode;
920
      else
921
        sri->t_icode = icode;
922
    }
923
  return rclass;
924
}
925
 
926
/* By default, if flag_pic is true, then neither local nor global relocs
927
   should be placed in readonly memory.  */
928
 
929
int
930
default_reloc_rw_mask (void)
931
{
932
  return flag_pic ? 3 : 0;
933
}
934
 
935
/* By default, do no modification. */
936
tree default_mangle_decl_assembler_name (tree decl ATTRIBUTE_UNUSED,
937
                                         tree id)
938
{
939
   return id;
940
}
941
 
942
bool
943
default_builtin_vector_alignment_reachable (const_tree type, bool is_packed)
944
{
945
  if (is_packed)
946
    return false;
947
 
948
  /* Assuming that types whose size is > pointer-size are not guaranteed to be
949
     naturally aligned.  */
950
  if (tree_int_cst_compare (TYPE_SIZE (type), bitsize_int (POINTER_SIZE)) > 0)
951
    return false;
952
 
953
  /* Assuming that types whose size is <= pointer-size
954
     are naturally aligned.  */
955
  return true;
956
}
957
 
958
/* By default, assume that a target supports any factor of misalignment
959
   memory access if it supports movmisalign patten.
960
   is_packed is true if the memory access is defined in a packed struct.  */
961
bool
962
default_builtin_support_vector_misalignment (enum machine_mode mode,
963
                                             const_tree type
964
                                             ATTRIBUTE_UNUSED,
965
                                             int misalignment
966
                                             ATTRIBUTE_UNUSED,
967
                                             bool is_packed
968
                                             ATTRIBUTE_UNUSED)
969
{
970
  if (optab_handler (movmisalign_optab, mode) != CODE_FOR_nothing)
971
    return true;
972
  return false;
973
}
974
 
975
/* By default, only attempt to parallelize bitwise operations, and
976
   possibly adds/subtracts using bit-twiddling.  */
977
 
978
enum machine_mode
979
default_preferred_simd_mode (enum machine_mode mode ATTRIBUTE_UNUSED)
980
{
981
  return word_mode;
982
}
983
 
984
/* By default only the size derived from the preferred vector mode
985
   is tried.  */
986
 
987
unsigned int
988
default_autovectorize_vector_sizes (void)
989
{
990
  return 0;
991
}
992
 
993
/* Determine whether or not a pointer mode is valid. Assume defaults
994
   of ptr_mode or Pmode - can be overridden.  */
995
bool
996
default_valid_pointer_mode (enum machine_mode mode)
997
{
998
  return (mode == ptr_mode || mode == Pmode);
999
}
1000
 
1001
/* Determine whether the memory reference specified by REF may alias
1002
   the C libraries errno location.  */
1003
bool
1004
default_ref_may_alias_errno (ao_ref *ref)
1005
{
1006
  tree base = ao_ref_base (ref);
1007
  /* The default implementation assumes the errno location is
1008
     a declaration of type int or is always accessed via a
1009
     pointer to int.  We assume that accesses to errno are
1010
     not deliberately obfuscated (even in conforming ways).  */
1011
  if (TYPE_UNSIGNED (TREE_TYPE (base))
1012
      || TYPE_MODE (TREE_TYPE (base)) != TYPE_MODE (integer_type_node))
1013
    return false;
1014
  /* The default implementation assumes an errno location
1015
     declaration is never defined in the current compilation unit.  */
1016
  if (DECL_P (base)
1017
      && !TREE_STATIC (base))
1018
    return true;
1019
  else if (TREE_CODE (base) == MEM_REF
1020
           && TREE_CODE (TREE_OPERAND (base, 0)) == SSA_NAME)
1021
    {
1022
      struct ptr_info_def *pi = SSA_NAME_PTR_INFO (TREE_OPERAND (base, 0));
1023
      return !pi || pi->pt.anything || pi->pt.nonlocal;
1024
    }
1025
  return false;
1026
}
1027
 
1028
/* Return the mode for a pointer to a given ADDRSPACE, defaulting to ptr_mode
1029
   for the generic address space only.  */
1030
 
1031
enum machine_mode
1032
default_addr_space_pointer_mode (addr_space_t addrspace ATTRIBUTE_UNUSED)
1033
{
1034
  gcc_assert (ADDR_SPACE_GENERIC_P (addrspace));
1035
  return ptr_mode;
1036
}
1037
 
1038
/* Return the mode for an address in a given ADDRSPACE, defaulting to Pmode
1039
   for the generic address space only.  */
1040
 
1041
enum machine_mode
1042
default_addr_space_address_mode (addr_space_t addrspace ATTRIBUTE_UNUSED)
1043
{
1044
  gcc_assert (ADDR_SPACE_GENERIC_P (addrspace));
1045
  return Pmode;
1046
}
1047
 
1048
/* Named address space version of valid_pointer_mode.  */
1049
 
1050
bool
1051
default_addr_space_valid_pointer_mode (enum machine_mode mode, addr_space_t as)
1052
{
1053
  if (!ADDR_SPACE_GENERIC_P (as))
1054
    return (mode == targetm.addr_space.pointer_mode (as)
1055
            || mode == targetm.addr_space.address_mode (as));
1056
 
1057
  return targetm.valid_pointer_mode (mode);
1058
}
1059
 
1060
/* Some places still assume that all pointer or address modes are the
1061
   standard Pmode and ptr_mode.  These optimizations become invalid if
1062
   the target actually supports multiple different modes.  For now,
1063
   we disable such optimizations on such targets, using this function.  */
1064
 
1065
bool
1066
target_default_pointer_address_modes_p (void)
1067
{
1068
  if (targetm.addr_space.address_mode != default_addr_space_address_mode)
1069
    return false;
1070
  if (targetm.addr_space.pointer_mode != default_addr_space_pointer_mode)
1071
    return false;
1072
 
1073
  return true;
1074
}
1075
 
1076
/* Named address space version of legitimate_address_p.  */
1077
 
1078
bool
1079
default_addr_space_legitimate_address_p (enum machine_mode mode, rtx mem,
1080
                                         bool strict, addr_space_t as)
1081
{
1082
  if (!ADDR_SPACE_GENERIC_P (as))
1083
    gcc_unreachable ();
1084
 
1085
  return targetm.legitimate_address_p (mode, mem, strict);
1086
}
1087
 
1088
/* Named address space version of LEGITIMIZE_ADDRESS.  */
1089
 
1090
rtx
1091
default_addr_space_legitimize_address (rtx x, rtx oldx,
1092
                                       enum machine_mode mode, addr_space_t as)
1093
{
1094
  if (!ADDR_SPACE_GENERIC_P (as))
1095
    return x;
1096
 
1097
  return targetm.legitimize_address (x, oldx, mode);
1098
}
1099
 
1100
/* The default hook for determining if one named address space is a subset of
1101
   another and to return which address space to use as the common address
1102
   space.  */
1103
 
1104
bool
1105
default_addr_space_subset_p (addr_space_t subset, addr_space_t superset)
1106
{
1107
  return (subset == superset);
1108
}
1109
 
1110
/* The default hook for TARGET_ADDR_SPACE_CONVERT. This hook should never be
1111
   called for targets with only a generic address space.  */
1112
 
1113
rtx
1114
default_addr_space_convert (rtx op ATTRIBUTE_UNUSED,
1115
                            tree from_type ATTRIBUTE_UNUSED,
1116
                            tree to_type ATTRIBUTE_UNUSED)
1117
{
1118
  gcc_unreachable ();
1119
}
1120
 
1121
bool
1122
default_hard_regno_scratch_ok (unsigned int regno ATTRIBUTE_UNUSED)
1123
{
1124
  return true;
1125
}
1126
 
1127
/* The default implementation of TARGET_MODE_DEPENDENT_ADDRESS_P.  */
1128
 
1129
bool
1130
default_mode_dependent_address_p (const_rtx addr ATTRIBUTE_UNUSED)
1131
{
1132
#ifdef GO_IF_MODE_DEPENDENT_ADDRESS
1133
 
1134
  GO_IF_MODE_DEPENDENT_ADDRESS (CONST_CAST_RTX (addr), win);
1135
  return false;
1136
  /* Label `win' might (not) be used via GO_IF_MODE_DEPENDENT_ADDRESS.  */
1137
 win: ATTRIBUTE_UNUSED_LABEL
1138
  return true;
1139
 
1140
#else
1141
 
1142
  return false;
1143
 
1144
#endif
1145
}
1146
 
1147
bool
1148
default_target_option_valid_attribute_p (tree ARG_UNUSED (fndecl),
1149
                                         tree ARG_UNUSED (name),
1150
                                         tree ARG_UNUSED (args),
1151
                                         int ARG_UNUSED (flags))
1152
{
1153
  warning (OPT_Wattributes,
1154
           "target attribute is not supported on this machine");
1155
 
1156
  return false;
1157
}
1158
 
1159
bool
1160
default_target_option_pragma_parse (tree ARG_UNUSED (args),
1161
                                    tree ARG_UNUSED (pop_target))
1162
{
1163
  warning (OPT_Wpragmas,
1164
           "#pragma GCC target is not supported for this machine");
1165
 
1166
  return false;
1167
}
1168
 
1169
bool
1170
default_target_can_inline_p (tree caller, tree callee)
1171
{
1172
  bool ret = false;
1173
  tree callee_opts = DECL_FUNCTION_SPECIFIC_TARGET (callee);
1174
  tree caller_opts = DECL_FUNCTION_SPECIFIC_TARGET (caller);
1175
 
1176
  /* If callee has no option attributes, then it is ok to inline */
1177
  if (!callee_opts)
1178
    ret = true;
1179
 
1180
  /* If caller has no option attributes, but callee does then it is not ok to
1181
     inline */
1182
  else if (!caller_opts)
1183
    ret = false;
1184
 
1185
  /* If both caller and callee have attributes, assume that if the
1186
     pointer is different, the two functions have different target
1187
     options since build_target_option_node uses a hash table for the
1188
     options.  */
1189
  else
1190
    ret = (callee_opts == caller_opts);
1191
 
1192
  return ret;
1193
}
1194
 
1195
#ifndef HAVE_casesi
1196
# define HAVE_casesi 0
1197
#endif
1198
 
1199
/* If the machine does not have a case insn that compares the bounds,
1200
   this means extra overhead for dispatch tables, which raises the
1201
   threshold for using them.  */
1202
 
1203
unsigned int default_case_values_threshold (void)
1204
{
1205
  return (HAVE_casesi ? 4 : 5);
1206
}
1207
 
1208
bool
1209
default_have_conditional_execution (void)
1210
{
1211
#ifdef HAVE_conditional_execution
1212
  return HAVE_conditional_execution;
1213
#else
1214
  return false;
1215
#endif
1216
}
1217
 
1218
tree
1219
default_builtin_tm_load_store (tree ARG_UNUSED (type))
1220
{
1221
  return NULL_TREE;
1222
}
1223
 
1224
/* Compute cost of moving registers to/from memory.  */
1225
 
1226
int
1227
default_memory_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
1228
                          reg_class_t rclass ATTRIBUTE_UNUSED,
1229
                          bool in ATTRIBUTE_UNUSED)
1230
{
1231
#ifndef MEMORY_MOVE_COST
1232
    return (4 + memory_move_secondary_cost (mode, (enum reg_class) rclass, in));
1233
#else
1234
    return MEMORY_MOVE_COST (mode, (enum reg_class) rclass, in);
1235
#endif
1236
}
1237
 
1238
/* Compute cost of moving data from a register of class FROM to one of
1239
   TO, using MODE.  */
1240
 
1241
int
1242
default_register_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
1243
                            reg_class_t from ATTRIBUTE_UNUSED,
1244
                            reg_class_t to ATTRIBUTE_UNUSED)
1245
{
1246
#ifndef REGISTER_MOVE_COST
1247
  return 2;
1248
#else
1249
  return REGISTER_MOVE_COST (mode, (enum reg_class) from, (enum reg_class) to);
1250
#endif
1251
}
1252
 
1253
bool
1254
default_profile_before_prologue (void)
1255
{
1256
#ifdef PROFILE_BEFORE_PROLOGUE
1257
  return true;
1258
#else
1259
  return false;
1260
#endif
1261
}
1262
 
1263
/* The default implementation of TARGET_PREFERRED_RELOAD_CLASS.  */
1264
 
1265
reg_class_t
1266
default_preferred_reload_class (rtx x ATTRIBUTE_UNUSED,
1267
                                reg_class_t rclass)
1268
{
1269
#ifdef PREFERRED_RELOAD_CLASS 
1270
  return (reg_class_t) PREFERRED_RELOAD_CLASS (x, (enum reg_class) rclass);
1271
#else
1272
  return rclass;
1273
#endif
1274
}
1275
 
1276
/* The default implementation of TARGET_OUTPUT_PREFERRED_RELOAD_CLASS.  */
1277
 
1278
reg_class_t
1279
default_preferred_output_reload_class (rtx x ATTRIBUTE_UNUSED,
1280
                                       reg_class_t rclass)
1281
{
1282
  return rclass;
1283
}
1284
 
1285
/* The default implementation of TARGET_PREFERRED_RENAME_CLASS.  */
1286
reg_class_t
1287
default_preferred_rename_class (reg_class_t rclass ATTRIBUTE_UNUSED)
1288
{
1289
  return NO_REGS;
1290
}
1291
 
1292
/* The default implementation of TARGET_CLASS_LIKELY_SPILLED_P.  */
1293
 
1294
bool
1295
default_class_likely_spilled_p (reg_class_t rclass)
1296
{
1297
  return (reg_class_size[(int) rclass] == 1);
1298
}
1299
 
1300
/* The default implementation of TARGET_CLASS_MAX_NREGS.  */
1301
 
1302
unsigned char
1303
default_class_max_nregs (reg_class_t rclass ATTRIBUTE_UNUSED,
1304
                         enum machine_mode mode ATTRIBUTE_UNUSED)
1305
{
1306
#ifdef CLASS_MAX_NREGS
1307
  return (unsigned char) CLASS_MAX_NREGS ((enum reg_class) rclass, mode);
1308
#else
1309
  return ((GET_MODE_SIZE (mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD);
1310
#endif
1311
}
1312
 
1313
/* Determine the debugging unwind mechanism for the target.  */
1314
 
1315
enum unwind_info_type
1316
default_debug_unwind_info (void)
1317
{
1318
  /* If the target wants to force the use of dwarf2 unwind info, let it.  */
1319
  /* ??? Change all users to the hook, then poison this.  */
1320
#ifdef DWARF2_FRAME_INFO
1321
  if (DWARF2_FRAME_INFO)
1322
    return UI_DWARF2;
1323
#endif
1324
 
1325
  /* Otherwise, only turn it on if dwarf2 debugging is enabled.  */
1326
#ifdef DWARF2_DEBUGGING_INFO
1327
  if (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
1328
    return UI_DWARF2;
1329
#endif
1330
 
1331
  return UI_NONE;
1332
}
1333
 
1334
/* To be used by targets where reg_raw_mode doesn't return the right
1335
   mode for registers used in apply_builtin_return and apply_builtin_arg.  */
1336
 
1337
enum machine_mode
1338
default_get_reg_raw_mode(int regno)
1339
{
1340
  return reg_raw_mode[regno];
1341
}
1342
 
1343
/* Return true if the state of option OPTION should be stored in PCH files
1344
   and checked by default_pch_valid_p.  Store the option's current state
1345
   in STATE if so.  */
1346
 
1347
static inline bool
1348
option_affects_pch_p (int option, struct cl_option_state *state)
1349
{
1350
  if ((cl_options[option].flags & CL_TARGET) == 0)
1351
    return false;
1352
  if (option_flag_var (option, &global_options) == &target_flags)
1353
    if (targetm.check_pch_target_flags)
1354
      return false;
1355
  return get_option_state (&global_options, option, state);
1356
}
1357
 
1358
/* Default version of get_pch_validity.
1359
   By default, every flag difference is fatal; that will be mostly right for
1360
   most targets, but completely right for very few.  */
1361
 
1362
void *
1363
default_get_pch_validity (size_t *sz)
1364
{
1365
  struct cl_option_state state;
1366
  size_t i;
1367
  char *result, *r;
1368
 
1369
  *sz = 2;
1370
  if (targetm.check_pch_target_flags)
1371
    *sz += sizeof (target_flags);
1372
  for (i = 0; i < cl_options_count; i++)
1373
    if (option_affects_pch_p (i, &state))
1374
      *sz += state.size;
1375
 
1376
  result = r = XNEWVEC (char, *sz);
1377
  r[0] = flag_pic;
1378
  r[1] = flag_pie;
1379
  r += 2;
1380
  if (targetm.check_pch_target_flags)
1381
    {
1382
      memcpy (r, &target_flags, sizeof (target_flags));
1383
      r += sizeof (target_flags);
1384
    }
1385
 
1386
  for (i = 0; i < cl_options_count; i++)
1387
    if (option_affects_pch_p (i, &state))
1388
      {
1389
        memcpy (r, state.data, state.size);
1390
        r += state.size;
1391
      }
1392
 
1393
  return result;
1394
}
1395
 
1396
/* Return a message which says that a PCH file was created with a different
1397
   setting of OPTION.  */
1398
 
1399
static const char *
1400
pch_option_mismatch (const char *option)
1401
{
1402
  char *r;
1403
 
1404
  asprintf (&r, _("created and used with differing settings of '%s'"), option);
1405
  if (r == NULL)
1406
    return _("out of memory");
1407
  return r;
1408
}
1409
 
1410
/* Default version of pch_valid_p.  */
1411
 
1412
const char *
1413
default_pch_valid_p (const void *data_p, size_t len)
1414
{
1415
  struct cl_option_state state;
1416
  const char *data = (const char *)data_p;
1417
  size_t i;
1418
 
1419
  /* -fpic and -fpie also usually make a PCH invalid.  */
1420
  if (data[0] != flag_pic)
1421
    return _("created and used with different settings of -fpic");
1422
  if (data[1] != flag_pie)
1423
    return _("created and used with different settings of -fpie");
1424
  data += 2;
1425
 
1426
  /* Check target_flags.  */
1427
  if (targetm.check_pch_target_flags)
1428
    {
1429
      int tf;
1430
      const char *r;
1431
 
1432
      memcpy (&tf, data, sizeof (target_flags));
1433
      data += sizeof (target_flags);
1434
      len -= sizeof (target_flags);
1435
      r = targetm.check_pch_target_flags (tf);
1436
      if (r != NULL)
1437
        return r;
1438
    }
1439
 
1440
  for (i = 0; i < cl_options_count; i++)
1441
    if (option_affects_pch_p (i, &state))
1442
      {
1443
        if (memcmp (data, state.data, state.size) != 0)
1444
          return pch_option_mismatch (cl_options[i].opt_text);
1445
        data += state.size;
1446
        len -= state.size;
1447
      }
1448
 
1449
  return NULL;
1450
}
1451
 
1452
#include "gt-targhooks.h"

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.