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