source: arduino-1-6-7/trunk/fuentes/arduino-ide-amd64/hardware/tools/avr/lib/gcc/avr/4.9.2/plugin/include/langhooks.h @ 4837

Last change on this file since 4837 was 4837, checked in by daduve, 2 years ago

Adding new version

File size: 19.6 KB
Line 
1/* The lang_hooks data structure.
2   Copyright (C) 2001-2014 Free Software Foundation, Inc.
3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify
7it under the terms of the GNU General Public License as published by
8the Free Software Foundation; either version 3, or (at your option)
9any later version.
10
11GCC is distributed in the hope that it will be useful,
12but WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14GNU General Public License for more details.
15
16You should have received a copy of the GNU General Public License
17along 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
25struct diagnostic_info;
26
27struct gimplify_omp_ctx;
28
29struct array_descr_info;
30
31/* A print hook for print_tree ().  */
32typedef void (*lang_print_tree_hook) (FILE *, tree, int indent);
33
34enum 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
40struct 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
47struct 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
59struct 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) (enum 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.  */
104  void (*incomplete_type_error) (const_tree value, const_tree type);
105
106  /* Called from assign_temp to return the maximum size, if there is one,
107     for a type.  */
108  tree (*max_size) (const_tree);
109
110  /* Register language specific type size variables as potentially OpenMP
111     firstprivate variables.  */
112  void (*omp_firstprivatize_type_sizes) (struct gimplify_omp_ctx *, tree);
113
114  /* Return true if TYPE is a mappable type.  */
115  bool (*omp_mappable_type) (tree type);
116
117  /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
118     Called only after doing all language independent checks.
119     At present, this function is only called when both TYPE1 and TYPE2 are
120     FUNCTION_TYPEs.  */
121  bool (*type_hash_eq) (const_tree, const_tree);
122
123  /* Return TRUE if TYPE uses a hidden descriptor and fills in information
124     for the debugger about the array bounds, strides, etc.  */
125  bool (*get_array_descr_info) (const_tree, struct array_descr_info *);
126
127  /* Fill in information for the debugger about the bounds of TYPE.  */
128  void (*get_subrange_bounds) (const_tree, tree *, tree *);
129
130  /* A type descriptive of TYPE's complex layout generated to help the
131     debugger to decode variable-length or self-referential constructs.
132     This is only used for the AT_GNAT_descriptive_type DWARF attribute.  */
133  tree (*descriptive_type) (const_tree);
134
135  /* If we requested a pointer to a vector, build up the pointers that
136     we stripped off while looking for the inner type.  Similarly for
137     return values from functions.  The argument TYPE is the top of the
138     chain, and BOTTOM is the new type which we will point to.  */
139  tree (*reconstruct_complex_type) (tree, tree);
140};
141
142/* Language hooks related to decls and the symbol table.  */
143
144struct lang_hooks_for_decls
145{
146  /* Return true if we are in the global binding level.  This hook is really
147     needed only if the language supports variable-sized types at the global
148     level, i.e. declared outside subprograms.  */
149  bool (*global_bindings_p) (void);
150
151  /* Function to add a decl to the current scope level.  Takes one
152     argument, a decl to add.  Returns that decl, or, if the same
153     symbol is already declared, may return a different decl for that
154     name.  */
155  tree (*pushdecl) (tree);
156
157  /* Returns the chain of decls so far in the current scope level.  */
158  tree (*getdecls) (void);
159
160  /* Returns true if DECL is explicit member function.  */
161  bool (*function_decl_explicit_p) (tree);
162
163  /* Returns True if the parameter is a generic parameter decl
164     of a generic type, e.g a template template parameter for the C++ FE.  */
165  bool (*generic_generic_parameter_decl_p) (const_tree);
166
167  /* Determine if a function parameter got expanded from a
168     function parameter pack.  */
169  bool (*function_parm_expanded_from_pack_p) (tree, tree);
170
171  /* Returns the generic declaration of a generic function instantiations.  */
172  tree (*get_generic_function_decl) (const_tree);
173
174  /* Returns true when we should warn for an unused global DECL.
175     We will already have checked that it has static binding.  */
176  bool (*warn_unused_global) (const_tree);
177
178  /* Obtain a list of globals and do final output on them at end
179     of compilation */
180  void (*final_write_globals) (void);
181
182  /* True if this decl may be called via a sibcall.  */
183  bool (*ok_for_sibcall) (const_tree);
184
185  /* True if OpenMP should privatize what this DECL points to rather
186     than the DECL itself.  */
187  bool (*omp_privatize_by_reference) (const_tree);
188
189  /* Return sharing kind if OpenMP sharing attribute of DECL is
190     predetermined, OMP_CLAUSE_DEFAULT_UNSPECIFIED otherwise.  */
191  enum omp_clause_default_kind (*omp_predetermined_sharing) (tree);
192
193  /* Return decl that should be reported for DEFAULT(NONE) failure
194     diagnostics.  Usually the DECL passed in.  */
195  tree (*omp_report_decl) (tree);
196
197  /* Return true if DECL's DECL_VALUE_EXPR (if any) should be
198     disregarded in OpenMP construct, because it is going to be
199     remapped during OpenMP lowering.  SHARED is true if DECL
200     is going to be shared, false if it is going to be privatized.  */
201  bool (*omp_disregard_value_expr) (tree, bool);
202
203  /* Return true if DECL that is shared iff SHARED is true should
204     be put into OMP_CLAUSE_PRIVATE_DEBUG.  */
205  bool (*omp_private_debug_clause) (tree, bool);
206
207  /* Return true if DECL in private clause needs
208     OMP_CLAUSE_PRIVATE_OUTER_REF on the private clause.  */
209  bool (*omp_private_outer_ref) (tree);
210
211  /* Build and return code for a default constructor for DECL in
212     response to CLAUSE.  OUTER is corresponding outer region's
213     variable if needed.  Return NULL if nothing to be done.  */
214  tree (*omp_clause_default_ctor) (tree clause, tree decl, tree outer);
215
216  /* Build and return code for a copy constructor from SRC to DST.  */
217  tree (*omp_clause_copy_ctor) (tree clause, tree dst, tree src);
218
219  /* Similarly, except use an assignment operator instead.  */
220  tree (*omp_clause_assign_op) (tree clause, tree dst, tree src);
221
222  /* Build and return code for a constructor of DST that sets it to
223     SRC + ADD.  */
224  tree (*omp_clause_linear_ctor) (tree clause, tree dst, tree src, tree add);
225
226  /* Build and return code destructing DECL.  Return NULL if nothing
227     to be done.  */
228  tree (*omp_clause_dtor) (tree clause, tree decl);
229
230  /* Do language specific checking on an implicitly determined clause.  */
231  void (*omp_finish_clause) (tree clause, gimple_seq *pre_p);
232};
233
234/* Language hooks related to LTO serialization.  */
235
236struct lang_hooks_for_lto
237{
238  /* Begin a new LTO section named NAME.  */
239  void (*begin_section) (const char *name);
240
241  /* Write DATA of length LEN to the currently open LTO section.  BLOCK is a
242     pointer to the dynamically allocated memory containing DATA.  The
243     append_data function is responsible for freeing it when it is no longer
244     needed.  */
245  void (*append_data) (const void *data, size_t len, void *block);
246
247  /* End the previously begun LTO section.  */
248  void (*end_section) (void);
249};
250
251/* Language-specific hooks.  See langhooks-def.h for defaults.  */
252
253struct lang_hooks
254{
255  /* String identifying the front end.  e.g. "GNU C++".  */
256  const char *name;
257
258  /* sizeof (struct lang_identifier), so make_node () creates
259     identifier nodes long enough for the language-specific slots.  */
260  size_t identifier_size;
261
262  /* Remove any parts of the tree that are used only by the FE. */
263  void (*free_lang_data) (tree);
264
265  /* Determines the size of any language-specific tcc_constant or
266     tcc_exceptional nodes.  Since it is called from make_node, the
267     only information available is the tree code.  Expected to die
268     on unrecognized codes.  */
269  size_t (*tree_size) (enum tree_code);
270
271  /* Return the language mask used for converting argv into a sequence
272     of options.  */
273  unsigned int (*option_lang_mask) (void);
274
275  /* Initialize variables in an options structure.  */
276  void (*init_options_struct) (struct gcc_options *opts);
277
278  /* After the initialize_diagnostics hook is called, do any simple
279     initialization needed before any calls to handle_option, other
280     than that done by the init_options_struct hook.  */
281  void (*init_options) (unsigned int decoded_options_count,
282                        struct cl_decoded_option *decoded_options);
283
284  /* Callback used to perform language-specific initialization for the
285     global diagnostic context structure.  */
286  void (*initialize_diagnostics) (diagnostic_context *);
287
288  /* Return true if a warning should be given about option OPTION,
289     which is for the wrong language, false if it should be quietly
290     ignored.  */
291  bool (*complain_wrong_lang_p) (const struct cl_option *option);
292
293  /* Handle the switch CODE, which has real type enum opt_code from
294     options.h.  If the switch takes an argument, it is passed in ARG
295     which points to permanent storage.  The handler is responsible for
296     checking whether ARG is NULL, which indicates that no argument
297     was in fact supplied.  For -f and -W switches, VALUE is 1 or 0
298     for the positive and negative forms respectively.  HANDLERS should
299     be passed to any recursive handle_option calls.  LOC is the
300     location of the option.
301
302     Return true if the switch is valid, false if invalid.  */
303  bool (*handle_option) (size_t code, const char *arg, int value, int kind,
304                         location_t loc,
305                         const struct cl_option_handlers *handlers);
306
307  /* Called when all command line options have been parsed to allow
308     further processing and initialization
309
310     Should return true to indicate that a compiler back-end is
311     not required, such as with the -E option.
312
313     If errorcount is nonzero after this call the compiler exits
314     immediately and the finish hook is not called.  */
315  bool (*post_options) (const char **);
316
317  /* Called after post_options to initialize the front end.  Return
318     false to indicate that no further compilation be performed, in
319     which case the finish hook is called immediately.  */
320  bool (*init) (void);
321
322  /* Called at the end of compilation, as a finalizer.  */
323  void (*finish) (void);
324
325  /* Parses the entire file.  */
326  void (*parse_file) (void);
327
328  /* Determines if it's ok for a function to have no noreturn attribute.  */
329  bool (*missing_noreturn_ok_p) (tree);
330
331  /* Called to obtain the alias set to be used for an expression or type.
332     Returns -1 if the language does nothing special for it.  */
333  alias_set_type (*get_alias_set) (tree);
334
335  /* Function to finish handling an incomplete decl at the end of
336     compilation.  Default hook is does nothing.  */
337  void (*finish_incomplete_decl) (tree);
338
339  /* Replace the DECL_LANG_SPECIFIC data, which may be NULL, of the
340     DECL_NODE with a newly GC-allocated copy.  */
341  void (*dup_lang_specific_decl) (tree);
342
343  /* Set the DECL_ASSEMBLER_NAME for a node.  If it is the sort of
344     thing that the assembler should talk about, set
345     DECL_ASSEMBLER_NAME to an appropriate IDENTIFIER_NODE.
346     Otherwise, set it to the ERROR_MARK_NODE to ensure that the
347     assembler does not talk about it.  */
348  void (*set_decl_assembler_name) (tree);
349
350  /* The front end can add its own statistics to -fmem-report with
351     this hook.  It should output to stderr.  */
352  void (*print_statistics) (void);
353
354  /* Called by print_tree when there is a tree of class tcc_exceptional
355     that it doesn't know how to display.  */
356  lang_print_tree_hook print_xnode;
357
358  /* Called to print language-dependent parts of tcc_decl, tcc_type,
359     and IDENTIFIER_NODE nodes.  */
360  lang_print_tree_hook print_decl;
361  lang_print_tree_hook print_type;
362  lang_print_tree_hook print_identifier;
363
364  /* Computes the name to use to print a declaration.  DECL is the
365     non-NULL declaration in question.  VERBOSITY determines what
366     information will be printed: 0: DECL_NAME, demangled as
367     necessary.  1: and scope information.  2: and any other
368     information that might be interesting, such as function parameter
369     types in C++.  The name is in the internal character set and
370     needs to be converted to the locale character set of diagnostics,
371     or to the execution character set for strings such as
372     __PRETTY_FUNCTION__.  */
373  const char *(*decl_printable_name) (tree decl, int verbosity);
374
375  /* Computes the dwarf-2/3 name for a tree.  VERBOSITY determines what
376     information will be printed: 0: DECL_NAME, demangled as
377     necessary.  1: and scope information.  */
378  const char *(*dwarf_name) (tree, int verbosity);
379
380  /* This compares two types for equivalence ("compatible" in C-based languages).
381     This routine should only return 1 if it is sure.  It should not be used
382     in contexts where erroneously returning 0 causes problems.  */
383  int (*types_compatible_p) (tree x, tree y);
384
385  /* Called by report_error_function to print out function name.  */
386  void (*print_error_function) (diagnostic_context *, const char *,
387                                struct diagnostic_info *);
388
389  /* Convert a character from the host's to the target's character
390     set.  The character should be in what C calls the "basic source
391     character set" (roughly, the set of characters defined by plain
392     old ASCII).  The default is to return the character unchanged,
393     which is correct in most circumstances.  Note that both argument
394     and result should be sign-extended under -fsigned-char,
395     zero-extended under -fno-signed-char.  */
396  HOST_WIDE_INT (*to_target_charset) (HOST_WIDE_INT);
397
398  /* Pointers to machine-independent attribute tables, for front ends
399     using attribs.c.  If one is NULL, it is ignored.  Respectively, a
400     table of attributes specific to the language, a table of
401     attributes common to two or more languages (to allow easy
402     sharing), and a table of attributes for checking formats.  */
403  const struct attribute_spec *attribute_table;
404  const struct attribute_spec *common_attribute_table;
405  const struct attribute_spec *format_attribute_table;
406
407  struct lang_hooks_for_tree_inlining tree_inlining;
408
409  struct lang_hooks_for_tree_dump tree_dump;
410
411  struct lang_hooks_for_decls decls;
412
413  struct lang_hooks_for_types types;
414 
415  struct lang_hooks_for_lto lto;
416
417  /* Returns a TREE_VEC of the generic parameters of an instantiation of
418     a generic type or decl, e.g. C++ template instantiation.  If
419     TREE_CHAIN of the return value is set, it is an INTEGER_CST
420     indicating how many of the elements are non-default.  */
421  tree (*get_innermost_generic_parms) (const_tree);
422
423  /* Returns the TREE_VEC of arguments of an instantiation
424     of a generic type of decl, e.g. C++ template instantiation.  */
425  tree (*get_innermost_generic_args) (const_tree);
426
427  /* Determine if a tree is a function parameter pack.  */
428  bool (*function_parameter_pack_p) (const_tree);
429
430  /* Perform language-specific gimplification on the argument.  Returns an
431     enum gimplify_status, though we can't see that type here.  */
432  int (*gimplify_expr) (tree *, gimple_seq *, gimple_seq *);
433
434  /* Do language specific processing in the builtin function DECL  */
435  tree (*builtin_function) (tree decl);
436
437  /* Like builtin_function, but make sure the scope is the external scope.
438     This is used to delay putting in back end builtin functions until the ISA
439     that defines the builtin is declared via function specific target options,
440     which can save memory for machines like the x86_64 that have multiple
441     ISAs.  If this points to the same function as builtin_function, the
442     backend must add all of the builtins at program initialization time.  */
443  tree (*builtin_function_ext_scope) (tree decl);
444
445  /* Used to set up the tree_contains_structure array for a frontend. */
446  void (*init_ts) (void);
447
448  /* Called by recompute_tree_invariant_for_addr_expr to go from EXPR
449     to a contained expression or DECL, possibly updating *TC or *SE
450     if in the process TREE_CONSTANT or TREE_SIDE_EFFECTS need updating.  */
451  tree (*expr_to_decl) (tree expr, bool *tc, bool *se);
452
453  /* The EH personality function decl.  */
454  tree (*eh_personality) (void);
455
456  /* Map a type to a runtime object to match type.  */
457  tree (*eh_runtime_type) (tree);
458
459  /* If non-NULL, this is a function that returns a function decl to be
460     executed if an unhandled exception is propagated out of a cleanup
461     region.  For example, in C++, an exception thrown by a destructor
462     during stack unwinding is required to result in a call to
463     `std::terminate', so the C++ version of this function returns a
464     FUNCTION_DECL for `std::terminate'.  */
465  tree (*eh_protect_cleanup_actions) (void);
466
467  /* Return true if a stmt can fallthru.  Used by block_may_fallthru
468     to possibly handle language trees.  */
469  bool (*block_may_fallthru) (const_tree);
470
471  /* True if this language uses __cxa_end_cleanup when the ARM EABI
472     is enabled.  */
473  bool eh_use_cxa_end_cleanup;
474
475  /* True if this language requires deep unsharing of tree nodes prior to
476     gimplification.  */
477  bool deep_unsharing;
478
479  /* Whenever you add entries here, make sure you adjust langhooks-def.h
480     and langhooks.c accordingly.  */
481};
482
483/* Each front end provides its own.  */
484extern struct lang_hooks lang_hooks;
485
486extern tree add_builtin_function (const char *name, tree type,
487                                  int function_code, enum built_in_class cl,
488                                  const char *library_name,
489                                  tree attrs);
490
491extern tree add_builtin_function_ext_scope (const char *name, tree type,
492                                            int function_code,
493                                            enum built_in_class cl,
494                                            const char *library_name,
495                                            tree attrs);
496extern tree add_builtin_type (const char *name, tree type);
497 
498#endif /* GCC_LANG_HOOKS_H */
Note: See TracBrowser for help on using the repository browser.