OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [langhooks.h] - Blame information for rev 684

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.