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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [gcc/] [langhooks.c] - Blame information for rev 38

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

Line No. Rev Author Line
1 38 julius
/* Default language-specific hooks.
2
   Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007
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 "tree-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 "langhooks-def.h"
37
#include "ggc.h"
38
#include "diagnostic.h"
39
 
40
/* Do nothing; in many cases the default hook.  */
41
 
42
void
43
lhd_do_nothing (void)
44
{
45
}
46
 
47
/* Do nothing (tree).  */
48
 
49
void
50
lhd_do_nothing_t (tree ARG_UNUSED (t))
51
{
52
}
53
 
54
/* Do nothing (int).  */
55
 
56
void
57
lhd_do_nothing_i (int ARG_UNUSED (i))
58
{
59
}
60
 
61
/* Do nothing (int, int, int).  Return NULL_TREE.  */
62
 
63
tree
64
lhd_do_nothing_iii_return_null_tree (int ARG_UNUSED (i),
65
                                     int ARG_UNUSED (j),
66
                                     int ARG_UNUSED (k))
67
{
68
  return NULL_TREE;
69
}
70
 
71
/* Do nothing (function).  */
72
 
73
void
74
lhd_do_nothing_f (struct function * ARG_UNUSED (f))
75
{
76
}
77
 
78
/* Do nothing (return the tree node passed).  */
79
 
80
tree
81
lhd_return_tree (tree t)
82
{
83
  return t;
84
}
85
 
86
/* Do nothing (return NULL_TREE).  */
87
 
88
tree
89
lhd_return_null_tree_v (void)
90
{
91
  return NULL_TREE;
92
}
93
 
94
/* Do nothing (return NULL_TREE).  */
95
 
96
tree
97
lhd_return_null_tree (tree ARG_UNUSED (t))
98
{
99
  return NULL_TREE;
100
}
101
 
102
/* The default post options hook.  */
103
 
104
bool
105
lhd_post_options (const char ** ARG_UNUSED (pfilename))
106
{
107
  return false;
108
}
109
 
110
/* Called from by print-tree.c.  */
111
 
112
void
113
lhd_print_tree_nothing (FILE * ARG_UNUSED (file),
114
                        tree ARG_UNUSED (node),
115
                        int ARG_UNUSED (indent))
116
{
117
}
118
 
119
/* Called from safe_from_p.  */
120
 
121
int
122
lhd_safe_from_p (rtx ARG_UNUSED (x), tree ARG_UNUSED (exp))
123
{
124
  return 1;
125
}
126
 
127
/* Called from staticp.  */
128
 
129
tree
130
lhd_staticp (tree ARG_UNUSED (exp))
131
{
132
  return NULL;
133
}
134
 
135
/* Called from check_global_declarations.  */
136
 
137
bool
138
lhd_warn_unused_global_decl (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_INLINE (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.  */
154
void
155
lhd_set_decl_assembler_name (tree decl)
156
{
157
  /* The language-independent code should never use the
158
     DECL_ASSEMBLER_NAME for lots of DECLs.  Only FUNCTION_DECLs and
159
     VAR_DECLs for variables with static storage duration need a real
160
     DECL_ASSEMBLER_NAME.  */
161
  gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
162
              || (TREE_CODE (decl) == VAR_DECL
163
                  && (TREE_STATIC (decl)
164
                      || DECL_EXTERNAL (decl)
165
                      || TREE_PUBLIC (decl))));
166
 
167
  /* By default, assume the name to use in assembly code is the same
168
     as that used in the source language.  (That's correct for C, and
169
     GCC used to set DECL_ASSEMBLER_NAME to the same value as
170
     DECL_NAME in build_decl, so this choice provides backwards
171
     compatibility with existing front-ends.
172
 
173
     Can't use just the variable's own name for a variable whose scope
174
     is less than the whole compilation.  Concatenate a distinguishing
175
     number - we use the DECL_UID.  */
176
  if (TREE_PUBLIC (decl) || DECL_CONTEXT (decl) == NULL_TREE)
177
    SET_DECL_ASSEMBLER_NAME (decl, DECL_NAME (decl));
178
  else
179
    {
180
      const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
181
      char *label;
182
 
183
      ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
184
      SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
185
    }
186
}
187
 
188
/* By default we always allow bit-field based optimizations.  */
189
bool
190
lhd_can_use_bit_fields_p (void)
191
{
192
  return true;
193
}
194
 
195
/* Type promotion for variable arguments.  */
196
tree
197
lhd_type_promotes_to (tree ARG_UNUSED (type))
198
{
199
  gcc_unreachable ();
200
}
201
 
202
/* Registration of machine- or os-specific builtin types.  */
203
void
204
lhd_register_builtin_type (tree ARG_UNUSED (type),
205
                           const char * ARG_UNUSED (name))
206
{
207
}
208
 
209
/* Invalid use of an incomplete type.  */
210
void
211
lhd_incomplete_type_error (tree ARG_UNUSED (value), 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
 
220
HOST_WIDE_INT
221
lhd_get_alias_set (tree ARG_UNUSED (t))
222
{
223
  return -1;
224
}
225
 
226
/* Provide a hook routine for alias sets that always returns 0.  This is
227
   used by languages that haven't deal with alias sets yet.  */
228
 
229
HOST_WIDE_INT
230
hook_get_alias_set_0 (tree ARG_UNUSED (t))
231
{
232
  return 0;
233
}
234
 
235
/* This is the default expand_expr function.  */
236
 
237
rtx
238
lhd_expand_expr (tree ARG_UNUSED (t), rtx ARG_UNUSED (r),
239
                 enum machine_mode ARG_UNUSED (mm),
240
                 int ARG_UNUSED (em),
241
                 rtx * ARG_UNUSED (a))
242
{
243
  gcc_unreachable ();
244
}
245
 
246
/* The default language-specific function for expanding a decl.  After
247
   the language-independent cases are handled, this function will be
248
   called.  If this function is not defined, it is assumed that
249
   declarations other than those for variables and labels do not require
250
   any RTL generation.  */
251
 
252
int
253
lhd_expand_decl (tree ARG_UNUSED (t))
254
{
255
  return 0;
256
}
257
 
258
/* This is the default decl_printable_name function.  */
259
 
260
const char *
261
lhd_decl_printable_name (tree decl, int ARG_UNUSED (verbosity))
262
{
263
  gcc_assert (decl && DECL_NAME (decl));
264
  return IDENTIFIER_POINTER (DECL_NAME (decl));
265
}
266
 
267
/* This is the default dwarf_name function.  */
268
 
269
const char *
270
lhd_dwarf_name (tree t, int verbosity)
271
{
272
  gcc_assert (DECL_P (t));
273
 
274
  return lang_hooks.decl_printable_name (t, verbosity);
275
}
276
 
277
/* This compares two types for equivalence ("compatible" in C-based languages).
278
   This routine should only return 1 if it is sure.  It should not be used
279
   in contexts where erroneously returning 0 causes problems.  */
280
 
281
int
282
lhd_types_compatible_p (tree x, tree y)
283
{
284
  return TYPE_MAIN_VARIANT (x) == TYPE_MAIN_VARIANT (y);
285
}
286
 
287
/* lang_hooks.tree_inlining.walk_subtrees is called by walk_tree()
288
   after handling common cases, but before walking code-specific
289
   sub-trees.  If this hook is overridden for a language, it should
290
   handle language-specific tree codes, as well as language-specific
291
   information associated to common tree codes.  If a tree node is
292
   completely handled within this function, it should set *SUBTREES to
293
   0, so that generic handling isn't attempted.  The generic handling
294
   cannot deal with language-specific tree codes, so make sure it is
295
   set properly.  Both SUBTREES and *SUBTREES is guaranteed to be
296
   nonzero when the function is called.  */
297
 
298
tree
299
lhd_tree_inlining_walk_subtrees (tree *tp ATTRIBUTE_UNUSED,
300
                                 int *subtrees ATTRIBUTE_UNUSED,
301
                                 walk_tree_fn func ATTRIBUTE_UNUSED,
302
                                 void *data ATTRIBUTE_UNUSED,
303
                                 struct pointer_set_t *pset ATTRIBUTE_UNUSED)
304
{
305
  return NULL_TREE;
306
}
307
 
308
/* lang_hooks.tree_inlining.cannot_inline_tree_fn is called to
309
   determine whether there are language-specific reasons for not
310
   inlining a given function.  */
311
 
312
int
313
lhd_tree_inlining_cannot_inline_tree_fn (tree *fnp)
314
{
315
  if (flag_really_no_inline
316
      && lookup_attribute ("always_inline", DECL_ATTRIBUTES (*fnp)) == NULL)
317
    return 1;
318
 
319
  return 0;
320
}
321
 
322
/* lang_hooks.tree_inlining.disregard_inline_limits is called to
323
   determine whether a function should be considered for inlining even
324
   if it would exceed inlining limits.  */
325
 
326
int
327
lhd_tree_inlining_disregard_inline_limits (tree fn)
328
{
329
  if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) != NULL)
330
    return 1;
331
 
332
  return 0;
333
}
334
 
335
/* lang_hooks.tree_inlining.add_pending_fn_decls is called before
336
   starting to inline a function, to push any language-specific
337
   functions that should not be inlined into the current function,
338
   into VAFNP.  PFN is the top of varray, and should be returned if no
339
   functions are pushed into VAFNP.  The top of the varray should be
340
   returned.  */
341
 
342
tree
343
lhd_tree_inlining_add_pending_fn_decls (void *vafnp ATTRIBUTE_UNUSED, tree pfn)
344
{
345
  return pfn;
346
}
347
 
348
/* lang_hooks.tree_inlining.auto_var_in_fn_p is called to determine
349
   whether VT is an automatic variable defined in function FT.  */
350
 
351
int
352
lhd_tree_inlining_auto_var_in_fn_p (tree var, tree fn)
353
{
354
  return (DECL_P (var) && DECL_CONTEXT (var) == fn
355
          && (((TREE_CODE (var) == VAR_DECL || TREE_CODE (var) == PARM_DECL)
356
               && ! TREE_STATIC (var))
357
              || TREE_CODE (var) == LABEL_DECL
358
              || TREE_CODE (var) == RESULT_DECL));
359
}
360
 
361
/* lang_hooks.tree_inlining.anon_aggr_type_p determines whether T is a
362
   type node representing an anonymous aggregate (union, struct, etc),
363
   i.e., one whose members are in the same scope as the union itself.  */
364
 
365
int
366
lhd_tree_inlining_anon_aggr_type_p (tree t ATTRIBUTE_UNUSED)
367
{
368
  return 0;
369
}
370
 
371
/* lang_hooks.tree_inlining.start_inlining and end_inlining perform any
372
   language-specific bookkeeping necessary for processing
373
   FN. start_inlining returns nonzero if inlining should proceed, zero if
374
   not.
375
 
376
   For instance, the C++ version keeps track of template instantiations to
377
   avoid infinite recursion.  */
378
 
379
int
380
lhd_tree_inlining_start_inlining (tree fn ATTRIBUTE_UNUSED)
381
{
382
  return 1;
383
}
384
 
385
void
386
lhd_tree_inlining_end_inlining (tree fn ATTRIBUTE_UNUSED)
387
{
388
}
389
 
390
/* lang_hooks.tree_inlining.convert_parm_for_inlining performs any
391
   language-specific conversion before assigning VALUE to PARM.  */
392
 
393
tree
394
lhd_tree_inlining_convert_parm_for_inlining (tree parm ATTRIBUTE_UNUSED,
395
                                             tree value,
396
                                             tree fndecl ATTRIBUTE_UNUSED,
397
                                             int argnum ATTRIBUTE_UNUSED)
398
{
399
  return value;
400
}
401
 
402
/* lang_hooks.tree_dump.dump_tree:  Dump language-specific parts of tree
403
   nodes.  Returns nonzero if it does not want the usual dumping of the
404
   second argument.  */
405
 
406
bool
407
lhd_tree_dump_dump_tree (void *di ATTRIBUTE_UNUSED, tree t ATTRIBUTE_UNUSED)
408
{
409
  return false;
410
}
411
 
412
/* lang_hooks.tree_dump.type_qual:  Determine type qualifiers in a
413
   language-specific way.  */
414
 
415
int
416
lhd_tree_dump_type_quals (tree t)
417
{
418
  return TYPE_QUALS (t);
419
}
420
 
421
/* lang_hooks.expr_size: Determine the size of the value of an expression T
422
   in a language-specific way.  Returns a tree for the size in bytes.  */
423
 
424
tree
425
lhd_expr_size (tree exp)
426
{
427
  if (DECL_P (exp)
428
      && DECL_SIZE_UNIT (exp) != 0)
429
    return DECL_SIZE_UNIT (exp);
430
  else
431
    return size_in_bytes (TREE_TYPE (exp));
432
}
433
 
434
/* lang_hooks.gimplify_expr re-writes *EXPR_P into GIMPLE form.  */
435
 
436
int
437
lhd_gimplify_expr (tree *expr_p ATTRIBUTE_UNUSED, tree *pre_p ATTRIBUTE_UNUSED,
438
                   tree *post_p ATTRIBUTE_UNUSED)
439
{
440
  return GS_UNHANDLED;
441
}
442
 
443
/* lang_hooks.tree_size: Determine the size of a tree with code C,
444
   which is a language-specific tree code in category tcc_constant or
445
   tcc_exceptional.  The default expects never to be called.  */
446
size_t
447
lhd_tree_size (enum tree_code c ATTRIBUTE_UNUSED)
448
{
449
  gcc_unreachable ();
450
}
451
 
452
/* Return true if decl, which is a function decl, may be called by a
453
   sibcall.  */
454
 
455
bool
456
lhd_decl_ok_for_sibcall (tree decl ATTRIBUTE_UNUSED)
457
{
458
  return true;
459
}
460
 
461
/* Return the COMDAT group into which DECL should be placed.  */
462
 
463
const char *
464
lhd_comdat_group (tree decl)
465
{
466
  return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
467
}
468
 
469
/* lang_hooks.decls.final_write_globals: perform final processing on
470
   global variables.  */
471
void
472
write_global_declarations (void)
473
{
474
  /* Really define vars that have had only a tentative definition.
475
     Really output inline functions that must actually be callable
476
     and have not been output so far.  */
477
 
478
  tree globals = lang_hooks.decls.getdecls ();
479
  int len = list_length (globals);
480
  tree *vec = XNEWVEC (tree, len);
481
  int i;
482
  tree decl;
483
 
484
  /* Process the decls in reverse order--earliest first.
485
     Put them into VEC from back to front, then take out from front.  */
486
 
487
  for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
488
    vec[len - i - 1] = decl;
489
 
490
  wrapup_global_declarations (vec, len);
491
  check_global_declarations (vec, len);
492
  emit_debug_global_declarations (vec, len);
493
 
494
  /* Clean up.  */
495
  free (vec);
496
}
497
 
498
/* Called to perform language-specific initialization of CTX.  */
499
void
500
lhd_initialize_diagnostics (struct diagnostic_context *ctx ATTRIBUTE_UNUSED)
501
{
502
}
503
 
504
/* The default function to print out name of current function that caused
505
   an error.  */
506
void
507
lhd_print_error_function (diagnostic_context *context, const char *file)
508
{
509
  if (diagnostic_last_function_changed (context))
510
    {
511
      const char *old_prefix = context->printer->prefix;
512
      char *new_prefix = file ? file_name_as_prefix (file) : NULL;
513
 
514
      pp_set_prefix (context->printer, new_prefix);
515
 
516
      if (current_function_decl == NULL)
517
        pp_printf (context->printer, _("At top level:"));
518
      else
519
        {
520
          if (TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE)
521
            pp_printf
522
              (context->printer, _("In member function %qs:"),
523
               lang_hooks.decl_printable_name (current_function_decl, 2));
524
          else
525
            pp_printf
526
              (context->printer, _("In function %qs:"),
527
               lang_hooks.decl_printable_name (current_function_decl, 2));
528
        }
529
 
530
      diagnostic_set_last_function (context);
531
      pp_flush (context->printer);
532
      context->printer->prefix = old_prefix;
533
      free ((char*) new_prefix);
534
    }
535
}
536
 
537
tree
538
lhd_callgraph_analyze_expr (tree *tp ATTRIBUTE_UNUSED,
539
                            int *walk_subtrees ATTRIBUTE_UNUSED,
540
                            tree decl ATTRIBUTE_UNUSED)
541
{
542
  return NULL;
543
}
544
 
545
tree
546
lhd_make_node (enum tree_code code)
547
{
548
  return make_node (code);
549
}
550
 
551
HOST_WIDE_INT
552
lhd_to_target_charset (HOST_WIDE_INT c)
553
{
554
  return c;
555
}
556
 
557
tree
558
lhd_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED,
559
                  bool *ti ATTRIBUTE_UNUSED, bool *se ATTRIBUTE_UNUSED)
560
{
561
  return expr;
562
}
563
 
564
/* Return sharing kind if OpenMP sharing attribute of DECL is
565
   predetermined, OMP_CLAUSE_DEFAULT_UNSPECIFIED otherwise.  */
566
 
567
enum omp_clause_default_kind
568
lhd_omp_predetermined_sharing (tree decl ATTRIBUTE_UNUSED)
569
{
570
  if (DECL_ARTIFICIAL (decl))
571
    return OMP_CLAUSE_DEFAULT_SHARED;
572
  return OMP_CLAUSE_DEFAULT_UNSPECIFIED;
573
}
574
 
575
/* Generate code to copy SRC to DST.  */
576
 
577
tree
578
lhd_omp_assignment (tree clause ATTRIBUTE_UNUSED, tree dst, tree src)
579
{
580
  return build2 (MODIFY_EXPR, void_type_node, dst, src);
581
}
582
 
583
/* Register language specific type size variables as potentially OpenMP
584
   firstprivate variables.  */
585
 
586
void
587
lhd_omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *c ATTRIBUTE_UNUSED,
588
                                   tree t ATTRIBUTE_UNUSED)
589
{
590
}

powered by: WebSVN 2.1.0

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