X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Ftarget.h;h=7f7f177904f1b55854b682647f50bb4a6cabde75;hb=59fbccf3888d3fae161967c88c1be8dfd3605722;hp=468e5d7f0833c2b1bb1f9254e8763341c32c5fb1;hpb=46f8e3b0dc1cbb88c7dde984d0f0c2ce8935011d;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/target.h b/gcc/target.h index 468e5d7f083..7f7f177904f 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 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it @@ -91,6 +91,18 @@ struct _dep; /* This is defined in ddg.h . */ struct ddg; +/* 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 +113,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 @@ -245,6 +251,8 @@ 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); } asm_out; /* Functions relating to instruction scheduling. */ @@ -274,7 +282,7 @@ struct gcc_target /* Finalize machine-dependent scheduling code. */ void (* md_finish) (FILE *, int); - /* Initialize machine-dependent function while scheduling code. */ + /* Initialize machine-dependent function wide scheduling code. */ void (* md_init_global) (FILE *, int, int); /* Finalize machine-dependent function wide scheduling code. */ @@ -354,11 +362,33 @@ struct gcc_target second insn (second parameter). */ bool (* is_costly_dependence) (struct _dep *_dep, int, int); + /* 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 of type DEP_TYPE. The default is to make no adjustment. */ + int (* adjust_cost_2) (rtx insn, int, rtx dep_insn, int cost, int dw); + /* 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); - + + /* Next 5 functions are for multi-point scheduling. */ + + /* Allocate memory for scheduler context. */ + void *(* alloc_sched_context) (void); + + /* Fills the context from the local machine scheduler context. */ + void (* init_sched_context) (void *, bool); + + /* Sets local machine scheduler context to a saved value. */ + void (* set_sched_context) (void *); + + /* Clears a scheduler context so it becomes like after init. */ + void (* clear_sched_context) (void *); + + /* Frees the scheduler context. */ + void (* free_sched_context) (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 @@ -374,9 +404,8 @@ struct gcc_target /* 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) (const_rtx); + passed as the parameter needs a recovery block. */ + bool (* needs_block_p) (int); /* The following member value is a pointer to a function called by the insn scheduler. It should return a pattern for the check @@ -386,7 +415,7 @@ struct gcc_target 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); + rtx (* gen_spec_check) (rtx, rtx, int); /* The following member value is a pointer to a function controlling what insns from the ready insn queue will be considered for the @@ -401,6 +430,17 @@ struct gcc_target The parameter is a pointer to spec_info variable. */ void (* set_sched_flags) (struct spec_info_def *); + /* Return speculation types of the instruction passed as the parameter. */ + int (* get_insn_spec_ds) (rtx); + + /* Return speculation types that are checked for the instruction passed as + the parameter. */ + int (* get_insn_checked_ds) (rtx); + + /* Return bool if rtx scanning should just skip current layer and + advance to the inner rtxes. */ + bool (* skip_rtx_p) (const_rtx); + /* The following member value is a pointer to a function that provides information about the target resource-based lower bound which is used by the swing modulo scheduler. The parameter is a pointer @@ -438,6 +478,9 @@ struct gcc_target /* Return true if vector alignment is reachable (by peeling N iterations) for the given type. */ bool (* vector_alignment_reachable) (const_tree, bool); + + /* Target builtin that implements vector permute. */ + tree (* builtin_vec_perm) (tree, tree*); } vectorize; /* The initial value of target_flags. */ @@ -516,10 +559,13 @@ struct gcc_target 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); @@ -547,7 +593,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 @@ -564,9 +610,16 @@ struct gcc_target /* True if X is considered to be commutative. */ bool (* commutative_p) (const_rtx, int); + /* 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); @@ -591,7 +644,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, @@ -637,19 +690,16 @@ 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); - /* Compute a (partial) cost for rtx X. Return true if the complete cost has been computed, and false if subexpressions should be scanned. In either case, *TOTAL contains the cost result. */ /* Note that CODE and OUTER_CODE ought to be RTX_CODE, but that's not necessarily defined at this point. */ - bool (* rtx_costs) (rtx x, int code, int outer_code, int *total); + bool (* rtx_costs) (rtx x, int code, int outer_code, int *total, bool speed); /* Compute the cost of X, used as an address. Never called with invalid addresses. */ - int (* address_cost) (rtx x); + int (* address_cost) (rtx x, bool speed); /* Return where to allocate pseudo for a given hard register initial value. */ @@ -707,8 +757,8 @@ struct gcc_target void (* expand_builtin_va_start) (tree valist, rtx nextarg); /* Gimplifies a VA_ARG_EXPR. */ - tree (* gimplify_va_arg_expr) (tree valist, tree type, tree *pre_p, - tree *post_p); + tree (* gimplify_va_arg_expr) (tree valist, tree type, gimple_seq *pre_p, + gimple_seq *post_p); /* Validity-checking routines for PCH files, target-specific. get_pch_validity returns a pointer to the data to be stored, @@ -754,10 +804,9 @@ struct gcc_target 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, const_tree lhs, const_tree rhs); + from VA_ARG_EXPR. STMT is the statement. Returns true if the statement + doesn't need to be checked for va_list references. */ + bool (* stdarg_optimize_hook) (struct stdarg_info *ai, const_gimple stmt); /* This target hook allows the operating system to override the DECL that represents the external variable that contains the stack @@ -777,10 +826,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); @@ -836,10 +892,21 @@ 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, rtx); + /* Return an rtx for the argument pointer incoming to the current function. */ rtx (*internal_arg_pointer) (void); + /* Update the current function stack boundary if needed. */ + void (*update_stack_boundary) (void); + + /* Handle stack alignment and return an rtx for Dynamic Realign + Argument Pointer if necessary. */ + rtx (*get_drap_rtx) (void); + /* Return true if all function parameters should be spilled to the stack. */ bool (*allocate_stack_slots_for_args) (void); @@ -858,6 +925,27 @@ 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, @@ -876,6 +964,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 @@ -982,10 +1081,10 @@ struct gcc_target void (*print) (FILE *, int, struct cl_target_option *); /* Function to parse arguments to be validated for #pragma option, and to - change the state if the options are valid. If the arguments are NULL, - use the default target options. Return true if the options are valid, - and set the current state. */ - bool (*pragma_parse) (tree); + change the state if the options are valid. If the first argument is + NULL, the second argument specifies the default options to use. Return + true if the options are valid, and set the current state. */ + bool (*pragma_parse) (tree, tree); /* Function to determine if one function can inline another function. */ bool (*can_inline_p) (tree, tree); @@ -1029,9 +1128,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;