/* Data structure definitions for a generic GCC target.
- Copyright (C) 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
+ Copyright (C) 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
-Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
In other words, you are welcome to use, share and improve this program.
You are forbidden to forbid anyone else to use, share and improve
#include "tm.h"
#include "insn-modes.h"
+struct stdarg_info;
+
struct gcc_target
{
/* Functions that output assembler for the target. */
/* Output an internal label. */
void (* internal_label) (FILE *, const char *, unsigned long);
+ /* Emit a ttype table reference to a typeinfo object. */
+ bool (* ttype) (rtx);
+
/* Emit an assembler directive to set visibility for the symbol
associated with the tree decl. */
void (* visibility) (tree, int);
linker to not dead code strip this symbol. */
void (*mark_decl_preserved) (const char *);
+ /* Output a DTP-relative reference to a TLS symbol. */
+ void (*output_dwarf_dtprel) (FILE *file, int size, rtx x);
+
} asm_out;
/* Functions relating to instruction scheduling. */
struct vectorize
{
/* The following member value is a pointer to a function called
- by the vectorizer, and when expanding a MISALIGNED_INDIREC_REF
- expression. If the hook returns true (false) then a move* pattern
- to/from memory can (cannot) be generated for this mode even if the
- memory location is unaligned. */
- bool (* misaligned_mem_ok) (enum machine_mode);
-
- /* The following member values are pointers to functions called
by the vectorizer, and return the decl of the target builtin
function. */
tree (* builtin_mask_for_load) (void);
- tree (* builtin_mask_for_store) (void);
} vectorize;
+ /* The initial value of target_flags. */
+ int default_target_flags;
+
+ /* Handle target switch CODE (an OPT_* value). ARG is the argument
+ passed to the switch; it is NULL if no argument was. VALUE is the
+ value of ARG if CODE specifies a UInteger option, otherwise it is
+ 1 if the positive form of the switch was used and 0 if the negative
+ form was. Return true if the switch was valid. */
+ bool (* handle_option) (size_t code, const char *arg, int value);
+
/* Return machine mode for filter value. */
enum machine_mode (* eh_return_filter_mode) (void);
rtx (* expand_builtin) (tree exp, rtx target, rtx subtarget,
enum machine_mode mode, int ignore);
- /* Fold a target-specific builtin. */
- tree (* fold_builtin) (tree exp, bool ignore);
+ /* Select a replacement for a target-specific builtin. This is done
+ *before* regular type checking, and so allows the target to implement
+ a crude form of function overloading. The result is a complete
+ expression that implements the operation. */
+ tree (*resolve_overloaded_builtin) (tree decl, tree params);
+ /* Fold a target-specific builtin. */
+ tree (* fold_builtin) (tree fndecl, tree arglist, bool ignore);
+
/* For a vendor-specific fundamental TYPE, return a pointer to
a statically-allocated string containing the C++ mangling for
TYPE. In all other cases, return NULL. */
void * (* get_pch_validity) (size_t *);
const char * (* pch_valid_p) (const void *, size_t);
+ /* If nonnull, this function checks whether a PCH file with the
+ given set of target flags can be used. It returns NULL if so,
+ otherwise it returns an error message. */
+ const char *(*check_pch_target_flags) (int);
+
/* True if the compiler should give an enum type only as many
bytes as it takes to represent the range of possible values of
that type. */
rtx (* builtin_setjmp_frame_value) (void);
/* This target hook should add STRING_CST trees for any hard regs
- the port wishes to automatically clobber for all asms. */
- tree (* md_asm_clobbers) (tree);
-
+ the port wishes to automatically clobber for an asm. */
+ tree (* md_asm_clobbers) (tree, tree, tree);
+
+ /* This target hook allows the backend to specify a calling convention
+ in the debug information. This function actually returns an
+ enum dwarf_calling_convention, but because of forward declarations
+ and not wanting to include dwarf2.h everywhere target.h is included
+ the function is being declared as an int. */
+ int (* dwarf_calling_convention) (tree);
+
+ /* This target hook allows the backend to emit frame-related insns that
+ contain UNSPECs or UNSPEC_VOLATILEs. The call frame debugging info
+ engine will invoke it on insns of the form
+ (set (reg) (unspec [...] UNSPEC_INDEX))
+ and
+ (set (reg) (unspec_volatile [...] UNSPECV_INDEX))
+ to let the backend emit the call frame instructions. */
+ void (* dwarf_handle_frame_unspec) (const char *, rtx, int);
+
+ /* Perform architecture specific checking of statements gimplified
+ from VA_ARG_EXPR. LHS is left hand side of MODIFY_EXPR, RHS
+ is right hand side. Returns true if the statements doesn't need
+ to be checked for va_list references. */
+ bool (* stdarg_optimize_hook) (struct stdarg_info *ai, tree lhs, tree rhs);
+
+ /* This target hook allows the operating system to override the DECL
+ that represents the external variable that contains the stack
+ protection guard variable. The type of this DECL is ptr_type_node. */
+ tree (* stack_protect_guard) (void);
+
+ /* This target hook allows the operating system to override the CALL_EXPR
+ that is invoked when a check vs the guard variable fails. */
+ tree (* stack_protect_fail) (void);
+
+ /* Returns NULL if target supports the insn within a doloop block,
+ otherwise it returns an error message. */
+ const char * (*invalid_within_doloop) (rtx);
+
/* Functions relating to calls - argument passing, returns, etc. */
struct calls {
bool (*promote_function_args) (tree fntype);
the caller. It is never called for TYPE requiring constructors. */
bool (* callee_copies) (CUMULATIVE_ARGS *ca, enum machine_mode mode,
tree type, bool named);
+
+ /* Return zero for arguments passed entirely on the stack or entirely
+ in registers. If passed in both, return the number of bytes passed
+ in registers; the balance is therefore passed on the stack. */
+ int (* arg_partial_bytes) (CUMULATIVE_ARGS *ca, enum machine_mode mode,
+ tree type, bool named);
+
+ /* Return the diagnostic message string if function without a prototype
+ is not allowed for this 'val' argument; NULL otherwise. */
+ const char *(*invalid_arg_for_unprototyped_fn) (tree typelist,
+ tree funcdecl, tree val);
} calls;
+ /* Return the diagnostic message string if conversion from FROMTYPE
+ to TOTYPE is not allowed, NULL otherwise. */
+ const char *(*invalid_conversion) (tree fromtype, tree totype);
+
+ /* Return the diagnostic message string if the unary operation OP is
+ not permitted on TYPE, NULL otherwise. */
+ const char *(*invalid_unary_op) (int op, tree type);
+
+ /* Return the diagnostic message string if the binary operation OP
+ is not permitted on TYPE1 and TYPE2, NULL otherwise. */
+ const char *(*invalid_binary_op) (int op, tree type1, tree type2);
+
/* Functions specific to the C++ frontend. */
struct cxx {
/* Return the integer type used for guard variables. */
itself. Returning true is the behavior required by the Itanium
C++ ABI. */
bool (*key_method_may_be_inline) (void);
- /* Returns true if all class data (virtual tables, type info,
- etc.) should be exported from the current DLL, even when the
- associated class is not exported. */
- bool (*export_class_data) (void);
+ /* DECL is a virtual table, virtual table table, typeinfo object,
+ or other similar implicit class data object that will be
+ emitted with external linkage in this translation unit. No ELF
+ visibility has been explicitly specified. If the target needs
+ to specify a visibility other than that of the containing class,
+ use this hook to set DECL_VISIBILITY and
+ DECL_VISIBILITY_SPECIFIED. */
+ void (*determine_class_data_visibility) (tree decl);
+ /* Returns true (the default) if virtual tables and other
+ similar implicit class data objects are always COMDAT if they
+ have external linkage. If this hook returns false, then
+ class data for classes whose virtual table will be emitted in
+ only one translation unit will not be COMDAT. */
+ bool (*class_data_always_comdat) (void);
+ /* Returns true if __aeabi_atexit should be used to register static
+ destructors. */
+ bool (*use_aeabi_atexit) (void);
} cxx;
+ /* True if unwinding tables should be generated by default. */
+ bool unwind_tables_default;
+
/* Leave the boolean fields at the end. */
/* True if arbitrary sections are supported. */
/* True if #pragma extern_prefix is to be supported. */
bool handle_pragma_extern_prefix;
- /* True if the RTL prologue and epilogue should be expanded after all
- passes that modify the instructions (and not merely reorder them)
- have been run. */
- bool late_rtl_prologue_epilogue;
+ /* True if the target is allowed to reorder memory accesses unless
+ synchronization is explicitly requested. */
+ bool relaxed_ordering;
+
+ /* Returns true if we should generate exception tables for use with the
+ ARM EABI. The effects the encoding of function exception specifications.
+ */
+ bool arm_eabi_unwinder;
/* Leave the boolean fields at the end. */
};
OSDN Git Service
