From b2a8872fbe1ec1c49094559ac7b78e6ea4ab7180 Mon Sep 17 00:00:00 2001 From: kan Date: Fri, 11 Jul 2003 03:40:53 +0000 Subject: Gcc 3.3.1-pre as of 2003-07-11. --- contrib/gcc/langhooks.h | 219 +++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 209 insertions(+), 10 deletions(-) (limited to 'contrib/gcc/langhooks.h') diff --git a/contrib/gcc/langhooks.h b/contrib/gcc/langhooks.h index a77ddee..546e50e 100644 --- a/contrib/gcc/langhooks.h +++ b/contrib/gcc/langhooks.h @@ -1,5 +1,5 @@ /* The lang_hooks data structure. - Copyright 2001 Free Software Foundation, Inc. + Copyright 2001, 2002 Free Software Foundation, Inc. This file is part of GNU CC. @@ -21,6 +21,10 @@ Boston, MA 02111-1307, USA. */ #ifndef GCC_LANG_HOOKS_H #define GCC_LANG_HOOKS_H +/* This file should be #include-d after tree.h. */ + +struct diagnostic_context; + /* A print hook for print_tree (). */ typedef void (*lang_print_tree_hook) PARAMS ((FILE *, tree, int indent)); @@ -54,11 +58,28 @@ struct lang_hooks_for_tree_inlining union tree_node *)); }; +/* Lang hooks for management of language-specific data or status + when entering / leaving functions etc. */ +struct lang_hooks_for_functions +{ + /* Called when entering a function. */ + void (*init) PARAMS ((struct function *)); + + /* Called when leaving a function. */ + void (*final) PARAMS ((struct function *)); + + /* Called when entering a nested function. */ + void (*enter_nested) PARAMS ((struct function *)); + + /* Called when leaving a nested function. */ + void (*leave_nested) PARAMS ((struct function *)); +}; + /* The following hooks are used by tree-dump.c. */ struct lang_hooks_for_tree_dump { - /* Dump language-specific parts of tree nodes. Returns non-zero if it + /* Dump language-specific parts of tree nodes. Returns nonzero if it does not want the usual dumping of the second argument. */ int (*dump_tree) PARAMS ((void *, tree)); @@ -66,6 +87,95 @@ struct lang_hooks_for_tree_dump int (*type_quals) PARAMS ((tree)); }; +/* Hooks related to types. */ + +struct lang_hooks_for_types +{ + /* Return a new type (with the indicated CODE), doing whatever + language-specific processing is required. */ + tree (*make_type) PARAMS ((enum tree_code)); + + /* Given MODE and UNSIGNEDP, return a suitable type-tree with that + mode. */ + tree (*type_for_mode) PARAMS ((enum machine_mode, int)); + + /* Given PRECISION and UNSIGNEDP, return a suitable type-tree for an + integer type with at least that precision. */ + tree (*type_for_size) PARAMS ((unsigned, int)); + + /* Given an integer type T, return a type like T but unsigned. + If T is unsigned, the value is T. */ + tree (*unsigned_type) PARAMS ((tree)); + + /* Given an integer type T, return a type like T but signed. + If T is signed, the value is T. */ + tree (*signed_type) PARAMS ((tree)); + + /* Return a type the same as TYPE except unsigned or signed + according to UNSIGNEDP. */ + tree (*signed_or_unsigned_type) PARAMS ((int, tree)); + + /* Given a type, apply default promotions to unnamed function + arguments and return the new type. Return the same type if no + change. Required by any language that supports variadic + arguments. The default hook aborts. */ + tree (*type_promotes_to) PARAMS ((tree)); + + /* This routine is called in tree.c to print an error message for + invalid use of an incomplete type. VALUE is the expression that + was used (or 0 if that isn't known) and TYPE is the type that was + invalid. */ + void (*incomplete_type_error) PARAMS ((tree value, tree type)); +}; + +/* Language hooks related to decls and the symbol table. */ + +struct lang_hooks_for_decls +{ + /* Enter a new lexical scope. Argument is always zero when called + from outside the front end. */ + void (*pushlevel) PARAMS ((int)); + + /* Exit a lexical scope and return a BINDING for that scope. + Takes three arguments: + KEEP -- nonzero if there were declarations in this scope. + REVERSE -- reverse the order of decls before returning them. + FUNCTIONBODY -- nonzero if this level is the body of a function. */ + tree (*poplevel) PARAMS ((int, int, int)); + + /* Returns nonzero if we are in the global binding level. Ada + returns -1 for an undocumented reason used in stor-layout.c. */ + int (*global_bindings_p) PARAMS ((void)); + + /* Insert BLOCK at the end of the list of subblocks of the + current binding level. This is used when a BIND_EXPR is expanded, + to handle the BLOCK node inside the BIND_EXPR. */ + void (*insert_block) PARAMS ((tree)); + + /* Set the BLOCK node for the current scope level. */ + void (*set_block) PARAMS ((tree)); + + /* Function to add a decl to the current scope level. Takes one + argument, a decl to add. Returns that decl, or, if the same + symbol is already declared, may return a different decl for that + name. */ + tree (*pushdecl) PARAMS ((tree)); + + /* Returns the chain of decls so far in the current scope level. */ + tree (*getdecls) PARAMS ((void)); + + /* Returns true when we should warn for an unused global DECL. + We will already have checked that it has static binding. */ + bool (*warn_unused_global) PARAMS ((tree)); + + /* Obtain a list of globals and do final output on them at end + of compilation */ + void (*final_write_globals) PARAMS ((void)); + + /* True if this decl may be called via a sibcall. */ + bool (*ok_for_sibcall) PARAMS ((tree)); +}; + /* Language-specific hooks. See langhooks-def.h for defaults. */ struct lang_hooks @@ -84,7 +194,7 @@ struct lang_hooks /* Function called with an option vector as argument, to decode a single option (typically starting with -f or -W or +). It should return the number of command-line arguments it uses if it handles - the option, or 0 and not complain if it does not recognise the + the option, or 0 and not complain if it does not recognize the option. If this function returns a negative number, then its absolute value is the number of command-line arguments used, but, in addition, no language-independent option processing should be @@ -96,9 +206,12 @@ struct lang_hooks initialization should be left to the "init" callback, since GC and the identifier hashes are set up between now and then. - If errorcount is non-zero after this call the compiler exits + Should return zero unless the compiler back-end does not need to + be initialized, such as with the -E option. + + If errorcount is nonzero after this call the compiler exits immediately and the finish hook is not called. */ - void (*post_options) PARAMS ((void)); + bool (*post_options) PARAMS ((void)); /* Called after post_options, to initialize the front end. The main input filename is passed, which may be NULL; the front end should @@ -111,6 +224,10 @@ struct lang_hooks /* Called at the end of compilation, as a finalizer. */ void (*finish) PARAMS ((void)); + /* Parses the entire file. The argument is nonzero to cause bison + parsers to dump debugging information during parsing. */ + void (*parse_file) PARAMS ((int)); + /* Called immediately after parsing to clear the binding stack. */ void (*clear_binding_stack) PARAMS ((void)); @@ -123,6 +240,27 @@ struct lang_hooks constant equivalent to its input. */ tree (*expand_constant) PARAMS ((tree)); + /* Called by expand_expr for language-specific tree codes. + Fourth argument is actually an enum expand_modifier. */ + rtx (*expand_expr) PARAMS ((tree, rtx, enum machine_mode, int)); + + /* Prepare expr to be an argument of a TRUTH_NOT_EXPR or other logical + operation. + + This preparation consists of taking the ordinary representation + of an expression expr and producing a valid tree boolean + expression describing whether expr is nonzero. We could simply + always do build_binary_op (NE_EXPR, expr, integer_zero_node, 1), + but we optimize comparisons, &&, ||, and !. + + The result should be an expression of boolean type (if not an + error_mark_node). */ + tree (*truthvalue_conversion) PARAMS ((tree)); + + /* Possibly apply default attributes to a function (represented by + a FUNCTION_DECL). */ + void (*insert_default_attributes) PARAMS ((tree)); + /* Hook called by safe_from_p for language-specific tree codes. It is up to the language front-end to install a hook if it has any such codes that safe_from_p needs to know about. Since same_from_p will @@ -132,9 +270,47 @@ struct lang_hooks parameter. */ int (*safe_from_p) PARAMS ((rtx, tree)); + /* Function to finish handling an incomplete decl at the end of + compilation. Default hook is does nothing. */ + void (*finish_incomplete_decl) PARAMS ((tree)); + + /* Function used by unsafe_for_reeval. A non-negative number is + returned directly from unsafe_for_reeval, a negative number falls + through. The default hook returns a negative number. */ + int (*unsafe_for_reeval) PARAMS ((tree)); + + /* Mark EXP saying that we need to be able to take the address of + it; it should not be allocated in a register. Return true if + successful. */ + bool (*mark_addressable) PARAMS ((tree)); + /* Hook called by staticp for language-specific tree codes. */ int (*staticp) PARAMS ((tree)); + /* Replace the DECL_LANG_SPECIFIC data, which may be NULL, of the + DECL_NODE with a newly GC-allocated copy. */ + void (*dup_lang_specific_decl) PARAMS ((tree)); + + /* Called before its argument, an UNSAVE_EXPR, is to be + unsaved. Modify it in-place so that all the evaluate only once + things are cleared out. */ + tree (*unsave_expr_now) PARAMS ((tree)); + + /* Called by expand_expr to build and return the cleanup-expression + for the passed TARGET_EXPR. Return NULL if there is none. */ + tree (*maybe_build_cleanup) PARAMS ((tree)); + + /* Set the DECL_ASSEMBLER_NAME for a node. If it is the sort of + thing that the assembler should talk about, set + DECL_ASSEMBLER_NAME to an appropriate IDENTIFIER_NODE. + Otherwise, set it to the ERROR_MARK_NODE to ensure that the + assembler does not talk about it. */ + void (*set_decl_assembler_name) PARAMS ((tree)); + + /* Return nonzero if fold-const is free to use bit-field + optimizations, for instance in fold_truthop(). */ + bool (*can_use_bit_fields_p) PARAMS ((void)); + /* Nonzero if TYPE_READONLY and TREE_READONLY should always be honored. */ bool honor_readonly; @@ -152,10 +328,17 @@ struct lang_hooks lang_print_tree_hook print_type; lang_print_tree_hook print_identifier; - /* Set yydebug for bison-based parsers, when -dy is given on the - command line. By default, if the parameter is non-zero, prints a - warning that the front end does not use such a parser. */ - void (*set_yydebug) PARAMS ((int)); + /* Computes the name to use to print a declaration. DECL is the + non-NULL declaration in question. VERBOSITY determines what + information will be printed: 0: DECL_NAME, demangled as + necessary. 1: and scope information. 2: and any other + information that might be interesting, such as function parameter + types in C++. */ + const char *(*decl_printable_name) PARAMS ((tree decl, int verbosity)); + + /* Called by report_error_function to print out function name. */ + void (*print_error_function) PARAMS ((struct diagnostic_context *, + const char *)); /* Called from expr_size to calculate the size of the value of an expression in a language-dependent way. Returns a tree for the size @@ -163,10 +346,26 @@ struct lang_hooks semantics in cases that it doesn't want to handle specially. */ tree (*expr_size) PARAMS ((tree)); + /* Pointers to machine-independent attribute tables, for front ends + using attribs.c. If one is NULL, it is ignored. Respectively, a + table of attributes specific to the language, a table of + attributes common to two or more languages (to allow easy + sharing), and a table of attributes for checking formats. */ + const struct attribute_spec *attribute_table; + const struct attribute_spec *common_attribute_table; + const struct attribute_spec *format_attribute_table; + + /* Function-related language hooks. */ + struct lang_hooks_for_functions function; + struct lang_hooks_for_tree_inlining tree_inlining; - + struct lang_hooks_for_tree_dump tree_dump; + struct lang_hooks_for_decls decls; + + struct lang_hooks_for_types types; + /* Whenever you add entries here, make sure you adjust langhooks-def.h and langhooks.c accordingly. */ }; -- cgit v1.1