X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Flanghooks.c;h=0cf31be78067d727acf35eada568ff8502ba064e;hb=54daa60094d5125e41489c6f6fe28a6ec3302473;hp=c189a3b50b90ce4caa4b25cacf4cfbbbba424e71;hpb=af87ad830272721880f74898c75cc639a081fcec;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/langhooks.c b/gcc/langhooks.c index c189a3b50b9..0cf31be7806 100644 --- a/gcc/langhooks.c +++ b/gcc/langhooks.c @@ -1,116 +1,232 @@ /* Default language-specific hooks. - Copyright 2001 Free Software Foundation, Inc. + Copyright 2001, 2002, 2003, 2004 Free Software Foundation, Inc. Contributed by Alexandre Oliva -This file is part of GNU CC. +This file is part of GCC. -GNU CC is free software; you can redistribute it and/or modify +GCC 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. -GNU CC is distributed in the hope that it will be useful, +GCC 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 GNU CC; see the file COPYING. If not, write to +along with GCC; see the file COPYING. If not, write to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "config.h" #include "system.h" +#include "coretypes.h" +#include "intl.h" +#include "tm.h" #include "toplev.h" #include "tree.h" -#include "c-tree.h" #include "tree-inline.h" +#include "tree-gimple.h" #include "rtl.h" #include "insn-config.h" #include "integrate.h" +#include "flags.h" #include "langhooks.h" #include "langhooks-def.h" +#include "ggc.h" +#include "diagnostic.h" /* Do nothing; in many cases the default hook. */ void -lhd_do_nothing () +lhd_do_nothing (void) +{ +} + +/* Do nothing (tree). */ + +void +lhd_do_nothing_t (tree ARG_UNUSED (t)) +{ +} + +/* Do nothing (int). */ + +void +lhd_do_nothing_i (int ARG_UNUSED (i)) +{ +} + +/* Do nothing (int, int, int). Return NULL_TREE. */ + +tree +lhd_do_nothing_iii_return_null_tree (int ARG_UNUSED (i), + int ARG_UNUSED (j), + int ARG_UNUSED (k)) +{ + return NULL_TREE; +} + +/* Do nothing (function). */ + +void +lhd_do_nothing_f (struct function * ARG_UNUSED (f)) { } /* Do nothing (return the tree node passed). */ tree -lhd_return_tree (t) - tree t; +lhd_return_tree (tree t) { return t; } -/* Do nothing; the default hook to decode an option. */ +/* Do nothing (return NULL_TREE). */ -int -lhd_decode_option (argc, argv) - int argc ATTRIBUTE_UNUSED; - char **argv ATTRIBUTE_UNUSED; +tree +lhd_return_null_tree_v (void) { - return 0; + return NULL_TREE; +} + +/* Do nothing (return NULL_TREE). */ + +tree +lhd_return_null_tree (tree ARG_UNUSED (t)) +{ + return NULL_TREE; +} + +/* The default post options hook. */ + +bool +lhd_post_options (const char ** ARG_UNUSED (pfilename)) +{ + return false; } /* Called from by print-tree.c. */ void -lhd_print_tree_nothing (file, node, indent) - FILE *file ATTRIBUTE_UNUSED; - tree node ATTRIBUTE_UNUSED; - int indent ATTRIBUTE_UNUSED; +lhd_print_tree_nothing (FILE * ARG_UNUSED (file), + tree ARG_UNUSED (node), + int ARG_UNUSED (indent)) { } /* Called from safe_from_p. */ int -lhd_safe_from_p (x, exp) - rtx x ATTRIBUTE_UNUSED; - tree exp ATTRIBUTE_UNUSED; +lhd_safe_from_p (rtx ARG_UNUSED (x), tree ARG_UNUSED (exp)) { return 1; } /* Called from staticp. */ -int -lhd_staticp (exp) - tree exp ATTRIBUTE_UNUSED; +tree +lhd_staticp (tree ARG_UNUSED (exp)) { - return 0; + return NULL; } -/* Called when -dy is given on the command line. */ +/* Called from check_global_declarations. */ + +bool +lhd_warn_unused_global_decl (tree decl) +{ + /* This is what used to exist in check_global_declarations. Probably + not many of these actually apply to non-C languages. */ + if (TREE_CODE (decl) == FUNCTION_DECL && DECL_INLINE (decl)) + return false; + if (TREE_CODE (decl) == VAR_DECL && TREE_READONLY (decl)) + return false; + if (DECL_IN_SYSTEM_HEADER (decl)) + return false; + + return true; +} + +/* Set the DECL_ASSEMBLER_NAME for DECL. */ void -lhd_set_yydebug (value) - int value; +lhd_set_decl_assembler_name (tree decl) +{ + /* The language-independent code should never use the + DECL_ASSEMBLER_NAME for lots of DECLs. Only FUNCTION_DECLs and + VAR_DECLs for variables with static storage duration need a real + DECL_ASSEMBLER_NAME. */ + if (TREE_CODE (decl) == FUNCTION_DECL + || (TREE_CODE (decl) == VAR_DECL + && (TREE_STATIC (decl) + || DECL_EXTERNAL (decl) + || TREE_PUBLIC (decl)))) + { + /* By default, assume the name to use in assembly code is the + same as that used in the source language. (That's correct + for C, and GCC used to set DECL_ASSEMBLER_NAME to the same + value as DECL_NAME in build_decl, so this choice provides + backwards compatibility with existing front-ends. + + Can't use just the variable's own name for a variable whose + scope is less than the whole compilation. Concatenate a + distinguishing number - we use the DECL_UID. */ + if (TREE_PUBLIC (decl) || DECL_CONTEXT (decl) == NULL_TREE) + SET_DECL_ASSEMBLER_NAME (decl, DECL_NAME (decl)); + else + { + const char *name = IDENTIFIER_POINTER (DECL_NAME (decl)); + char *label; + + ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl)); + SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label)); + } + } + else + /* Nobody should ever be asking for the DECL_ASSEMBLER_NAME of + these DECLs -- unless they're in language-dependent code, in + which case set_decl_assembler_name hook should handle things. */ + abort (); +} + +/* By default we always allow bit-field based optimizations. */ +bool +lhd_can_use_bit_fields_p (void) { - if (value) - fprintf (stderr, "warning: no yacc/bison-generated output to debug!\n"); + return true; } -/* Provide a default routine to clear the binding stack. This is used - by languages that don't need to do anything special. */ +/* Type promotion for variable arguments. */ +tree +lhd_type_promotes_to (tree ARG_UNUSED (type)) +{ + abort (); +} + +/* Registration of machine- or os-specific builtin types. */ void -lhd_clear_binding_stack () +lhd_register_builtin_type (tree ARG_UNUSED (type), + const char * ARG_UNUSED (name)) { - while (! global_bindings_p ()) - poplevel (0, 0, 0); +} + +/* Invalid use of an incomplete type. */ +void +lhd_incomplete_type_error (tree ARG_UNUSED (value), tree type) +{ + if (TREE_CODE (type) == ERROR_MARK) + return; + + abort (); } /* Provide a default routine for alias sets that always returns -1. This is used by languages that don't need to do anything special. */ HOST_WIDE_INT -lhd_get_alias_set (t) - tree t ATTRIBUTE_UNUSED; +lhd_get_alias_set (tree ARG_UNUSED (t)) { return -1; } @@ -119,12 +235,53 @@ lhd_get_alias_set (t) used by languages that haven't deal with alias sets yet. */ HOST_WIDE_INT -hook_get_alias_set_0 (t) - tree t ATTRIBUTE_UNUSED; +hook_get_alias_set_0 (tree ARG_UNUSED (t)) { return 0; } +/* This is the default expand_expr function. */ + +rtx +lhd_expand_expr (tree ARG_UNUSED (t), rtx ARG_UNUSED (r), + enum machine_mode ARG_UNUSED (mm), + int ARG_UNUSED (em), + rtx * ARG_UNUSED (a)) +{ + abort (); +} + +/* The default language-specific function for expanding a decl. After + the language-independent cases are handled, this function will be + called. If this function is not defined, it is assumed that + declarations other than those for variables and labels do not require + any RTL generation. */ + +int +lhd_expand_decl (tree ARG_UNUSED (t)) +{ + return 0; +} + +/* This is the default decl_printable_name function. */ + +const char * +lhd_decl_printable_name (tree decl, int ARG_UNUSED (verbosity)) +{ + gcc_assert (decl && DECL_NAME (decl)); + return IDENTIFIER_POINTER (DECL_NAME (decl)); +} + +/* This compares two types for equivalence ("compatible" in C-based languages). + This routine should only return 1 if it is sure. It should not be used + in contexts where erroneously returning 0 causes problems. */ + +int +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 @@ -133,16 +290,15 @@ hook_get_alias_set_0 (t) completely handled within this function, it should set *SUBTREES to 0, so that generic handling isn't attempted. For language-specific tree codes, generic handling would abort(), so make sure it is set - properly. Both SUBTREES and *SUBTREES is guaranteed to be non-zero + properly. Both SUBTREES and *SUBTREES is guaranteed to be nonzero when the function is called. */ tree -lhd_tree_inlining_walk_subtrees (tp,subtrees,func,data,htab) - tree *tp ATTRIBUTE_UNUSED; - int *subtrees ATTRIBUTE_UNUSED; - walk_tree_fn func ATTRIBUTE_UNUSED; - void *data ATTRIBUTE_UNUSED; - void *htab ATTRIBUTE_UNUSED; +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; } @@ -152,10 +308,9 @@ lhd_tree_inlining_walk_subtrees (tp,subtrees,func,data,htab) inlining a given function. */ int -lhd_tree_inlining_cannot_inline_tree_fn (fnp) - tree *fnp; +lhd_tree_inlining_cannot_inline_tree_fn (tree *fnp) { - if (optimize == 0 + if (flag_really_no_inline && lookup_attribute ("always_inline", DECL_ATTRIBUTES (*fnp)) == NULL) return 1; @@ -167,8 +322,7 @@ lhd_tree_inlining_cannot_inline_tree_fn (fnp) if it would exceed inlining limits. */ int -lhd_tree_inlining_disregard_inline_limits (fn) - tree fn; +lhd_tree_inlining_disregard_inline_limits (tree fn) { if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) != NULL) return 1; @@ -184,30 +338,16 @@ lhd_tree_inlining_disregard_inline_limits (fn) returned. */ tree -lhd_tree_inlining_add_pending_fn_decls (vafnp, pfn) - void *vafnp ATTRIBUTE_UNUSED; - tree pfn; +lhd_tree_inlining_add_pending_fn_decls (void *vafnp ATTRIBUTE_UNUSED, tree pfn) { return pfn; } -/* lang_hooks.tree_inlining.tree_chain_matters_p indicates whether the - TREE_CHAIN of a language-specific tree node is relevant, i.e., - whether it should be walked, copied and preserved across copies. */ - -int -lhd_tree_inlining_tree_chain_matters_p (t) - tree t ATTRIBUTE_UNUSED; -{ - 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 (var, fn) - tree var, fn; +lhd_tree_inlining_auto_var_in_fn_p (tree var, tree fn) { return (DECL_P (var) && DECL_CONTEXT (var) == fn && (((TREE_CODE (var) == VAR_DECL || TREE_CODE (var) == PARM_DECL) @@ -216,77 +356,193 @@ lhd_tree_inlining_auto_var_in_fn_p (var, fn) || TREE_CODE (var) == RESULT_DECL)); } -/* lang_hooks.tree_inlining.copy_res_decl_for_inlining should return a - declaration for the result RES of function FN to be inlined into - CALLER. NDP points to an integer that should be set in case a new - declaration wasn't created (presumably because RES was of aggregate - type, such that a TARGET_EXPR is used for the result). TEXPS is a - pointer to a varray with the stack of TARGET_EXPRs seen while - inlining functions into caller; the top of TEXPS is supposed to - match RES. */ - -tree -lhd_tree_inlining_copy_res_decl_for_inlining (res, fn, caller, - dm, ndp, texps) - tree res, fn, caller; - void *dm ATTRIBUTE_UNUSED; - int *ndp ATTRIBUTE_UNUSED; - void *texps ATTRIBUTE_UNUSED; -{ - return copy_decl_for_inlining (res, fn, caller); -} - /* lang_hooks.tree_inlining.anon_aggr_type_p determines whether T is a type node representing an anonymous aggregate (union, struct, etc), i.e., one whose members are in the same scope as the union itself. */ int -lhd_tree_inlining_anon_aggr_type_p (t) - tree t ATTRIBUTE_UNUSED; +lhd_tree_inlining_anon_aggr_type_p (tree t ATTRIBUTE_UNUSED) { return 0; } /* lang_hooks.tree_inlining.start_inlining and end_inlining perform any language-specific bookkeeping necessary for processing - FN. start_inlining returns non-zero if inlining should proceed, zero if + FN. start_inlining returns nonzero if inlining should proceed, zero if not. For instance, the C++ version keeps track of template instantiations to avoid infinite recursion. */ int -lhd_tree_inlining_start_inlining (fn) - tree fn ATTRIBUTE_UNUSED; +lhd_tree_inlining_start_inlining (tree fn ATTRIBUTE_UNUSED) { return 1; } void -lhd_tree_inlining_end_inlining (fn) - tree fn ATTRIBUTE_UNUSED; +lhd_tree_inlining_end_inlining (tree fn ATTRIBUTE_UNUSED) { } -/* lang_hooks.tree_dump.dump_tree: Dump language-specific parts of tree - nodes. Returns non-zero if it does not want the usual dumping of the +/* lang_hooks.tree_inlining.convert_parm_for_inlining performs any + language-specific conversion before assigning VALUE to PARM. */ + +tree +lhd_tree_inlining_convert_parm_for_inlining (tree parm ATTRIBUTE_UNUSED, + tree value, + tree fndecl ATTRIBUTE_UNUSED, + int argnum ATTRIBUTE_UNUSED) +{ + return value; +} + +/* 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. */ -int -lhd_tree_dump_dump_tree (di, t) - void *di ATTRIBUTE_UNUSED; - tree t ATTRIBUTE_UNUSED; +bool +lhd_tree_dump_dump_tree (void *di ATTRIBUTE_UNUSED, tree t ATTRIBUTE_UNUSED) { - return 0; + return false; } -/* lang_hooks.tree_dump.type_qual: Determine type qualifiers in a +/* lang_hooks.tree_dump.type_qual: Determine type qualifiers in a language-specific way. */ int -lhd_tree_dump_type_quals (t) - tree t; +lhd_tree_dump_type_quals (tree t) { return TYPE_QUALS (t); } +/* lang_hooks.expr_size: Determine the size of the value of an expression T + in a language-specific way. Returns a tree for the size in bytes. */ + +tree +lhd_expr_size (tree exp) +{ + if (DECL_P (exp) + && DECL_SIZE_UNIT (exp) != 0) + return DECL_SIZE_UNIT (exp); + else + return size_in_bytes (TREE_TYPE (exp)); +} + +/* lang_hooks.gimplify_expr re-writes *EXPR_P into GIMPLE form. */ + +int +lhd_gimplify_expr (tree *expr_p ATTRIBUTE_UNUSED, tree *pre_p ATTRIBUTE_UNUSED, + tree *post_p ATTRIBUTE_UNUSED) +{ + return GS_UNHANDLED; +} + +/* lang_hooks.tree_size: Determine the size of a tree with code C, + which is a language-specific tree code in category tcc_constant or + tcc_exceptional. The default expects never to be called. */ +size_t +lhd_tree_size (enum tree_code c ATTRIBUTE_UNUSED) +{ + abort (); + return 0; +} + +/* Return true if decl, which is a function decl, may be called by a + sibcall. */ + +bool +lhd_decl_ok_for_sibcall (tree decl ATTRIBUTE_UNUSED) +{ + return true; +} + +/* Return the COMDAT group into which DECL should be placed. */ + +const char * +lhd_comdat_group (tree decl) +{ + return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); +} + +/* lang_hooks.decls.final_write_globals: perform final processing on + global variables. */ +void +write_global_declarations (void) +{ + /* Really define vars that have had only a tentative definition. + Really output inline functions that must actually be callable + and have not been output so far. */ + + tree globals = lang_hooks.decls.getdecls (); + int len = list_length (globals); + tree *vec = xmalloc (sizeof (tree) * len); + int i; + tree decl; + + /* Process the decls in reverse order--earliest first. + Put them into VEC from back to front, then take out from front. */ + + for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl)) + vec[len - i - 1] = decl; + + wrapup_global_declarations (vec, len); + + check_global_declarations (vec, len); + + /* Clean up. */ + free (vec); +} + +/* Called to perform language-specific initialization of CTX. */ +void +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) +{ + if (diagnostic_last_function_changed (context)) + { + const char *old_prefix = context->printer->prefix; + char *new_prefix = file ? file_name_as_prefix (file) : NULL; + + pp_set_prefix (context->printer, new_prefix); + + if (current_function_decl == NULL) + pp_printf (context->printer, _("At top level:")); + else + { + if (TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE) + pp_printf + (context->printer, _("In member function %qs:"), + lang_hooks.decl_printable_name (current_function_decl, 2)); + else + pp_printf + (context->printer, _("In function %qs:"), + lang_hooks.decl_printable_name (current_function_decl, 2)); + } + + diagnostic_set_last_function (context); + pp_flush (context->printer); + context->printer->prefix = old_prefix; + free ((char*) new_prefix); + } +} + +tree +lhd_callgraph_analyze_expr (tree *tp ATTRIBUTE_UNUSED, + int *walk_subtrees ATTRIBUTE_UNUSED, + tree decl ATTRIBUTE_UNUSED) +{ + return NULL; +} + +tree +lhd_make_node (enum tree_code code) +{ + return make_node (code); +}