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