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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [langhooks.c] - Blame information for rev 747

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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