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