Mercurial > hg > CbC > CbC_gcc

comparison gcc/langhooks.c @ 0:a06113de4d67

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