gcc/langhooks.h

   1 /* The lang_hooks data structure.
   2    Copyright 2001, 2002, 2003 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GCC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21 #ifndef GCC_LANG_HOOKS_H
  22 #define GCC_LANG_HOOKS_H
  23
  24 /* This file should be #include-d after tree.h.  */
  25
  26 struct diagnostic_context;
  27
  28 /* A print hook for print_tree ().  */
  29 typedef void (*lang_print_tree_hook) (FILE *, tree, int indent);
  30
  31 /* The following hooks are documented in langhooks.c.  Must not be
  32    NULL.  */
  33
  34 struct lang_hooks_for_tree_inlining
  35 {
  36   tree (*walk_subtrees) (tree *, int *,
  37                          tree (*) (tree *, int *, void *),
  38                          void *, void *);
  39   int (*cannot_inline_tree_fn) (tree *);
  40   int (*disregard_inline_limits) (tree);
  41   tree (*add_pending_fn_decls) (void *, tree);
  42   int (*tree_chain_matters_p) (tree);
  43   int (*auto_var_in_fn_p) (tree, tree);
  44   tree (*copy_res_decl_for_inlining) (tree, tree, tree,
  45                                       void *, int *, tree);
  46   int (*anon_aggr_type_p) (tree);
  47   bool (*var_mod_type_p) (tree);
  48   int (*start_inlining) (tree);
  49   void (*end_inlining) (tree);
  50   tree (*convert_parm_for_inlining) (tree, tree, tree);
  51   int (*estimate_num_insns) (tree);
  52 };
  53
  54 struct lang_hooks_for_callgraph
  55 {
  56   /* Function passed as argument is needed and will be compiled.
  57      Lower the representation so the calls are explicit.  */
  58   void (*lower_function) (tree);
  59   /* Produce RTL for function passed as argument.  */
  60   void (*expand_function) (tree);
  61 };
  62
  63 /* Lang hooks for management of language-specific data or status
  64    when entering / leaving functions etc.  */
  65 struct lang_hooks_for_functions
  66 {
  67   /* Called when entering a function.  */
  68   void (*init) (struct function *);
  69
  70   /* Called when leaving a function.  */
  71   void (*final) (struct function *);
  72
  73   /* Called when entering a nested function.  */
  74   void (*enter_nested) (struct function *);
  75
  76   /* Called when leaving a nested function.  */
  77   void (*leave_nested) (struct function *);
  78 };
  79
  80 /* Lang hooks for rtl code generation.  */
  81 struct lang_hooks_for_rtl_expansion
  82 {
  83   /* Called after expand_function_start, but before expanding the body.  */
  84   void (*start) (void);
  85
  86   /* Called to expand each statement.  */
  87   void (*stmt) (tree);
  88
  89   /* Called after expanding the body but before expand_function_end.  */
  90   void (*end) (void);
  91 };
  92
  93 /* The following hooks are used by tree-dump.c.  */
  94
  95 struct lang_hooks_for_tree_dump
  96 {
  97   /* Dump language-specific parts of tree nodes.  Returns nonzero if it
  98      does not want the usual dumping of the second argument.  */
  99   bool (*dump_tree) (void *, tree);
 100
 101   /* Determine type qualifiers in a language-specific way.  */
 102   int (*type_quals) (tree);
 103 };
 104
 105 /* Hooks related to types.  */
 106
 107 struct lang_hooks_for_types
 108 {
 109   /* Return a new type (with the indicated CODE), doing whatever
 110      language-specific processing is required.  */
 111   tree (*make_type) (enum tree_code);
 112
 113   /* Given MODE and UNSIGNEDP, return a suitable type-tree with that
 114      mode.  */
 115   tree (*type_for_mode) (enum machine_mode, int);
 116
 117   /* Given PRECISION and UNSIGNEDP, return a suitable type-tree for an
 118      integer type with at least that precision.  */
 119   tree (*type_for_size) (unsigned, int);
 120
 121   /* Given an integer type T, return a type like T but unsigned.
 122      If T is unsigned, the value is T.  */
 123   tree (*unsigned_type) (tree);
 124
 125   /* Given an integer type T, return a type like T but signed.
 126      If T is signed, the value is T.  */
 127   tree (*signed_type) (tree);
 128
 129   /* Return a type the same as TYPE except unsigned or signed
 130      according to UNSIGNEDP.  */
 131   tree (*signed_or_unsigned_type) (int, tree);
 132
 133   /* Given a type, apply default promotions to unnamed function
 134      arguments and return the new type.  Return the same type if no
 135      change.  Required by any language that supports variadic
 136      arguments.  The default hook aborts.  */
 137   tree (*type_promotes_to) (tree);
 138
 139   /* Register TYPE as a builtin type with the indicated NAME.  The
 140      TYPE is placed in the outermost lexical scope.  The semantics
 141      should be analogous to:
 142
 143        typedef TYPE NAME;
 144
 145      in C.  The default hook ignores the declaration.  */
 146   void (*register_builtin_type) (tree, const char *);
 147
 148   /* This routine is called in tree.c to print an error message for
 149      invalid use of an incomplete type.  VALUE is the expression that
 150      was used (or 0 if that isn't known) and TYPE is the type that was
 151      invalid.  */
 152   void (*incomplete_type_error) (tree value, tree type);
 153 };
 154
 155 /* Language hooks related to decls and the symbol table.  */
 156
 157 struct lang_hooks_for_decls
 158 {
 159   /* Enter a new lexical scope.  Argument is always zero when called
 160      from outside the front end.  */
 161   void (*pushlevel) (int);
 162
 163   /* Exit a lexical scope and return a BINDING for that scope.
 164      Takes three arguments:
 165      KEEP -- nonzero if there were declarations in this scope.
 166      REVERSE -- reverse the order of decls before returning them.
 167      FUNCTIONBODY -- nonzero if this level is the body of a function.  */
 168   tree (*poplevel) (int, int, int);
 169
 170   /* Returns nonzero if we are in the global binding level.  Ada
 171      returns -1 for an undocumented reason used in stor-layout.c.  */
 172   int (*global_bindings_p) (void);
 173
 174   /* Insert BLOCK at the end of the list of subblocks of the
 175      current binding level.  This is used when a BIND_EXPR is expanded,
 176      to handle the BLOCK node inside the BIND_EXPR.  */
 177   void (*insert_block) (tree);
 178
 179   /* Set the BLOCK node for the current scope level.  */
 180   void (*set_block) (tree);
 181
 182   /* Function to add a decl to the current scope level.  Takes one
 183      argument, a decl to add.  Returns that decl, or, if the same
 184      symbol is already declared, may return a different decl for that
 185      name.  */
 186   tree (*pushdecl) (tree);
 187
 188   /* Returns the chain of decls so far in the current scope level.  */
 189   tree (*getdecls) (void);
 190
 191   /* Returns true when we should warn for an unused global DECL.
 192      We will already have checked that it has static binding.  */
 193   bool (*warn_unused_global) (tree);
 194
 195   /* Obtain a list of globals and do final output on them at end
 196      of compilation */
 197   void (*final_write_globals) (void);
 198
 199   /* Do necessary preparations before assemble_variable can proceed.  */
 200   void (*prepare_assemble_variable) (tree);
 201
 202   /* True if this decl may be called via a sibcall.  */
 203   bool (*ok_for_sibcall) (tree);
 204 };
 205
 206 /* Language-specific hooks.  See langhooks-def.h for defaults.  */
 207
 208 struct lang_hooks
 209 {
 210   /* String identifying the front end.  e.g. "GNU C++".  */
 211   const char *name;
 212
 213   /* sizeof (struct lang_identifier), so make_node () creates
 214      identifier nodes long enough for the language-specific slots.  */
 215   size_t identifier_size;
 216
 217   /* Determines the size of any language-specific 'x' or 'c' nodes.
 218      Since it is called from make_node, the only information available
 219      is the tree code.  Expected to abort on unrecognized codes.  */
 220   size_t (*tree_size) (enum tree_code);
 221
 222   /* The first callback made to the front end, for simple
 223      initialization needed before any calls to handle_option.  Return
 224      the language mask to filter the switch array with.  */
 225   unsigned int (*init_options) (unsigned int argc, const char **argv);
 226
 227   /* Callback used to perform language-specific initialization for the
 228      global diagnostic context structure.  */
 229   void (*initialize_diagnostics) (struct diagnostic_context *);
 230
 231   /* Handle the switch CODE, which has real type enum opt_code from
 232      options.h.  If the switch takes an argument, it is passed in ARG
 233      which points to permanent storage.  The handler is responsible for
 234      checking whether ARG is NULL, which indicates that no argument
 235      was in fact supplied.  For -f and -W switches, VALUE is 1 or 0
 236      for the positive and negative forms respectively.
 237
 238      Return 1 if the switch is valid, 0 if invalid, and -1 if it's
 239      valid and should not be treated as language-independent too.  */
 240   int (*handle_option) (size_t code, const char *arg, int value);
 241
 242   /* Return false to use the default complaint about a missing
 243      argument, otherwise output a complaint and return true.  */
 244   bool (*missing_argument) (const char *opt, size_t code);
 245
 246   /* Called when all command line options have been parsed to allow
 247      further processing and initialization
 248
 249      Should return true to indicate that a compiler back-end is
 250      not required, such as with the -E option.
 251
 252      If errorcount is nonzero after this call the compiler exits
 253      immediately and the finish hook is not called.  */
 254   bool (*post_options) (const char **);
 255
 256   /* Called after post_options to initialize the front end.  Return
 257      false to indicate that no further compilation be performed, in
 258      which case the finish hook is called immediately.  */
 259   bool (*init) (void);
 260
 261   /* Called at the end of compilation, as a finalizer.  */
 262   void (*finish) (void);
 263
 264   /* Parses the entire file.  The argument is nonzero to cause bison
 265      parsers to dump debugging information during parsing.  */
 266   void (*parse_file) (int);
 267
 268   /* Called immediately after parsing to clear the binding stack.  */
 269   void (*clear_binding_stack) (void);
 270
 271   /* Called to obtain the alias set to be used for an expression or type.
 272      Returns -1 if the language does nothing special for it.  */
 273   HOST_WIDE_INT (*get_alias_set) (tree);
 274
 275   /* Called with an expression that is to be processed as a constant.
 276      Returns either the same expression or a language-independent
 277      constant equivalent to its input.  */
 278   tree (*expand_constant) (tree);
 279
 280   /* Called by expand_expr for language-specific tree codes.
 281      Fourth argument is actually an enum expand_modifier.  */
 282   rtx (*expand_expr) (tree, rtx, enum machine_mode, int);
 283
 284   /* Prepare expr to be an argument of a TRUTH_NOT_EXPR or other logical
 285      operation.
 286
 287      This preparation consists of taking the ordinary representation
 288      of an expression expr and producing a valid tree boolean
 289      expression describing whether expr is nonzero.  We could simply
 290      always do build_binary_op (NE_EXPR, expr, integer_zero_node, 1),
 291      but we optimize comparisons, &&, ||, and !.
 292
 293      The result should be an expression of boolean type (if not an
 294      error_mark_node).  */
 295   tree (*truthvalue_conversion) (tree);
 296
 297   /* Hook called by safe_from_p for language-specific tree codes.  It is
 298      up to the language front-end to install a hook if it has any such
 299      codes that safe_from_p needs to know about.  Since same_from_p will
 300      recursively explore the TREE_OPERANDs of an expression, this hook
 301      should not reexamine those pieces.  This routine may recursively
 302      call safe_from_p; it should always pass `0' as the TOP_P
 303      parameter.  */
 304   int (*safe_from_p) (rtx, tree);
 305
 306   /* Function to finish handling an incomplete decl at the end of
 307      compilation.  Default hook is does nothing.  */
 308   void (*finish_incomplete_decl) (tree);
 309
 310   /* Function used by unsafe_for_reeval.  A non-negative number is
 311      returned directly from unsafe_for_reeval, a negative number falls
 312      through.  The default hook returns a negative number.  */
 313   int (*unsafe_for_reeval) (tree);
 314
 315   /* Mark EXP saying that we need to be able to take the address of
 316      it; it should not be allocated in a register.  Return true if
 317      successful.  */
 318   bool (*mark_addressable) (tree);
 319
 320   /* Hook called by staticp for language-specific tree codes.  */
 321   int (*staticp) (tree);
 322
 323   /* Replace the DECL_LANG_SPECIFIC data, which may be NULL, of the
 324      DECL_NODE with a newly GC-allocated copy.  */
 325   void (*dup_lang_specific_decl) (tree);
 326
 327   /* Called before its argument, an UNSAVE_EXPR, is to be
 328      unsaved.  Modify it in-place so that all the evaluate only once
 329      things are cleared out.  */
 330   tree (*unsave_expr_now) (tree);
 331
 332   /* Called by expand_expr to build and return the cleanup-expression
 333      for the passed TARGET_EXPR.  Return NULL if there is none.  */
 334   tree (*maybe_build_cleanup) (tree);
 335
 336   /* Set the DECL_ASSEMBLER_NAME for a node.  If it is the sort of
 337      thing that the assembler should talk about, set
 338      DECL_ASSEMBLER_NAME to an appropriate IDENTIFIER_NODE.
 339      Otherwise, set it to the ERROR_MARK_NODE to ensure that the
 340      assembler does not talk about it.  */
 341   void (*set_decl_assembler_name) (tree);
 342
 343   /* Return nonzero if fold-const is free to use bit-field
 344      optimizations, for instance in fold_truthop().  */
 345   bool (*can_use_bit_fields_p) (void);
 346
 347   /* Nonzero if TYPE_READONLY and TREE_READONLY should always be honored.  */
 348   bool honor_readonly;
 349
 350   /* Nonzero if this front end does not generate a dummy BLOCK between
 351      the outermost scope of the function and the FUNCTION_DECL.  See
 352      is_body_block in stmt.c, and its callers.  */
 353   bool no_body_blocks;
 354
 355   /* The front end can add its own statistics to -fmem-report with
 356      this hook.  It should output to stderr.  */
 357   void (*print_statistics) (void);
 358
 359   /* Called by print_tree when there is a tree of class 'x' that it
 360      doesn't know how to display.  */
 361   lang_print_tree_hook print_xnode;
 362
 363   /* Called to print language-dependent parts of a class 'd', class
 364      't', and IDENTIFIER_NODE nodes.  */
 365   lang_print_tree_hook print_decl;
 366   lang_print_tree_hook print_type;
 367   lang_print_tree_hook print_identifier;
 368
 369   /* Computes the name to use to print a declaration.  DECL is the
 370      non-NULL declaration in question.  VERBOSITY determines what
 371      information will be printed: 0: DECL_NAME, demangled as
 372      necessary.  1: and scope information.  2: and any other
 373      information that might be interesting, such as function parameter
 374      types in C++.  */
 375   const char *(*decl_printable_name) (tree decl, int verbosity);
 376
 377   /* Called by report_error_function to print out function name.  */
 378   void (*print_error_function) (struct diagnostic_context *, const char *);
 379
 380   /* Called from expr_size to calculate the size of the value of an
 381      expression in a language-dependent way.  Returns a tree for the size
 382      in bytes.  A frontend can call lhd_expr_size to get the default
 383      semantics in cases that it doesn't want to handle specially.  */
 384   tree (*expr_size) (tree);
 385
 386   /* Called from uninitialized_vars_warning to find out if a variable is
 387      uninitialized based on DECL_INITIAL.  */
 388   bool (*decl_uninit) (tree);
 389
 390   /* Pointers to machine-independent attribute tables, for front ends
 391      using attribs.c.  If one is NULL, it is ignored.  Respectively, a
 392      table of attributes specific to the language, a table of
 393      attributes common to two or more languages (to allow easy
 394      sharing), and a table of attributes for checking formats.  */
 395   const struct attribute_spec *attribute_table;
 396   const struct attribute_spec *common_attribute_table;
 397   const struct attribute_spec *format_attribute_table;
 398
 399   /* Function-related language hooks.  */
 400   struct lang_hooks_for_functions function;
 401
 402   struct lang_hooks_for_tree_inlining tree_inlining;
 403
 404   struct lang_hooks_for_callgraph callgraph;
 405
 406   struct lang_hooks_for_tree_dump tree_dump;
 407
 408   struct lang_hooks_for_decls decls;
 409
 410   struct lang_hooks_for_types types;
 411
 412   struct lang_hooks_for_rtl_expansion rtl_expand;
 413
 414   /* Whenever you add entries here, make sure you adjust langhooks-def.h
 415      and langhooks.c accordingly.  */
 416 };
 417
 418 /* Each front end provides its own.  */
 419 extern const struct lang_hooks lang_hooks;
 420
 421 #endif /* GCC_LANG_HOOKS_H */