1/* Data structure definitions for a generic GCC target.
2   Copyright (C) 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
3
4This program is free software; you can redistribute it and/or modify it
5under the terms of the GNU General Public License as published by the
6Free Software Foundation; either version 2, or (at your option) any
7later version.
8
9This program is distributed in the hope that it will be useful,
10but WITHOUT ANY WARRANTY; without even the implied warranty of
11MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12GNU General Public License for more details.
13
14You should have received a copy of the GNU General Public License
15along with this program; if not, write to the Free Software
16Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17
18 In other words, you are welcome to use, share and improve this program.
19 You are forbidden to forbid anyone else to use, share and improve
20 what you give them.   Help stamp out software-hoarding!  */
21
22/* This file contains a data structure that describes a GCC target.
23   At present it is incomplete, but in future it should grow to
24   contain most or all target machine and target O/S specific
25   information.
26
27   This structure has its initializer declared in target-def.h in the
28   form of large macro TARGET_INITIALIZER that expands to many smaller
29   macros.
30
31   The smaller macros each initialize one component of the structure,
32   and each has a default.  Each target should have a file that
33   includes target.h and target-def.h, and overrides any inappropriate
34   defaults by undefining the relevant macro and defining a suitable
35   replacement.  That file should then contain the definition of
36   "targetm" like so:
37
38   struct gcc_target targetm = TARGET_INITIALIZER;
39
40   Doing things this way allows us to bring together everything that
41   defines a GCC target.  By supplying a default that is appropriate
42   to most targets, we can easily add new items without needing to
43   edit dozens of target configuration files.  It should also allow us
44   to gradually reduce the amount of conditional compilation that is
45   scattered throughout GCC.  */
46
47#ifndef GCC_TARGET_H
48#define GCC_TARGET_H
49
50#include "tm.h"
51#include "insn-modes.h"
52
53struct stdarg_info;
54
55struct gcc_target
56{
57  /* Functions that output assembler for the target.  */
58  struct asm_out
59  {
60    /* Opening and closing parentheses for asm expression grouping.  */
61    const char *open_paren, *close_paren;
62
63    /* Assembler instructions for creating various kinds of integer object.  */
64    const char *byte_op;
65    struct asm_int_op
66    {
67      const char *hi;
68      const char *si;
69      const char *di;
70      const char *ti;
71    } aligned_op, unaligned_op;
72
73    /* Try to output the assembler code for an integer object whose
74       value is given by X.  SIZE is the size of the object in bytes and
75       ALIGNED_P indicates whether it is aligned.  Return true if
76       successful.  Only handles cases for which BYTE_OP, ALIGNED_OP
77       and UNALIGNED_OP are NULL.  */
78    bool (* integer) (rtx x, unsigned int size, int aligned_p);
79
80    /* Output code that will globalize a label.  */
81    void (* globalize_label) (FILE *, const char *);
82
83    /* Output code that will emit a label for unwind info, if this
84       target requires such labels.  Second argument is the decl the
85       unwind info is associated with, third is a boolean: true if
86       this is for exception handling, fourth is a boolean: true if
87       this is only a placeholder for an omitted FDE.  */
88    void (* unwind_label) (FILE *, tree, int, int);
89
90    /* Emit any directives required to unwind this instruction.  */
91    void (* unwind_emit) (FILE *, rtx);
92
93    /* Output an internal label.  */
94    void (* internal_label) (FILE *, const char *, unsigned long);
95
96    /* Emit a ttype table reference to a typeinfo object.  */
97    bool (* ttype) (rtx);
98
99    /* Emit an assembler directive to set visibility for the symbol
100       associated with the tree decl.  */
101    void (* visibility) (tree, int);
102
103    /* Output the assembler code for entry to a function.  */
104    void (* function_prologue) (FILE *, HOST_WIDE_INT);
105
106    /* Output the assembler code for end of prologue.  */
107    void (* function_end_prologue) (FILE *);
108
109    /* Output the assembler code for start of epilogue.  */
110    void (* function_begin_epilogue) (FILE *);
111
112    /* Output the assembler code for function exit.  */
113    void (* function_epilogue) (FILE *, HOST_WIDE_INT);
114
115    /* Tell assembler to change to section NAME with attributes FLAGS.
116       If DECL is non-NULL, it is the VAR_DECL or FUNCTION_DECL with
117       which this section is associated.  */
118    void (* named_section) (const char *name, unsigned int flags, tree decl);
119
120    /* Switch to the section that holds the exception table.  */
121    void (* exception_section) (void);
122
123    /* Switch to the section that holds the exception frames.  */
124    void (* eh_frame_section) (void);
125
126    /* Select and switch to a section for EXP.  It may be a DECL or a
127       constant.  RELOC is nonzero if runtime relocations must be applied;
128       bit 1 will be set if the runtime relocations require non-local
129       name resolution.  ALIGN is the required alignment of the data.  */
130    void (* select_section) (tree, int, unsigned HOST_WIDE_INT);
131
132    /* Select and switch to a section for X with MODE.  ALIGN is
133       the desired alignment of the data.  */
134    void (* select_rtx_section) (enum machine_mode, rtx,
135				 unsigned HOST_WIDE_INT);
136
137    /* Select a unique section name for DECL.  RELOC is the same as
138       for SELECT_SECTION.  */
139    void (* unique_section) (tree, int);
140
141    /* Tell assembler to switch to the readonly data section associated
142       with function DECL.  */
143    void (* function_rodata_section) (tree);
144
145    /* Output a constructor for a symbol with a given priority.  */
146    void (* constructor) (rtx, int);
147
148    /* Output a destructor for a symbol with a given priority.  */
149    void (* destructor) (rtx, int);
150
151    /* Output the assembler code for a thunk function.  THUNK_DECL is the
152       declaration for the thunk function itself, FUNCTION is the decl for
153       the target function.  DELTA is an immediate constant offset to be
154       added to THIS.  If VCALL_OFFSET is nonzero, the word at
155       *(*this + vcall_offset) should be added to THIS.  */
156    void (* output_mi_thunk) (FILE *file, tree thunk_decl,
157			      HOST_WIDE_INT delta, HOST_WIDE_INT vcall_offset,
158			      tree function_decl);
159
160    /* Determine whether output_mi_thunk would succeed.  */
161    /* ??? Ideally, this hook would not exist, and success or failure
162       would be returned from output_mi_thunk directly.  But there's
163       too much undo-able setup involved in invoking output_mi_thunk.
164       Could be fixed by making output_mi_thunk emit rtl instead of
165       text to the output file.  */
166    bool (* can_output_mi_thunk) (tree thunk_decl, HOST_WIDE_INT delta,
167				  HOST_WIDE_INT vcall_offset,
168				  tree function_decl);
169
170    /* Output any boilerplate text needed at the beginning of a
171       translation unit.  */
172    void (*file_start) (void);
173
174    /* Output any boilerplate text needed at the end of a
175       translation unit.  */
176    void (*file_end) (void);
177
178    /* Output an assembler pseudo-op to declare a library function name
179       external.  */
180    void (*external_libcall) (rtx);
181
182     /* Output an assembler directive to mark decl live. This instructs
183	linker to not dead code strip this symbol.  */
184    void (*mark_decl_preserved) (const char *);
185
186    /* Output a DTP-relative reference to a TLS symbol.  */
187    void (*output_dwarf_dtprel) (FILE *file, int size, rtx x);
188
189  } asm_out;
190
191  /* Functions relating to instruction scheduling.  */
192  struct sched
193  {
194    /* Given the current cost, COST, of an insn, INSN, calculate and
195       return a new cost based on its relationship to DEP_INSN through
196       the dependence LINK.  The default is to make no adjustment.  */
197    int (* adjust_cost) (rtx insn, rtx link, rtx def_insn, int cost);
198
199    /* Adjust the priority of an insn as you see fit.  Returns the new
200       priority.  */
201    int (* adjust_priority) (rtx, int);
202
203    /* Function which returns the maximum number of insns that can be
204       scheduled in the same machine cycle.  This must be constant
205       over an entire compilation.  The default is 1.  */
206    int (* issue_rate) (void);
207
208    /* Calculate how much this insn affects how many more insns we
209       can emit this cycle.  Default is they all cost the same.  */
210    int (* variable_issue) (FILE *, int, rtx, int);
211
212    /* Initialize machine-dependent scheduling code.  */
213    void (* md_init) (FILE *, int, int);
214
215    /* Finalize machine-dependent scheduling code.  */
216    void (* md_finish) (FILE *, int);
217
218    /* Initialize machine-dependent function while scheduling code.  */
219    void (* md_init_global) (FILE *, int, int);
220
221    /* Finalize machine-dependent function wide scheduling code.  */
222    void (* md_finish_global) (FILE *, int);
223
224    /* Reorder insns in a machine-dependent fashion, in two different
225       places.  Default does nothing.  */
226    int (* reorder) (FILE *, int, rtx *, int *, int);
227    int (* reorder2) (FILE *, int, rtx *, int *, int);
228
229    /* The following member value is a pointer to a function called
230       after evaluation forward dependencies of insns in chain given
231       by two parameter values (head and tail correspondingly).  */
232    void (* dependencies_evaluation_hook) (rtx, rtx);
233
234    /* The values of the following four members are pointers to
235       functions used to simplify the automaton descriptions.
236       dfa_pre_cycle_insn and dfa_post_cycle_insn give functions
237       returning insns which are used to change the pipeline hazard
238       recognizer state when the new simulated processor cycle
239       correspondingly starts and finishes.  The function defined by
240       init_dfa_pre_cycle_insn and init_dfa_post_cycle_insn are used
241       to initialize the corresponding insns.  The default values of
242       the members result in not changing the automaton state when
243       the new simulated processor cycle correspondingly starts and
244       finishes.  */
245    void (* init_dfa_pre_cycle_insn) (void);
246    rtx (* dfa_pre_cycle_insn) (void);
247    void (* init_dfa_post_cycle_insn) (void);
248    rtx (* dfa_post_cycle_insn) (void);
249
250    /* The following member value is a pointer to a function returning value
251       which defines how many insns in queue `ready' will we try for
252       multi-pass scheduling.  If the member value is nonzero and the
253       function returns positive value, the DFA based scheduler will make
254       multi-pass scheduling for the first cycle.  In other words, we will
255       try to choose ready insn which permits to start maximum number of
256       insns on the same cycle.  */
257    int (* first_cycle_multipass_dfa_lookahead) (void);
258
259    /* The following member value is pointer to a function controlling
260       what insns from the ready insn queue will be considered for the
261       multipass insn scheduling.  If the hook returns zero for insn
262       passed as the parameter, the insn will be not chosen to be
263       issued.  */
264    int (* first_cycle_multipass_dfa_lookahead_guard) (rtx);
265
266    /* The following member value is pointer to a function called by
267       the insn scheduler before issuing insn passed as the third
268       parameter on given cycle.  If the hook returns nonzero, the
269       insn is not issued on given processors cycle.  Instead of that,
270       the processor cycle is advanced.  If the value passed through
271       the last parameter is zero, the insn ready queue is not sorted
272       on the new cycle start as usually.  The first parameter passes
273       file for debugging output.  The second one passes the scheduler
274       verbose level of the debugging output.  The forth and the fifth
275       parameter values are correspondingly processor cycle on which
276       the previous insn has been issued and the current processor
277       cycle.  */
278    int (* dfa_new_cycle) (FILE *, int, rtx, int, int, int *);
279
280    /* The following member value is a pointer to a function called
281       by the insn scheduler.  It should return true if there exists a
282       dependence which is considered costly by the target, between
283       the insn passed as the first parameter, and the insn passed as
284       the second parameter.  The third parameter is the INSN_DEPEND
285       link that represents the dependence between the two insns.  The
286       fourth argument is the cost of the dependence as estimated by
287       the scheduler.  The last argument is the distance in cycles
288       between the already scheduled insn (first parameter) and the
289       the second insn (second parameter).  */
290    bool (* is_costly_dependence) (rtx, rtx, rtx, int, int);
291  } sched;
292
293  /* Functions relating to vectorization.  */
294  struct vectorize
295  {
296    /* The following member value is a pointer to a function called
297       by the vectorizer, and return the decl of the target builtin
298       function.  */
299    tree (* builtin_mask_for_load) (void);
300  } vectorize;
301
302  /* The initial value of target_flags.  */
303  int default_target_flags;
304
305  /* Handle target switch CODE (an OPT_* value).  ARG is the argument
306     passed to the switch; it is NULL if no argument was.  VALUE is the
307     value of ARG if CODE specifies a UInteger option, otherwise it is
308     1 if the positive form of the switch was used and 0 if the negative
309     form was.  Return true if the switch was valid.  */
310  bool (* handle_option) (size_t code, const char *arg, int value);
311
312  /* Return machine mode for filter value.  */
313  enum machine_mode (* eh_return_filter_mode) (void);
314
315  /* Given two decls, merge their attributes and return the result.  */
316  tree (* merge_decl_attributes) (tree, tree);
317
318  /* Given two types, merge their attributes and return the result.  */
319  tree (* merge_type_attributes) (tree, tree);
320
321  /* Table of machine attributes and functions to handle them.
322     Ignored if NULL.  */
323  const struct attribute_spec *attribute_table;
324
325  /* Return zero if the attributes on TYPE1 and TYPE2 are incompatible,
326     one if they are compatible and two if they are nearly compatible
327     (which causes a warning to be generated).  */
328  int (* comp_type_attributes) (tree type1, tree type2);
329
330  /* Assign default attributes to the newly defined TYPE.  */
331  void (* set_default_type_attributes) (tree type);
332
333  /* Insert attributes on the newly created DECL.  */
334  void (* insert_attributes) (tree decl, tree *attributes);
335
336  /* Return true if FNDECL (which has at least one machine attribute)
337     can be inlined despite its machine attributes, false otherwise.  */
338  bool (* function_attribute_inlinable_p) (tree fndecl);
339
340  /* Return true if bitfields in RECORD_TYPE should follow the
341     Microsoft Visual C++ bitfield layout rules.  */
342  bool (* ms_bitfield_layout_p) (tree record_type);
343
344  /* Return true if anonymous bitfields affect structure alignment.  */
345  bool (* align_anon_bitfield) (void);
346
347  /* Set up target-specific built-in functions.  */
348  void (* init_builtins) (void);
349
350  /* Expand a target-specific builtin.  */
351  rtx (* expand_builtin) (tree exp, rtx target, rtx subtarget,
352			  enum machine_mode mode, int ignore);
353
354  /* Select a replacement for a target-specific builtin.  This is done
355     *before* regular type checking, and so allows the target to implement
356     a crude form of function overloading.  The result is a complete
357     expression that implements the operation.  */
358  tree (*resolve_overloaded_builtin) (tree decl, tree params);
359
360  /* Fold a target-specific builtin.  */
361  tree (* fold_builtin) (tree fndecl, tree arglist, bool ignore);
362
363  /* For a vendor-specific fundamental TYPE, return a pointer to
364     a statically-allocated string containing the C++ mangling for
365     TYPE.  In all other cases, return NULL.  */
366  const char * (* mangle_fundamental_type) (tree type);
367
368  /* Make any adjustments to libfunc names needed for this target.  */
369  void (* init_libfuncs) (void);
370
371  /* Given a decl, a section name, and whether the decl initializer
372     has relocs, choose attributes for the section.  */
373  /* ??? Should be merged with SELECT_SECTION and UNIQUE_SECTION.  */
374  unsigned int (* section_type_flags) (tree, const char *, int);
375
376  /* True if new jumps cannot be created, to replace existing ones or
377     not, at the current point in the compilation.  */
378  bool (* cannot_modify_jumps_p) (void);
379
380  /* Return a register class for which branch target register
381     optimizations should be applied.  */
382  int (* branch_target_register_class) (void);
383
384  /* Return true if branch target register optimizations should include
385     callee-saved registers that are not already live during the current
386     function.  AFTER_PE_GEN is true if prologues and epilogues have
387     already been generated.  */
388  bool (* branch_target_register_callee_saved) (bool after_pe_gen);
389
390  /* True if the constant X cannot be placed in the constant pool.  */
391  bool (* cannot_force_const_mem) (rtx);
392
393  /* True if the insn X cannot be duplicated.  */
394  bool (* cannot_copy_insn_p) (rtx);
395
396  /* True if X is considered to be commutative.  */
397  bool (* commutative_p) (rtx, int);
398
399  /* Given an address RTX, undo the effects of LEGITIMIZE_ADDRESS.  */
400  rtx (* delegitimize_address) (rtx);
401
402  /* True if it is OK to do sibling call optimization for the specified
403     call expression EXP.  DECL will be the called function, or NULL if
404     this is an indirect call.  */
405  bool (*function_ok_for_sibcall) (tree decl, tree exp);
406
407  /* True if EXP should be placed in a "small data" section.  */
408  bool (* in_small_data_p) (tree);
409
410  /* True if EXP names an object for which name resolution must resolve
411     to the current module.  */
412  bool (* binds_local_p) (tree);
413
414  /* Do something target-specific to record properties of the DECL into
415     the associated SYMBOL_REF.  */
416  void (* encode_section_info) (tree, rtx, int);
417
418  /* Undo the effects of encode_section_info on the symbol string.  */
419  const char * (* strip_name_encoding) (const char *);
420
421  /* If shift optabs for MODE are known to always truncate the shift count,
422     return the mask that they apply.  Return 0 otherwise.  */
423  unsigned HOST_WIDE_INT (* shift_truncation_mask) (enum machine_mode mode);
424
425  /* Return the number of divisions in the given MODE that should be present,
426     so that it is profitable to turn the division into a multiplication by
427     the reciprocal.  */
428  unsigned int (* min_divisions_for_recip_mul) (enum machine_mode mode);
429
430  /* True if MODE is valid for a pointer in __attribute__((mode("MODE"))).  */
431  bool (* valid_pointer_mode) (enum machine_mode mode);
432
433  /* True if MODE is valid for the target.  By "valid", we mean able to
434     be manipulated in non-trivial ways.  In particular, this means all
435     the arithmetic is supported.  */
436  bool (* scalar_mode_supported_p) (enum machine_mode mode);
437
438  /* Similarly for vector modes.  "Supported" here is less strict.  At
439     least some operations are supported; need to check optabs or builtins
440     for further details.  */
441  bool (* vector_mode_supported_p) (enum machine_mode mode);
442
443  /* True if a vector is opaque.  */
444  bool (* vector_opaque_p) (tree);
445
446  /* Compute a (partial) cost for rtx X.  Return true if the complete
447     cost has been computed, and false if subexpressions should be
448     scanned.  In either case, *TOTAL contains the cost result.  */
449  /* Note that CODE and OUTER_CODE ought to be RTX_CODE, but that's
450     not necessarily defined at this point.  */
451  bool (* rtx_costs) (rtx x, int code, int outer_code, int *total);
452
453  /* Compute the cost of X, used as an address.  Never called with
454     invalid addresses.  */
455  int (* address_cost) (rtx x);
456
457  /* Return where to allocate pseudo for a given hard register initial
458     value.  */
459  rtx (* allocate_initial_value) (rtx x);
460
461  /* Given a register, this hook should return a parallel of registers
462     to represent where to find the register pieces.  Define this hook
463     if the register and its mode are represented in Dwarf in
464     non-contiguous locations, or if the register should be
465     represented in more than one register in Dwarf.  Otherwise, this
466     hook should return NULL_RTX.  */
467  rtx (* dwarf_register_span) (rtx);
468
469  /* Fetch the fixed register(s) which hold condition codes, for
470     targets where it makes sense to look for duplicate assignments to
471     the condition codes.  This should return true if there is such a
472     register, false otherwise.  The arguments should be set to the
473     fixed register numbers.  Up to two condition code registers are
474     supported.  If there is only one for this target, the int pointed
475     at by the second argument should be set to -1.  */
476  bool (* fixed_condition_code_regs) (unsigned int *, unsigned int *);
477
478  /* If two condition code modes are compatible, return a condition
479     code mode which is compatible with both, such that a comparison
480     done in the returned mode will work for both of the original
481     modes.  If the condition code modes are not compatible, return
482     VOIDmode.  */
483  enum machine_mode (* cc_modes_compatible) (enum machine_mode,
484					     enum machine_mode);
485
486  /* Do machine-dependent code transformations.  Called just before
487     delayed-branch scheduling.  */
488  void (* machine_dependent_reorg) (void);
489
490  /* Create the __builtin_va_list type.  */
491  tree (* build_builtin_va_list) (void);
492
493  /* Gimplifies a VA_ARG_EXPR.  */
494  tree (* gimplify_va_arg_expr) (tree valist, tree type, tree *pre_p,
495				 tree *post_p);
496
497  /* Validity-checking routines for PCH files, target-specific.
498     get_pch_validity returns a pointer to the data to be stored,
499     and stores the size in its argument.  pch_valid_p gets the same
500     information back and returns NULL if the PCH is valid,
501     or an error message if not.
502  */
503  void * (* get_pch_validity) (size_t *);
504  const char * (* pch_valid_p) (const void *, size_t);
505
506  /* If nonnull, this function checks whether a PCH file with the
507     given set of target flags can be used.  It returns NULL if so,
508     otherwise it returns an error message.  */
509  const char *(*check_pch_target_flags) (int);
510
511  /* True if the compiler should give an enum type only as many
512     bytes as it takes to represent the range of possible values of
513     that type.  */
514  bool (* default_short_enums) (void);
515
516  /* This target hook returns an rtx that is used to store the address
517     of the current frame into the built-in setjmp buffer.  */
518  rtx (* builtin_setjmp_frame_value) (void);
519
520  /* This target hook should add STRING_CST trees for any hard regs
521     the port wishes to automatically clobber for an asm.  */
522  tree (* md_asm_clobbers) (tree, tree, tree);
523
524  /* This target hook allows the backend to specify a calling convention
525     in the debug information.  This function actually returns an
526     enum dwarf_calling_convention, but because of forward declarations
527     and not wanting to include dwarf2.h everywhere target.h is included
528     the function is being declared as an int.  */
529  int (* dwarf_calling_convention) (tree);
530
531  /* This target hook allows the backend to emit frame-related insns that
532     contain UNSPECs or UNSPEC_VOLATILEs.  The call frame debugging info
533     engine will invoke it on insns of the form
534       (set (reg) (unspec [...] UNSPEC_INDEX))
535     and
536       (set (reg) (unspec_volatile [...] UNSPECV_INDEX))
537     to let the backend emit the call frame instructions.  */
538  void (* dwarf_handle_frame_unspec) (const char *, rtx, int);
539
540  /* Perform architecture specific checking of statements gimplified
541     from VA_ARG_EXPR.  LHS is left hand side of MODIFY_EXPR, RHS
542     is right hand side.  Returns true if the statements doesn't need
543     to be checked for va_list references.  */
544  bool (* stdarg_optimize_hook) (struct stdarg_info *ai, tree lhs, tree rhs);
545
546  /* This target hook allows the operating system to override the DECL
547     that represents the external variable that contains the stack
548     protection guard variable.  The type of this DECL is ptr_type_node.  */
549  tree (* stack_protect_guard) (void);
550
551  /* This target hook allows the operating system to override the CALL_EXPR
552     that is invoked when a check vs the guard variable fails.  */
553  tree (* stack_protect_fail) (void);
554
555  /* Returns NULL if target supports the insn within a doloop block,
556     otherwise it returns an error message.  */
557  const char * (*invalid_within_doloop) (rtx);
558
559  /* DECL is a variable or function with __attribute__((dllimport))
560     specified.  Use this hook if the target needs to add extra validation
561     checks to  handle_dll_attribute ().  */
562  bool (* valid_dllimport_attribute_p) (tree decl);
563
564  /* Functions relating to calls - argument passing, returns, etc.  */
565  struct calls {
566    bool (*promote_function_args) (tree fntype);
567    bool (*promote_function_return) (tree fntype);
568    bool (*promote_prototypes) (tree fntype);
569    rtx (*struct_value_rtx) (tree fndecl, int incoming);
570    bool (*return_in_memory) (tree type, tree fndecl);
571    bool (*return_in_msb) (tree type);
572
573    /* Return true if a parameter must be passed by reference.  TYPE may
574       be null if this is a libcall.  CA may be null if this query is
575       from __builtin_va_arg.  */
576    bool (*pass_by_reference) (CUMULATIVE_ARGS *ca, enum machine_mode mode,
577			       tree type, bool named_arg);
578
579    rtx (*expand_builtin_saveregs) (void);
580    /* Returns pretend_argument_size.  */
581    void (*setup_incoming_varargs) (CUMULATIVE_ARGS *ca, enum machine_mode mode,
582				    tree type, int *pretend_arg_size,
583				    int second_time);
584    bool (*strict_argument_naming) (CUMULATIVE_ARGS *ca);
585    /* Returns true if we should use
586       targetm.calls.setup_incoming_varargs() and/or
587       targetm.calls.strict_argument_naming().  */
588    bool (*pretend_outgoing_varargs_named) (CUMULATIVE_ARGS *ca);
589
590    /* Given a complex type T, return true if a parameter of type T
591       should be passed as two scalars.  */
592    bool (* split_complex_arg) (tree type);
593
594    /* Return true if type T, mode MODE, may not be passed in registers,
595       but must be passed on the stack.  */
596    /* ??? This predicate should be applied strictly after pass-by-reference.
597       Need audit to verify that this is the case.  */
598    bool (* must_pass_in_stack) (enum machine_mode mode, tree t);
599
600    /* Return true if type TYPE, mode MODE, which is passed by reference,
601       should have the object copy generated by the callee rather than
602       the caller.  It is never called for TYPE requiring constructors.  */
603    bool (* callee_copies) (CUMULATIVE_ARGS *ca, enum machine_mode mode,
604			    tree type, bool named);
605
606    /* Return zero for arguments passed entirely on the stack or entirely
607       in registers.  If passed in both, return the number of bytes passed
608       in registers; the balance is therefore passed on the stack.  */
609    int (* arg_partial_bytes) (CUMULATIVE_ARGS *ca, enum machine_mode mode,
610			       tree type, bool named);
611
612    /* Return the diagnostic message string if function without a prototype
613       is not allowed for this 'val' argument; NULL otherwise. */
614    const char *(*invalid_arg_for_unprototyped_fn) (tree typelist,
615					     	    tree funcdecl, tree val);
616
617    /* Return an rtx for the return value location of the function
618       specified by FN_DECL_OR_TYPE with a return type of RET_TYPE.  */
619    rtx (*function_value) (tree ret_type, tree fn_decl_or_type,
620			   bool outgoing);
621
622    /* Return an rtx for the argument pointer incoming to the
623       current function.  */
624    rtx (*internal_arg_pointer) (void);
625  } calls;
626
627  /* Return the diagnostic message string if conversion from FROMTYPE
628     to TOTYPE is not allowed, NULL otherwise.  */
629  const char *(*invalid_conversion) (tree fromtype, tree totype);
630
631  /* Return the diagnostic message string if the unary operation OP is
632     not permitted on TYPE, NULL otherwise.  */
633  const char *(*invalid_unary_op) (int op, tree type);
634
635  /* Return the diagnostic message string if the binary operation OP
636     is not permitted on TYPE1 and TYPE2, NULL otherwise.  */
637  const char *(*invalid_binary_op) (int op, tree type1, tree type2);
638
639  /* Functions specific to the C++ frontend.  */
640  struct cxx {
641    /* Return the integer type used for guard variables.  */
642    tree (*guard_type) (void);
643    /* Return true if only the low bit of the guard should be tested.  */
644    bool (*guard_mask_bit) (void);
645    /* Returns the size of the array cookie for an array of type.  */
646    tree (*get_cookie_size) (tree);
647    /* Returns true if the element size should be stored in the
648       array cookie.  */
649    bool (*cookie_has_size) (void);
650    /* Allows backends to perform additional processing when
651       deciding if a class should be exported or imported.  */
652    int (*import_export_class) (tree, int);
653    /* Returns true if constructors and destructors return "this".  */
654    bool (*cdtor_returns_this) (void);
655    /* Returns true if the key method for a class can be an inline
656       function, so long as it is not declared inline in the class
657       itself.  Returning true is the behavior required by the Itanium
658       C++ ABI.  */
659    bool (*key_method_may_be_inline) (void);
660    /* DECL is a virtual table, virtual table table, typeinfo object,
661       or other similar implicit class data object that will be
662       emitted with external linkage in this translation unit.  No ELF
663       visibility has been explicitly specified.  If the target needs
664       to specify a visibility other than that of the containing class,
665       use this hook to set DECL_VISIBILITY and
666       DECL_VISIBILITY_SPECIFIED.  */
667    void (*determine_class_data_visibility) (tree decl);
668    /* Returns true (the default) if virtual tables and other
669       similar implicit class data objects are always COMDAT if they
670       have external linkage.  If this hook returns false, then
671       class data for classes whose virtual table will be emitted in
672       only one translation unit will not be COMDAT.  */
673    bool (*class_data_always_comdat) (void);
674    /* Returns true if __aeabi_atexit should be used to register static
675       destructors.  */
676    bool (*use_aeabi_atexit) (void);
677    /* TYPE is a C++ class (i.e., RECORD_TYPE or UNION_TYPE) that
678       has just been defined.  Use this hook to make adjustments to the
679       class  (eg, tweak visibility or perform any other required
680       target modifications).  */
681    void (*adjust_class_at_definition) (tree type);
682  } cxx;
683
684  /* True if unwinding tables should be generated by default.  */
685  bool unwind_tables_default;
686
687  /* Leave the boolean fields at the end.  */
688
689  /* True if arbitrary sections are supported.  */
690  bool have_named_sections;
691
692  /* True if "native" constructors and destructors are supported,
693     false if we're using collect2 for the job.  */
694  bool have_ctors_dtors;
695
696  /* True if thread-local storage is supported.  */
697  bool have_tls;
698
699  /* True if a small readonly data section is supported.  */
700  bool have_srodata_section;
701
702  /* True if EH frame info sections should be zero-terminated.  */
703  bool terminate_dw2_eh_frame_info;
704
705  /* True if #NO_APP should be emitted at the beginning of
706     assembly output.  */
707  bool file_start_app_off;
708
709  /* True if output_file_directive should be called for main_input_filename
710     at the beginning of assembly output.  */
711  bool file_start_file_directive;
712
713  /* True if #pragma redefine_extname is to be supported.  */
714  bool handle_pragma_redefine_extname;
715
716  /* True if #pragma extern_prefix is to be supported.  */
717  bool handle_pragma_extern_prefix;
718
719  /* True if the target is allowed to reorder memory accesses unless
720     synchronization is explicitly requested.  */
721  bool relaxed_ordering;
722
723  /* Returns true if we should generate exception tables for use with the
724     ARM EABI.  The effects the encoding of function exception specifications.
725   */
726  bool arm_eabi_unwinder;
727
728  /* Leave the boolean fields at the end.  */
729};
730
731extern struct gcc_target targetm;
732
733#endif /* GCC_TARGET_H */
734