/* Data structure definitions for a generic GCC target.
- Copyright (C) 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+ Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007
+ 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
-Free Software Foundation; either version 2, or (at your option) any
-later version.
+ 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
+ Free Software Foundation; either version 3, or (at your option) any
+ later version.
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ You should have received a copy of the GNU General Public License
+ along with this program; see the file COPYING3. If not see
+ <http://www.gnu.org/licenses/>.
+
+ 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
+ what you give them. Help stamp out software-hoarding! */
- 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
- what you give them. Help stamp out software-hoarding! */
/* This file contains a data structure that describes a GCC target.
At present it is incomplete, but in future it should grow to
#include "tm.h"
#include "insn-modes.h"
+/* Types used by the record_gcc_switches() target function. */
+typedef enum
+{
+ SWITCH_TYPE_PASSED, /* A switch passed on the command line. */
+ SWITCH_TYPE_ENABLED, /* An option that is currently enabled. */
+ SWITCH_TYPE_DESCRIPTIVE, /* Descriptive text, not a switch or option. */
+ SWITCH_TYPE_LINE_START, /* Please emit any necessary text at the start of a line. */
+ SWITCH_TYPE_LINE_END /* Please emit a line terminator. */
+}
+print_switch_type;
+
+typedef int (* print_switch_fn_type) (print_switch_type, const char *);
+
+/* An example implementation for ELF targets. Defined in varasm.c */
+extern int elf_record_gcc_switches (print_switch_type type, const char *);
+
struct stdarg_info;
+struct spec_info_def;
/* The struct used by the secondary_reload target hook. */
typedef struct secondary_reload_info
int t_icode; /* Actually an enum insn_code - see above. */
} secondary_reload_info;
+/* This is defined in sched-int.h . */
+struct _dep;
struct gcc_target
{
/* Output code that will globalize a label. */
void (* globalize_label) (FILE *, const char *);
+ /* Output code that will globalize a declaration. */
+ void (* globalize_decl_name) (FILE *, tree);
+
/* Output code that will emit a label for unwind info, if this
target requires such labels. Second argument is the decl the
unwind info is associated with, third is a boolean: true if
which this section is associated. */
void (* named_section) (const char *name, unsigned int flags, tree decl);
+ /* Return a mask describing how relocations should be treated when
+ selecting sections. Bit 1 should be set if global relocations
+ should be placed in a read-write section; bit 0 should be set if
+ local relocations should be placed in a read-write section. */
+ int (*reloc_rw_mask) (void);
+
/* Return a section for EXP. It may be a DECL or a constant. RELOC
is nonzero if runtime relocations must be applied; bit 1 will be
set if the runtime relocations require non-local name resolution.
external. */
void (*external_libcall) (rtx);
- /* Output an assembler directive to mark decl live. This instructs
+ /* Output an assembler directive to mark decl live. This instructs
linker to not dead code strip this symbol. */
void (*mark_decl_preserved) (const char *);
+ /* Output a record of the command line switches that have been passed. */
+ print_switch_fn_type record_gcc_switches;
+ /* The name of the section that the example ELF implementation of
+ record_gcc_switches will use to store the information. Target
+ specific versions of record_gcc_switches may or may not use
+ this information. */
+ const char * record_gcc_switches_section;
+
+ /* Output the definition of a section anchor. */
+ void (*output_anchor) (rtx);
+
/* Output a DTP-relative reference to a TLS symbol. */
void (*output_dwarf_dtprel) (FILE *file, int size, rtx x);
/* Given the current cost, COST, of an insn, INSN, calculate and
return a new cost based on its relationship to DEP_INSN through
the dependence LINK. The default is to make no adjustment. */
- int (* adjust_cost) (rtx insn, rtx link, rtx def_insn, int cost);
+ int (* adjust_cost) (rtx insn, rtx link, rtx dep_insn, int cost);
/* Adjust the priority of an insn as you see fit. Returns the new
priority. */
void (* init_dfa_post_cycle_insn) (void);
rtx (* dfa_post_cycle_insn) (void);
+ /* The values of the following two members are pointers to
+ functions used to simplify the automaton descriptions.
+ dfa_pre_advance_cycle and dfa_post_advance_cycle are getting called
+ immediatelly before and after cycle is advanced. */
+ void (* dfa_pre_advance_cycle) (void);
+ void (* dfa_post_advance_cycle) (void);
+
/* The following member value is a pointer to a function returning value
which defines how many insns in queue `ready' will we try for
multi-pass scheduling. If the member value is nonzero and the
cycle. */
int (* dfa_new_cycle) (FILE *, int, rtx, int, int, int *);
- /* The following member value is a pointer to a function called
- by the insn scheduler. It should return true if there exists a
- dependence which is considered costly by the target, between
- the insn passed as the first parameter, and the insn passed as
- the second parameter. The third parameter is the INSN_DEPEND
- link that represents the dependence between the two insns. The
- fourth argument is the cost of the dependence as estimated by
+ /* The following member value is a pointer to a function called by the
+ insn scheduler. It should return true if there exists a dependence
+ which is considered costly by the target, between the insn
+ DEP_PRO (&_DEP), and the insn DEP_CON (&_DEP). The first parameter is
+ the dep that represents the dependence between the two insns. The
+ second argument is the cost of the dependence as estimated by
the scheduler. The last argument is the distance in cycles
between the already scheduled insn (first parameter) and the
the second insn (second parameter). */
- bool (* is_costly_dependence) (rtx, rtx, rtx, int, int);
+ bool (* is_costly_dependence) (struct _dep *_dep, int, int);
+
+ /* The following member value is a pointer to a function called
+ by the insn scheduler. This hook is called to notify the backend
+ that new instructions were emitted. */
+ void (* h_i_d_extended) (void);
+
+ /* The following member value is a pointer to a function called
+ by the insn scheduler.
+ The first parameter is an instruction, the second parameter is the type
+ of the requested speculation, and the third parameter is a pointer to the
+ speculative pattern of the corresponding type (set if return value == 1).
+ It should return
+ -1, if there is no pattern, that will satisfy the requested speculation
+ type,
+ 0, if current pattern satisfies the requested speculation type,
+ 1, if pattern of the instruction should be changed to the newly
+ generated one. */
+ int (* speculate_insn) (rtx, int, rtx *);
+
+ /* The following member value is a pointer to a function called
+ by the insn scheduler. It should return true if the check instruction
+ corresponding to the instruction passed as the parameter needs a
+ recovery block. */
+ bool (* needs_block_p) (rtx);
+
+ /* The following member value is a pointer to a function called
+ by the insn scheduler. It should return a pattern for the check
+ instruction.
+ The first parameter is a speculative instruction, the second parameter
+ is the label of the corresponding recovery block (or null, if it is a
+ simple check). If the mutation of the check is requested (e.g. from
+ ld.c to chk.a), the third parameter is true - in this case the first
+ parameter is the previous check. */
+ rtx (* gen_check) (rtx, rtx, bool);
+
+ /* The following member value is a pointer to a function controlling
+ what insns from the ready insn queue will be considered for the
+ multipass insn scheduling. If the hook returns zero for the insn
+ passed as the parameter, the insn will not be chosen to be
+ issued. This hook is used to discard speculative instructions,
+ that stand at the first position of the ready list. */
+ bool (* first_cycle_multipass_dfa_lookahead_guard_spec) (rtx);
+
+ /* The following member value is a pointer to a function that provides
+ information about the speculation capabilities of the target.
+ The parameter is a pointer to spec_info variable. */
+ void (* set_sched_flags) (struct spec_info_def *);
} sched;
/* Functions relating to vectorization. */
by the vectorizer, and return the decl of the target builtin
function. */
tree (* builtin_mask_for_load) (void);
+
+ /* Returns a code for builtin that realizes vectorized version of
+ function, or NULL_TREE if not available. */
+ tree (* builtin_vectorized_function) (unsigned, tree, tree);
+
+ /* Returns a code for builtin that realizes vectorized version of
+ conversion, or NULL_TREE if not available. */
+ tree (* builtin_conversion) (unsigned, tree);
+
+ /* Target builtin that implements vector widening multiplication.
+ builtin_mul_widen_eve computes the element-by-element products
+ for the even elements, and builtin_mul_widen_odd computes the
+ element-by-element products for the odd elements. */
+ tree (* builtin_mul_widen_even) (tree);
+ tree (* builtin_mul_widen_odd) (tree);
+
+ /* Returns the cost to be added to the overheads involved with
+ executing the vectorized version of a loop. */
+ int (*builtin_vectorization_cost) (bool);
+
+ /* Return true if vector alignment is reachable (by peeling N
+ iterations) for the given type. */
+ bool (* vector_alignment_reachable) (tree, bool);
} vectorize;
/* The initial value of target_flags. */
form was. Return true if the switch was valid. */
bool (* handle_option) (size_t code, const char *arg, int value);
+ /* Display extra, target specific information in response to a
+ --target-help switch. */
+ void (* target_help) (void);
+
/* Return machine mode for filter value. */
enum machine_mode (* eh_return_filter_mode) (void);
+ /* Return machine mode for libgcc expanded cmp instructions. */
+ enum machine_mode (* libgcc_cmp_return_mode) (void);
+
+ /* Return machine mode for libgcc expanded shift instructions. */
+ enum machine_mode (* libgcc_shift_count_mode) (void);
+
/* Given two decls, merge their attributes and return the result. */
tree (* merge_decl_attributes) (tree, tree);
/* True if the target supports decimal floating point. */
bool (* decimal_float_supported_p) (void);
+ /* True if the target supports fixed-point. */
+ bool (* fixed_point_supported_p) (void);
+
/* Return true if anonymous bitfields affect structure alignment. */
bool (* align_anon_bitfield) (void);
+ /* Return true if volatile bitfields should use the narrowest type possible.
+ Return false if they should use the container type. */
+ bool (* narrow_volatile_bitfield) (void);
+
/* Set up target-specific built-in functions. */
void (* init_builtins) (void);
/* 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. */
- const char * (* mangle_fundamental_type) (tree type);
+ /* Returns a code for a target-specific builtin that implements
+ reciprocal of the function, or NULL_TREE if not available. */
+ tree (* builtin_reciprocal) (unsigned, bool, bool);
+
+ /* For a vendor-specific TYPE, return a pointer to a statically-allocated
+ string containing the C++ mangling for TYPE. In all other cases, return
+ NULL. */
+ const char * (* mangle_type) (tree type);
/* Make any adjustments to libfunc names needed for this target. */
void (* init_libfuncs) (void);
/* Given an address RTX, undo the effects of LEGITIMIZE_ADDRESS. */
rtx (* delegitimize_address) (rtx);
+ /* True if the given constant can be put into an object_block. */
+ bool (* use_blocks_for_constant_p) (enum machine_mode, rtx);
+
+ /* The minimum and maximum byte offsets for anchored addresses. */
+ HOST_WIDE_INT min_anchor_offset;
+ HOST_WIDE_INT max_anchor_offset;
+
+ /* True if section anchors can be used to access the given symbol. */
+ bool (* use_anchors_for_symbol_p) (rtx);
+
/* True if it is OK to do sibling call optimization for the specified
call expression EXP. DECL will be the called function, or NULL if
this is an indirect call. */
to the current module. */
bool (* binds_local_p) (tree);
+ /* Modify and return the identifier of a DECL's external name,
+ originally identified by ID, as required by the target,
+ (eg, append @nn to windows32 stdcall function names).
+ The default is to return ID without modification. */
+ tree (* mangle_decl_assembler_name) (tree decl, tree id);
+
/* Do something target-specific to record properties of the DECL into
the associated SYMBOL_REF. */
void (* encode_section_info) (tree, rtx, int);
the reciprocal. */
unsigned int (* min_divisions_for_recip_mul) (enum machine_mode mode);
+ /* If the representation of integral MODE is such that values are
+ always sign-extended to a wider mode MODE_REP then return
+ SIGN_EXTEND. Return UNKNOWN otherwise. */
+ /* Note that the return type ought to be RTX_CODE, but that's not
+ necessarily defined at this point. */
+ int (* mode_rep_extended) (enum machine_mode mode,
+ enum machine_mode mode_rep);
+
/* True if MODE is valid for a pointer in __attribute__((mode("MODE"))). */
bool (* valid_pointer_mode) (enum machine_mode mode);
hook should return NULL_RTX. */
rtx (* dwarf_register_span) (rtx);
+ /* If expand_builtin_init_dwarf_reg_sizes needs to fill in table
+ entries not corresponding directly to registers below
+ FIRST_PSEUDO_REGISTER, this hook should generate the necessary
+ code, given the address of the table. */
+ void (* init_dwarf_reg_sizes_extra) (tree);
+
/* Fetch the fixed register(s) which hold condition codes, for
targets where it makes sense to look for duplicate assignments to
the condition codes. This should return true if there is such a
enum machine_mode,
struct secondary_reload_info *);
+ /* Functions specific to the C family of frontends. */
+ struct c {
+ /* Return machine mode for non-standard suffix
+ or VOIDmode if non-standard suffixes are unsupported. */
+ enum machine_mode (*mode_for_suffix) (char);
+ } c;
+
/* Functions specific to the C++ frontend. */
struct cxx {
/* Return the integer type used for guard variables. */
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 (the default) if the RTTI for the basic types,
+ which is always defined in the C++ runtime, should be COMDAT;
+ false if it should not be COMDAT. */
+ bool (*library_rtti_comdat) (void);
/* Returns true if __aeabi_atexit should be used to register static
destructors. */
bool (*use_aeabi_atexit) (void);
+ /* Returns true if target may use atexit in the same manner as
+ __cxa_atexit to register static destructors. */
+ bool (*use_atexit_for_cxa_atexit) (void);
/* TYPE is a C++ class (i.e., RECORD_TYPE or UNION_TYPE) that
has just been defined. Use this hook to make adjustments to the
class (eg, tweak visibility or perform any other required
target modifications). */
void (*adjust_class_at_definition) (tree type);
} cxx;
-
+
/* For targets that need to mark extra registers as live on entry to
the function, they should define this target hook and set their
bits in the bitmap passed in. */
/* True if arbitrary sections are supported. */
bool have_named_sections;
+ /* True if we can create zeroed data by switching to a BSS section
+ and then using ASM_OUTPUT_SKIP to allocate the space. */
+ bool have_switchable_bss_sections;
+
/* True if "native" constructors and destructors are supported,
false if we're using collect2 for the job. */
bool have_ctors_dtors;
extern struct gcc_target targetm;
+struct gcc_targetcm {
+ /* 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_c_option) (size_t code, const char *arg, int value);
+};
+
+/* Each target can provide their own. */
+extern struct gcc_targetcm targetcm;
+
#endif /* GCC_TARGET_H */
OSDN Git Service
