]>
Commit | Line | Data |
---|---|---|
e8602e56 | 1 | /* Default language-specific hooks. |
f1717362 | 2 | Copyright (C) 2001-2016 Free Software Foundation, Inc. |
e8602e56 | 3 | Contributed by Alexandre Oliva <aoliva@redhat.com> |
4 | ||
5a8b6e6a | 5 | This file is part of GCC. |
e8602e56 | 6 | |
5a8b6e6a | 7 | GCC is free software; you can redistribute it and/or modify |
e8602e56 | 8 | it under the terms of the GNU General Public License as published by |
8c4c00c1 | 9 | the Free Software Foundation; either version 3, or (at your option) |
e8602e56 | 10 | any later version. |
11 | ||
5a8b6e6a | 12 | GCC is distributed in the hope that it will be useful, |
e8602e56 | 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 | |
8c4c00c1 | 18 | along with GCC; see the file COPYING3. If not see |
19 | <http://www.gnu.org/licenses/>. */ | |
e8602e56 | 20 | |
21 | #include "config.h" | |
22 | #include "system.h" | |
805e22b2 | 23 | #include "coretypes.h" |
7c29e30e | 24 | #include "target.h" |
7c29e30e | 25 | #include "rtl.h" |
26 | #include "tree.h" | |
27 | #include "timevar.h" | |
28 | #include "stringpool.h" | |
7c29e30e | 29 | #include "diagnostic.h" |
eb586f2c | 30 | #include "intl.h" |
e8602e56 | 31 | #include "toplev.h" |
9ed99284 | 32 | #include "attribs.h" |
a8783bee | 33 | #include "gimplify.h" |
95898760 | 34 | #include "langhooks.h" |
ce084dfc | 35 | #include "tree-diagnostic.h" |
7bfefa9d | 36 | #include "output.h" |
c1183ec8 | 37 | #include "timevar.h" |
95898760 | 38 | |
7cd99a60 | 39 | /* Do nothing; in many cases the default hook. */ |
2a631e19 | 40 | |
7cd99a60 | 41 | void |
3ad4992f | 42 | lhd_do_nothing (void) |
7cd99a60 | 43 | { |
44 | } | |
45 | ||
c80c4f22 | 46 | /* Do nothing (tree). */ |
dbc42b78 | 47 | |
48 | void | |
9a03a746 | 49 | lhd_do_nothing_t (tree ARG_UNUSED (t)) |
dbc42b78 | 50 | { |
51 | } | |
52 | ||
58d82cd0 | 53 | /* Pass through (tree). */ |
54 | tree | |
55 | lhd_pass_through_t (tree t) | |
56 | { | |
57 | return t; | |
58 | } | |
59 | ||
37b9a732 | 60 | /* Do nothing (int, int, int). Return NULL_TREE. */ |
61 | ||
62 | tree | |
b27ac6b5 | 63 | lhd_do_nothing_iii_return_null_tree (int ARG_UNUSED (i), |
9a03a746 | 64 | int ARG_UNUSED (j), |
65 | int ARG_UNUSED (k)) | |
37b9a732 | 66 | { |
67 | return NULL_TREE; | |
68 | } | |
69 | ||
c80c4f22 | 70 | /* Do nothing (function). */ |
71 | ||
72 | void | |
9a03a746 | 73 | lhd_do_nothing_f (struct function * ARG_UNUSED (f)) |
c80c4f22 | 74 | { |
75 | } | |
76 | ||
04745efb | 77 | /* Do nothing (return NULL_TREE). */ |
78 | ||
54bd1509 | 79 | tree |
80 | lhd_return_null_tree_v (void) | |
81 | { | |
82 | return NULL_TREE; | |
83 | } | |
84 | ||
85 | /* Do nothing (return NULL_TREE). */ | |
86 | ||
04745efb | 87 | tree |
9a03a746 | 88 | lhd_return_null_tree (tree ARG_UNUSED (t)) |
04745efb | 89 | { |
90 | return NULL_TREE; | |
91 | } | |
92 | ||
b7bf20db | 93 | /* Do nothing (return NULL_TREE). */ |
94 | ||
95 | tree | |
96 | lhd_return_null_const_tree (const_tree ARG_UNUSED (t)) | |
97 | { | |
98 | return NULL_TREE; | |
99 | } | |
100 | ||
03bde601 | 101 | /* The default post options hook. */ |
102 | ||
103 | bool | |
9a03a746 | 104 | lhd_post_options (const char ** ARG_UNUSED (pfilename)) |
03bde601 | 105 | { |
c6418a4e | 106 | /* Excess precision other than "fast" requires front-end |
107 | support. */ | |
108 | flag_excess_precision_cmdline = EXCESS_PRECISION_FAST; | |
03bde601 | 109 | return false; |
110 | } | |
111 | ||
b7fced5e | 112 | /* Called from by print-tree.c. */ |
113 | ||
114 | void | |
9a03a746 | 115 | lhd_print_tree_nothing (FILE * ARG_UNUSED (file), |
116 | tree ARG_UNUSED (node), | |
117 | int ARG_UNUSED (indent)) | |
b7fced5e | 118 | { |
b3187c7c | 119 | } |
120 | ||
3a1c9df2 | 121 | /* Called from check_global_declaration. */ |
8d58a5a7 | 122 | |
123 | bool | |
f8fd23c0 | 124 | lhd_warn_unused_global_decl (const_tree decl) |
8d58a5a7 | 125 | { |
3a1c9df2 | 126 | /* This is what used to exist in check_global_declaration. Probably |
8d58a5a7 | 127 | not many of these actually apply to non-C languages. */ |
128 | ||
81549c4d | 129 | if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl)) |
8d58a5a7 | 130 | return false; |
131 | if (TREE_CODE (decl) == VAR_DECL && TREE_READONLY (decl)) | |
132 | return false; | |
133 | if (DECL_IN_SYSTEM_HEADER (decl)) | |
134 | return false; | |
135 | ||
136 | return true; | |
137 | } | |
138 | ||
d1f6c8f2 | 139 | /* Set the DECL_ASSEMBLER_NAME for DECL. */ |
140 | void | |
3ad4992f | 141 | lhd_set_decl_assembler_name (tree decl) |
d1f6c8f2 | 142 | { |
97a424bc | 143 | tree id; |
144 | ||
d585ba22 | 145 | /* set_decl_assembler_name may be called on TYPE_DECL to record ODR |
146 | name for C++ types. By default types have no ODR names. */ | |
147 | if (TREE_CODE (decl) == TYPE_DECL) | |
148 | return; | |
149 | ||
d1f6c8f2 | 150 | /* The language-independent code should never use the |
151 | DECL_ASSEMBLER_NAME for lots of DECLs. Only FUNCTION_DECLs and | |
152 | VAR_DECLs for variables with static storage duration need a real | |
2045cdd4 | 153 | DECL_ASSEMBLER_NAME. */ |
a53ff4c1 | 154 | gcc_assert (TREE_CODE (decl) == FUNCTION_DECL |
155 | || (TREE_CODE (decl) == VAR_DECL | |
156 | && (TREE_STATIC (decl) | |
157 | || DECL_EXTERNAL (decl) | |
158 | || TREE_PUBLIC (decl)))); | |
48e1416a | 159 | |
a53ff4c1 | 160 | /* By default, assume the name to use in assembly code is the same |
161 | as that used in the source language. (That's correct for C, and | |
162 | GCC used to set DECL_ASSEMBLER_NAME to the same value as | |
163 | DECL_NAME in build_decl, so this choice provides backwards | |
97a424bc | 164 | compatibility with existing front-ends. This assumption is wrapped |
165 | in a target hook, to allow for target-specific modification of the | |
166 | identifier. | |
48e1416a | 167 | |
a53ff4c1 | 168 | Can't use just the variable's own name for a variable whose scope |
169 | is less than the whole compilation. Concatenate a distinguishing | |
170 | number - we use the DECL_UID. */ | |
97a424bc | 171 | |
262b29f2 | 172 | if (TREE_PUBLIC (decl) || DECL_FILE_SCOPE_P (decl)) |
97a424bc | 173 | id = targetm.mangle_decl_assembler_name (decl, DECL_NAME (decl)); |
a53ff4c1 | 174 | else |
a6df3a0e | 175 | { |
a53ff4c1 | 176 | const char *name = IDENTIFIER_POINTER (DECL_NAME (decl)); |
177 | char *label; | |
48e1416a | 178 | |
a53ff4c1 | 179 | ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl)); |
97a424bc | 180 | id = get_identifier (label); |
a6df3a0e | 181 | } |
97a424bc | 182 | SET_DECL_ASSEMBLER_NAME (decl, id); |
183 | ||
d1f6c8f2 | 184 | } |
185 | ||
63c62881 | 186 | /* Type promotion for variable arguments. */ |
187 | tree | |
9a03a746 | 188 | lhd_type_promotes_to (tree ARG_UNUSED (type)) |
63c62881 | 189 | { |
a53ff4c1 | 190 | gcc_unreachable (); |
63c62881 | 191 | } |
192 | ||
b268e47e | 193 | /* Registration of machine- or os-specific builtin types. */ |
194 | void | |
b27ac6b5 | 195 | lhd_register_builtin_type (tree ARG_UNUSED (type), |
9a03a746 | 196 | const char * ARG_UNUSED (name)) |
b268e47e | 197 | { |
198 | } | |
199 | ||
1dd25100 | 200 | /* Invalid use of an incomplete type. */ |
201 | void | |
f8fd23c0 | 202 | lhd_incomplete_type_error (const_tree ARG_UNUSED (value), const_tree type) |
1dd25100 | 203 | { |
a53ff4c1 | 204 | gcc_assert (TREE_CODE (type) == ERROR_MARK); |
205 | return; | |
1dd25100 | 206 | } |
207 | ||
df2114d0 | 208 | /* Provide a default routine for alias sets that always returns -1. This |
209 | is used by languages that don't need to do anything special. */ | |
210 | ||
32c2fdea | 211 | alias_set_type |
9a03a746 | 212 | lhd_get_alias_set (tree ARG_UNUSED (t)) |
df2114d0 | 213 | { |
214 | return -1; | |
215 | } | |
216 | ||
96554925 | 217 | /* This is the default decl_printable_name function. */ |
218 | ||
219 | const char * | |
9a03a746 | 220 | lhd_decl_printable_name (tree decl, int ARG_UNUSED (verbosity)) |
96554925 | 221 | { |
a1080ab2 | 222 | gcc_assert (decl && DECL_NAME (decl)); |
96554925 | 223 | return IDENTIFIER_POINTER (DECL_NAME (decl)); |
224 | } | |
225 | ||
7d709201 | 226 | /* This is the default dwarf_name function. */ |
227 | ||
228 | const char * | |
229 | lhd_dwarf_name (tree t, int verbosity) | |
230 | { | |
231 | gcc_assert (DECL_P (t)); | |
232 | ||
233 | return lang_hooks.decl_printable_name (t, verbosity); | |
234 | } | |
235 | ||
4ee9c684 | 236 | /* This compares two types for equivalence ("compatible" in C-based languages). |
237 | This routine should only return 1 if it is sure. It should not be used | |
238 | in contexts where erroneously returning 0 causes problems. */ | |
239 | ||
240 | int | |
241 | lhd_types_compatible_p (tree x, tree y) | |
242 | { | |
243 | return TYPE_MAIN_VARIANT (x) == TYPE_MAIN_VARIANT (y); | |
244 | } | |
245 | ||
8851e806 | 246 | /* lang_hooks.tree_dump.dump_tree: Dump language-specific parts of tree |
6ef828f9 | 247 | nodes. Returns nonzero if it does not want the usual dumping of the |
3119c950 | 248 | second argument. */ |
249 | ||
fb84380a | 250 | bool |
3ad4992f | 251 | lhd_tree_dump_dump_tree (void *di ATTRIBUTE_UNUSED, tree t ATTRIBUTE_UNUSED) |
3119c950 | 252 | { |
fb84380a | 253 | return false; |
3119c950 | 254 | } |
255 | ||
8851e806 | 256 | /* lang_hooks.tree_dump.type_qual: Determine type qualifiers in a |
3119c950 | 257 | language-specific way. */ |
258 | ||
259 | int | |
f8fd23c0 | 260 | lhd_tree_dump_type_quals (const_tree t) |
3119c950 | 261 | { |
262 | return TYPE_QUALS (t); | |
263 | } | |
c3f16ae3 | 264 | |
4ee9c684 | 265 | /* lang_hooks.gimplify_expr re-writes *EXPR_P into GIMPLE form. */ |
266 | ||
267 | int | |
75a70cf9 | 268 | lhd_gimplify_expr (tree *expr_p ATTRIBUTE_UNUSED, |
269 | gimple_seq *pre_p ATTRIBUTE_UNUSED, | |
270 | gimple_seq *post_p ATTRIBUTE_UNUSED) | |
a0d8c66d | 271 | { |
4ee9c684 | 272 | return GS_UNHANDLED; |
a0d8c66d | 273 | } |
d3ea5d40 | 274 | |
295e387a | 275 | /* lang_hooks.tree_size: Determine the size of a tree with code C, |
ce45a448 | 276 | which is a language-specific tree code in category tcc_constant or |
277 | tcc_exceptional. The default expects never to be called. */ | |
295e387a | 278 | size_t |
3ad4992f | 279 | lhd_tree_size (enum tree_code c ATTRIBUTE_UNUSED) |
295e387a | 280 | { |
a53ff4c1 | 281 | gcc_unreachable (); |
295e387a | 282 | } |
283 | ||
e2e9c55b | 284 | /* Return true if decl, which is a function decl, may be called by a |
285 | sibcall. */ | |
286 | ||
287 | bool | |
9f627b1a | 288 | lhd_decl_ok_for_sibcall (const_tree decl ATTRIBUTE_UNUSED) |
e2e9c55b | 289 | { |
290 | return true; | |
291 | } | |
292 | ||
3a1c9df2 | 293 | /* Generic global declaration processing. This is meant to be called |
294 | by the front-ends at the end of parsing. C/C++ do their own thing, | |
295 | but other front-ends may call this. */ | |
296 | ||
d3ea5d40 | 297 | void |
3a1c9df2 | 298 | global_decl_processing (void) |
d3ea5d40 | 299 | { |
bfec3452 | 300 | tree globals, decl, *vec; |
301 | int len, i; | |
302 | ||
3a1c9df2 | 303 | timevar_stop (TV_PHASE_PARSING); |
3d1c0354 | 304 | timevar_start (TV_PHASE_DEFERRED); |
d3ea5d40 | 305 | /* Really define vars that have had only a tentative definition. |
306 | Really output inline functions that must actually be callable | |
307 | and have not been output so far. */ | |
308 | ||
bfec3452 | 309 | globals = lang_hooks.decls.getdecls (); |
310 | len = list_length (globals); | |
311 | vec = XNEWVEC (tree, len); | |
d3ea5d40 | 312 | |
313 | /* Process the decls in reverse order--earliest first. | |
314 | Put them into VEC from back to front, then take out from front. */ | |
315 | ||
1767a056 | 316 | for (i = 0, decl = globals; i < len; i++, decl = DECL_CHAIN (decl)) |
d3ea5d40 | 317 | vec[len - i - 1] = decl; |
318 | ||
319 | wrapup_global_declarations (vec, len); | |
3d1c0354 | 320 | timevar_stop (TV_PHASE_DEFERRED); |
321 | ||
3a1c9df2 | 322 | timevar_start (TV_PHASE_PARSING); |
d3ea5d40 | 323 | free (vec); |
324 | } | |
a6df3a0e | 325 | |
f63da8d3 | 326 | /* Called to perform language-specific initialization of CTX. */ |
327 | void | |
24ca3b4e | 328 | lhd_initialize_diagnostics (diagnostic_context *ctx ATTRIBUTE_UNUSED) |
f63da8d3 | 329 | { |
330 | } | |
331 | ||
e88d34f6 | 332 | /* Called to perform language-specific options initialization. */ |
333 | void | |
334 | lhd_init_options (unsigned int decoded_options_count ATTRIBUTE_UNUSED, | |
335 | struct cl_decoded_option *decoded_options ATTRIBUTE_UNUSED) | |
336 | { | |
337 | } | |
338 | ||
339 | /* By default, always complain about options for the wrong language. */ | |
340 | bool | |
341 | lhd_complain_wrong_lang_p (const struct cl_option *option ATTRIBUTE_UNUSED) | |
342 | { | |
343 | return true; | |
344 | } | |
345 | ||
b78351e5 | 346 | /* By default, no language-specific options are valid. */ |
347 | bool | |
348 | lhd_handle_option (size_t code ATTRIBUTE_UNUSED, | |
349 | const char *arg ATTRIBUTE_UNUSED, | |
350 | int value ATTRIBUTE_UNUSED, int kind ATTRIBUTE_UNUSED, | |
3c6c0e40 | 351 | location_t loc ATTRIBUTE_UNUSED, |
b78351e5 | 352 | const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED) |
353 | { | |
354 | return false; | |
355 | } | |
356 | ||
2a576742 | 357 | /* The default function to print out name of current function that caused |
358 | an error. */ | |
359 | void | |
b8c23db3 | 360 | lhd_print_error_function (diagnostic_context *context, const char *file, |
361 | diagnostic_info *diagnostic) | |
2a576742 | 362 | { |
b8c23db3 | 363 | if (diagnostic_last_function_changed (context, diagnostic)) |
2a576742 | 364 | { |
365 | const char *old_prefix = context->printer->prefix; | |
ce084dfc | 366 | tree abstract_origin = diagnostic_abstract_origin (diagnostic); |
b8c23db3 | 367 | char *new_prefix = (file && abstract_origin == NULL) |
2cafe211 | 368 | ? file_name_as_prefix (context, file) : NULL; |
2a576742 | 369 | |
370 | pp_set_prefix (context->printer, new_prefix); | |
371 | ||
372 | if (current_function_decl == NULL) | |
eb586f2c | 373 | pp_printf (context->printer, _("At top level:")); |
2a576742 | 374 | else |
375 | { | |
b8c23db3 | 376 | tree fndecl, ao; |
377 | ||
378 | if (abstract_origin) | |
379 | { | |
380 | ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin); | |
5a6ca2d1 | 381 | while (TREE_CODE (ao) == BLOCK |
382 | && BLOCK_ABSTRACT_ORIGIN (ao) | |
383 | && BLOCK_ABSTRACT_ORIGIN (ao) != ao) | |
b8c23db3 | 384 | ao = BLOCK_ABSTRACT_ORIGIN (ao); |
385 | gcc_assert (TREE_CODE (ao) == FUNCTION_DECL); | |
386 | fndecl = ao; | |
387 | } | |
388 | else | |
389 | fndecl = current_function_decl; | |
390 | ||
391 | if (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE) | |
2a576742 | 392 | pp_printf |
b8c23db3 | 393 | (context->printer, _("In member function %qs"), |
abd3e6b5 | 394 | identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2))); |
2a576742 | 395 | else |
396 | pp_printf | |
b8c23db3 | 397 | (context->printer, _("In function %qs"), |
abd3e6b5 | 398 | identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2))); |
b8c23db3 | 399 | |
400 | while (abstract_origin) | |
401 | { | |
402 | location_t *locus; | |
403 | tree block = abstract_origin; | |
404 | ||
405 | locus = &BLOCK_SOURCE_LOCATION (block); | |
406 | fndecl = NULL; | |
407 | block = BLOCK_SUPERCONTEXT (block); | |
408 | while (block && TREE_CODE (block) == BLOCK | |
409 | && BLOCK_ABSTRACT_ORIGIN (block)) | |
410 | { | |
411 | ao = BLOCK_ABSTRACT_ORIGIN (block); | |
412 | ||
5a6ca2d1 | 413 | while (TREE_CODE (ao) == BLOCK |
414 | && BLOCK_ABSTRACT_ORIGIN (ao) | |
415 | && BLOCK_ABSTRACT_ORIGIN (ao) != ao) | |
b8c23db3 | 416 | ao = BLOCK_ABSTRACT_ORIGIN (ao); |
417 | ||
418 | if (TREE_CODE (ao) == FUNCTION_DECL) | |
419 | { | |
420 | fndecl = ao; | |
421 | break; | |
422 | } | |
423 | else if (TREE_CODE (ao) != BLOCK) | |
424 | break; | |
425 | ||
426 | block = BLOCK_SUPERCONTEXT (block); | |
427 | } | |
428 | if (fndecl) | |
429 | abstract_origin = block; | |
430 | else | |
431 | { | |
432 | while (block && TREE_CODE (block) == BLOCK) | |
433 | block = BLOCK_SUPERCONTEXT (block); | |
434 | ||
aa03bd5e | 435 | if (block && TREE_CODE (block) == FUNCTION_DECL) |
b8c23db3 | 436 | fndecl = block; |
437 | abstract_origin = NULL; | |
438 | } | |
439 | if (fndecl) | |
440 | { | |
441 | expanded_location s = expand_location (*locus); | |
dda4f0ec | 442 | pp_comma (context->printer); |
b8c23db3 | 443 | pp_newline (context->printer); |
444 | if (s.file != NULL) | |
445 | { | |
2c2efebb | 446 | if (context->show_column) |
b8c23db3 | 447 | pp_printf (context->printer, |
41609f8b | 448 | _(" inlined from %qs at %r%s:%d:%d%R"), |
abd3e6b5 | 449 | identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2)), |
41609f8b | 450 | "locus", s.file, s.line, s.column); |
b8c23db3 | 451 | else |
b8c23db3 | 452 | pp_printf (context->printer, |
41609f8b | 453 | _(" inlined from %qs at %r%s:%d%R"), |
abd3e6b5 | 454 | identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2)), |
41609f8b | 455 | "locus", s.file, s.line); |
b8c23db3 | 456 | |
457 | } | |
458 | else | |
459 | pp_printf (context->printer, _(" inlined from %qs"), | |
abd3e6b5 | 460 | identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2))); |
b8c23db3 | 461 | } |
462 | } | |
dda4f0ec | 463 | pp_colon (context->printer); |
2a576742 | 464 | } |
2a576742 | 465 | |
b8c23db3 | 466 | diagnostic_set_last_function (context, diagnostic); |
5f7f600e | 467 | pp_newline_and_flush (context->printer); |
2a576742 | 468 | context->printer->prefix = old_prefix; |
469 | free ((char*) new_prefix); | |
470 | } | |
471 | } | |
472 | ||
674b05f5 | 473 | tree |
474 | lhd_make_node (enum tree_code code) | |
475 | { | |
476 | return make_node (code); | |
477 | } | |
624d37a6 | 478 | |
479 | HOST_WIDE_INT | |
480 | lhd_to_target_charset (HOST_WIDE_INT c) | |
481 | { | |
482 | return c; | |
483 | } | |
54d7165a | 484 | |
485 | tree | |
c7d4e749 | 486 | lhd_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED, bool *se ATTRIBUTE_UNUSED) |
54d7165a | 487 | { |
488 | return expr; | |
489 | } | |
1e8e9920 | 490 | |
491 | /* Return sharing kind if OpenMP sharing attribute of DECL is | |
492 | predetermined, OMP_CLAUSE_DEFAULT_UNSPECIFIED otherwise. */ | |
493 | ||
494 | enum omp_clause_default_kind | |
495 | lhd_omp_predetermined_sharing (tree decl ATTRIBUTE_UNUSED) | |
496 | { | |
497 | if (DECL_ARTIFICIAL (decl)) | |
498 | return OMP_CLAUSE_DEFAULT_SHARED; | |
499 | return OMP_CLAUSE_DEFAULT_UNSPECIFIED; | |
500 | } | |
501 | ||
502 | /* Generate code to copy SRC to DST. */ | |
503 | ||
504 | tree | |
505 | lhd_omp_assignment (tree clause ATTRIBUTE_UNUSED, tree dst, tree src) | |
506 | { | |
75a70cf9 | 507 | return build2 (MODIFY_EXPR, TREE_TYPE (dst), dst, src); |
1e8e9920 | 508 | } |
509 | ||
691447ab | 510 | /* Finalize clause C. */ |
511 | ||
512 | void | |
513 | lhd_omp_finish_clause (tree, gimple_seq *) | |
514 | { | |
515 | } | |
516 | ||
1e8e9920 | 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 | } | |
54be5d7e | 525 | |
9ec099a3 | 526 | /* Return true if TYPE is an OpenMP mappable type. */ |
bc7bff74 | 527 | |
528 | bool | |
529 | lhd_omp_mappable_type (tree type) | |
530 | { | |
9ec099a3 | 531 | /* Mappable type has to be complete. */ |
532 | if (type == error_mark_node || !COMPLETE_TYPE_P (type)) | |
533 | return false; | |
534 | return true; | |
bc7bff74 | 535 | } |
536 | ||
24470055 | 537 | /* Common function for add_builtin_function and |
538 | add_builtin_function_ext_scope. */ | |
539 | static tree | |
540 | add_builtin_function_common (const char *name, | |
541 | tree type, | |
542 | int function_code, | |
543 | enum built_in_class cl, | |
544 | const char *library_name, | |
545 | tree attrs, | |
546 | tree (*hook) (tree)) | |
54be5d7e | 547 | { |
548 | tree id = get_identifier (name); | |
e60a6f7b | 549 | tree decl = build_decl (BUILTINS_LOCATION, FUNCTION_DECL, id, type); |
54be5d7e | 550 | |
551 | TREE_PUBLIC (decl) = 1; | |
552 | DECL_EXTERNAL (decl) = 1; | |
553 | DECL_BUILT_IN_CLASS (decl) = cl; | |
ebb7d626 | 554 | |
8458f4ca | 555 | DECL_FUNCTION_CODE (decl) = (enum built_in_function) function_code; |
556 | ||
557 | /* DECL_FUNCTION_CODE is a bitfield; verify that the value fits. */ | |
558 | gcc_assert (DECL_FUNCTION_CODE (decl) == function_code); | |
54be5d7e | 559 | |
7d4c98bc | 560 | if (library_name) |
561 | { | |
562 | tree libname = get_identifier (library_name); | |
563 | SET_DECL_ASSEMBLER_NAME (decl, libname); | |
564 | } | |
54be5d7e | 565 | |
566 | /* Possibly apply some default attributes to this built-in function. */ | |
567 | if (attrs) | |
568 | decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN); | |
569 | else | |
570 | decl_attributes (&decl, NULL_TREE, 0); | |
571 | ||
24470055 | 572 | return hook (decl); |
573 | ||
574 | } | |
575 | ||
576 | /* Create a builtin function. */ | |
577 | ||
578 | tree | |
579 | add_builtin_function (const char *name, | |
580 | tree type, | |
581 | int function_code, | |
582 | enum built_in_class cl, | |
583 | const char *library_name, | |
584 | tree attrs) | |
585 | { | |
586 | return add_builtin_function_common (name, type, function_code, cl, | |
587 | library_name, attrs, | |
588 | lang_hooks.builtin_function); | |
589 | } | |
54be5d7e | 590 | |
24470055 | 591 | /* Like add_builtin_function, but make sure the scope is the external scope. |
592 | This is used to delay putting in back end builtin functions until the ISA | |
593 | that defines the builtin is declared via function specific target options, | |
594 | which can save memory for machines like the x86_64 that have multiple ISAs. | |
595 | If this points to the same function as builtin_function, the backend must | |
596 | add all of the builtins at program initialization time. */ | |
597 | ||
598 | tree | |
599 | add_builtin_function_ext_scope (const char *name, | |
600 | tree type, | |
601 | int function_code, | |
602 | enum built_in_class cl, | |
603 | const char *library_name, | |
604 | tree attrs) | |
605 | { | |
606 | return add_builtin_function_common (name, type, function_code, cl, | |
607 | library_name, attrs, | |
608 | lang_hooks.builtin_function_ext_scope); | |
54be5d7e | 609 | } |
610 | ||
611 | tree | |
612 | lhd_builtin_function (tree decl) | |
613 | { | |
614 | lang_hooks.decls.pushdecl (decl); | |
615 | return decl; | |
616 | } | |
7bfefa9d | 617 | |
549aab72 | 618 | /* Create a builtin type. */ |
619 | ||
620 | tree | |
621 | add_builtin_type (const char *name, tree type) | |
622 | { | |
623 | tree id = get_identifier (name); | |
624 | tree decl = build_decl (BUILTINS_LOCATION, TYPE_DECL, id, type); | |
625 | return lang_hooks.decls.pushdecl (decl); | |
626 | } | |
627 | ||
7bfefa9d | 628 | /* LTO hooks. */ |
629 | ||
630 | /* Used to save and restore any previously active section. */ | |
631 | static section *saved_section; | |
632 | ||
633 | ||
634 | /* Begin a new LTO output section named NAME. This default implementation | |
635 | saves the old section and emits assembly code to switch to the new | |
636 | section. */ | |
637 | ||
638 | void | |
639 | lhd_begin_section (const char *name) | |
640 | { | |
641 | section *section; | |
642 | ||
643 | /* Save the old section so we can restore it in lto_end_asm_section. */ | |
644 | gcc_assert (!saved_section); | |
645 | saved_section = in_section; | |
4e38f8ec | 646 | if (!saved_section) |
647 | saved_section = text_section; | |
7bfefa9d | 648 | |
649 | /* Create a new section and switch to it. */ | |
1479afa4 | 650 | section = get_section (name, SECTION_DEBUG | SECTION_EXCLUDE, NULL); |
7bfefa9d | 651 | switch_to_section (section); |
652 | } | |
653 | ||
654 | ||
655 | /* Write DATA of length LEN to the current LTO output section. This default | |
2d97af95 | 656 | implementation just calls assemble_string. */ |
7bfefa9d | 657 | |
658 | void | |
2d97af95 | 659 | lhd_append_data (const void *data, size_t len, void *) |
7bfefa9d | 660 | { |
661 | if (data) | |
c1183ec8 | 662 | { |
663 | timevar_push (TV_IPA_LTO_OUTPUT); | |
664 | assemble_string ((const char *)data, len); | |
665 | timevar_pop (TV_IPA_LTO_OUTPUT); | |
666 | } | |
7bfefa9d | 667 | } |
668 | ||
669 | ||
670 | /* Finish the current LTO output section. This default implementation emits | |
671 | assembly code to switch to any section previously saved by | |
672 | lhd_begin_section. */ | |
673 | ||
674 | void | |
675 | lhd_end_section (void) | |
676 | { | |
677 | if (saved_section) | |
678 | { | |
679 | switch_to_section (saved_section); | |
680 | saved_section = NULL; | |
681 | } | |
682 | } | |
1b006e46 | 683 | |
684 | /* Default implementation of enum_underlying_base_type using type_for_size. */ | |
685 | ||
686 | tree | |
687 | lhd_enum_underlying_base_type (const_tree enum_type) | |
688 | { | |
689 | return lang_hooks.types.type_for_size (TYPE_PRECISION (enum_type), | |
690 | TYPE_UNSIGNED (enum_type)); | |
691 | } | |
3a4a2292 | 692 | |
693 | /* Returns true if the current lang_hooks represents the GNU C frontend. */ | |
694 | ||
695 | bool | |
696 | lang_GNU_C (void) | |
697 | { | |
698 | return (strncmp (lang_hooks.name, "GNU C", 5) == 0 | |
699 | && (lang_hooks.name[5] == '\0' || ISDIGIT (lang_hooks.name[5]))); | |
700 | } | |
701 | ||
702 | /* Returns true if the current lang_hooks represents the GNU C++ frontend. */ | |
703 | ||
704 | bool | |
705 | lang_GNU_CXX (void) | |
706 | { | |
707 | return strncmp (lang_hooks.name, "GNU C++", 7) == 0; | |
708 | } | |
f36f9b8b | 709 | |
710 | /* Returns true if the current lang_hooks represents the GNU Fortran frontend. */ | |
711 | ||
712 | bool | |
713 | lang_GNU_Fortran (void) | |
714 | { | |
715 | return strncmp (lang_hooks.name, "GNU Fortran", 11) == 0; | |
716 | } |