X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Ftarget.h;h=29ec84f1a48a6861b41e00ada5f09b9393d7882e;hb=2abf995f90bb8441b573eba4ea14c0b8e0c1bba9;hp=21c46adbbe2c674a19477117092ad586c324f746;hpb=cf7898a69f1895645eb9c9835c1a31a8002eafee;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/target.h b/gcc/target.h index 21c46adbbe2..29ec84f1a48 100644 --- a/gcc/target.h +++ b/gcc/target.h @@ -1,5 +1,5 @@ /* Data structure definitions for a generic GCC target. - Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 + Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it @@ -68,6 +68,12 @@ 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 *); +/* Some places still assume that all pointer or address modes are the + standard Pmode and ptr_mode. These optimizations become invalid if + the target actually supports multiple different modes. For now, + we disable such optimizations on such targets, using this function. */ +extern bool target_default_pointer_address_modes_p (void); + struct stdarg_info; struct spec_info_def; @@ -91,6 +97,21 @@ struct _dep; /* This is defined in ddg.h . */ struct ddg; +/* This is defined in cfgloop.h . */ +struct loop; + +/* Assembler instructions for creating various kinds of integer object. */ + +struct asm_int_op +{ + const char *hi; + const char *si; + const char *di; + const char *ti; +}; + +/* The target structure. This holds all the backend hooks. */ + struct gcc_target { /* Functions that output assembler for the target. */ @@ -101,13 +122,7 @@ struct gcc_target /* Assembler instructions for creating various kinds of integer object. */ const char *byte_op; - struct asm_int_op - { - const char *hi; - const char *si; - const char *di; - const char *ti; - } aligned_op, unaligned_op; + struct asm_int_op aligned_op, unaligned_op; /* Try to output the assembler code for an integer object whose value is given by X. SIZE is the size of the object in bytes and @@ -223,6 +238,18 @@ struct gcc_target translation unit. */ void (*file_end) (void); + /* Output any boilerplate text needed at the beginning of an + LTO output stream. */ + void (*lto_start) (void); + + /* Output any boilerplate text needed at the end of an + LTO output stream. */ + void (*lto_end) (void); + + /* Output any boilerplace text needed at the end of a + translation unit before debug and unwind info is emitted. */ + void (*code_end) (void); + /* Output an assembler pseudo-op to declare a library function name external. */ void (*external_libcall) (rtx); @@ -245,6 +272,11 @@ struct gcc_target /* Output a DTP-relative reference to a TLS symbol. */ void (*output_dwarf_dtprel) (FILE *file, int size, rtx x); + /* Some target machines need to postscan each insn after it is output. */ + void (*final_postscan_insn) (FILE *, rtx, rtx *, int); + + /* Emit the trampoline template. This hook may be NULL. */ + void (*trampoline_template) (FILE *); } asm_out; /* Functions relating to instruction scheduling. */ @@ -450,14 +482,14 @@ struct gcc_target /* Returns a code for builtin that realizes vectorized version of function, or NULL_TREE if not available. */ - tree (* builtin_vectorized_function) (unsigned, tree, tree); + tree (* builtin_vectorized_function) (tree, tree, tree); - /* Returns a code for builtin that realizes vectorized version of - conversion, or NULL_TREE if not available. */ - tree (* builtin_conversion) (unsigned, tree); + /* Returns a function declaration for a builtin that realizes the + vector conversion, or NULL_TREE if not available. */ + tree (* builtin_conversion) (unsigned, tree, tree); /* Target builtin that implements vector widening multiplication. - builtin_mul_widen_eve computes the element-by-element products + 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); @@ -473,11 +505,25 @@ struct gcc_target /* Target builtin that implements vector permute. */ tree (* builtin_vec_perm) (tree, tree*); -} vectorize; + + /* Return true if a vector created for builtin_vec_perm is valid. */ + bool (* builtin_vec_perm_ok) (tree, tree); + + /* Return true if the target supports misaligned store/load of a + specific factor denoted in the third parameter. The last parameter + is true if the access is defined in a packed struct. */ + bool (* builtin_support_vector_misalignment) (enum machine_mode, + const_tree, int, bool); + } vectorize; /* The initial value of target_flags. */ int default_target_flags; + /* Allow target specific overriding of option settings after options have + been changed by an attribute or pragma or when it is reset at the + end of the code affected by an attribute or pragma. */ + void (* override_options_after_change) (void); + /* 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 @@ -511,6 +557,10 @@ struct gcc_target Ignored if NULL. */ const struct attribute_spec *attribute_table; + /* Return true iff attribute NAME expects a plain identifier as its first + argument. */ + bool (*attribute_takes_identifier_p) (const_tree name); + /* Return zero if the attributes on TYPE1 and TYPE2 are incompatible, one if they are compatible and two if they are nearly compatible (which causes a warning to be generated). */ @@ -546,15 +596,24 @@ struct gcc_target /* Set up target-specific built-in functions. */ void (* init_builtins) (void); + /* Initialize (if INITIALIZE_P is true) and return the target-specific + built-in function decl for CODE. + Return NULL if that is not possible. Return error_mark_node if CODE + is outside of the range of valid target builtin function codes. */ + tree (* builtin_decl) (unsigned code, bool initialize_p); + /* Expand a target-specific builtin. */ rtx (* expand_builtin) (tree exp, rtx target, rtx subtarget, enum machine_mode mode, int 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); + *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. PARAMS really + has type VEC(tree,gc)*, but we don't want to include tree.h + here. */ + tree (*resolve_overloaded_builtin) (unsigned int /*location_t*/, + tree decl, void *params); /* Fold a target-specific builtin. */ tree (* fold_builtin) (tree fndecl, tree arglist, bool ignore); @@ -582,7 +641,7 @@ struct gcc_target /* Return a register class for which branch target register optimizations should be applied. */ - int (* branch_target_register_class) (void); + enum reg_class (* branch_target_register_class) (void); /* Return true if branch target register optimizations should include callee-saved registers that are not already live during the current @@ -590,6 +649,12 @@ struct gcc_target already been generated. */ bool (* branch_target_register_callee_saved) (bool after_pe_gen); + /* Return true if the target supports conditional execution. */ + bool (* have_conditional_execution) (void); + + /* Return a new value for loop unroll size. */ + unsigned (* loop_unroll_adjust) (unsigned nunroll, struct loop *loop); + /* True if the constant X cannot be placed in the constant pool. */ bool (* cannot_force_const_mem) (rtx); @@ -598,10 +663,21 @@ struct gcc_target /* True if X is considered to be commutative. */ bool (* commutative_p) (const_rtx, int); + + /* True if ADDR is an address-expression whose effect depends + on the mode of the memory reference it is used in. */ + bool (* mode_dependent_address_p) (const_rtx addr); + + /* Given an invalid address X for a given machine mode, try machine-specific + ways to make it legitimate. Return X or an invalid address on failure. */ + rtx (* legitimize_address) (rtx, rtx, enum machine_mode); /* Given an address RTX, undo the effects of LEGITIMIZE_ADDRESS. */ rtx (* delegitimize_address) (rtx); + /* Given an address RTX, say whether it is valid. */ + bool (* legitimate_address_p) (enum machine_mode, rtx, bool); + /* True if the given constant can be put into an object_block. */ bool (* use_blocks_for_constant_p) (enum machine_mode, const_rtx); @@ -626,7 +702,7 @@ struct gcc_target bool (* in_small_data_p) (const_tree); /* True if EXP names an object for which name resolution must resolve - to the current module. */ + to the current executable or shared library. */ bool (* binds_local_p) (const_tree); /* Modify and return the identifier of a DECL's external name, @@ -662,6 +738,36 @@ struct gcc_target /* True if MODE is valid for a pointer in __attribute__((mode("MODE"))). */ bool (* valid_pointer_mode) (enum machine_mode mode); + /* Support for named address spaces. */ + struct addr_space { + /* MODE to use for a pointer into another address space. */ + enum machine_mode (* pointer_mode) (addr_space_t); + + /* MODE to use for an address in another address space. */ + enum machine_mode (* address_mode) (addr_space_t); + + /* True if MODE is valid for a pointer in __attribute__((mode("MODE"))) + in another address space. */ + bool (* valid_pointer_mode) (enum machine_mode, addr_space_t); + + /* True if an address is a valid memory address to a given named address + space for a given mode. */ + bool (* legitimate_address_p) (enum machine_mode, rtx, bool, addr_space_t); + + /* Return an updated address to convert an invalid pointer to a named + address space to a valid one. If NULL_RTX is returned use machine + independent methods to make the address valid. */ + rtx (* legitimize_address) (rtx, rtx, enum machine_mode, addr_space_t); + + /* True if one named address space is a subset of another named address. */ + bool (* subset_p) (addr_space_t, addr_space_t); + + /* Function to convert an rtl expression from one address space to + another. */ + rtx (* convert) (rtx, tree, tree); + + } addr_space; + /* True if MODE is valid for the target. By "valid", we mean able to be manipulated in non-trivial ways. In particular, this means all the arithmetic is supported. */ @@ -672,8 +778,11 @@ struct gcc_target for further details. */ bool (* vector_mode_supported_p) (enum machine_mode mode); - /* True if a vector is opaque. */ - bool (* vector_opaque_p) (const_tree); + /* True for MODE if the target expects that registers in this mode will + be allocated to registers in a small register class. The compiler is + allowed to use registers explicitly used in the rtl as spill registers + but it should prevent extending the lifetime of these registers. */ + bool (* small_register_classes_for_mode_p) (enum machine_mode mode); /* Compute a (partial) cost for rtx X. Return true if the complete cost has been computed, and false if subexpressions should be @@ -811,10 +920,17 @@ struct gcc_target checks to handle_dll_attribute (). */ bool (* valid_dllimport_attribute_p) (const_tree decl); + /* If non-zero, align constant anchors in CSE to a multiple of this + value. */ + unsigned HOST_WIDE_INT const_anchor; + /* Functions relating to calls - argument passing, returns, etc. */ struct calls { - bool (*promote_function_args) (const_tree fntype); - bool (*promote_function_return) (const_tree fntype); + enum machine_mode (*promote_function_mode) (const_tree type, + enum machine_mode mode, + int *punsignedp, + const_tree fntype, + int for_return); bool (*promote_prototypes) (const_tree fntype); rtx (*struct_value_rtx) (tree fndecl, int incoming); bool (*return_in_memory) (const_tree type, const_tree fndecl); @@ -870,6 +986,14 @@ struct gcc_target rtx (*function_value) (const_tree ret_type, const_tree fn_decl_or_type, bool outgoing); + /* Return the rtx for the result of a libcall of mode MODE, + calling the function FN_NAME. */ + rtx (*libcall_value) (enum machine_mode, const_rtx); + + /* Return true if REGNO is a possible register number for + a function value as seen by the caller. */ + bool (*function_value_regno_p) (const unsigned int); + /* Return an rtx for the argument pointer incoming to the current function. */ rtx (*internal_arg_pointer) (void); @@ -884,7 +1008,17 @@ struct gcc_target /* Return true if all function parameters should be spilled to the stack. */ bool (*allocate_stack_slots_for_args) (void); - + + /* Return an rtx for the static chain for FNDECL. If INCOMING_P is true, + then it should be for the callee; otherwise for the caller. */ + rtx (*static_chain) (const_tree fndecl, bool incoming_p); + + /* Fill in the trampoline at MEM with a call to FNDECL and a + static chain value of CHAIN. */ + void (*trampoline_init) (rtx mem, tree fndecl, rtx chain); + + /* Adjust the address of the trampoline in a target-specific way. */ + rtx (*trampoline_adjust_address) (rtx addr); } calls; /* Return the diagnostic message string if conversion from FROMTYPE @@ -899,13 +1033,31 @@ struct gcc_target is not permitted on TYPE1 and TYPE2, NULL otherwise. */ const char *(*invalid_binary_op) (int op, const_tree type1, const_tree type2); + /* Return the diagnostic message string if TYPE is not valid as a + function parameter type, NULL otherwise. */ + const char *(*invalid_parameter_type) (const_tree type); + + /* Return the diagnostic message string if TYPE is not valid as a + function return type, NULL otherwise. */ + const char *(*invalid_return_type) (const_tree type); + + /* If values of TYPE are promoted to some other type when used in + expressions (analogous to the integer promotions), return that type, + or NULL_TREE otherwise. */ + tree (*promoted_type) (const_tree type); + + /* Convert EXPR to TYPE, if target-specific types with special conversion + rules are involved. Return the converted expression, or NULL to apply + the standard conversion rules. */ + tree (*convert_to_type) (tree type, tree expr); + /* Return the array of IRA cover classes for the current target. */ const enum reg_class *(*ira_cover_classes) (void); /* Return the class for a secondary reload, and fill in extra information. */ enum reg_class (*secondary_reload) (bool, rtx, enum reg_class, enum machine_mode, - struct secondary_reload_info *); + secondary_reload_info *); /* This target hook allows the backend to perform additional processing while initializing for variable expansion. */ @@ -920,6 +1072,17 @@ struct gcc_target in peephole2. */ bool (* hard_regno_scratch_ok) (unsigned int regno); + /* Return the smallest number of different values for which it is best to + use a jump-table instead of a tree of conditional branches. */ + unsigned int (* case_values_threshold) (void); + + /* Retutn true if a function must have and use a frame pointer. */ + bool (* frame_pointer_required) (void); + + /* Returns true if the compiler is allowed to try to replace register number + from-reg with register number to-reg. */ + bool (* can_eliminate) (const int, const int); + /* Functions specific to the C family of frontends. */ struct c { /* Return machine mode for non-standard suffix @@ -992,7 +1155,7 @@ struct gcc_target /* Prefixes for proxy variable and template. */ const char *var_prefix; const char *tmpl_prefix; - + /* Function to generate field definitions of the proxy variable. */ tree (*var_fields) (tree, tree *); @@ -1005,7 +1168,7 @@ struct gcc_target /* Whether we can emit debug information for TLS vars. */ bool debug_form_tls_address; - } emutls; + } emutls; struct target_option_hooks { /* Function to validate the attribute((option(...))) strings or NULL. If @@ -1037,8 +1200,8 @@ struct gcc_target /* 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. */ - void (*live_on_entry) (bitmap); + bits in the bitmap passed in. */ + void (*live_on_entry) (bitmap); /* True if unwinding tables should be generated by default. */ bool unwind_tables_default; @@ -1073,9 +1236,6 @@ struct gcc_target at the beginning of assembly output. */ bool file_start_file_directive; - /* True if #pragma redefine_extname is to be supported. */ - bool handle_pragma_redefine_extname; - /* True if #pragma extern_prefix is to be supported. */ bool handle_pragma_extern_prefix;