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