gcc/langhooks.h

   1 /* The lang_hooks data structure.
   2    Copyright (C) 2001-2016 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 3, 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 COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 #ifndef GCC_LANG_HOOKS_H
  21 #define GCC_LANG_HOOKS_H
  22
  23 /* FIXME: This file should be #include-d after tree.h (for enum tree_code).  */
  24
  25 struct diagnostic_info;
  26
  27 struct gimplify_omp_ctx;
  28
  29 struct array_descr_info;
  30
  31 /* A print hook for print_tree ().  */
  32 typedef void (*lang_print_tree_hook) (FILE *, tree, int indent);
  33
  34 enum classify_record
  35   { RECORD_IS_STRUCT, RECORD_IS_CLASS, RECORD_IS_INTERFACE };
  36
  37 /* The following hooks are documented in langhooks.c.  Must not be
  38    NULL.  */
  39
  40 struct lang_hooks_for_tree_inlining
  41 {
  42   bool (*var_mod_type_p) (tree, tree);
  43 };
  44
  45 /* The following hooks are used by tree-dump.c.  */
  46
  47 struct lang_hooks_for_tree_dump
  48 {
  49   /* Dump language-specific parts of tree nodes.  Returns nonzero if it
  50      does not want the usual dumping of the second argument.  */
  51   bool (*dump_tree) (void *, tree);
  52
  53   /* Determine type qualifiers in a language-specific way.  */
  54   int (*type_quals) (const_tree);
  55 };
  56
  57 /* Hooks related to types.  */
  58
  59 struct lang_hooks_for_types
  60 {
  61   /* Return a new type (with the indicated CODE), doing whatever
  62      language-specific processing is required.  */
  63   tree (*make_type) (enum tree_code);
  64
  65   /* Return what kind of RECORD_TYPE this is, mainly for purposes of
  66      debug information.  If not defined, record types are assumed to
  67      be structures.  */
  68   enum classify_record (*classify_record) (tree);
  69
  70   /* Given MODE and UNSIGNEDP, return a suitable type-tree with that
  71      mode.  */
  72   tree (*type_for_mode) (machine_mode, int);
  73
  74   /* Given PRECISION and UNSIGNEDP, return a suitable type-tree for an
  75      integer type with at least that precision.  */
  76   tree (*type_for_size) (unsigned, int);
  77
  78   /* True if the type is an instantiation of a generic type,
  79      e.g. C++ template implicit specializations.  */
  80   bool (*generic_p) (const_tree);
  81
  82   /* Returns the TREE_VEC of elements of a given generic argument pack.  */
  83   tree (*get_argument_pack_elems) (const_tree);
  84
  85   /* Given a type, apply default promotions to unnamed function
  86      arguments and return the new type.  Return the same type if no
  87      change.  Required by any language that supports variadic
  88      arguments.  The default hook dies.  */
  89   tree (*type_promotes_to) (tree);
  90
  91   /* Register TYPE as a builtin type with the indicated NAME.  The
  92      TYPE is placed in the outermost lexical scope.  The semantics
  93      should be analogous to:
  94
  95        typedef TYPE NAME;
  96
  97      in C.  The default hook ignores the declaration.  */
  98   void (*register_builtin_type) (tree, const char *);
  99
 100   /* This routine is called in tree.c to print an error message for
 101      invalid use of an incomplete type.  VALUE is the expression that
 102      was used (or 0 if that isn't known) and TYPE is the type that was
 103      invalid.  LOC is the location of the use.  */
 104   void (*incomplete_type_error) (location_t loc, const_tree value,
 105                                  const_tree type);
 106
 107   /* Called from assign_temp to return the maximum size, if there is one,
 108      for a type.  */
 109   tree (*max_size) (const_tree);
 110
 111   /* Register language specific type size variables as potentially OpenMP
 112      firstprivate variables.  */
 113   void (*omp_firstprivatize_type_sizes) (struct gimplify_omp_ctx *, tree);
 114
 115   /* Return true if TYPE is a mappable type.  */
 116   bool (*omp_mappable_type) (tree type);
 117
 118   /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
 119      Called only after doing all language independent checks.
 120      At present, this function is only called when both TYPE1 and TYPE2 are
 121      FUNCTION_TYPEs.  */
 122   bool (*type_hash_eq) (const_tree, const_tree);
 123
 124   /* Return TRUE if TYPE uses a hidden descriptor and fills in information
 125      for the debugger about the array bounds, strides, etc.  */
 126   bool (*get_array_descr_info) (const_tree, struct array_descr_info *);
 127
 128   /* Fill in information for the debugger about the bounds of TYPE.  */
 129   void (*get_subrange_bounds) (const_tree, tree *, tree *);
 130
 131   /* Called on INTEGER_TYPEs.  Return NULL_TREE for non-biased types.  For
 132      biased types, return as an INTEGER_CST node the value that is represented
 133      by a physical zero.  */
 134   tree (*get_type_bias) (const_tree);
 135
 136   /* A type descriptive of TYPE's complex layout generated to help the
 137      debugger to decode variable-length or self-referential constructs.
 138      This is only used for the AT_GNAT_descriptive_type DWARF attribute.  */
 139   tree (*descriptive_type) (const_tree);
 140
 141   /* If we requested a pointer to a vector, build up the pointers that
 142      we stripped off while looking for the inner type.  Similarly for
 143      return values from functions.  The argument TYPE is the top of the
 144      chain, and BOTTOM is the new type which we will point to.  */
 145   tree (*reconstruct_complex_type) (tree, tree);
 146
 147   /* Returns the tree that represents the underlying data type used to
 148      implement the enumeration.  The default implementation will just use
 149      type_for_size.  Used in dwarf2out.c to add a DW_AT_type base type
 150      reference to a DW_TAG_enumeration.  */
 151   tree (*enum_underlying_base_type) (const_tree);
 152
 153   /* Return a type to use in the debug info instead of TYPE, or NULL_TREE to
 154      keep TYPE.  This is useful to keep a single "source type" when the
 155      middle-end uses specialized types, for instance constrained discriminated
 156      types in Ada.  */
 157   tree (*get_debug_type) (const_tree);
 158
 159   /* Return TRUE if TYPE implements a fixed point type and fills in information
 160      for the debugger about scale factor, etc.  */
 161   bool (*get_fixed_point_type_info) (const_tree,
 162                                      struct fixed_point_type_info *);
 163 };
 164
 165 /* Language hooks related to decls and the symbol table.  */
 166
 167 struct lang_hooks_for_decls
 168 {
 169   /* Return true if we are in the global binding level.  This hook is really
 170      needed only if the language supports variable-sized types at the global
 171      level, i.e. declared outside subprograms.  */
 172   bool (*global_bindings_p) (void);
 173
 174   /* Function to add a decl to the current scope level.  Takes one
 175      argument, a decl to add.  Returns that decl, or, if the same
 176      symbol is already declared, may return a different decl for that
 177      name.  */
 178   tree (*pushdecl) (tree);
 179
 180   /* Returns the chain of decls so far in the current scope level.  */
 181   tree (*getdecls) (void);
 182
 183   /* Returns true if DECL is explicit member function.  */
 184   bool (*function_decl_explicit_p) (const_tree);
 185
 186   /* Returns true if DECL is C++11 deleted special member function.  */
 187   bool (*function_decl_deleted_p) (const_tree);
 188
 189   /* Returns 0 if DECL is NOT a C++11 defaulted special member
 190      function, 1 if it is explicitly defaulted within the class body,
 191      or 2 if it is explicitly defaulted outside the class body.  */
 192   int (*function_decl_defaulted) (const_tree);
 193
 194   /* Returns True if the parameter is a generic parameter decl
 195      of a generic type, e.g a template template parameter for the C++ FE.  */
 196   bool (*generic_generic_parameter_decl_p) (const_tree);
 197
 198   /* Determine if a function parameter got expanded from a
 199      function parameter pack.  */
 200   bool (*function_parm_expanded_from_pack_p) (tree, tree);
 201
 202   /* Returns the generic declaration of a generic function instantiations.  */
 203   tree (*get_generic_function_decl) (const_tree);
 204
 205   /* Returns true when we should warn for an unused global DECL.
 206      We will already have checked that it has static binding.  */
 207   bool (*warn_unused_global) (const_tree);
 208
 209   /* Perform any post compilation-proper parser cleanups and
 210      processing.  This is currently only needed for the C++ parser,
 211      which hopefully can be cleaned up so this hook is no longer
 212      necessary.  */
 213   void (*post_compilation_parsing_cleanups) (void);
 214
 215   /* True if this decl may be called via a sibcall.  */
 216   bool (*ok_for_sibcall) (const_tree);
 217
 218   /* True if OpenMP should privatize what this DECL points to rather
 219      than the DECL itself.  */
 220   bool (*omp_privatize_by_reference) (const_tree);
 221
 222   /* Return sharing kind if OpenMP sharing attribute of DECL is
 223      predetermined, OMP_CLAUSE_DEFAULT_UNSPECIFIED otherwise.  */
 224   enum omp_clause_default_kind (*omp_predetermined_sharing) (tree);
 225
 226   /* Return decl that should be reported for DEFAULT(NONE) failure
 227      diagnostics.  Usually the DECL passed in.  */
 228   tree (*omp_report_decl) (tree);
 229
 230   /* Return true if DECL's DECL_VALUE_EXPR (if any) should be
 231      disregarded in OpenMP construct, because it is going to be
 232      remapped during OpenMP lowering.  SHARED is true if DECL
 233      is going to be shared, false if it is going to be privatized.  */
 234   bool (*omp_disregard_value_expr) (tree, bool);
 235
 236   /* Return true if DECL that is shared iff SHARED is true should
 237      be put into OMP_CLAUSE_PRIVATE_DEBUG.  */
 238   bool (*omp_private_debug_clause) (tree, bool);
 239
 240   /* Return true if DECL in private clause needs
 241      OMP_CLAUSE_PRIVATE_OUTER_REF on the private clause.  */
 242   bool (*omp_private_outer_ref) (tree);
 243
 244   /* Build and return code for a default constructor for DECL in
 245      response to CLAUSE.  OUTER is corresponding outer region's
 246      variable if needed.  Return NULL if nothing to be done.  */
 247   tree (*omp_clause_default_ctor) (tree clause, tree decl, tree outer);
 248
 249   /* Build and return code for a copy constructor from SRC to DST.  */
 250   tree (*omp_clause_copy_ctor) (tree clause, tree dst, tree src);
 251
 252   /* Similarly, except use an assignment operator instead.  */
 253   tree (*omp_clause_assign_op) (tree clause, tree dst, tree src);
 254
 255   /* Build and return code for a constructor of DST that sets it to
 256      SRC + ADD.  */
 257   tree (*omp_clause_linear_ctor) (tree clause, tree dst, tree src, tree add);
 258
 259   /* Build and return code destructing DECL.  Return NULL if nothing
 260      to be done.  */
 261   tree (*omp_clause_dtor) (tree clause, tree decl);
 262
 263   /* Do language specific checking on an implicitly determined clause.  */
 264   void (*omp_finish_clause) (tree clause, gimple_seq *pre_p);
 265 };
 266
 267 /* Language hooks related to LTO serialization.  */
 268
 269 struct lang_hooks_for_lto
 270 {
 271   /* Begin a new LTO section named NAME.  */
 272   void (*begin_section) (const char *name);
 273
 274   /* Write DATA of length LEN to the currently open LTO section.  BLOCK is a
 275      pointer to the dynamically allocated memory containing DATA.  The
 276      append_data function is responsible for freeing it when it is no longer
 277      needed.  */
 278   void (*append_data) (const void *data, size_t len, void *block);
 279
 280   /* End the previously begun LTO section.  */
 281   void (*end_section) (void);
 282 };
 283
 284 /* Language-specific hooks.  See langhooks-def.h for defaults.  */
 285
 286 struct lang_hooks
 287 {
 288   /* String identifying the front end and optionally language standard
 289      version, e.g. "GNU C++98" or "GNU Java".  */
 290   const char *name;
 291
 292   /* sizeof (struct lang_identifier), so make_node () creates
 293      identifier nodes long enough for the language-specific slots.  */
 294   size_t identifier_size;
 295
 296   /* Remove any parts of the tree that are used only by the FE. */
 297   void (*free_lang_data) (tree);
 298
 299   /* Determines the size of any language-specific tcc_constant or
 300      tcc_exceptional nodes.  Since it is called from make_node, the
 301      only information available is the tree code.  Expected to die
 302      on unrecognized codes.  */
 303   size_t (*tree_size) (enum tree_code);
 304
 305   /* Return the language mask used for converting argv into a sequence
 306      of options.  */
 307   unsigned int (*option_lang_mask) (void);
 308
 309   /* Initialize variables in an options structure.  */
 310   void (*init_options_struct) (struct gcc_options *opts);
 311
 312   /* After the initialize_diagnostics hook is called, do any simple
 313      initialization needed before any calls to handle_option, other
 314      than that done by the init_options_struct hook.  */
 315   void (*init_options) (unsigned int decoded_options_count,
 316                         struct cl_decoded_option *decoded_options);
 317
 318   /* Callback used to perform language-specific initialization for the
 319      global diagnostic context structure.  */
 320   void (*initialize_diagnostics) (diagnostic_context *);
 321
 322   /* Return true if a warning should be given about option OPTION,
 323      which is for the wrong language, false if it should be quietly
 324      ignored.  */
 325   bool (*complain_wrong_lang_p) (const struct cl_option *option);
 326
 327   /* Handle the switch CODE, which has real type enum opt_code from
 328      options.h.  If the switch takes an argument, it is passed in ARG
 329      which points to permanent storage.  The handler is responsible for
 330      checking whether ARG is NULL, which indicates that no argument
 331      was in fact supplied.  For -f and -W switches, VALUE is 1 or 0
 332      for the positive and negative forms respectively.  HANDLERS should
 333      be passed to any recursive handle_option calls.  LOC is the
 334      location of the option.
 335
 336      Return true if the switch is valid, false if invalid.  */
 337   bool (*handle_option) (size_t code, const char *arg, int value, int kind,
 338                          location_t loc,
 339                          const struct cl_option_handlers *handlers);
 340
 341   /* Called when all command line options have been parsed to allow
 342      further processing and initialization
 343
 344      Should return true to indicate that a compiler back-end is
 345      not required, such as with the -E option.
 346
 347      If errorcount is nonzero after this call the compiler exits
 348      immediately and the finish hook is not called.  */
 349   bool (*post_options) (const char **);
 350
 351   /* Called after post_options to initialize the front end.  Return
 352      false to indicate that no further compilation be performed, in
 353      which case the finish hook is called immediately.  */
 354   bool (*init) (void);
 355
 356   /* Called at the end of compilation, as a finalizer.  */
 357   void (*finish) (void);
 358
 359   /* Parses the entire file.  */
 360   void (*parse_file) (void);
 361
 362   /* Determines if it's ok for a function to have no noreturn attribute.  */
 363   bool (*missing_noreturn_ok_p) (tree);
 364
 365   /* Called to obtain the alias set to be used for an expression or type.
 366      Returns -1 if the language does nothing special for it.  */
 367   alias_set_type (*get_alias_set) (tree);
 368
 369   /* Function to finish handling an incomplete decl at the end of
 370      compilation.  Default hook is does nothing.  */
 371   void (*finish_incomplete_decl) (tree);
 372
 373   /* Replace the DECL_LANG_SPECIFIC data, which may be NULL, of the
 374      DECL_NODE with a newly GC-allocated copy.  */
 375   void (*dup_lang_specific_decl) (tree);
 376
 377   /* Set the DECL_ASSEMBLER_NAME for a node.  If it is the sort of
 378      thing that the assembler should talk about, set
 379      DECL_ASSEMBLER_NAME to an appropriate IDENTIFIER_NODE.
 380      Otherwise, set it to the ERROR_MARK_NODE to ensure that the
 381      assembler does not talk about it.  */
 382   void (*set_decl_assembler_name) (tree);
 383
 384   /* The front end can add its own statistics to -fmem-report with
 385      this hook.  It should output to stderr.  */
 386   void (*print_statistics) (void);
 387
 388   /* Called by print_tree when there is a tree of class tcc_exceptional
 389      that it doesn't know how to display.  */
 390   lang_print_tree_hook print_xnode;
 391
 392   /* Called to print language-dependent parts of tcc_decl, tcc_type,
 393      and IDENTIFIER_NODE nodes.  */
 394   lang_print_tree_hook print_decl;
 395   lang_print_tree_hook print_type;
 396   lang_print_tree_hook print_identifier;
 397
 398   /* Computes the name to use to print a declaration.  DECL is the
 399      non-NULL declaration in question.  VERBOSITY determines what
 400      information will be printed: 0: DECL_NAME, demangled as
 401      necessary.  1: and scope information.  2: and any other
 402      information that might be interesting, such as function parameter
 403      types in C++.  The name is in the internal character set and
 404      needs to be converted to the locale character set of diagnostics,
 405      or to the execution character set for strings such as
 406      __PRETTY_FUNCTION__.  */
 407   const char *(*decl_printable_name) (tree decl, int verbosity);
 408
 409   /* Computes the dwarf-2/3 name for a tree.  VERBOSITY determines what
 410      information will be printed: 0: DECL_NAME, demangled as
 411      necessary.  1: and scope information.  */
 412   const char *(*dwarf_name) (tree, int verbosity);
 413
 414   /* This compares two types for equivalence ("compatible" in C-based languages).
 415      This routine should only return 1 if it is sure.  It should not be used
 416      in contexts where erroneously returning 0 causes problems.  */
 417   int (*types_compatible_p) (tree x, tree y);
 418
 419   /* Called by report_error_function to print out function name.  */
 420   void (*print_error_function) (diagnostic_context *, const char *,
 421                                 struct diagnostic_info *);
 422
 423   /* Convert a character from the host's to the target's character
 424      set.  The character should be in what C calls the "basic source
 425      character set" (roughly, the set of characters defined by plain
 426      old ASCII).  The default is to return the character unchanged,
 427      which is correct in most circumstances.  Note that both argument
 428      and result should be sign-extended under -fsigned-char,
 429      zero-extended under -fno-signed-char.  */
 430   HOST_WIDE_INT (*to_target_charset) (HOST_WIDE_INT);
 431
 432   /* Pointers to machine-independent attribute tables, for front ends
 433      using attribs.c.  If one is NULL, it is ignored.  Respectively, a
 434      table of attributes specific to the language, a table of
 435      attributes common to two or more languages (to allow easy
 436      sharing), and a table of attributes for checking formats.  */
 437   const struct attribute_spec *attribute_table;
 438   const struct attribute_spec *common_attribute_table;
 439   const struct attribute_spec *format_attribute_table;
 440
 441   struct lang_hooks_for_tree_inlining tree_inlining;
 442
 443   struct lang_hooks_for_tree_dump tree_dump;
 444
 445   struct lang_hooks_for_decls decls;
 446
 447   struct lang_hooks_for_types types;
 448
 449   struct lang_hooks_for_lto lto;
 450
 451   /* Returns a TREE_VEC of the generic parameters of an instantiation of
 452      a generic type or decl, e.g. C++ template instantiation.  If
 453      TREE_CHAIN of the return value is set, it is an INTEGER_CST
 454      indicating how many of the elements are non-default.  */
 455   tree (*get_innermost_generic_parms) (const_tree);
 456
 457   /* Returns the TREE_VEC of arguments of an instantiation
 458      of a generic type of decl, e.g. C++ template instantiation.  */
 459   tree (*get_innermost_generic_args) (const_tree);
 460
 461   /* Determine if a tree is a function parameter pack.  */
 462   bool (*function_parameter_pack_p) (const_tree);
 463
 464   /* Perform language-specific gimplification on the argument.  Returns an
 465      enum gimplify_status, though we can't see that type here.  */
 466   int (*gimplify_expr) (tree *, gimple_seq *, gimple_seq *);
 467
 468   /* Do language specific processing in the builtin function DECL  */
 469   tree (*builtin_function) (tree decl);
 470
 471   /* Like builtin_function, but make sure the scope is the external scope.
 472      This is used to delay putting in back end builtin functions until the ISA
 473      that defines the builtin is declared via function specific target options,
 474      which can save memory for machines like the x86_64 that have multiple
 475      ISAs.  If this points to the same function as builtin_function, the
 476      backend must add all of the builtins at program initialization time.  */
 477   tree (*builtin_function_ext_scope) (tree decl);
 478
 479   /* Used to set up the tree_contains_structure array for a frontend. */
 480   void (*init_ts) (void);
 481
 482   /* Called by recompute_tree_invariant_for_addr_expr to go from EXPR
 483      to a contained expression or DECL, possibly updating *TC or *SE
 484      if in the process TREE_CONSTANT or TREE_SIDE_EFFECTS need updating.  */
 485   tree (*expr_to_decl) (tree expr, bool *tc, bool *se);
 486
 487   /* The EH personality function decl.  */
 488   tree (*eh_personality) (void);
 489
 490   /* Map a type to a runtime object to match type.  */
 491   tree (*eh_runtime_type) (tree);
 492
 493   /* If non-NULL, this is a function that returns a function decl to be
 494      executed if an unhandled exception is propagated out of a cleanup
 495      region.  For example, in C++, an exception thrown by a destructor
 496      during stack unwinding is required to result in a call to
 497      `std::terminate', so the C++ version of this function returns a
 498      FUNCTION_DECL for `std::terminate'.  */
 499   tree (*eh_protect_cleanup_actions) (void);
 500
 501   /* Return true if a stmt can fallthru.  Used by block_may_fallthru
 502      to possibly handle language trees.  */
 503   bool (*block_may_fallthru) (const_tree);
 504
 505   /* True if this language uses __cxa_end_cleanup when the ARM EABI
 506      is enabled.  */
 507   bool eh_use_cxa_end_cleanup;
 508
 509   /* True if this language requires deep unsharing of tree nodes prior to
 510      gimplification.  */
 511   bool deep_unsharing;
 512
 513   /* Run all lang-specific selftests.  */
 514   void (*run_lang_selftests) (void);
 515
 516   /* Whenever you add entries here, make sure you adjust langhooks-def.h
 517      and langhooks.c accordingly.  */
 518 };
 519
 520 /* Each front end provides its own.  */
 521 extern struct lang_hooks lang_hooks;
 522
 523 extern tree add_builtin_function (const char *name, tree type,
 524                                   int function_code, enum built_in_class cl,
 525                                   const char *library_name,
 526                                   tree attrs);
 527
 528 extern tree add_builtin_function_ext_scope (const char *name, tree type,
 529                                             int function_code,
 530                                             enum built_in_class cl,
 531                                             const char *library_name,
 532                                             tree attrs);
 533 extern tree add_builtin_type (const char *name, tree type);
 534
 535 /* Language helper functions.  */
 536
 537 extern bool lang_GNU_C (void);
 538 extern bool lang_GNU_CXX (void);
 539 extern bool lang_GNU_Fortran (void);
 540
 541 #endif /* GCC_LANG_HOOKS_H */