gcc/langhooks.h

   1 /* The lang_hooks data structure.
   2    Copyright 2001 Free Software Foundation, Inc.
   3
   4 This file is part of GNU CC.
   5
   6 GNU CC 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 GNU CC 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 GNU CC; 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 /* A print hook for print_tree ().  */
  25 typedef void (*lang_print_tree_hook) PARAMS ((FILE *, tree, int indent));
  26
  27 /* The following hooks are documented in langhooks.c.  Must not be
  28    NULL.  */
  29
  30 struct lang_hooks_for_tree_inlining
  31 {
  32   union tree_node *(*walk_subtrees) PARAMS ((union tree_node **, int *,
  33                                              union tree_node *(*)
  34                                              (union tree_node **,
  35                                               int *, void *),
  36                                              void *, void *));
  37   int (*cannot_inline_tree_fn) PARAMS ((union tree_node **));
  38   int (*disregard_inline_limits) PARAMS ((union tree_node *));
  39   union tree_node *(*add_pending_fn_decls) PARAMS ((void *,
  40                                                     union tree_node *));
  41   int (*tree_chain_matters_p) PARAMS ((union tree_node *));
  42   int (*auto_var_in_fn_p) PARAMS ((union tree_node *, union tree_node *));
  43   union tree_node *(*copy_res_decl_for_inlining) PARAMS ((union tree_node *,
  44                                                           union tree_node *,
  45                                                           union tree_node *,
  46                                                           void *, int *,
  47                                                           void *));
  48   int (*anon_aggr_type_p) PARAMS ((union tree_node *));
  49   int (*start_inlining) PARAMS ((union tree_node *));
  50   void (*end_inlining) PARAMS ((union tree_node *));
  51   union tree_node *(*convert_parm_for_inlining) PARAMS ((union tree_node *,
  52                                                          union tree_node *,
  53                                                          union tree_node *));
  54 };
  55
  56 /* The following hooks are used by tree-dump.c.  */
  57
  58 struct lang_hooks_for_tree_dump
  59 {
  60   /* Dump language-specific parts of tree nodes.  Returns non-zero if it
  61      does not want the usual dumping of the second argument.  */
  62   int (*dump_tree) PARAMS ((void *, tree));
  63
  64   /* Determine type qualifiers in a language-specific way.  */
  65   int (*type_quals) PARAMS ((tree));
  66 };
  67
  68 /* Language-specific hooks.  See langhooks-def.h for defaults.  */
  69
  70 struct lang_hooks
  71 {
  72   /* String identifying the front end.  e.g. "GNU C++".  */
  73   const char *name;
  74
  75   /* sizeof (struct lang_identifier), so make_node () creates
  76      identifier nodes long enough for the language-specific slots.  */
  77   size_t identifier_size;
  78
  79   /* The first callback made to the front end, for simple
  80      initialization needed before any calls to decode_option.  */
  81   void (*init_options) PARAMS ((void));
  82
  83   /* Function called with an option vector as argument, to decode a
  84      single option (typically starting with -f or -W or +).  It should
  85      return the number of command-line arguments it uses if it handles
  86      the option, or 0 and not complain if it does not recognise the
  87      option.  If this function returns a negative number, then its
  88      absolute value is the number of command-line arguments used, but,
  89      in addition, no language-independent option processing should be
  90      done for this option.  */
  91   int (*decode_option) PARAMS ((int, char **));
  92
  93   /* Called when all command line options have been parsed.  Should do
  94      any required consistency checks, modifications etc.  Complex
  95      initialization should be left to the "init" callback, since GC
  96      and the identifier hashes are set up between now and then.  */
  97   void (*post_options) PARAMS ((void));
  98
  99   /* Called after post_options, to initialize the front end.  The main
 100      input filename is passed, which may be NULL; the front end should
 101      return the original filename (e.g. foo.i -> foo.c).  Return NULL
 102      to indicate a serious error of some sort; in that case no
 103      compilation is performed, and the finish hook is called
 104      immediately.  */
 105   const char * (*init) PARAMS ((const char *));
 106
 107   /* Called at the end of compilation, as a finalizer.  */
 108   void (*finish) PARAMS ((void));
 109
 110   /* Parses the entire file.  */
 111   void (*parse_file) PARAMS ((void));
 112
 113   /* Called immediately after parsing to clear the binding stack.  */
 114   void (*clear_binding_stack) PARAMS ((void));
 115
 116   /* Called to obtain the alias set to be used for an expression or type.
 117      Returns -1 if the language does nothing special for it.  */
 118   HOST_WIDE_INT (*get_alias_set) PARAMS ((tree));
 119
 120   /* Called with an expression that is to be processed as a constant.
 121      Returns either the same expression or a language-independent
 122      constant equivalent to its input.  */
 123   tree (*expand_constant) PARAMS ((tree));
 124
 125   /* Hook called by safe_from_p for language-specific tree codes.  It is
 126      up to the language front-end to install a hook if it has any such
 127      codes that safe_from_p needs to know about.  Since same_from_p will
 128      recursively explore the TREE_OPERANDs of an expression, this hook
 129      should not reexamine those pieces.  This routine may recursively
 130      call safe_from_p; it should always pass `0' as the TOP_P
 131      parameter.  */
 132   int (*safe_from_p) PARAMS ((rtx, tree));
 133
 134   /* Hook called by staticp for language-specific tree codes.  */
 135   int (*staticp) PARAMS ((tree));
 136
 137   /* Replace the DECL_LANG_SPECIFIC data, which may be NULL, of the
 138      DECL_NODE with a newly GC-allocated copy.  */
 139   void (*dup_lang_specific_decl) PARAMS ((tree));
 140
 141   /* Called before its argument, an UNSAVE_EXPR, is to be
 142      unsaved.  Modify it in-place so that all the evaluate only once
 143      things are cleared out.  */
 144   tree (*unsave_expr_now) PARAMS ((tree));
 145
 146   /* Nonzero if TYPE_READONLY and TREE_READONLY should always be honored.  */
 147   bool honor_readonly;
 148
 149   /* The front end can add its own statistics to -fmem-report with
 150      this hook.  It should output to stderr.  */
 151   void (*print_statistics) PARAMS ((void));
 152
 153   /* Called by print_tree when there is a tree of class 'x' that it
 154      doesn't know how to display.  */
 155   lang_print_tree_hook print_xnode;
 156
 157   /* Called to print language-dependent parts of a class 'd', class
 158      't', and IDENTIFIER_NODE nodes.  */
 159   lang_print_tree_hook print_decl;
 160   lang_print_tree_hook print_type;
 161   lang_print_tree_hook print_identifier;
 162
 163   /* Computes the name to use to print a declaration.  DECL is the
 164      non-NULL declaration in question.  VERBOSITY determines what
 165      information will be printed: 0: DECL_NAME, demangled as
 166      necessary.  1: and scope information.  2: and any other
 167      information that might be interesting, such as function parameter
 168      types in C++.  */
 169   const char *(*decl_printable_name) PARAMS ((tree decl, int verbosity));
 170
 171   /* Set yydebug for bison-based parsers, when -dy is given on the
 172      command line.  By default, if the parameter is non-zero, prints a
 173      warning that the front end does not use such a parser.  */
 174   void (*set_yydebug) PARAMS ((int));
 175
 176   struct lang_hooks_for_tree_inlining tree_inlining;
 177
 178   struct lang_hooks_for_tree_dump tree_dump;
 179
 180   /* Whenever you add entries here, make sure you adjust langhooks-def.h
 181      and langhooks.c accordingly.  */
 182 };
 183
 184 /* Each front end provides its own.  */
 185 extern const struct lang_hooks lang_hooks;
 186
 187 #endif /* GCC_LANG_HOOKS_H */