]>
Commit | Line | Data |
---|---|---|
69dcadff | 1 | /* Default language-specific hooks. |
8d9254fc | 2 | Copyright (C) 2001-2020 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" |
957060b5 | 24 | #include "target.h" |
957060b5 AM |
25 | #include "rtl.h" |
26 | #include "tree.h" | |
27 | #include "timevar.h" | |
28 | #include "stringpool.h" | |
957060b5 | 29 | #include "diagnostic.h" |
971801ff | 30 | #include "intl.h" |
69dcadff | 31 | #include "toplev.h" |
d8a2d370 | 32 | #include "attribs.h" |
45b0be94 | 33 | #include "gimplify.h" |
59bee412 | 34 | #include "langhooks.h" |
cf835838 | 35 | #include "tree-diagnostic.h" |
d7f09764 | 36 | #include "output.h" |
ed7dc894 | 37 | #include "timevar.h" |
ab341f50 | 38 | #include "stor-layout.h" |
59bee412 | 39 | |
77b1a921 | 40 | /* Do nothing; in many cases the default hook. */ |
8ac61af7 | 41 | |
77b1a921 | 42 | void |
0c20a65f | 43 | lhd_do_nothing (void) |
77b1a921 NB |
44 | { |
45 | } | |
46 | ||
b03e38e1 | 47 | /* Do nothing (tree). */ |
63e1b1c4 NB |
48 | |
49 | void | |
e18476eb | 50 | lhd_do_nothing_t (tree ARG_UNUSED (t)) |
63e1b1c4 NB |
51 | { |
52 | } | |
53 | ||
f9417da1 RG |
54 | /* Pass through (tree). */ |
55 | tree | |
56 | lhd_pass_through_t (tree t) | |
57 | { | |
58 | return t; | |
59 | } | |
60 | ||
a7e8c268 MM |
61 | /* Do nothing (int, int, int). Return NULL_TREE. */ |
62 | ||
63 | tree | |
9f63daea | 64 | lhd_do_nothing_iii_return_null_tree (int ARG_UNUSED (i), |
e18476eb BI |
65 | int ARG_UNUSED (j), |
66 | int ARG_UNUSED (k)) | |
a7e8c268 MM |
67 | { |
68 | return NULL_TREE; | |
69 | } | |
70 | ||
b03e38e1 NB |
71 | /* Do nothing (function). */ |
72 | ||
73 | void | |
e18476eb | 74 | lhd_do_nothing_f (struct function * ARG_UNUSED (f)) |
b03e38e1 NB |
75 | { |
76 | } | |
77 | ||
c88770e9 NB |
78 | /* Do nothing (return NULL_TREE). */ |
79 | ||
80 | tree | |
e18476eb | 81 | lhd_return_null_tree (tree ARG_UNUSED (t)) |
c88770e9 NB |
82 | { |
83 | return NULL_TREE; | |
84 | } | |
85 | ||
fa233e34 KG |
86 | /* Do nothing (return NULL_TREE). */ |
87 | ||
88 | tree | |
89 | lhd_return_null_const_tree (const_tree ARG_UNUSED (t)) | |
90 | { | |
91 | return NULL_TREE; | |
92 | } | |
93 | ||
4bfec483 NB |
94 | /* The default post options hook. */ |
95 | ||
96 | bool | |
e18476eb | 97 | lhd_post_options (const char ** ARG_UNUSED (pfilename)) |
4bfec483 | 98 | { |
8ce94e44 JM |
99 | /* Excess precision other than "fast" requires front-end |
100 | support. */ | |
df375b03 | 101 | flag_excess_precision = EXCESS_PRECISION_FAST; |
4bfec483 NB |
102 | return false; |
103 | } | |
104 | ||
5d69f816 NB |
105 | /* Called from by print-tree.c. */ |
106 | ||
107 | void | |
e18476eb BI |
108 | lhd_print_tree_nothing (FILE * ARG_UNUSED (file), |
109 | tree ARG_UNUSED (node), | |
110 | int ARG_UNUSED (indent)) | |
5d69f816 | 111 | { |
ac79cd5a RK |
112 | } |
113 | ||
d7438551 | 114 | /* Called from check_global_declaration. */ |
ef4f94ac RH |
115 | |
116 | bool | |
ac7d7749 | 117 | lhd_warn_unused_global_decl (const_tree decl) |
ef4f94ac | 118 | { |
d7438551 | 119 | /* This is what used to exist in check_global_declaration. Probably |
ef4f94ac RH |
120 | not many of these actually apply to non-C languages. */ |
121 | ||
54dfd46b | 122 | if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl)) |
ef4f94ac | 123 | return false; |
8813a647 | 124 | if (VAR_P (decl) && TREE_READONLY (decl)) |
ef4f94ac RH |
125 | return false; |
126 | if (DECL_IN_SYSTEM_HEADER (decl)) | |
127 | return false; | |
128 | ||
129 | return true; | |
130 | } | |
131 | ||
599bba86 NB |
132 | /* Set the DECL_ASSEMBLER_NAME for DECL. */ |
133 | void | |
0c20a65f | 134 | lhd_set_decl_assembler_name (tree decl) |
599bba86 | 135 | { |
5234b8f5 DS |
136 | tree id; |
137 | ||
1ee85ee1 JH |
138 | /* set_decl_assembler_name may be called on TYPE_DECL to record ODR |
139 | name for C++ types. By default types have no ODR names. */ | |
140 | if (TREE_CODE (decl) == TYPE_DECL) | |
141 | return; | |
142 | ||
599bba86 NB |
143 | /* The language-independent code should never use the |
144 | DECL_ASSEMBLER_NAME for lots of DECLs. Only FUNCTION_DECLs and | |
145 | VAR_DECLs for variables with static storage duration need a real | |
8127d0e0 | 146 | DECL_ASSEMBLER_NAME. */ |
41806d92 | 147 | gcc_assert (TREE_CODE (decl) == FUNCTION_DECL |
8813a647 | 148 | || (VAR_P (decl) |
41806d92 NS |
149 | && (TREE_STATIC (decl) |
150 | || DECL_EXTERNAL (decl) | |
151 | || TREE_PUBLIC (decl)))); | |
b8698a0f | 152 | |
41806d92 NS |
153 | /* By default, assume the name to use in assembly code is the same |
154 | as that used in the source language. (That's correct for C, and | |
155 | GCC used to set DECL_ASSEMBLER_NAME to the same value as | |
156 | DECL_NAME in build_decl, so this choice provides backwards | |
5234b8f5 DS |
157 | compatibility with existing front-ends. This assumption is wrapped |
158 | in a target hook, to allow for target-specific modification of the | |
159 | identifier. | |
b8698a0f | 160 | |
41806d92 NS |
161 | Can't use just the variable's own name for a variable whose scope |
162 | is less than the whole compilation. Concatenate a distinguishing | |
158cccea | 163 | number. */ |
5234b8f5 | 164 | |
116f30c3 | 165 | if (TREE_PUBLIC (decl) || DECL_FILE_SCOPE_P (decl)) |
5234b8f5 | 166 | id = targetm.mangle_decl_assembler_name (decl, DECL_NAME (decl)); |
41806d92 | 167 | else |
26e0dcb3 | 168 | { |
41806d92 | 169 | const char *name = IDENTIFIER_POINTER (DECL_NAME (decl)); |
158cccea | 170 | static unsigned long num; |
41806d92 | 171 | char *label; |
b8698a0f | 172 | |
158cccea | 173 | ASM_FORMAT_PRIVATE_NAME (label, name, num++); |
5234b8f5 | 174 | id = get_identifier (label); |
26e0dcb3 | 175 | } |
5f3682ff | 176 | |
5234b8f5 | 177 | SET_DECL_ASSEMBLER_NAME (decl, id); |
5f3682ff | 178 | } |
5234b8f5 | 179 | |
5f3682ff NS |
180 | /* Forcibly overwrite the DECL_ASSEMBLER_NAME for DECL to NAME. */ |
181 | void | |
182 | lhd_overwrite_decl_assembler_name (tree decl, tree name) | |
183 | { | |
184 | DECL_ASSEMBLER_NAME_RAW (decl) = name; | |
599bba86 NB |
185 | } |
186 | ||
ab393bf1 NB |
187 | /* Type promotion for variable arguments. */ |
188 | tree | |
e18476eb | 189 | lhd_type_promotes_to (tree ARG_UNUSED (type)) |
ab393bf1 | 190 | { |
41806d92 | 191 | gcc_unreachable (); |
ab393bf1 NB |
192 | } |
193 | ||
9649812a MM |
194 | /* Registration of machine- or os-specific builtin types. */ |
195 | void | |
9f63daea | 196 | lhd_register_builtin_type (tree ARG_UNUSED (type), |
e18476eb | 197 | const char * ARG_UNUSED (name)) |
9649812a MM |
198 | { |
199 | } | |
200 | ||
7a228918 NB |
201 | /* Invalid use of an incomplete type. */ |
202 | void | |
4f2e1536 MP |
203 | lhd_incomplete_type_error (location_t ARG_UNUSED (loc), |
204 | const_tree ARG_UNUSED (value), const_tree type) | |
7a228918 | 205 | { |
41806d92 NS |
206 | gcc_assert (TREE_CODE (type) == ERROR_MARK); |
207 | return; | |
7a228918 NB |
208 | } |
209 | ||
37207ee7 ZW |
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 | ||
4862826d | 213 | alias_set_type |
e18476eb | 214 | lhd_get_alias_set (tree ARG_UNUSED (t)) |
37207ee7 ZW |
215 | { |
216 | return -1; | |
217 | } | |
218 | ||
7afff7cf NB |
219 | /* This is the default decl_printable_name function. */ |
220 | ||
221 | const char * | |
e18476eb | 222 | lhd_decl_printable_name (tree decl, int ARG_UNUSED (verbosity)) |
7afff7cf | 223 | { |
05cf561d | 224 | gcc_assert (decl && DECL_NAME (decl)); |
7afff7cf NB |
225 | return IDENTIFIER_POINTER (DECL_NAME (decl)); |
226 | } | |
227 | ||
721a8ac5 NS |
228 | /* This is the default dwarf_name function. */ |
229 | ||
230 | const char * | |
231 | lhd_dwarf_name (tree t, int verbosity) | |
232 | { | |
233 | gcc_assert (DECL_P (t)); | |
234 | ||
235 | return lang_hooks.decl_printable_name (t, verbosity); | |
236 | } | |
237 | ||
6de9cd9a DN |
238 | /* This compares two types for equivalence ("compatible" in C-based languages). |
239 | This routine should only return 1 if it is sure. It should not be used | |
240 | in contexts where erroneously returning 0 causes problems. */ | |
241 | ||
242 | int | |
243 | lhd_types_compatible_p (tree x, tree y) | |
244 | { | |
245 | return TYPE_MAIN_VARIANT (x) == TYPE_MAIN_VARIANT (y); | |
246 | } | |
247 | ||
e11e816e | 248 | /* lang_hooks.tree_dump.dump_tree: Dump language-specific parts of tree |
cc2902df | 249 | nodes. Returns nonzero if it does not want the usual dumping of the |
89d684bb BM |
250 | second argument. */ |
251 | ||
2bd3ecad | 252 | bool |
0c20a65f | 253 | lhd_tree_dump_dump_tree (void *di ATTRIBUTE_UNUSED, tree t ATTRIBUTE_UNUSED) |
89d684bb | 254 | { |
2bd3ecad | 255 | return false; |
89d684bb BM |
256 | } |
257 | ||
e11e816e | 258 | /* lang_hooks.tree_dump.type_qual: Determine type qualifiers in a |
89d684bb BM |
259 | language-specific way. */ |
260 | ||
261 | int | |
ac7d7749 | 262 | lhd_tree_dump_type_quals (const_tree t) |
89d684bb BM |
263 | { |
264 | return TYPE_QUALS (t); | |
265 | } | |
a77a9a18 | 266 | |
6de9cd9a DN |
267 | /* lang_hooks.gimplify_expr re-writes *EXPR_P into GIMPLE form. */ |
268 | ||
269 | int | |
726a989a RB |
270 | lhd_gimplify_expr (tree *expr_p ATTRIBUTE_UNUSED, |
271 | gimple_seq *pre_p ATTRIBUTE_UNUSED, | |
272 | gimple_seq *post_p ATTRIBUTE_UNUSED) | |
16b0d23f | 273 | { |
6de9cd9a | 274 | return GS_UNHANDLED; |
16b0d23f | 275 | } |
2f51bb1d | 276 | |
d78e771d | 277 | /* lang_hooks.tree_size: Determine the size of a tree with code C, |
8e7014b4 JJ |
278 | which is a language-specific tree code in category tcc_constant, |
279 | tcc_exceptional or tcc_type. The default expects never to be called. */ | |
d78e771d | 280 | size_t |
0c20a65f | 281 | lhd_tree_size (enum tree_code c ATTRIBUTE_UNUSED) |
d78e771d | 282 | { |
41806d92 | 283 | gcc_unreachable (); |
d78e771d ZW |
284 | } |
285 | ||
e076f71a AH |
286 | /* Return true if decl, which is a function decl, may be called by a |
287 | sibcall. */ | |
288 | ||
289 | bool | |
58f9752a | 290 | lhd_decl_ok_for_sibcall (const_tree decl ATTRIBUTE_UNUSED) |
e076f71a AH |
291 | { |
292 | return true; | |
293 | } | |
294 | ||
d7438551 AH |
295 | /* Generic global declaration processing. This is meant to be called |
296 | by the front-ends at the end of parsing. C/C++ do their own thing, | |
297 | but other front-ends may call this. */ | |
298 | ||
2f51bb1d | 299 | void |
d7438551 | 300 | global_decl_processing (void) |
2f51bb1d | 301 | { |
a406865a RG |
302 | tree globals, decl, *vec; |
303 | int len, i; | |
304 | ||
d7438551 | 305 | timevar_stop (TV_PHASE_PARSING); |
0d6bf48c | 306 | timevar_start (TV_PHASE_DEFERRED); |
2f51bb1d MA |
307 | /* Really define vars that have had only a tentative definition. |
308 | Really output inline functions that must actually be callable | |
309 | and have not been output so far. */ | |
310 | ||
a406865a RG |
311 | globals = lang_hooks.decls.getdecls (); |
312 | len = list_length (globals); | |
313 | vec = XNEWVEC (tree, len); | |
2f51bb1d MA |
314 | |
315 | /* Process the decls in reverse order--earliest first. | |
316 | Put them into VEC from back to front, then take out from front. */ | |
317 | ||
910ad8de | 318 | for (i = 0, decl = globals; i < len; i++, decl = DECL_CHAIN (decl)) |
2f51bb1d MA |
319 | vec[len - i - 1] = decl; |
320 | ||
321 | wrapup_global_declarations (vec, len); | |
0d6bf48c JH |
322 | timevar_stop (TV_PHASE_DEFERRED); |
323 | ||
d7438551 | 324 | timevar_start (TV_PHASE_PARSING); |
2f51bb1d MA |
325 | free (vec); |
326 | } | |
26e0dcb3 | 327 | |
21ecc5a7 GDR |
328 | /* Called to perform language-specific initialization of CTX. */ |
329 | void | |
1ebe4b4f | 330 | lhd_initialize_diagnostics (diagnostic_context *ctx ATTRIBUTE_UNUSED) |
21ecc5a7 GDR |
331 | { |
332 | } | |
333 | ||
2a8a8d7b NS |
334 | /* Called to register dumps. */ |
335 | void | |
336 | lhd_register_dumps (gcc::dump_manager *) | |
337 | { | |
338 | } | |
339 | ||
7a9bf9a4 JM |
340 | /* Called to perform language-specific options initialization. */ |
341 | void | |
342 | lhd_init_options (unsigned int decoded_options_count ATTRIBUTE_UNUSED, | |
343 | struct cl_decoded_option *decoded_options ATTRIBUTE_UNUSED) | |
344 | { | |
345 | } | |
346 | ||
347 | /* By default, always complain about options for the wrong language. */ | |
348 | bool | |
349 | lhd_complain_wrong_lang_p (const struct cl_option *option ATTRIBUTE_UNUSED) | |
350 | { | |
351 | return true; | |
352 | } | |
353 | ||
5f20c657 JM |
354 | /* By default, no language-specific options are valid. */ |
355 | bool | |
356 | lhd_handle_option (size_t code ATTRIBUTE_UNUSED, | |
357 | const char *arg ATTRIBUTE_UNUSED, | |
00abf86c MS |
358 | HOST_WIDE_INT value ATTRIBUTE_UNUSED, |
359 | int kind ATTRIBUTE_UNUSED, | |
a4d8c676 | 360 | location_t loc ATTRIBUTE_UNUSED, |
5f20c657 JM |
361 | const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED) |
362 | { | |
363 | return false; | |
364 | } | |
365 | ||
dba65e79 GDR |
366 | /* The default function to print out name of current function that caused |
367 | an error. */ | |
368 | void | |
c94ed7a1 JJ |
369 | lhd_print_error_function (diagnostic_context *context, const char *file, |
370 | diagnostic_info *diagnostic) | |
dba65e79 | 371 | { |
c94ed7a1 | 372 | if (diagnostic_last_function_changed (context, diagnostic)) |
dba65e79 | 373 | { |
653fee19 | 374 | char *old_prefix = pp_take_prefix (context->printer); |
cf835838 | 375 | tree abstract_origin = diagnostic_abstract_origin (diagnostic); |
c94ed7a1 | 376 | char *new_prefix = (file && abstract_origin == NULL) |
e78e8a0b | 377 | ? file_name_as_prefix (context, file) : NULL; |
dba65e79 GDR |
378 | |
379 | pp_set_prefix (context->printer, new_prefix); | |
380 | ||
381 | if (current_function_decl == NULL) | |
971801ff | 382 | pp_printf (context->printer, _("At top level:")); |
dba65e79 GDR |
383 | else |
384 | { | |
c94ed7a1 JJ |
385 | tree fndecl, ao; |
386 | ||
387 | if (abstract_origin) | |
388 | { | |
389 | ao = BLOCK_ABSTRACT_ORIGIN (abstract_origin); | |
c94ed7a1 JJ |
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) | |
dba65e79 | 397 | pp_printf |
c94ed7a1 | 398 | (context->printer, _("In member function %qs"), |
4f1e4960 | 399 | identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2))); |
dba65e79 GDR |
400 | else |
401 | pp_printf | |
c94ed7a1 | 402 | (context->printer, _("In function %qs"), |
4f1e4960 | 403 | identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2))); |
c94ed7a1 JJ |
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); | |
c94ed7a1 JJ |
417 | if (TREE_CODE (ao) == FUNCTION_DECL) |
418 | { | |
419 | fndecl = ao; | |
420 | break; | |
421 | } | |
422 | else if (TREE_CODE (ao) != BLOCK) | |
423 | break; | |
424 | ||
425 | block = BLOCK_SUPERCONTEXT (block); | |
426 | } | |
427 | if (fndecl) | |
428 | abstract_origin = block; | |
429 | else | |
430 | { | |
431 | while (block && TREE_CODE (block) == BLOCK) | |
432 | block = BLOCK_SUPERCONTEXT (block); | |
433 | ||
91ab2c86 | 434 | if (block && TREE_CODE (block) == FUNCTION_DECL) |
c94ed7a1 JJ |
435 | fndecl = block; |
436 | abstract_origin = NULL; | |
437 | } | |
438 | if (fndecl) | |
439 | { | |
440 | expanded_location s = expand_location (*locus); | |
07838b13 | 441 | pp_comma (context->printer); |
c94ed7a1 JJ |
442 | pp_newline (context->printer); |
443 | if (s.file != NULL) | |
444 | { | |
243fbddd | 445 | if (context->show_column) |
c94ed7a1 | 446 | pp_printf (context->printer, |
4b84d650 | 447 | _(" inlined from %qs at %r%s:%d:%d%R"), |
4f1e4960 | 448 | identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2)), |
4b84d650 | 449 | "locus", s.file, s.line, s.column); |
c94ed7a1 | 450 | else |
c94ed7a1 | 451 | pp_printf (context->printer, |
4b84d650 | 452 | _(" inlined from %qs at %r%s:%d%R"), |
4f1e4960 | 453 | identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2)), |
4b84d650 | 454 | "locus", s.file, s.line); |
c94ed7a1 JJ |
455 | |
456 | } | |
457 | else | |
458 | pp_printf (context->printer, _(" inlined from %qs"), | |
4f1e4960 | 459 | identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2))); |
c94ed7a1 JJ |
460 | } |
461 | } | |
07838b13 | 462 | pp_colon (context->printer); |
dba65e79 | 463 | } |
dba65e79 | 464 | |
c94ed7a1 | 465 | diagnostic_set_last_function (context, diagnostic); |
f8923f7e | 466 | pp_newline_and_flush (context->printer); |
dba65e79 GDR |
467 | context->printer->prefix = old_prefix; |
468 | free ((char*) new_prefix); | |
469 | } | |
470 | } | |
471 | ||
b9dcdee4 JH |
472 | tree |
473 | lhd_make_node (enum tree_code code) | |
474 | { | |
475 | return make_node (code); | |
476 | } | |
c5ff069d | 477 | |
ab341f50 RS |
478 | /* Default implementation of LANG_HOOKS_SIMULATE_ENUM_DECL. Assume a |
479 | simple int-based enumerator (which is all the hook can be used for | |
480 | at present) and push each decl individually without any decoration. | |
481 | ||
482 | This definition is suitable for LTO and is generic enough that it | |
483 | might be reusable elsewhere. */ | |
484 | tree | |
485 | lhd_simulate_enum_decl (location_t loc, const char *name, | |
486 | vec<string_int_pair> values) | |
487 | { | |
488 | tree enumtype = lang_hooks.types.make_type (ENUMERAL_TYPE); | |
489 | tree enumdecl = build_decl (loc, TYPE_DECL, get_identifier (name), enumtype); | |
490 | TYPE_STUB_DECL (enumtype) = enumdecl; | |
491 | ||
492 | tree value_chain = NULL_TREE; | |
493 | string_int_pair *value; | |
494 | unsigned int i; | |
495 | FOR_EACH_VEC_ELT (values, i, value) | |
496 | { | |
497 | tree value_decl = build_decl (loc, CONST_DECL, | |
498 | get_identifier (value->first), enumtype); | |
499 | DECL_INITIAL (value_decl) = build_int_cst (integer_type_node, | |
500 | value->second); | |
501 | lang_hooks.decls.pushdecl (value_decl); | |
502 | value_chain = tree_cons (value_decl, DECL_INITIAL (value_decl), | |
503 | value_chain); | |
504 | } | |
505 | ||
506 | TYPE_MIN_VALUE (enumtype) = TYPE_MIN_VALUE (integer_type_node); | |
507 | TYPE_MAX_VALUE (enumtype) = TYPE_MAX_VALUE (integer_type_node); | |
508 | SET_TYPE_ALIGN (enumtype, TYPE_ALIGN (integer_type_node)); | |
509 | TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node); | |
510 | layout_type (enumtype); | |
511 | lang_hooks.decls.pushdecl (enumdecl); | |
512 | ||
513 | return enumtype; | |
514 | } | |
515 | ||
8a3a6ab4 DM |
516 | /* Default implementation of LANG_HOOKS_TYPE_FOR_SIZE. |
517 | Return an integer type with PRECISION bits of precision, | |
518 | that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */ | |
519 | ||
520 | tree | |
521 | lhd_type_for_size (unsigned precision, int unsignedp) | |
522 | { | |
523 | int i; | |
524 | ||
525 | if (precision == TYPE_PRECISION (integer_type_node)) | |
526 | return unsignedp ? unsigned_type_node : integer_type_node; | |
527 | ||
528 | if (precision == TYPE_PRECISION (signed_char_type_node)) | |
529 | return unsignedp ? unsigned_char_type_node : signed_char_type_node; | |
530 | ||
531 | if (precision == TYPE_PRECISION (short_integer_type_node)) | |
532 | return unsignedp ? short_unsigned_type_node : short_integer_type_node; | |
533 | ||
534 | if (precision == TYPE_PRECISION (long_integer_type_node)) | |
535 | return unsignedp ? long_unsigned_type_node : long_integer_type_node; | |
536 | ||
537 | if (precision == TYPE_PRECISION (long_long_integer_type_node)) | |
538 | return unsignedp | |
539 | ? long_long_unsigned_type_node | |
540 | : long_long_integer_type_node; | |
541 | ||
542 | for (i = 0; i < NUM_INT_N_ENTS; i ++) | |
543 | if (int_n_enabled_p[i] | |
544 | && precision == int_n_data[i].bitsize) | |
545 | return (unsignedp ? int_n_trees[i].unsigned_type | |
546 | : int_n_trees[i].signed_type); | |
547 | ||
548 | if (precision <= TYPE_PRECISION (intQI_type_node)) | |
549 | return unsignedp ? unsigned_intQI_type_node : intQI_type_node; | |
550 | ||
551 | if (precision <= TYPE_PRECISION (intHI_type_node)) | |
552 | return unsignedp ? unsigned_intHI_type_node : intHI_type_node; | |
553 | ||
554 | if (precision <= TYPE_PRECISION (intSI_type_node)) | |
555 | return unsignedp ? unsigned_intSI_type_node : intSI_type_node; | |
556 | ||
557 | if (precision <= TYPE_PRECISION (intDI_type_node)) | |
558 | return unsignedp ? unsigned_intDI_type_node : intDI_type_node; | |
559 | ||
560 | if (precision <= TYPE_PRECISION (intTI_type_node)) | |
561 | return unsignedp ? unsigned_intTI_type_node : intTI_type_node; | |
562 | ||
563 | return NULL_TREE; | |
564 | } | |
565 | ||
c5ff069d ZW |
566 | HOST_WIDE_INT |
567 | lhd_to_target_charset (HOST_WIDE_INT c) | |
568 | { | |
569 | return c; | |
570 | } | |
73f397d4 JM |
571 | |
572 | tree | |
51eed280 | 573 | lhd_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED, bool *se ATTRIBUTE_UNUSED) |
73f397d4 JM |
574 | { |
575 | return expr; | |
576 | } | |
953ff289 DN |
577 | |
578 | /* Return sharing kind if OpenMP sharing attribute of DECL is | |
579 | predetermined, OMP_CLAUSE_DEFAULT_UNSPECIFIED otherwise. */ | |
580 | ||
581 | enum omp_clause_default_kind | |
582 | lhd_omp_predetermined_sharing (tree decl ATTRIBUTE_UNUSED) | |
583 | { | |
584 | if (DECL_ARTIFICIAL (decl)) | |
585 | return OMP_CLAUSE_DEFAULT_SHARED; | |
586 | return OMP_CLAUSE_DEFAULT_UNSPECIFIED; | |
587 | } | |
588 | ||
589 | /* Generate code to copy SRC to DST. */ | |
590 | ||
591 | tree | |
592 | lhd_omp_assignment (tree clause ATTRIBUTE_UNUSED, tree dst, tree src) | |
593 | { | |
726a989a | 594 | return build2 (MODIFY_EXPR, TREE_TYPE (dst), dst, src); |
953ff289 DN |
595 | } |
596 | ||
f014c653 JJ |
597 | /* Finalize clause C. */ |
598 | ||
599 | void | |
600 | lhd_omp_finish_clause (tree, gimple_seq *) | |
601 | { | |
602 | } | |
603 | ||
b4c3a85b JJ |
604 | /* Return true if DECL is a scalar variable (for the purpose of |
605 | implicit firstprivatization). */ | |
606 | ||
607 | bool | |
608 | lhd_omp_scalar_p (tree decl) | |
609 | { | |
610 | tree type = TREE_TYPE (decl); | |
611 | if (TREE_CODE (type) == REFERENCE_TYPE) | |
612 | type = TREE_TYPE (type); | |
613 | if (TREE_CODE (type) == COMPLEX_TYPE) | |
614 | type = TREE_TYPE (type); | |
615 | if (INTEGRAL_TYPE_P (type) | |
616 | || SCALAR_FLOAT_TYPE_P (type) | |
617 | || TREE_CODE (type) == POINTER_TYPE) | |
618 | return true; | |
619 | return false; | |
620 | } | |
621 | ||
953ff289 DN |
622 | /* Register language specific type size variables as potentially OpenMP |
623 | firstprivate variables. */ | |
624 | ||
625 | void | |
626 | lhd_omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *c ATTRIBUTE_UNUSED, | |
627 | tree t ATTRIBUTE_UNUSED) | |
628 | { | |
629 | } | |
c79efc4d | 630 | |
b17a8b07 | 631 | /* Return true if TYPE is an OpenMP mappable type. */ |
acf0174b JJ |
632 | |
633 | bool | |
634 | lhd_omp_mappable_type (tree type) | |
635 | { | |
b17a8b07 TS |
636 | /* Mappable type has to be complete. */ |
637 | if (type == error_mark_node || !COMPLETE_TYPE_P (type)) | |
638 | return false; | |
639 | return true; | |
acf0174b JJ |
640 | } |
641 | ||
74078538 RS |
642 | /* Common function for add_builtin_function, add_builtin_function_ext_scope |
643 | and simulate_builtin_function_decl. */ | |
644 | ||
5779e713 | 645 | static tree |
74078538 RS |
646 | build_builtin_function (location_t location, const char *name, tree type, |
647 | int function_code, enum built_in_class cl, | |
648 | const char *library_name, tree attrs) | |
c79efc4d RÁE |
649 | { |
650 | tree id = get_identifier (name); | |
74078538 | 651 | tree decl = build_decl (location, FUNCTION_DECL, id, type); |
c79efc4d RÁE |
652 | |
653 | TREE_PUBLIC (decl) = 1; | |
654 | DECL_EXTERNAL (decl) = 1; | |
c536a6a7 | 655 | |
4d732405 | 656 | set_decl_built_in_function (decl, cl, function_code); |
c79efc4d | 657 | |
428aba16 RS |
658 | if (library_name) |
659 | { | |
660 | tree libname = get_identifier (library_name); | |
72b1108c NS |
661 | |
662 | libname = targetm.mangle_decl_assembler_name (decl, libname); | |
428aba16 RS |
663 | SET_DECL_ASSEMBLER_NAME (decl, libname); |
664 | } | |
c79efc4d RÁE |
665 | |
666 | /* Possibly apply some default attributes to this built-in function. */ | |
667 | if (attrs) | |
668 | decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN); | |
669 | else | |
670 | decl_attributes (&decl, NULL_TREE, 0); | |
671 | ||
74078538 | 672 | return decl; |
5779e713 MM |
673 | } |
674 | ||
675 | /* Create a builtin function. */ | |
676 | ||
677 | tree | |
678 | add_builtin_function (const char *name, | |
679 | tree type, | |
680 | int function_code, | |
681 | enum built_in_class cl, | |
682 | const char *library_name, | |
683 | tree attrs) | |
684 | { | |
74078538 RS |
685 | tree decl = build_builtin_function (BUILTINS_LOCATION, name, type, |
686 | function_code, cl, library_name, attrs); | |
687 | return lang_hooks.builtin_function (decl); | |
5779e713 | 688 | } |
c79efc4d | 689 | |
5779e713 MM |
690 | /* Like add_builtin_function, but make sure the scope is the external scope. |
691 | This is used to delay putting in back end builtin functions until the ISA | |
692 | that defines the builtin is declared via function specific target options, | |
693 | which can save memory for machines like the x86_64 that have multiple ISAs. | |
694 | If this points to the same function as builtin_function, the backend must | |
695 | add all of the builtins at program initialization time. */ | |
696 | ||
697 | tree | |
698 | add_builtin_function_ext_scope (const char *name, | |
699 | tree type, | |
700 | int function_code, | |
701 | enum built_in_class cl, | |
702 | const char *library_name, | |
703 | tree attrs) | |
704 | { | |
74078538 RS |
705 | tree decl = build_builtin_function (BUILTINS_LOCATION, name, type, |
706 | function_code, cl, library_name, attrs); | |
707 | return lang_hooks.builtin_function_ext_scope (decl); | |
708 | } | |
709 | ||
710 | /* Simulate a declaration of a target-specific built-in function at | |
711 | location LOCATION, as though it had been declared directly in the | |
712 | source language. NAME is the name of the function, TYPE is its function | |
713 | type, FUNCTION_CODE is the target-specific function code, LIBRARY_NAME | |
714 | is the name of the underlying library function (NULL if none) and | |
715 | ATTRS is a list of function attributes. | |
716 | ||
717 | Return the decl of the declared function. */ | |
718 | ||
719 | tree | |
720 | simulate_builtin_function_decl (location_t location, const char *name, | |
721 | tree type, int function_code, | |
722 | const char *library_name, tree attrs) | |
723 | { | |
724 | tree decl = build_builtin_function (location, name, type, | |
725 | function_code, BUILT_IN_MD, | |
726 | library_name, attrs); | |
727 | tree new_decl = lang_hooks.simulate_builtin_function_decl (decl); | |
728 | ||
729 | /* Give the front end a chance to create a new decl if necessary, | |
730 | but if the front end discards the decl in favour of a conflicting | |
731 | (erroneous) previous definition, return the decl that we tried but | |
732 | failed to add. This allows the caller to process the returned decl | |
733 | normally, even though the source code won't be able to use it. */ | |
734 | if (TREE_CODE (new_decl) == FUNCTION_DECL | |
735 | && fndecl_built_in_p (new_decl, function_code, BUILT_IN_MD)) | |
736 | return new_decl; | |
737 | ||
738 | return decl; | |
c79efc4d RÁE |
739 | } |
740 | ||
741 | tree | |
742 | lhd_builtin_function (tree decl) | |
743 | { | |
744 | lang_hooks.decls.pushdecl (decl); | |
745 | return decl; | |
746 | } | |
d7f09764 | 747 | |
c0814136 SB |
748 | /* Create a builtin type. */ |
749 | ||
750 | tree | |
751 | add_builtin_type (const char *name, tree type) | |
752 | { | |
753 | tree id = get_identifier (name); | |
754 | tree decl = build_decl (BUILTINS_LOCATION, TYPE_DECL, id, type); | |
755 | return lang_hooks.decls.pushdecl (decl); | |
756 | } | |
757 | ||
d7f09764 DN |
758 | /* LTO hooks. */ |
759 | ||
760 | /* Used to save and restore any previously active section. */ | |
761 | static section *saved_section; | |
762 | ||
763 | ||
764 | /* Begin a new LTO output section named NAME. This default implementation | |
765 | saves the old section and emits assembly code to switch to the new | |
766 | section. */ | |
767 | ||
768 | void | |
769 | lhd_begin_section (const char *name) | |
770 | { | |
771 | section *section; | |
772 | ||
773 | /* Save the old section so we can restore it in lto_end_asm_section. */ | |
774 | gcc_assert (!saved_section); | |
775 | saved_section = in_section; | |
cb799353 RG |
776 | if (!saved_section) |
777 | saved_section = text_section; | |
d7f09764 DN |
778 | |
779 | /* Create a new section and switch to it. */ | |
d856054b | 780 | section = get_section (name, SECTION_DEBUG | SECTION_EXCLUDE, NULL); |
d7f09764 DN |
781 | switch_to_section (section); |
782 | } | |
783 | ||
784 | ||
785 | /* Write DATA of length LEN to the current LTO output section. This default | |
f6bcdb5e | 786 | implementation just calls assemble_string. */ |
d7f09764 DN |
787 | |
788 | void | |
f6bcdb5e | 789 | lhd_append_data (const void *data, size_t len, void *) |
d7f09764 DN |
790 | { |
791 | if (data) | |
ed7dc894 JH |
792 | { |
793 | timevar_push (TV_IPA_LTO_OUTPUT); | |
794 | assemble_string ((const char *)data, len); | |
795 | timevar_pop (TV_IPA_LTO_OUTPUT); | |
796 | } | |
d7f09764 DN |
797 | } |
798 | ||
799 | ||
800 | /* Finish the current LTO output section. This default implementation emits | |
801 | assembly code to switch to any section previously saved by | |
802 | lhd_begin_section. */ | |
803 | ||
804 | void | |
805 | lhd_end_section (void) | |
806 | { | |
807 | if (saved_section) | |
808 | { | |
809 | switch_to_section (saved_section); | |
810 | saved_section = NULL; | |
811 | } | |
812 | } | |
7315daa6 MW |
813 | |
814 | /* Default implementation of enum_underlying_base_type using type_for_size. */ | |
815 | ||
816 | tree | |
817 | lhd_enum_underlying_base_type (const_tree enum_type) | |
818 | { | |
819 | return lang_hooks.types.type_for_size (TYPE_PRECISION (enum_type), | |
820 | TYPE_UNSIGNED (enum_type)); | |
821 | } | |
dcc97066 | 822 | |
e5106e27 DM |
823 | /* Default implementation of LANG_HOOKS_GET_SUBSTRING_LOCATION. */ |
824 | ||
825 | const char * | |
826 | lhd_get_substring_location (const substring_loc &, location_t *) | |
827 | { | |
828 | return "unimplemented"; | |
829 | } | |
830 | ||
81b42cc6 JJ |
831 | /* Default implementation of LANG_HOOKS_DECL_DWARF_ATTRIBUTE. Don't add |
832 | any attributes. */ | |
833 | ||
834 | int | |
835 | lhd_decl_dwarf_attribute (const_tree, int) | |
836 | { | |
837 | return -1; | |
838 | } | |
839 | ||
6905c577 JJ |
840 | /* Default implementation of LANG_HOOKS_TYPE_DWARF_ATTRIBUTE. Don't add |
841 | any attributes. */ | |
842 | ||
843 | int | |
844 | lhd_type_dwarf_attribute (const_tree, int) | |
845 | { | |
846 | return -1; | |
847 | } | |
848 | ||
b7fc43d7 RB |
849 | /* Default implementation of LANG_HOOKS_UNIT_SIZE_WITHOUT_REUSABLE_PADDING. |
850 | Just return TYPE_SIZE_UNIT unadjusted. */ | |
851 | ||
852 | tree | |
853 | lhd_unit_size_without_reusable_padding (tree t) | |
854 | { | |
855 | return TYPE_SIZE_UNIT (t); | |
856 | } | |
857 | ||
dcc97066 MW |
858 | /* Returns true if the current lang_hooks represents the GNU C frontend. */ |
859 | ||
860 | bool | |
861 | lang_GNU_C (void) | |
862 | { | |
863 | return (strncmp (lang_hooks.name, "GNU C", 5) == 0 | |
864 | && (lang_hooks.name[5] == '\0' || ISDIGIT (lang_hooks.name[5]))); | |
865 | } | |
866 | ||
867 | /* Returns true if the current lang_hooks represents the GNU C++ frontend. */ | |
868 | ||
869 | bool | |
870 | lang_GNU_CXX (void) | |
871 | { | |
872 | return strncmp (lang_hooks.name, "GNU C++", 7) == 0; | |
873 | } | |
de3aebff JJ |
874 | |
875 | /* Returns true if the current lang_hooks represents the GNU Fortran frontend. */ | |
876 | ||
877 | bool | |
878 | lang_GNU_Fortran (void) | |
879 | { | |
880 | return strncmp (lang_hooks.name, "GNU Fortran", 11) == 0; | |
881 | } | |
81fea426 MP |
882 | |
883 | /* Returns true if the current lang_hooks represents the GNU Objective-C | |
884 | frontend. */ | |
885 | ||
886 | bool | |
887 | lang_GNU_OBJC (void) | |
888 | { | |
889 | return strncmp (lang_hooks.name, "GNU Objective-C", 15) == 0; | |
890 | } |