X-Git-Url: http://git.sourceforge.jp/view?p=pf3gnuchains%2Fgcc-fork.git;a=blobdiff_plain;f=gcc%2Ftarghooks.c;h=7889282d51b5d23055e462d448f521c851fc839e;hp=82e59a8f34e35b824cbcd64b679095d421c08cf8;hb=191678c8b9e88275c70a7d172f9234496fed359f;hpb=cc7d6aed6b7186313ada1a58107b9dbcaac2f435 diff --git a/gcc/targhooks.c b/gcc/targhooks.c index 82e59a8f34e..7889282d51b 100644 --- a/gcc/targhooks.c +++ b/gcc/targhooks.c @@ -1,5 +1,5 @@ /* Default target hook functions. - Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009, 2010 + Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc. This file is part of GCC. @@ -57,16 +57,20 @@ along with GCC; see the file COPYING3. If not see #include "expr.h" #include "output.h" #include "diagnostic-core.h" -#include "toplev.h" #include "function.h" #include "target.h" #include "tm_p.h" #include "target-def.h" #include "ggc.h" #include "hard-reg-set.h" +#include "regs.h" #include "reload.h" #include "optabs.h" #include "recog.h" +#include "intl.h" +#include "opts.h" +#include "tree-flow.h" +#include "tree-ssa-alias.h" bool @@ -120,7 +124,7 @@ default_promote_function_mode (const_tree type ATTRIBUTE_UNUSED, const_tree funtype ATTRIBUTE_UNUSED, int for_return ATTRIBUTE_UNUSED) { - if (for_return == 2) + if (type != NULL_TREE && for_return == 2) return promote_mode (type, mode, punsignedp); return mode; } @@ -166,7 +170,7 @@ default_expand_builtin_saveregs (void) } void -default_setup_incoming_varargs (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED, +default_setup_incoming_varargs (cumulative_args_t ca ATTRIBUTE_UNUSED, enum machine_mode mode ATTRIBUTE_UNUSED, tree type ATTRIBUTE_UNUSED, int *pretend_arg_size ATTRIBUTE_UNUSED, @@ -185,13 +189,13 @@ default_builtin_setjmp_frame_value (void) /* Generic hook that takes a CUMULATIVE_ARGS pointer and returns false. */ bool -hook_bool_CUMULATIVE_ARGS_false (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED) +hook_bool_CUMULATIVE_ARGS_false (cumulative_args_t ca ATTRIBUTE_UNUSED) { return false; } bool -default_pretend_outgoing_varargs_named (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED) +default_pretend_outgoing_varargs_named (cumulative_args_t ca ATTRIBUTE_UNUSED) { return (targetm.calls.setup_incoming_varargs != default_setup_incoming_varargs); @@ -249,7 +253,7 @@ default_mode_rep_extended (enum machine_mode mode ATTRIBUTE_UNUSED, /* Generic hook that takes a CUMULATIVE_ARGS pointer and returns true. */ bool -hook_bool_CUMULATIVE_ARGS_true (CUMULATIVE_ARGS * a ATTRIBUTE_UNUSED) +hook_bool_CUMULATIVE_ARGS_true (cumulative_args_t a ATTRIBUTE_UNUSED) { return true; } @@ -298,7 +302,7 @@ default_cxx_get_cookie_size (tree type) of the TARGET_PASS_BY_REFERENCE hook uses just MUST_PASS_IN_STACK. */ bool -hook_pass_by_reference_must_pass_in_stack (CUMULATIVE_ARGS *c ATTRIBUTE_UNUSED, +hook_pass_by_reference_must_pass_in_stack (cumulative_args_t c ATTRIBUTE_UNUSED, enum machine_mode mode ATTRIBUTE_UNUSED, const_tree type ATTRIBUTE_UNUSED, bool named_arg ATTRIBUTE_UNUSED) { @@ -309,7 +313,7 @@ hook_pass_by_reference_must_pass_in_stack (CUMULATIVE_ARGS *c ATTRIBUTE_UNUSED, version of the hook is true for all named arguments. */ bool -hook_callee_copies_named (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED, +hook_callee_copies_named (cumulative_args_t ca ATTRIBUTE_UNUSED, enum machine_mode mode ATTRIBUTE_UNUSED, const_tree type ATTRIBUTE_UNUSED, bool named) { @@ -356,19 +360,15 @@ default_print_operand_punct_valid_p (unsigned char code ATTRIBUTE_UNUSED) #endif } -/* The default implementation of TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA. */ - -bool -default_asm_output_addr_const_extra (FILE *file ATTRIBUTE_UNUSED, - rtx x ATTRIBUTE_UNUSED) +/* The default implementation of TARGET_MANGLE_ASSEMBLER_NAME. */ +tree +default_mangle_assembler_name (const char *name ATTRIBUTE_UNUSED) { -#ifdef OUTPUT_ADDR_CONST_EXTRA - OUTPUT_ADDR_CONST_EXTRA (file, x, fail); - return true; - -fail: -#endif - return false; + const char *skipped = name + (*name == '*' ? 1 : 0); + const char *stripped = targetm.strip_name_encoding (skipped); + if (*name != '*' && user_label_prefix[0]) + stripped = ACONCAT ((user_label_prefix, stripped, NULL)); + return get_identifier (stripped); } /* True if MODE is valid for the target. By "valid", we mean able to @@ -424,6 +424,19 @@ default_scalar_mode_supported_p (enum machine_mode mode) } } +/* Make some target macros useable by target-independent code. */ +bool +targhook_words_big_endian (void) +{ + return !!WORDS_BIG_ENDIAN; +} + +bool +targhook_float_words_big_endian (void) +{ + return !!FLOAT_WORDS_BIG_ENDIAN; +} + /* True if the target supports decimal floating point. */ bool @@ -501,6 +514,7 @@ default_builtin_vectorization_cost (enum vect_cost_for_stmt type_of_cost, case scalar_to_vec: case cond_branch_not_taken: case vec_perm: + case vec_promote_demote: return 1; case unaligned_load: @@ -527,7 +541,7 @@ default_builtin_reciprocal (unsigned int fn ATTRIBUTE_UNUSED, bool hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false ( - CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED, + cumulative_args_t ca ATTRIBUTE_UNUSED, enum machine_mode mode ATTRIBUTE_UNUSED, const_tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED) { @@ -536,7 +550,7 @@ hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false ( bool hook_bool_CUMULATIVE_ARGS_mode_tree_bool_true ( - CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED, + cumulative_args_t ca ATTRIBUTE_UNUSED, enum machine_mode mode ATTRIBUTE_UNUSED, const_tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED) { @@ -545,7 +559,7 @@ hook_bool_CUMULATIVE_ARGS_mode_tree_bool_true ( int hook_int_CUMULATIVE_ARGS_mode_tree_bool_0 ( - CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED, + cumulative_args_t ca ATTRIBUTE_UNUSED, enum machine_mode mode ATTRIBUTE_UNUSED, tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED) { @@ -553,44 +567,44 @@ hook_int_CUMULATIVE_ARGS_mode_tree_bool_0 ( } void -default_function_arg_advance (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED, +default_function_arg_advance (cumulative_args_t ca ATTRIBUTE_UNUSED, enum machine_mode mode ATTRIBUTE_UNUSED, const_tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED) { -#ifdef FUNCTION_ARG_ADVANCE - CUMULATIVE_ARGS args = *ca; - FUNCTION_ARG_ADVANCE (args, mode, CONST_CAST_TREE (type), named); - *ca = args; -#else gcc_unreachable (); -#endif } rtx -default_function_arg (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED, +default_function_arg (cumulative_args_t ca ATTRIBUTE_UNUSED, enum machine_mode mode ATTRIBUTE_UNUSED, const_tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED) { -#ifdef FUNCTION_ARG - return FUNCTION_ARG (*ca, mode, CONST_CAST_TREE (type), named); -#else gcc_unreachable (); -#endif } rtx -default_function_incoming_arg (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED, +default_function_incoming_arg (cumulative_args_t ca ATTRIBUTE_UNUSED, enum machine_mode mode ATTRIBUTE_UNUSED, const_tree type ATTRIBUTE_UNUSED, bool named ATTRIBUTE_UNUSED) { -#ifdef FUNCTION_INCOMING_ARG - return FUNCTION_INCOMING_ARG (*ca, mode, CONST_CAST_TREE (type), named); -#else gcc_unreachable (); -#endif +} + +unsigned int +default_function_arg_boundary (enum machine_mode mode ATTRIBUTE_UNUSED, + const_tree type ATTRIBUTE_UNUSED) +{ + return PARM_BOUNDARY; +} + +unsigned int +default_function_arg_round_boundary (enum machine_mode mode ATTRIBUTE_UNUSED, + const_tree type ATTRIBUTE_UNUSED) +{ + return PARM_BOUNDARY; } void @@ -820,15 +834,6 @@ default_branch_target_register_class (void) return NO_REGS; } -#ifdef IRA_COVER_CLASSES -const reg_class_t * -default_ira_cover_classes (void) -{ - static reg_class_t classes[] = IRA_COVER_CLASSES; - return classes; -} -#endif - reg_class_t default_secondary_reload (bool in_p ATTRIBUTE_UNUSED, rtx x ATTRIBUTE_UNUSED, reg_class_t reload_class_i ATTRIBUTE_UNUSED, @@ -858,8 +863,7 @@ default_secondary_reload (bool in_p ATTRIBUTE_UNUSED, rtx x ATTRIBUTE_UNUSED, reload_mode); if (icode != CODE_FOR_nothing - && insn_data[(int) icode].operand[in_p].predicate - && ! insn_data[(int) icode].operand[in_p].predicate (x, reload_mode)) + && !insn_operand_matches (icode, in_p, x)) icode = CODE_FOR_nothing; else if (icode != CODE_FOR_nothing) { @@ -919,14 +923,6 @@ default_secondary_reload (bool in_p ATTRIBUTE_UNUSED, rtx x ATTRIBUTE_UNUSED, return rclass; } -bool -default_handle_c_option (size_t code ATTRIBUTE_UNUSED, - const char *arg ATTRIBUTE_UNUSED, - int value ATTRIBUTE_UNUSED) -{ - return false; -} - /* By default, if flag_pic is true, then neither local nor global relocs should be placed in readonly memory. */ @@ -943,6 +939,13 @@ tree default_mangle_decl_assembler_name (tree decl ATTRIBUTE_UNUSED, return id; } +/* Default to natural alignment for vector types. */ +HOST_WIDE_INT +default_vector_alignment (const_tree type) +{ + return tree_low_cst (TYPE_SIZE (type), 0); +} + bool default_builtin_vector_alignment_reachable (const_tree type, bool is_packed) { @@ -979,10 +982,19 @@ default_builtin_support_vector_misalignment (enum machine_mode mode, /* By default, only attempt to parallelize bitwise operations, and possibly adds/subtracts using bit-twiddling. */ +enum machine_mode +default_preferred_simd_mode (enum machine_mode mode ATTRIBUTE_UNUSED) +{ + return word_mode; +} + +/* By default only the size derived from the preferred vector mode + is tried. */ + unsigned int -default_units_per_simd_word (enum machine_mode mode ATTRIBUTE_UNUSED) +default_autovectorize_vector_sizes (void) { - return UNITS_PER_WORD; + return 0; } /* Determine whether or not a pointer mode is valid. Assume defaults @@ -993,6 +1005,33 @@ default_valid_pointer_mode (enum machine_mode mode) return (mode == ptr_mode || mode == Pmode); } +/* Determine whether the memory reference specified by REF may alias + the C libraries errno location. */ +bool +default_ref_may_alias_errno (ao_ref *ref) +{ + tree base = ao_ref_base (ref); + /* The default implementation assumes the errno location is + a declaration of type int or is always accessed via a + pointer to int. We assume that accesses to errno are + not deliberately obfuscated (even in conforming ways). */ + if (TYPE_UNSIGNED (TREE_TYPE (base)) + || TYPE_MODE (TREE_TYPE (base)) != TYPE_MODE (integer_type_node)) + return false; + /* The default implementation assumes an errno location + declaration is never defined in the current compilation unit. */ + if (DECL_P (base) + && !TREE_STATIC (base)) + return true; + else if (TREE_CODE (base) == MEM_REF + && TREE_CODE (TREE_OPERAND (base, 0)) == SSA_NAME) + { + struct ptr_info_def *pi = SSA_NAME_PTR_INFO (TREE_OPERAND (base, 0)); + return !pi || pi->pt.anything || pi->pt.nonlocal; + } + return false; +} + /* Return the mode for a pointer to a given ADDRSPACE, defaulting to ptr_mode for the generic address space only. */ @@ -1150,9 +1189,10 @@ default_target_can_inline_p (tree caller, tree callee) else if (!caller_opts) ret = false; - /* If both caller and callee have attributes, assume that if the pointer is - different, the the two functions have different target options since - build_target_option_node uses a hash table for the options. */ + /* If both caller and callee have attributes, assume that if the + pointer is different, the two functions have different target + options since build_target_option_node uses a hash table for the + options. */ else ret = (callee_opts == caller_opts); @@ -1182,6 +1222,12 @@ default_have_conditional_execution (void) #endif } +tree +default_builtin_tm_load_store (tree ARG_UNUSED (type)) +{ + return NULL_TREE; +} + /* Compute cost of moving registers to/from memory. */ int @@ -1221,15 +1267,53 @@ default_profile_before_prologue (void) #endif } +/* The default implementation of TARGET_PREFERRED_RELOAD_CLASS. */ + +reg_class_t +default_preferred_reload_class (rtx x ATTRIBUTE_UNUSED, + reg_class_t rclass) +{ +#ifdef PREFERRED_RELOAD_CLASS + return (reg_class_t) PREFERRED_RELOAD_CLASS (x, (enum reg_class) rclass); +#else + return rclass; +#endif +} + +/* The default implementation of TARGET_OUTPUT_PREFERRED_RELOAD_CLASS. */ + +reg_class_t +default_preferred_output_reload_class (rtx x ATTRIBUTE_UNUSED, + reg_class_t rclass) +{ + return rclass; +} + +/* The default implementation of TARGET_PREFERRED_RENAME_CLASS. */ +reg_class_t +default_preferred_rename_class (reg_class_t rclass ATTRIBUTE_UNUSED) +{ + return NO_REGS; +} + /* The default implementation of TARGET_CLASS_LIKELY_SPILLED_P. */ bool default_class_likely_spilled_p (reg_class_t rclass) { -#ifndef CLASS_LIKELY_SPILLED_P return (reg_class_size[(int) rclass] == 1); +} + +/* The default implementation of TARGET_CLASS_MAX_NREGS. */ + +unsigned char +default_class_max_nregs (reg_class_t rclass ATTRIBUTE_UNUSED, + enum machine_mode mode ATTRIBUTE_UNUSED) +{ +#ifdef CLASS_MAX_NREGS + return (unsigned char) CLASS_MAX_NREGS ((enum reg_class) rclass, mode); #else - return CLASS_LIKELY_SPILLED_P ((enum reg_class) rclass); + return ((GET_MODE_SIZE (mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD); #endif } @@ -1254,52 +1338,122 @@ default_debug_unwind_info (void) return UI_NONE; } -/* Determine the exception handling mechanism for the target. */ +/* To be used by targets where reg_raw_mode doesn't return the right + mode for registers used in apply_builtin_return and apply_builtin_arg. */ -enum unwind_info_type -default_except_unwind_info (void) +enum machine_mode +default_get_reg_raw_mode(int regno) { - /* ??? Change the one user to the hook, then poison this. */ -#ifdef MUST_USE_SJLJ_EXCEPTIONS - if (MUST_USE_SJLJ_EXCEPTIONS) - return UI_SJLJ; -#endif + return reg_raw_mode[regno]; +} - /* Obey the configure switch to turn on sjlj exceptions. */ -#ifdef CONFIG_SJLJ_EXCEPTIONS - if (CONFIG_SJLJ_EXCEPTIONS) - return UI_SJLJ; -#endif +/* Return true if the state of option OPTION should be stored in PCH files + and checked by default_pch_valid_p. Store the option's current state + in STATE if so. */ - /* ??? Change all users to the hook, then poison this. */ -#ifdef DWARF2_UNWIND_INFO - if (DWARF2_UNWIND_INFO) - return UI_DWARF2; -#endif +static inline bool +option_affects_pch_p (int option, struct cl_option_state *state) +{ + if ((cl_options[option].flags & CL_TARGET) == 0) + return false; + if (option_flag_var (option, &global_options) == &target_flags) + if (targetm.check_pch_target_flags) + return false; + return get_option_state (&global_options, option, state); +} - return UI_SJLJ; +/* Default version of get_pch_validity. + By default, every flag difference is fatal; that will be mostly right for + most targets, but completely right for very few. */ + +void * +default_get_pch_validity (size_t *sz) +{ + struct cl_option_state state; + size_t i; + char *result, *r; + + *sz = 2; + if (targetm.check_pch_target_flags) + *sz += sizeof (target_flags); + for (i = 0; i < cl_options_count; i++) + if (option_affects_pch_p (i, &state)) + *sz += state.size; + + result = r = XNEWVEC (char, *sz); + r[0] = flag_pic; + r[1] = flag_pie; + r += 2; + if (targetm.check_pch_target_flags) + { + memcpy (r, &target_flags, sizeof (target_flags)); + r += sizeof (target_flags); + } + + for (i = 0; i < cl_options_count; i++) + if (option_affects_pch_p (i, &state)) + { + memcpy (r, state.data, state.size); + r += state.size; + } + + return result; } -/* To be used by targets that force dwarf2 unwind enabled. */ +/* Return a message which says that a PCH file was created with a different + setting of OPTION. */ -enum unwind_info_type -dwarf2_except_unwind_info (void) +static const char * +pch_option_mismatch (const char *option) { - /* Obey the configure switch to turn on sjlj exceptions. */ -#ifdef CONFIG_SJLJ_EXCEPTIONS - if (CONFIG_SJLJ_EXCEPTIONS) - return UI_SJLJ; -#endif + char *r; - return UI_DWARF2; + asprintf (&r, _("created and used with differing settings of '%s'"), option); + if (r == NULL) + return _("out of memory"); + return r; } -/* To be used by targets that force sjlj unwind enabled. */ +/* Default version of pch_valid_p. */ -enum unwind_info_type -sjlj_except_unwind_info (void) +const char * +default_pch_valid_p (const void *data_p, size_t len) { - return UI_SJLJ; + struct cl_option_state state; + const char *data = (const char *)data_p; + size_t i; + + /* -fpic and -fpie also usually make a PCH invalid. */ + if (data[0] != flag_pic) + return _("created and used with different settings of -fpic"); + if (data[1] != flag_pie) + return _("created and used with different settings of -fpie"); + data += 2; + + /* Check target_flags. */ + if (targetm.check_pch_target_flags) + { + int tf; + const char *r; + + memcpy (&tf, data, sizeof (target_flags)); + data += sizeof (target_flags); + len -= sizeof (target_flags); + r = targetm.check_pch_target_flags (tf); + if (r != NULL) + return r; + } + + for (i = 0; i < cl_options_count; i++) + if (option_affects_pch_p (i, &state)) + { + if (memcmp (data, state.data, state.size) != 0) + return pch_option_mismatch (cl_options[i].opt_text); + data += state.size; + len -= state.size; + } + + return NULL; } #include "gt-targhooks.h"