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