0
|
1 /* The lang_hooks data structure.
|
|
2 Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
|
|
3 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_context;
|
|
27 struct diagnostic_info;
|
|
28
|
|
29 struct gimplify_omp_ctx;
|
|
30
|
|
31 struct array_descr_info;
|
|
32
|
|
33 /* A print hook for print_tree (). */
|
|
34 typedef void (*lang_print_tree_hook) (FILE *, tree, int indent);
|
|
35
|
|
36 enum classify_record
|
|
37 { RECORD_IS_STRUCT, RECORD_IS_CLASS, RECORD_IS_INTERFACE };
|
|
38
|
|
39 /* The following hooks are documented in langhooks.c. Must not be
|
|
40 NULL. */
|
|
41
|
|
42 struct lang_hooks_for_tree_inlining
|
|
43 {
|
|
44 bool (*var_mod_type_p) (tree, tree);
|
|
45 };
|
|
46
|
|
47 struct lang_hooks_for_callgraph
|
|
48 {
|
|
49 /* The node passed is a language-specific tree node. If its contents
|
|
50 are relevant to use of other declarations, mark them. */
|
|
51 tree (*analyze_expr) (tree *, int *);
|
|
52
|
|
53 /* Emit thunks associated to function. */
|
|
54 void (*emit_associated_thunks) (tree);
|
|
55 };
|
|
56
|
|
57 /* The following hooks are used by tree-dump.c. */
|
|
58
|
|
59 struct lang_hooks_for_tree_dump
|
|
60 {
|
|
61 /* Dump language-specific parts of tree nodes. Returns nonzero if it
|
|
62 does not want the usual dumping of the second argument. */
|
|
63 bool (*dump_tree) (void *, tree);
|
|
64
|
|
65 /* Determine type qualifiers in a language-specific way. */
|
|
66 int (*type_quals) (const_tree);
|
|
67 };
|
|
68
|
|
69 /* Hooks related to types. */
|
|
70
|
|
71 struct lang_hooks_for_types
|
|
72 {
|
|
73 /* Return a new type (with the indicated CODE), doing whatever
|
|
74 language-specific processing is required. */
|
|
75 tree (*make_type) (enum tree_code);
|
|
76
|
|
77 /* Return what kind of RECORD_TYPE this is, mainly for purposes of
|
|
78 debug information. If not defined, record types are assumed to
|
|
79 be structures. */
|
|
80 enum classify_record (*classify_record) (tree);
|
|
81
|
|
82 /* Given MODE and UNSIGNEDP, return a suitable type-tree with that
|
|
83 mode. */
|
|
84 tree (*type_for_mode) (enum machine_mode, int);
|
|
85
|
|
86 /* Given PRECISION and UNSIGNEDP, return a suitable type-tree for an
|
|
87 integer type with at least that precision. */
|
|
88 tree (*type_for_size) (unsigned, int);
|
|
89
|
|
90 /* True if the type is an instantiation of a generic type,
|
|
91 e.g. C++ template implicit specializations. */
|
|
92 bool (*generic_p) (const_tree);
|
|
93
|
|
94 /* Given a type, apply default promotions to unnamed function
|
|
95 arguments and return the new type. Return the same type if no
|
|
96 change. Required by any language that supports variadic
|
|
97 arguments. The default hook dies. */
|
|
98 tree (*type_promotes_to) (tree);
|
|
99
|
|
100 /* Register TYPE as a builtin type with the indicated NAME. The
|
|
101 TYPE is placed in the outermost lexical scope. The semantics
|
|
102 should be analogous to:
|
|
103
|
|
104 typedef TYPE NAME;
|
|
105
|
|
106 in C. The default hook ignores the declaration. */
|
|
107 void (*register_builtin_type) (tree, const char *);
|
|
108
|
|
109 /* This routine is called in tree.c to print an error message for
|
|
110 invalid use of an incomplete type. VALUE is the expression that
|
|
111 was used (or 0 if that isn't known) and TYPE is the type that was
|
|
112 invalid. */
|
|
113 void (*incomplete_type_error) (const_tree value, const_tree type);
|
|
114
|
|
115 /* Called from assign_temp to return the maximum size, if there is one,
|
|
116 for a type. */
|
|
117 tree (*max_size) (const_tree);
|
|
118
|
|
119 /* Register language specific type size variables as potentially OpenMP
|
|
120 firstprivate variables. */
|
|
121 void (*omp_firstprivatize_type_sizes) (struct gimplify_omp_ctx *, tree);
|
|
122
|
|
123 /* Return TRUE if TYPE1 and TYPE2 are identical for type hashing purposes.
|
|
124 Called only after doing all language independent checks.
|
|
125 At present, this function is only called when both TYPE1 and TYPE2 are
|
|
126 FUNCTION_TYPEs. */
|
|
127 bool (*type_hash_eq) (const_tree, const_tree);
|
|
128
|
|
129 /* Return TRUE if TYPE uses a hidden descriptor and fills in information
|
|
130 for the debugger about the array bounds, strides, etc. */
|
|
131 bool (*get_array_descr_info) (const_tree, struct array_descr_info *);
|
|
132
|
|
133 /* If we requested a pointer to a vector, build up the pointers that
|
|
134 we stripped off while looking for the inner type. Similarly for
|
|
135 return values from functions. The argument TYPE is the top of the
|
|
136 chain, and BOTTOM is the new type which we will point to. */
|
|
137 tree (*reconstruct_complex_type) (tree, tree);
|
|
138
|
|
139 /* Nonzero if types that are identical are to be hashed so that only
|
|
140 one copy is kept. If a language requires unique types for each
|
|
141 user-specified type, such as Ada, this should be set to TRUE. */
|
|
142 bool hash_types;
|
|
143 };
|
|
144
|
|
145 /* Language hooks related to decls and the symbol table. */
|
|
146
|
|
147 struct lang_hooks_for_decls
|
|
148 {
|
|
149 /* Returns nonzero if we are in the global binding level. Ada
|
|
150 returns -1 for an undocumented reason used in stor-layout.c. */
|
|
151 int (*global_bindings_p) (void);
|
|
152
|
|
153 /* Function to add a decl to the current scope level. Takes one
|
|
154 argument, a decl to add. Returns that decl, or, if the same
|
|
155 symbol is already declared, may return a different decl for that
|
|
156 name. */
|
|
157 tree (*pushdecl) (tree);
|
|
158
|
|
159 /* Returns the chain of decls so far in the current scope level. */
|
|
160 tree (*getdecls) (void);
|
|
161
|
|
162 /* Returns true when we should warn for an unused global DECL.
|
|
163 We will already have checked that it has static binding. */
|
|
164 bool (*warn_unused_global) (const_tree);
|
|
165
|
|
166 /* Obtain a list of globals and do final output on them at end
|
|
167 of compilation */
|
|
168 void (*final_write_globals) (void);
|
|
169
|
|
170 /* True if this decl may be called via a sibcall. */
|
|
171 bool (*ok_for_sibcall) (const_tree);
|
|
172
|
|
173 /* Return the COMDAT group into which this DECL should be placed.
|
|
174 It is known that the DECL belongs in *some* COMDAT group when
|
|
175 this hook is called. The return value will be used immediately,
|
|
176 but not explicitly deallocated, so implementations should not use
|
|
177 xmalloc to allocate the string returned. (Typically, the return
|
|
178 value will be the string already stored in an
|
|
179 IDENTIFIER_NODE.) */
|
|
180 const char * (*comdat_group) (tree);
|
|
181
|
|
182 /* True if OpenMP should privatize what this DECL points to rather
|
|
183 than the DECL itself. */
|
|
184 bool (*omp_privatize_by_reference) (const_tree);
|
|
185
|
|
186 /* Return sharing kind if OpenMP sharing attribute of DECL is
|
|
187 predetermined, OMP_CLAUSE_DEFAULT_UNSPECIFIED otherwise. */
|
|
188 enum omp_clause_default_kind (*omp_predetermined_sharing) (tree);
|
|
189
|
|
190 /* Return true if DECL's DECL_VALUE_EXPR (if any) should be
|
|
191 disregarded in OpenMP construct, because it is going to be
|
|
192 remapped during OpenMP lowering. SHARED is true if DECL
|
|
193 is going to be shared, false if it is going to be privatized. */
|
|
194 bool (*omp_disregard_value_expr) (tree, bool);
|
|
195
|
|
196 /* Return true if DECL that is shared iff SHARED is true should
|
|
197 be put into OMP_CLAUSE_PRIVATE_DEBUG. */
|
|
198 bool (*omp_private_debug_clause) (tree, bool);
|
|
199
|
|
200 /* Return true if DECL in private clause needs
|
|
201 OMP_CLAUSE_PRIVATE_OUTER_REF on the private clause. */
|
|
202 bool (*omp_private_outer_ref) (tree);
|
|
203
|
|
204 /* Build and return code for a default constructor for DECL in
|
|
205 response to CLAUSE. OUTER is corresponding outer region's
|
|
206 variable if needed. Return NULL if nothing to be done. */
|
|
207 tree (*omp_clause_default_ctor) (tree clause, tree decl, tree outer);
|
|
208
|
|
209 /* Build and return code for a copy constructor from SRC to DST. */
|
|
210 tree (*omp_clause_copy_ctor) (tree clause, tree dst, tree src);
|
|
211
|
|
212 /* Similarly, except use an assignment operator instead. */
|
|
213 tree (*omp_clause_assign_op) (tree clause, tree dst, tree src);
|
|
214
|
|
215 /* Build and return code destructing DECL. Return NULL if nothing
|
|
216 to be done. */
|
|
217 tree (*omp_clause_dtor) (tree clause, tree decl);
|
|
218
|
|
219 /* Do language specific checking on an implicitly determined clause. */
|
|
220 void (*omp_finish_clause) (tree clause);
|
|
221 };
|
|
222
|
|
223 /* Language-specific hooks. See langhooks-def.h for defaults. */
|
|
224
|
|
225 struct lang_hooks
|
|
226 {
|
|
227 /* String identifying the front end. e.g. "GNU C++". */
|
|
228 const char *name;
|
|
229
|
|
230 /* sizeof (struct lang_identifier), so make_node () creates
|
|
231 identifier nodes long enough for the language-specific slots. */
|
|
232 size_t identifier_size;
|
|
233
|
|
234 /* Determines the size of any language-specific tcc_constant or
|
|
235 tcc_exceptional nodes. Since it is called from make_node, the
|
|
236 only information available is the tree code. Expected to die
|
|
237 on unrecognized codes. */
|
|
238 size_t (*tree_size) (enum tree_code);
|
|
239
|
|
240 /* The first callback made to the front end, for simple
|
|
241 initialization needed before any calls to handle_option. Return
|
|
242 the language mask to filter the switch array with. */
|
|
243 unsigned int (*init_options) (unsigned int argc, const char **argv);
|
|
244
|
|
245 /* Callback used to perform language-specific initialization for the
|
|
246 global diagnostic context structure. */
|
|
247 void (*initialize_diagnostics) (struct diagnostic_context *);
|
|
248
|
|
249 /* Handle the switch CODE, which has real type enum opt_code from
|
|
250 options.h. If the switch takes an argument, it is passed in ARG
|
|
251 which points to permanent storage. The handler is responsible for
|
|
252 checking whether ARG is NULL, which indicates that no argument
|
|
253 was in fact supplied. For -f and -W switches, VALUE is 1 or 0
|
|
254 for the positive and negative forms respectively.
|
|
255
|
|
256 Return 1 if the switch is valid, 0 if invalid, and -1 if it's
|
|
257 valid and should not be treated as language-independent too. */
|
|
258 int (*handle_option) (size_t code, const char *arg, int value);
|
|
259
|
|
260 /* Return false to use the default complaint about a missing
|
|
261 argument, otherwise output a complaint and return true. */
|
|
262 bool (*missing_argument) (const char *opt, size_t code);
|
|
263
|
|
264 /* Called when all command line options have been parsed to allow
|
|
265 further processing and initialization
|
|
266
|
|
267 Should return true to indicate that a compiler back-end is
|
|
268 not required, such as with the -E option.
|
|
269
|
|
270 If errorcount is nonzero after this call the compiler exits
|
|
271 immediately and the finish hook is not called. */
|
|
272 bool (*post_options) (const char **);
|
|
273
|
|
274 /* Called after post_options to initialize the front end. Return
|
|
275 false to indicate that no further compilation be performed, in
|
|
276 which case the finish hook is called immediately. */
|
|
277 bool (*init) (void);
|
|
278
|
|
279 /* Called at the end of compilation, as a finalizer. */
|
|
280 void (*finish) (void);
|
|
281
|
|
282 /* Parses the entire file. The argument is nonzero to cause bison
|
|
283 parsers to dump debugging information during parsing. */
|
|
284 void (*parse_file) (int);
|
|
285
|
|
286 /* Determines if it's ok for a function to have no noreturn attribute. */
|
|
287 bool (*missing_noreturn_ok_p) (tree);
|
|
288
|
|
289 /* Called to obtain the alias set to be used for an expression or type.
|
|
290 Returns -1 if the language does nothing special for it. */
|
|
291 alias_set_type (*get_alias_set) (tree);
|
|
292
|
|
293 /* Called by expand_expr for language-specific tree codes.
|
|
294 Fourth argument is actually an enum expand_modifier. */
|
|
295 rtx (*expand_expr) (tree, rtx, enum machine_mode, int, rtx *);
|
|
296
|
|
297 /* Function to finish handling an incomplete decl at the end of
|
|
298 compilation. Default hook is does nothing. */
|
|
299 void (*finish_incomplete_decl) (tree);
|
|
300
|
|
301 /* Mark EXP saying that we need to be able to take the address of
|
|
302 it; it should not be allocated in a register. Return true if
|
|
303 successful. */
|
|
304 bool (*mark_addressable) (tree);
|
|
305
|
|
306 /* Hook called by staticp for language-specific tree codes. */
|
|
307 tree (*staticp) (tree);
|
|
308
|
|
309 /* Replace the DECL_LANG_SPECIFIC data, which may be NULL, of the
|
|
310 DECL_NODE with a newly GC-allocated copy. */
|
|
311 void (*dup_lang_specific_decl) (tree);
|
|
312
|
|
313 /* Set the DECL_ASSEMBLER_NAME for a node. If it is the sort of
|
|
314 thing that the assembler should talk about, set
|
|
315 DECL_ASSEMBLER_NAME to an appropriate IDENTIFIER_NODE.
|
|
316 Otherwise, set it to the ERROR_MARK_NODE to ensure that the
|
|
317 assembler does not talk about it. */
|
|
318 void (*set_decl_assembler_name) (tree);
|
|
319
|
|
320 /* The front end can add its own statistics to -fmem-report with
|
|
321 this hook. It should output to stderr. */
|
|
322 void (*print_statistics) (void);
|
|
323
|
|
324 /* Called by print_tree when there is a tree of class tcc_exceptional
|
|
325 that it doesn't know how to display. */
|
|
326 lang_print_tree_hook print_xnode;
|
|
327
|
|
328 /* Called to print language-dependent parts of tcc_decl, tcc_type,
|
|
329 and IDENTIFIER_NODE nodes. */
|
|
330 lang_print_tree_hook print_decl;
|
|
331 lang_print_tree_hook print_type;
|
|
332 lang_print_tree_hook print_identifier;
|
|
333
|
|
334 /* Computes the name to use to print a declaration. DECL is the
|
|
335 non-NULL declaration in question. VERBOSITY determines what
|
|
336 information will be printed: 0: DECL_NAME, demangled as
|
|
337 necessary. 1: and scope information. 2: and any other
|
|
338 information that might be interesting, such as function parameter
|
|
339 types in C++. */
|
|
340 const char *(*decl_printable_name) (tree decl, int verbosity);
|
|
341
|
|
342 /* Computes the dwarf-2/3 name for a tree. VERBOSITY determines what
|
|
343 information will be printed: 0: DECL_NAME, demangled as
|
|
344 necessary. 1: and scope information. */
|
|
345 const char *(*dwarf_name) (tree, int verbosity);
|
|
346
|
|
347 /* This compares two types for equivalence ("compatible" in C-based languages).
|
|
348 This routine should only return 1 if it is sure. It should not be used
|
|
349 in contexts where erroneously returning 0 causes problems. */
|
|
350 int (*types_compatible_p) (tree x, tree y);
|
|
351
|
|
352 /* Called by report_error_function to print out function name. */
|
|
353 void (*print_error_function) (struct diagnostic_context *, const char *,
|
|
354 struct diagnostic_info *);
|
|
355
|
|
356 /* Called from expr_size to calculate the size of the value of an
|
|
357 expression in a language-dependent way. Returns a tree for the size
|
|
358 in bytes. A frontend can call lhd_expr_size to get the default
|
|
359 semantics in cases that it doesn't want to handle specially. */
|
|
360 tree (*expr_size) (const_tree);
|
|
361
|
|
362 /* Convert a character from the host's to the target's character
|
|
363 set. The character should be in what C calls the "basic source
|
|
364 character set" (roughly, the set of characters defined by plain
|
|
365 old ASCII). The default is to return the character unchanged,
|
|
366 which is correct in most circumstances. Note that both argument
|
|
367 and result should be sign-extended under -fsigned-char,
|
|
368 zero-extended under -fno-signed-char. */
|
|
369 HOST_WIDE_INT (*to_target_charset) (HOST_WIDE_INT);
|
|
370
|
|
371 /* Pointers to machine-independent attribute tables, for front ends
|
|
372 using attribs.c. If one is NULL, it is ignored. Respectively, a
|
|
373 table of attributes specific to the language, a table of
|
|
374 attributes common to two or more languages (to allow easy
|
|
375 sharing), and a table of attributes for checking formats. */
|
|
376 const struct attribute_spec *attribute_table;
|
|
377 const struct attribute_spec *common_attribute_table;
|
|
378 const struct attribute_spec *format_attribute_table;
|
|
379
|
|
380 struct lang_hooks_for_tree_inlining tree_inlining;
|
|
381
|
|
382 struct lang_hooks_for_callgraph callgraph;
|
|
383
|
|
384 struct lang_hooks_for_tree_dump tree_dump;
|
|
385
|
|
386 struct lang_hooks_for_decls decls;
|
|
387
|
|
388 struct lang_hooks_for_types types;
|
|
389
|
|
390 /* Perform language-specific gimplification on the argument. Returns an
|
|
391 enum gimplify_status, though we can't see that type here. */
|
|
392 int (*gimplify_expr) (tree *, gimple_seq *, gimple_seq *);
|
|
393
|
|
394 /* Fold an OBJ_TYPE_REF expression to the address of a function.
|
|
395 KNOWN_TYPE carries the true type of the OBJ_TYPE_REF_OBJECT. */
|
|
396 tree (*fold_obj_type_ref) (tree, tree);
|
|
397
|
|
398 /* Do language specific processing in the builtin function DECL */
|
|
399 tree (*builtin_function) (tree decl);
|
|
400
|
|
401 /* Like builtin_function, but make sure the scope is the external scope.
|
|
402 This is used to delay putting in back end builtin functions until the ISA
|
|
403 that defines the builtin is declared via function specific target options,
|
|
404 which can save memory for machines like the x86_64 that have multiple
|
|
405 ISAs. If this points to the same function as builtin_function, the
|
|
406 backend must add all of the builtins at program initialization time. */
|
|
407 tree (*builtin_function_ext_scope) (tree decl);
|
|
408
|
|
409 /* Used to set up the tree_contains_structure array for a frontend. */
|
|
410 void (*init_ts) (void);
|
|
411
|
|
412 /* Called by recompute_tree_invariant_for_addr_expr to go from EXPR
|
|
413 to a contained expression or DECL, possibly updating *TC or *SE
|
|
414 if in the process TREE_CONSTANT or TREE_SIDE_EFFECTS need updating. */
|
|
415 tree (*expr_to_decl) (tree expr, bool *tc, bool *se);
|
|
416
|
|
417 /* Whenever you add entries here, make sure you adjust langhooks-def.h
|
|
418 and langhooks.c accordingly. */
|
|
419 };
|
|
420
|
|
421 /* Each front end provides its own. */
|
|
422 extern const struct lang_hooks lang_hooks;
|
|
423 extern tree add_builtin_function (const char *name, tree type,
|
|
424 int function_code, enum built_in_class cl,
|
|
425 const char *library_name,
|
|
426 tree attrs);
|
|
427
|
|
428 extern tree add_builtin_function_ext_scope (const char *name, tree type,
|
|
429 int function_code,
|
|
430 enum built_in_class cl,
|
|
431 const char *library_name,
|
|
432 tree attrs);
|
|
433
|
|
434 #endif /* GCC_LANG_HOOKS_H */
|