OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [langhooks.c] - Blame information for rev 280

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.