|
0
|
1 /* Default language-specific hooks.
|
|
|
2 Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
|
|
|
3 Free Software Foundation, Inc.
|
|
|
4 Contributed by Alexandre Oliva <aoliva@redhat.com>
|
|
|
5
|
|
|
6 This file is part of GCC.
|
|
|
7
|
|
|
8 GCC is free software; you can redistribute it and/or modify
|
|
|
9 it under the terms of the GNU General Public License as published by
|
|
|
10 the Free Software Foundation; either version 3, or (at your option)
|
|
|
11 any later version.
|
|
|
12
|
|
|
13 GCC is distributed in the hope that it will be useful,
|
|
|
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
16 GNU General Public License for more details.
|
|
|
17
|
|
|
18 You should have received a copy of the GNU General Public License
|
|
|
19 along with GCC; see the file COPYING3. If not see
|
|
|
20 <http://www.gnu.org/licenses/>. */
|
|
|
21
|
|
|
22 #include "config.h"
|
|
|
23 #include "system.h"
|
|
|
24 #include "coretypes.h"
|
|
|
25 #include "intl.h"
|
|
|
26 #include "tm.h"
|
|
|
27 #include "toplev.h"
|
|
|
28 #include "tree.h"
|
|
|
29 #include "tree-inline.h"
|
|
|
30 #include "gimple.h"
|
|
|
31 #include "rtl.h"
|
|
|
32 #include "insn-config.h"
|
|
|
33 #include "integrate.h"
|
|
|
34 #include "flags.h"
|
|
|
35 #include "langhooks.h"
|
|
|
36 #include "target.h"
|
|
|
37 #include "langhooks-def.h"
|
|
|
38 #include "ggc.h"
|
|
|
39 #include "diagnostic.h"
|
|
|
40
|
|
|
41 /* Do nothing; in many cases the default hook. */
|
|
|
42
|
|
|
43 void
|
|
|
44 lhd_do_nothing (void)
|
|
|
45 {
|
|
|
46 }
|
|
|
47
|
|
|
48 /* Do nothing (tree). */
|
|
|
49
|
|
|
50 void
|
|
|
51 lhd_do_nothing_t (tree ARG_UNUSED (t))
|
|
|
52 {
|
|
|
53 }
|
|
|
54
|
|
|
55 /* Do nothing (int). */
|
|
|
56
|
|
|
57 void
|
|
|
58 lhd_do_nothing_i (int ARG_UNUSED (i))
|
|
|
59 {
|
|
|
60 }
|
|
|
61
|
|
|
62 /* Do nothing (int, int, int). Return NULL_TREE. */
|
|
|
63
|
|
|
64 tree
|
|
|
65 lhd_do_nothing_iii_return_null_tree (int ARG_UNUSED (i),
|
|
|
66 int ARG_UNUSED (j),
|
|
|
67 int ARG_UNUSED (k))
|
|
|
68 {
|
|
|
69 return NULL_TREE;
|
|
|
70 }
|
|
|
71
|
|
|
72 /* Do nothing (function). */
|
|
|
73
|
|
|
74 void
|
|
|
75 lhd_do_nothing_f (struct function * ARG_UNUSED (f))
|
|
|
76 {
|
|
|
77 }
|
|
|
78
|
|
|
79 /* Do nothing (return NULL_TREE). */
|
|
|
80
|
|
|
81 tree
|
|
|
82 lhd_return_null_tree_v (void)
|
|
|
83 {
|
|
|
84 return NULL_TREE;
|
|
|
85 }
|
|
|
86
|
|
|
87 /* Do nothing (return NULL_TREE). */
|
|
|
88
|
|
|
89 tree
|
|
|
90 lhd_return_null_tree (tree ARG_UNUSED (t))
|
|
|
91 {
|
|
|
92 return NULL_TREE;
|
|
|
93 }
|
|
|
94
|
|
|
95 /* Do nothing (return NULL_TREE). */
|
|
|
96
|
|
|
97 tree
|
|
|
98 lhd_return_null_const_tree (const_tree ARG_UNUSED (t))
|
|
|
99 {
|
|
|
100 return NULL_TREE;
|
|
|
101 }
|
|
|
102
|
|
|
103 /* The default post options hook. */
|
|
|
104
|
|
|
105 bool
|
|
|
106 lhd_post_options (const char ** ARG_UNUSED (pfilename))
|
|
|
107 {
|
|
|
108 return false;
|
|
|
109 }
|
|
|
110
|
|
|
111 /* Called from by print-tree.c. */
|
|
|
112
|
|
|
113 void
|
|
|
114 lhd_print_tree_nothing (FILE * ARG_UNUSED (file),
|
|
|
115 tree ARG_UNUSED (node),
|
|
|
116 int ARG_UNUSED (indent))
|
|
|
117 {
|
|
|
118 }
|
|
|
119
|
|
|
120 /* Called from staticp. */
|
|
|
121
|
|
|
122 tree
|
|
|
123 lhd_staticp (tree ARG_UNUSED (exp))
|
|
|
124 {
|
|
|
125 return NULL;
|
|
|
126 }
|
|
|
127
|
|
|
128 /* Called from check_global_declarations. */
|
|
|
129
|
|
|
130 bool
|
|
|
131 lhd_warn_unused_global_decl (const_tree decl)
|
|
|
132 {
|
|
|
133 /* This is what used to exist in check_global_declarations. Probably
|
|
|
134 not many of these actually apply to non-C languages. */
|
|
|
135
|
|
|
136 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl))
|
|
|
137 return false;
|
|
|
138 if (TREE_CODE (decl) == VAR_DECL && TREE_READONLY (decl))
|
|
|
139 return false;
|
|
|
140 if (DECL_IN_SYSTEM_HEADER (decl))
|
|
|
141 return false;
|
|
|
142
|
|
|
143 return true;
|
|
|
144 }
|
|
|
145
|
|
|
146 /* Set the DECL_ASSEMBLER_NAME for DECL. */
|
|
|
147 void
|
|
|
148 lhd_set_decl_assembler_name (tree decl)
|
|
|
149 {
|
|
|
150 tree id;
|
|
|
151
|
|
|
152 /* The language-independent code should never use the
|
|
|
153 DECL_ASSEMBLER_NAME for lots of DECLs. Only FUNCTION_DECLs and
|
|
|
154 VAR_DECLs for variables with static storage duration need a real
|
|
|
155 DECL_ASSEMBLER_NAME. */
|
|
|
156 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
|
|
|
157 || (TREE_CODE (decl) == VAR_DECL
|
|
|
158 && (TREE_STATIC (decl)
|
|
|
159 || DECL_EXTERNAL (decl)
|
|
|
160 || TREE_PUBLIC (decl))));
|
|
|
161
|
|
|
162 /* By default, assume the name to use in assembly code is the same
|
|
|
163 as that used in the source language. (That's correct for C, and
|
|
|
164 GCC used to set DECL_ASSEMBLER_NAME to the same value as
|
|
|
165 DECL_NAME in build_decl, so this choice provides backwards
|
|
|
166 compatibility with existing front-ends. This assumption is wrapped
|
|
|
167 in a target hook, to allow for target-specific modification of the
|
|
|
168 identifier.
|
|
|
169
|
|
|
170 Can't use just the variable's own name for a variable whose scope
|
|
|
171 is less than the whole compilation. Concatenate a distinguishing
|
|
|
172 number - we use the DECL_UID. */
|
|
|
173
|
|
|
174 if (TREE_PUBLIC (decl) || DECL_CONTEXT (decl) == NULL_TREE)
|
|
|
175 id = targetm.mangle_decl_assembler_name (decl, DECL_NAME (decl));
|
|
|
176 else
|
|
|
177 {
|
|
|
178 const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
|
|
|
179 char *label;
|
|
|
180
|
|
|
181 ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
|
|
|
182 id = get_identifier (label);
|
|
|
183 }
|
|
|
184 SET_DECL_ASSEMBLER_NAME (decl, id);
|
|
|
185
|
|
|
186 }
|
|
|
187
|
|
|
188 /* Type promotion for variable arguments. */
|
|
|
189 tree
|
|
|
190 lhd_type_promotes_to (tree ARG_UNUSED (type))
|
|
|
191 {
|
|
|
192 gcc_unreachable ();
|
|
|
193 }
|
|
|
194
|
|
|
195 /* Registration of machine- or os-specific builtin types. */
|
|
|
196 void
|
|
|
197 lhd_register_builtin_type (tree ARG_UNUSED (type),
|
|
|
198 const char * ARG_UNUSED (name))
|
|
|
199 {
|
|
|
200 }
|
|
|
201
|
|
|
202 /* Invalid use of an incomplete type. */
|
|
|
203 void
|
|
|
204 lhd_incomplete_type_error (const_tree ARG_UNUSED (value), const_tree type)
|
|
|
205 {
|
|
|
206 gcc_assert (TREE_CODE (type) == ERROR_MARK);
|
|
|
207 return;
|
|
|
208 }
|
|
|
209
|
|
|
210 /* Provide a default routine for alias sets that always returns -1. This
|
|
|
211 is used by languages that don't need to do anything special. */
|
|
|
212
|
|
|
213 alias_set_type
|
|
|
214 lhd_get_alias_set (tree ARG_UNUSED (t))
|
|
|
215 {
|
|
|
216 return -1;
|
|
|
217 }
|
|
|
218
|
|
|
219 /* This is the default expand_expr function. */
|
|
|
220
|
|
|
221 rtx
|
|
|
222 lhd_expand_expr (tree ARG_UNUSED (t), rtx ARG_UNUSED (r),
|
|
|
223 enum machine_mode ARG_UNUSED (mm),
|
|
|
224 int ARG_UNUSED (em),
|
|
|
225 rtx * ARG_UNUSED (a))
|
|
|
226 {
|
|
|
227 gcc_unreachable ();
|
|
|
228 }
|
|
|
229
|
|
|
230 /* This is the default decl_printable_name function. */
|
|
|
231
|
|
|
232 const char *
|
|
|
233 lhd_decl_printable_name (tree decl, int ARG_UNUSED (verbosity))
|
|
|
234 {
|
|
|
235 gcc_assert (decl && DECL_NAME (decl));
|
|
|
236 return IDENTIFIER_POINTER (DECL_NAME (decl));
|
|
|
237 }
|
|
|
238
|
|
|
239 /* This is the default dwarf_name function. */
|
|
|
240
|
|
|
241 const char *
|
|
|
242 lhd_dwarf_name (tree t, int verbosity)
|
|
|
243 {
|
|
|
244 gcc_assert (DECL_P (t));
|
|
|
245
|
|
|
246 return lang_hooks.decl_printable_name (t, verbosity);
|
|
|
247 }
|
|
|
248
|
|
|
249 /* This compares two types for equivalence ("compatible" in C-based languages).
|
|
|
250 This routine should only return 1 if it is sure. It should not be used
|
|
|
251 in contexts where erroneously returning 0 causes problems. */
|
|
|
252
|
|
|
253 int
|
|
|
254 lhd_types_compatible_p (tree x, tree y)
|
|
|
255 {
|
|
|
256 return TYPE_MAIN_VARIANT (x) == TYPE_MAIN_VARIANT (y);
|
|
|
257 }
|
|
|
258
|
|
|
259 /* lang_hooks.tree_dump.dump_tree: Dump language-specific parts of tree
|
|
|
260 nodes. Returns nonzero if it does not want the usual dumping of the
|
|
|
261 second argument. */
|
|
|
262
|
|
|
263 bool
|
|
|
264 lhd_tree_dump_dump_tree (void *di ATTRIBUTE_UNUSED, tree t ATTRIBUTE_UNUSED)
|
|
|
265 {
|
|
|
266 return false;
|
|
|
267 }
|
|
|
268
|
|
|
269 /* lang_hooks.tree_dump.type_qual: Determine type qualifiers in a
|
|
|
270 language-specific way. */
|
|
|
271
|
|
|
272 int
|
|
|
273 lhd_tree_dump_type_quals (const_tree t)
|
|
|
274 {
|
|
|
275 return TYPE_QUALS (t);
|
|
|
276 }
|
|
|
277
|
|
|
278 /* lang_hooks.expr_size: Determine the size of the value of an expression T
|
|
|
279 in a language-specific way. Returns a tree for the size in bytes. */
|
|
|
280
|
|
|
281 tree
|
|
|
282 lhd_expr_size (const_tree exp)
|
|
|
283 {
|
|
|
284 if (DECL_P (exp)
|
|
|
285 && DECL_SIZE_UNIT (exp) != 0)
|
|
|
286 return DECL_SIZE_UNIT (exp);
|
|
|
287 else
|
|
|
288 return size_in_bytes (TREE_TYPE (exp));
|
|
|
289 }
|
|
|
290
|
|
|
291 /* lang_hooks.gimplify_expr re-writes *EXPR_P into GIMPLE form. */
|
|
|
292
|
|
|
293 int
|
|
|
294 lhd_gimplify_expr (tree *expr_p ATTRIBUTE_UNUSED,
|
|
|
295 gimple_seq *pre_p ATTRIBUTE_UNUSED,
|
|
|
296 gimple_seq *post_p ATTRIBUTE_UNUSED)
|
|
|
297 {
|
|
|
298 return GS_UNHANDLED;
|
|
|
299 }
|
|
|
300
|
|
|
301 /* lang_hooks.tree_size: Determine the size of a tree with code C,
|
|
|
302 which is a language-specific tree code in category tcc_constant or
|
|
|
303 tcc_exceptional. The default expects never to be called. */
|
|
|
304 size_t
|
|
|
305 lhd_tree_size (enum tree_code c ATTRIBUTE_UNUSED)
|
|
|
306 {
|
|
|
307 gcc_unreachable ();
|
|
|
308 }
|
|
|
309
|
|
|
310 /* Return true if decl, which is a function decl, may be called by a
|
|
|
311 sibcall. */
|
|
|
312
|
|
|
313 bool
|
|
|
314 lhd_decl_ok_for_sibcall (const_tree decl ATTRIBUTE_UNUSED)
|
|
|
315 {
|
|
|
316 return true;
|
|
|
317 }
|
|
|
318
|
|
|
319 /* Return the COMDAT group into which DECL should be placed. */
|
|
|
320
|
|
|
321 const char *
|
|
|
322 lhd_comdat_group (tree decl)
|
|
|
323 {
|
|
|
324 return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
|
|
|
325 }
|
|
|
326
|
|
|
327 /* lang_hooks.decls.final_write_globals: perform final processing on
|
|
|
328 global variables. */
|
|
|
329 void
|
|
|
330 write_global_declarations (void)
|
|
|
331 {
|
|
|
332 /* Really define vars that have had only a tentative definition.
|
|
|
333 Really output inline functions that must actually be callable
|
|
|
334 and have not been output so far. */
|
|
|
335
|
|
|
336 tree globals = lang_hooks.decls.getdecls ();
|
|
|
337 int len = list_length (globals);
|
|
|
338 tree *vec = XNEWVEC (tree, len);
|
|
|
339 int i;
|
|
|
340 tree decl;
|
|
|
341
|
|
|
342 /* Process the decls in reverse order--earliest first.
|
|
|
343 Put them into VEC from back to front, then take out from front. */
|
|
|
344
|
|
|
345 for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
|
|
|
346 vec[len - i - 1] = decl;
|
|
|
347
|
|
|
348 wrapup_global_declarations (vec, len);
|
|
|
349 check_global_declarations (vec, len);
|
|
|
350 emit_debug_global_declarations (vec, len);
|
|
|
351
|
|
|
352 /* Clean up. */
|
|
|
353 free (vec);
|
|
|
354 }
|
|
|
355
|
|
|
356 /* Called to perform language-specific initialization of CTX. */
|
|
|
357 void
|
|
|
358 lhd_initialize_diagnostics (struct diagnostic_context *ctx ATTRIBUTE_UNUSED)
|
|
|
359 {
|
|
|
360 }
|
|
|
361
|
|
|
362 /* The default function to print out name of current function that caused
|
|
|
363 an error. */
|
|
|
364 void
|
|
|
365 lhd_print_error_function (diagnostic_context *context, const char *file,
|
|
|
366 diagnostic_info *diagnostic)
|
|
|
367 {
|
|
|
368 if (diagnostic_last_function_changed (context, diagnostic))
|
|
|
369 {
|
|
|
370 const char *old_prefix = context->printer->prefix;
|
|
|
371 tree abstract_origin = diagnostic->abstract_origin;
|
|
|
372 char *new_prefix = (file && abstract_origin == NULL)
|
|
|
373 ? file_name_as_prefix (file) : NULL;
|
|
|
374
|
|
|
375 pp_set_prefix (context->printer, new_prefix);
|
|
|
376
|
|
|
377 if (current_function_decl == NULL)
|
|
|
378 pp_printf (context->printer, _("At top level:"));
|
|
|
379 else
|
|
|
380 {
|
|
|
381 tree fndecl, ao;
|
|
|
382
|
|
|
383 if (abstract_origin)
|
|
|
384 {
|
|
|
385 ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin);
|
|
|
386 while (TREE_CODE (ao) == BLOCK
|
|
|
387 && BLOCK_ABSTRACT_ORIGIN (ao)
|
|
|
388 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
|
|
|
389 ao = BLOCK_ABSTRACT_ORIGIN (ao);
|
|
|
390 gcc_assert (TREE_CODE (ao) == FUNCTION_DECL);
|
|
|
391 fndecl = ao;
|
|
|
392 }
|
|
|
393 else
|
|
|
394 fndecl = current_function_decl;
|
|
|
395
|
|
|
396 if (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE)
|
|
|
397 pp_printf
|
|
|
398 (context->printer, _("In member function %qs"),
|
|
|
399 lang_hooks.decl_printable_name (fndecl, 2));
|
|
|
400 else
|
|
|
401 pp_printf
|
|
|
402 (context->printer, _("In function %qs"),
|
|
|
403 lang_hooks.decl_printable_name (fndecl, 2));
|
|
|
404
|
|
|
405 while (abstract_origin)
|
|
|
406 {
|
|
|
407 location_t *locus;
|
|
|
408 tree block = abstract_origin;
|
|
|
409
|
|
|
410 locus = &BLOCK_SOURCE_LOCATION (block);
|
|
|
411 fndecl = NULL;
|
|
|
412 block = BLOCK_SUPERCONTEXT (block);
|
|
|
413 while (block && TREE_CODE (block) == BLOCK
|
|
|
414 && BLOCK_ABSTRACT_ORIGIN (block))
|
|
|
415 {
|
|
|
416 ao = BLOCK_ABSTRACT_ORIGIN (block);
|
|
|
417
|
|
|
418 while (TREE_CODE (ao) == BLOCK
|
|
|
419 && BLOCK_ABSTRACT_ORIGIN (ao)
|
|
|
420 && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
|
|
|
421 ao = BLOCK_ABSTRACT_ORIGIN (ao);
|
|
|
422
|
|
|
423 if (TREE_CODE (ao) == FUNCTION_DECL)
|
|
|
424 {
|
|
|
425 fndecl = ao;
|
|
|
426 break;
|
|
|
427 }
|
|
|
428 else if (TREE_CODE (ao) != BLOCK)
|
|
|
429 break;
|
|
|
430
|
|
|
431 block = BLOCK_SUPERCONTEXT (block);
|
|
|
432 }
|
|
|
433 if (fndecl)
|
|
|
434 abstract_origin = block;
|
|
|
435 else
|
|
|
436 {
|
|
|
437 while (block && TREE_CODE (block) == BLOCK)
|
|
|
438 block = BLOCK_SUPERCONTEXT (block);
|
|
|
439
|
|
|
440 if (block && TREE_CODE (block) == FUNCTION_DECL)
|
|
|
441 fndecl = block;
|
|
|
442 abstract_origin = NULL;
|
|
|
443 }
|
|
|
444 if (fndecl)
|
|
|
445 {
|
|
|
446 expanded_location s = expand_location (*locus);
|
|
|
447 pp_character (context->printer, ',');
|
|
|
448 pp_newline (context->printer);
|
|
|
449 if (s.file != NULL)
|
|
|
450 {
|
|
|
451 if (flag_show_column && s.column != 0)
|
|
|
452 pp_printf (context->printer,
|
|
|
453 _(" inlined from %qs at %s:%d:%d"),
|
|
|
454 lang_hooks.decl_printable_name (fndecl, 2),
|
|
|
455 s.file, s.line, s.column);
|
|
|
456 else
|
|
|
457 pp_printf (context->printer,
|
|
|
458 _(" inlined from %qs at %s:%d"),
|
|
|
459 lang_hooks.decl_printable_name (fndecl, 2),
|
|
|
460 s.file, s.line);
|
|
|
461
|
|
|
462 }
|
|
|
463 else
|
|
|
464 pp_printf (context->printer, _(" inlined from %qs"),
|
|
|
465 lang_hooks.decl_printable_name (fndecl, 2));
|
|
|
466 }
|
|
|
467 }
|
|
|
468 pp_character (context->printer, ':');
|
|
|
469 }
|
|
|
470
|
|
|
471 diagnostic_set_last_function (context, diagnostic);
|
|
|
472 pp_flush (context->printer);
|
|
|
473 context->printer->prefix = old_prefix;
|
|
|
474 free ((char*) new_prefix);
|
|
|
475 }
|
|
|
476 }
|
|
|
477
|
|
|
478 tree
|
|
|
479 lhd_callgraph_analyze_expr (tree *tp ATTRIBUTE_UNUSED,
|
|
|
480 int *walk_subtrees ATTRIBUTE_UNUSED)
|
|
|
481 {
|
|
|
482 return NULL;
|
|
|
483 }
|
|
|
484
|
|
|
485 tree
|
|
|
486 lhd_make_node (enum tree_code code)
|
|
|
487 {
|
|
|
488 return make_node (code);
|
|
|
489 }
|
|
|
490
|
|
|
491 HOST_WIDE_INT
|
|
|
492 lhd_to_target_charset (HOST_WIDE_INT c)
|
|
|
493 {
|
|
|
494 return c;
|
|
|
495 }
|
|
|
496
|
|
|
497 tree
|
|
|
498 lhd_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED, bool *se ATTRIBUTE_UNUSED)
|
|
|
499 {
|
|
|
500 return expr;
|
|
|
501 }
|
|
|
502
|
|
|
503 /* Return sharing kind if OpenMP sharing attribute of DECL is
|
|
|
504 predetermined, OMP_CLAUSE_DEFAULT_UNSPECIFIED otherwise. */
|
|
|
505
|
|
|
506 enum omp_clause_default_kind
|
|
|
507 lhd_omp_predetermined_sharing (tree decl ATTRIBUTE_UNUSED)
|
|
|
508 {
|
|
|
509 if (DECL_ARTIFICIAL (decl))
|
|
|
510 return OMP_CLAUSE_DEFAULT_SHARED;
|
|
|
511 return OMP_CLAUSE_DEFAULT_UNSPECIFIED;
|
|
|
512 }
|
|
|
513
|
|
|
514 /* Generate code to copy SRC to DST. */
|
|
|
515
|
|
|
516 tree
|
|
|
517 lhd_omp_assignment (tree clause ATTRIBUTE_UNUSED, tree dst, tree src)
|
|
|
518 {
|
|
|
519 return build2 (MODIFY_EXPR, TREE_TYPE (dst), dst, src);
|
|
|
520 }
|
|
|
521
|
|
|
522 /* Register language specific type size variables as potentially OpenMP
|
|
|
523 firstprivate variables. */
|
|
|
524
|
|
|
525 void
|
|
|
526 lhd_omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *c ATTRIBUTE_UNUSED,
|
|
|
527 tree t ATTRIBUTE_UNUSED)
|
|
|
528 {
|
|
|
529 }
|
|
|
530
|
|
|
531 /* Common function for add_builtin_function and
|
|
|
532 add_builtin_function_ext_scope. */
|
|
|
533 static tree
|
|
|
534 add_builtin_function_common (const char *name,
|
|
|
535 tree type,
|
|
|
536 int function_code,
|
|
|
537 enum built_in_class cl,
|
|
|
538 const char *library_name,
|
|
|
539 tree attrs,
|
|
|
540 tree (*hook) (tree))
|
|
|
541 {
|
|
|
542 tree id = get_identifier (name);
|
|
|
543 tree decl = build_decl (FUNCTION_DECL, id, type);
|
|
|
544
|
|
|
545 TREE_PUBLIC (decl) = 1;
|
|
|
546 DECL_EXTERNAL (decl) = 1;
|
|
|
547 DECL_BUILT_IN_CLASS (decl) = cl;
|
|
|
548
|
|
|
549 DECL_FUNCTION_CODE (decl) = -1;
|
|
|
550 gcc_assert (DECL_FUNCTION_CODE (decl) >= function_code);
|
|
|
551 DECL_FUNCTION_CODE (decl) = function_code;
|
|
|
552
|
|
|
553 if (library_name)
|
|
|
554 {
|
|
|
555 tree libname = get_identifier (library_name);
|
|
|
556 SET_DECL_ASSEMBLER_NAME (decl, libname);
|
|
|
557 }
|
|
|
558
|
|
|
559 /* Possibly apply some default attributes to this built-in function. */
|
|
|
560 if (attrs)
|
|
|
561 decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
|
|
|
562 else
|
|
|
563 decl_attributes (&decl, NULL_TREE, 0);
|
|
|
564
|
|
|
565 return hook (decl);
|
|
|
566
|
|
|
567 }
|
|
|
568
|
|
|
569 /* Create a builtin function. */
|
|
|
570
|
|
|
571 tree
|
|
|
572 add_builtin_function (const char *name,
|
|
|
573 tree type,
|
|
|
574 int function_code,
|
|
|
575 enum built_in_class cl,
|
|
|
576 const char *library_name,
|
|
|
577 tree attrs)
|
|
|
578 {
|
|
|
579 return add_builtin_function_common (name, type, function_code, cl,
|
|
|
580 library_name, attrs,
|
|
|
581 lang_hooks.builtin_function);
|
|
|
582 }
|
|
|
583
|
|
|
584 /* Like add_builtin_function, but make sure the scope is the external scope.
|
|
|
585 This is used to delay putting in back end builtin functions until the ISA
|
|
|
586 that defines the builtin is declared via function specific target options,
|
|
|
587 which can save memory for machines like the x86_64 that have multiple ISAs.
|
|
|
588 If this points to the same function as builtin_function, the backend must
|
|
|
589 add all of the builtins at program initialization time. */
|
|
|
590
|
|
|
591 tree
|
|
|
592 add_builtin_function_ext_scope (const char *name,
|
|
|
593 tree type,
|
|
|
594 int function_code,
|
|
|
595 enum built_in_class cl,
|
|
|
596 const char *library_name,
|
|
|
597 tree attrs)
|
|
|
598 {
|
|
|
599 return add_builtin_function_common (name, type, function_code, cl,
|
|
|
600 library_name, attrs,
|
|
|
601 lang_hooks.builtin_function_ext_scope);
|
|
|
602 }
|
|
|
603
|
|
|
604 tree
|
|
|
605 lhd_builtin_function (tree decl)
|
|
|
606 {
|
|
|
607 lang_hooks.decls.pushdecl (decl);
|
|
|
608 return decl;
|
|
|
609 }
|
