X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Flanghooks.c;h=3943f02b794f75dbc90446fccb0d3a6f5b2ee3ff;hb=7558ba03eec917aced97315ab1deed07feeed773;hp=1074615c72f7d945d59d8605be9b1b55ab7a9a19;hpb=f8fd23c043e25507321039cc26eaa28d6d1f63f1;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/langhooks.c b/gcc/langhooks.c index 1074615c72f..3943f02b794 100644 --- a/gcc/langhooks.c +++ b/gcc/langhooks.c @@ -1,5 +1,5 @@ /* Default language-specific hooks. - Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007 + Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc. Contributed by Alexandre Oliva @@ -76,14 +76,6 @@ lhd_do_nothing_f (struct function * ARG_UNUSED (f)) { } -/* Do nothing (return the tree node passed). */ - -tree -lhd_return_tree (tree t) -{ - return t; -} - /* Do nothing (return NULL_TREE). */ tree @@ -276,67 +268,6 @@ lhd_types_compatible_p (tree x, tree y) return TYPE_MAIN_VARIANT (x) == TYPE_MAIN_VARIANT (y); } -/* lang_hooks.tree_inlining.walk_subtrees is called by walk_tree() - after handling common cases, but before walking code-specific - sub-trees. If this hook is overridden for a language, it should - handle language-specific tree codes, as well as language-specific - information associated to common tree codes. If a tree node is - completely handled within this function, it should set *SUBTREES to - 0, so that generic handling isn't attempted. The generic handling - cannot deal with language-specific tree codes, so make sure it is - set properly. Both SUBTREES and *SUBTREES is guaranteed to be - nonzero when the function is called. */ - -tree -lhd_tree_inlining_walk_subtrees (tree *tp ATTRIBUTE_UNUSED, - int *subtrees ATTRIBUTE_UNUSED, - walk_tree_fn func ATTRIBUTE_UNUSED, - void *data ATTRIBUTE_UNUSED, - struct pointer_set_t *pset ATTRIBUTE_UNUSED) -{ - return NULL_TREE; -} - -/* lang_hooks.tree_inlining.cannot_inline_tree_fn is called to - determine whether there are language-specific reasons for not - inlining a given function. */ - -int -lhd_tree_inlining_cannot_inline_tree_fn (tree *fnp) -{ - if (flag_really_no_inline - && lookup_attribute ("always_inline", DECL_ATTRIBUTES (*fnp)) == NULL) - return 1; - - return 0; -} - -/* lang_hooks.tree_inlining.disregard_inline_limits is called to - determine whether a function should be considered for inlining even - if it would exceed inlining limits. */ - -int -lhd_tree_inlining_disregard_inline_limits (const_tree fn) -{ - if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) != NULL) - return 1; - - return 0; -} - -/* lang_hooks.tree_inlining.auto_var_in_fn_p is called to determine - whether VT is an automatic variable defined in function FT. */ - -int -lhd_tree_inlining_auto_var_in_fn_p (const_tree var, const_tree fn) -{ - return (DECL_P (var) && DECL_CONTEXT (var) == fn - && (((TREE_CODE (var) == VAR_DECL || TREE_CODE (var) == PARM_DECL) - && ! TREE_STATIC (var)) - || TREE_CODE (var) == LABEL_DECL - || TREE_CODE (var) == RESULT_DECL)); -} - /* lang_hooks.tree_dump.dump_tree: Dump language-specific parts of tree nodes. Returns nonzero if it does not want the usual dumping of the second argument. */ @@ -391,7 +322,7 @@ lhd_tree_size (enum tree_code c ATTRIBUTE_UNUSED) sibcall. */ bool -lhd_decl_ok_for_sibcall (tree decl ATTRIBUTE_UNUSED) +lhd_decl_ok_for_sibcall (const_tree decl ATTRIBUTE_UNUSED) { return true; } @@ -442,12 +373,15 @@ lhd_initialize_diagnostics (struct diagnostic_context *ctx ATTRIBUTE_UNUSED) /* The default function to print out name of current function that caused an error. */ void -lhd_print_error_function (diagnostic_context *context, const char *file) +lhd_print_error_function (diagnostic_context *context, const char *file, + diagnostic_info *diagnostic) { - if (diagnostic_last_function_changed (context)) + if (diagnostic_last_function_changed (context, diagnostic)) { const char *old_prefix = context->printer->prefix; - char *new_prefix = file ? file_name_as_prefix (file) : NULL; + tree abstract_origin = diagnostic->abstract_origin; + char *new_prefix = (file && abstract_origin == NULL) + ? file_name_as_prefix (file) : NULL; pp_set_prefix (context->printer, new_prefix); @@ -455,17 +389,93 @@ lhd_print_error_function (diagnostic_context *context, const char *file) pp_printf (context->printer, _("At top level:")); else { - if (TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE) + tree fndecl, ao; + + if (abstract_origin) + { + ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin); + while (TREE_CODE (ao) == BLOCK && BLOCK_ABSTRACT_ORIGIN (ao)) + ao = BLOCK_ABSTRACT_ORIGIN (ao); + gcc_assert (TREE_CODE (ao) == FUNCTION_DECL); + fndecl = ao; + } + else + fndecl = current_function_decl; + + if (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE) pp_printf - (context->printer, _("In member function %qs:"), - lang_hooks.decl_printable_name (current_function_decl, 2)); + (context->printer, _("In member function %qs"), + lang_hooks.decl_printable_name (fndecl, 2)); else pp_printf - (context->printer, _("In function %qs:"), - lang_hooks.decl_printable_name (current_function_decl, 2)); + (context->printer, _("In function %qs"), + lang_hooks.decl_printable_name (fndecl, 2)); + + while (abstract_origin) + { + location_t *locus; + tree block = abstract_origin; + + locus = &BLOCK_SOURCE_LOCATION (block); + fndecl = NULL; + block = BLOCK_SUPERCONTEXT (block); + while (block && TREE_CODE (block) == BLOCK + && BLOCK_ABSTRACT_ORIGIN (block)) + { + ao = BLOCK_ABSTRACT_ORIGIN (block); + + while (TREE_CODE (ao) == BLOCK && BLOCK_ABSTRACT_ORIGIN (ao)) + ao = BLOCK_ABSTRACT_ORIGIN (ao); + + if (TREE_CODE (ao) == FUNCTION_DECL) + { + fndecl = ao; + break; + } + else if (TREE_CODE (ao) != BLOCK) + break; + + block = BLOCK_SUPERCONTEXT (block); + } + if (fndecl) + abstract_origin = block; + else + { + while (block && TREE_CODE (block) == BLOCK) + block = BLOCK_SUPERCONTEXT (block); + + if (TREE_CODE (block) == FUNCTION_DECL) + fndecl = block; + abstract_origin = NULL; + } + if (fndecl) + { + expanded_location s = expand_location (*locus); + pp_character (context->printer, ','); + pp_newline (context->printer); + if (s.file != NULL) + { + if (flag_show_column && s.column != 0) + pp_printf (context->printer, + _(" inlined from %qs at %s:%d:%d"), + lang_hooks.decl_printable_name (fndecl, 2), + s.file, s.line, s.column); + else + pp_printf (context->printer, + _(" inlined from %qs at %s:%d"), + lang_hooks.decl_printable_name (fndecl, 2), + s.file, s.line); + + } + else + pp_printf (context->printer, _(" inlined from %qs"), + lang_hooks.decl_printable_name (fndecl, 2)); + } + } + pp_character (context->printer, ':'); } - diagnostic_set_last_function (context); + diagnostic_set_last_function (context, diagnostic); pp_flush (context->printer); context->printer->prefix = old_prefix; free ((char*) new_prefix); @@ -474,8 +484,7 @@ lhd_print_error_function (diagnostic_context *context, const char *file) tree lhd_callgraph_analyze_expr (tree *tp ATTRIBUTE_UNUSED, - int *walk_subtrees ATTRIBUTE_UNUSED, - tree decl ATTRIBUTE_UNUSED) + int *walk_subtrees ATTRIBUTE_UNUSED) { return NULL; } @@ -493,8 +502,7 @@ lhd_to_target_charset (HOST_WIDE_INT c) } tree -lhd_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED, - bool *ti ATTRIBUTE_UNUSED, bool *se ATTRIBUTE_UNUSED) +lhd_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED, bool *se ATTRIBUTE_UNUSED) { return expr; } @@ -541,6 +549,9 @@ add_builtin_function (const char *name, TREE_PUBLIC (decl) = 1; DECL_EXTERNAL (decl) = 1; DECL_BUILT_IN_CLASS (decl) = cl; + + DECL_FUNCTION_CODE (decl) = -1; + gcc_assert (DECL_FUNCTION_CODE (decl) >= function_code); DECL_FUNCTION_CODE (decl) = function_code; if (library_name)