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

Subversion Repositories scarts

[/] [scarts/] [trunk/] [toolchain/] [scarts-gcc/] [gcc-4.1.1/] [gcc/] [langhooks.c] - Blame information for rev 12

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 12 jlechner
/* Default language-specific hooks.
2
   Copyright 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
3
   Contributed by Alexandre Oliva  <aoliva@redhat.com>
4
 
5
This file is part of GCC.
6
 
7
GCC is free software; you can redistribute it and/or modify
8
it under the terms of the GNU General Public License as published by
9
the Free Software Foundation; either version 2, or (at your option)
10
any later version.
11
 
12
GCC is distributed in the hope that it will be useful,
13
but WITHOUT ANY WARRANTY; without even the implied warranty of
14
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
GNU General Public License for more details.
16
 
17
You should have received a copy of the GNU General Public License
18
along with GCC; see the file COPYING.  If not, write to
19
the Free Software Foundation, 51 Franklin Street, Fifth Floor,
20
Boston, MA 02110-1301, USA.  */
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 compares two types for equivalence ("compatible" in C-based languages).
268
   This routine should only return 1 if it is sure.  It should not be used
269
   in contexts where erroneously returning 0 causes problems.  */
270
 
271
int
272
lhd_types_compatible_p (tree x, tree y)
273
{
274
  return TYPE_MAIN_VARIANT (x) == TYPE_MAIN_VARIANT (y);
275
}
276
 
277
/* lang_hooks.tree_inlining.walk_subtrees is called by walk_tree()
278
   after handling common cases, but before walking code-specific
279
   sub-trees.  If this hook is overridden for a language, it should
280
   handle language-specific tree codes, as well as language-specific
281
   information associated to common tree codes.  If a tree node is
282
   completely handled within this function, it should set *SUBTREES to
283
   0, so that generic handling isn't attempted.  The generic handling
284
   cannot deal with language-specific tree codes, so make sure it is
285
   set properly.  Both SUBTREES and *SUBTREES is guaranteed to be
286
   nonzero when the function is called.  */
287
 
288
tree
289
lhd_tree_inlining_walk_subtrees (tree *tp ATTRIBUTE_UNUSED,
290
                                 int *subtrees ATTRIBUTE_UNUSED,
291
                                 walk_tree_fn func ATTRIBUTE_UNUSED,
292
                                 void *data ATTRIBUTE_UNUSED,
293
                                 struct pointer_set_t *pset ATTRIBUTE_UNUSED)
294
{
295
  return NULL_TREE;
296
}
297
 
298
/* lang_hooks.tree_inlining.cannot_inline_tree_fn is called to
299
   determine whether there are language-specific reasons for not
300
   inlining a given function.  */
301
 
302
int
303
lhd_tree_inlining_cannot_inline_tree_fn (tree *fnp)
304
{
305
  if (flag_really_no_inline
306
      && lookup_attribute ("always_inline", DECL_ATTRIBUTES (*fnp)) == NULL)
307
    return 1;
308
 
309
  return 0;
310
}
311
 
312
/* lang_hooks.tree_inlining.disregard_inline_limits is called to
313
   determine whether a function should be considered for inlining even
314
   if it would exceed inlining limits.  */
315
 
316
int
317
lhd_tree_inlining_disregard_inline_limits (tree fn)
318
{
319
  if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) != NULL)
320
    return 1;
321
 
322
  return 0;
323
}
324
 
325
/* lang_hooks.tree_inlining.add_pending_fn_decls is called before
326
   starting to inline a function, to push any language-specific
327
   functions that should not be inlined into the current function,
328
   into VAFNP.  PFN is the top of varray, and should be returned if no
329
   functions are pushed into VAFNP.  The top of the varray should be
330
   returned.  */
331
 
332
tree
333
lhd_tree_inlining_add_pending_fn_decls (void *vafnp ATTRIBUTE_UNUSED, tree pfn)
334
{
335
  return pfn;
336
}
337
 
338
/* lang_hooks.tree_inlining.auto_var_in_fn_p is called to determine
339
   whether VT is an automatic variable defined in function FT.  */
340
 
341
int
342
lhd_tree_inlining_auto_var_in_fn_p (tree var, tree fn)
343
{
344
  return (DECL_P (var) && DECL_CONTEXT (var) == fn
345
          && (((TREE_CODE (var) == VAR_DECL || TREE_CODE (var) == PARM_DECL)
346
               && ! TREE_STATIC (var))
347
              || TREE_CODE (var) == LABEL_DECL
348
              || TREE_CODE (var) == RESULT_DECL));
349
}
350
 
351
/* lang_hooks.tree_inlining.anon_aggr_type_p determines whether T is a
352
   type node representing an anonymous aggregate (union, struct, etc),
353
   i.e., one whose members are in the same scope as the union itself.  */
354
 
355
int
356
lhd_tree_inlining_anon_aggr_type_p (tree t ATTRIBUTE_UNUSED)
357
{
358
  return 0;
359
}
360
 
361
/* lang_hooks.tree_inlining.start_inlining and end_inlining perform any
362
   language-specific bookkeeping necessary for processing
363
   FN. start_inlining returns nonzero if inlining should proceed, zero if
364
   not.
365
 
366
   For instance, the C++ version keeps track of template instantiations to
367
   avoid infinite recursion.  */
368
 
369
int
370
lhd_tree_inlining_start_inlining (tree fn ATTRIBUTE_UNUSED)
371
{
372
  return 1;
373
}
374
 
375
void
376
lhd_tree_inlining_end_inlining (tree fn ATTRIBUTE_UNUSED)
377
{
378
}
379
 
380
/* lang_hooks.tree_inlining.convert_parm_for_inlining performs any
381
   language-specific conversion before assigning VALUE to PARM.  */
382
 
383
tree
384
lhd_tree_inlining_convert_parm_for_inlining (tree parm ATTRIBUTE_UNUSED,
385
                                             tree value,
386
                                             tree fndecl ATTRIBUTE_UNUSED,
387
                                             int argnum ATTRIBUTE_UNUSED)
388
{
389
  return value;
390
}
391
 
392
/* lang_hooks.tree_dump.dump_tree:  Dump language-specific parts of tree
393
   nodes.  Returns nonzero if it does not want the usual dumping of the
394
   second argument.  */
395
 
396
bool
397
lhd_tree_dump_dump_tree (void *di ATTRIBUTE_UNUSED, tree t ATTRIBUTE_UNUSED)
398
{
399
  return false;
400
}
401
 
402
/* lang_hooks.tree_dump.type_qual:  Determine type qualifiers in a
403
   language-specific way.  */
404
 
405
int
406
lhd_tree_dump_type_quals (tree t)
407
{
408
  return TYPE_QUALS (t);
409
}
410
 
411
/* lang_hooks.expr_size: Determine the size of the value of an expression T
412
   in a language-specific way.  Returns a tree for the size in bytes.  */
413
 
414
tree
415
lhd_expr_size (tree exp)
416
{
417
  if (DECL_P (exp)
418
      && DECL_SIZE_UNIT (exp) != 0)
419
    return DECL_SIZE_UNIT (exp);
420
  else
421
    return size_in_bytes (TREE_TYPE (exp));
422
}
423
 
424
/* lang_hooks.gimplify_expr re-writes *EXPR_P into GIMPLE form.  */
425
 
426
int
427
lhd_gimplify_expr (tree *expr_p ATTRIBUTE_UNUSED, tree *pre_p ATTRIBUTE_UNUSED,
428
                   tree *post_p ATTRIBUTE_UNUSED)
429
{
430
  return GS_UNHANDLED;
431
}
432
 
433
/* lang_hooks.tree_size: Determine the size of a tree with code C,
434
   which is a language-specific tree code in category tcc_constant or
435
   tcc_exceptional.  The default expects never to be called.  */
436
size_t
437
lhd_tree_size (enum tree_code c ATTRIBUTE_UNUSED)
438
{
439
  gcc_unreachable ();
440
}
441
 
442
/* Return true if decl, which is a function decl, may be called by a
443
   sibcall.  */
444
 
445
bool
446
lhd_decl_ok_for_sibcall (tree decl ATTRIBUTE_UNUSED)
447
{
448
  return true;
449
}
450
 
451
/* Return the COMDAT group into which DECL should be placed.  */
452
 
453
const char *
454
lhd_comdat_group (tree decl)
455
{
456
  return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
457
}
458
 
459
/* lang_hooks.decls.final_write_globals: perform final processing on
460
   global variables.  */
461
void
462
write_global_declarations (void)
463
{
464
  /* Really define vars that have had only a tentative definition.
465
     Really output inline functions that must actually be callable
466
     and have not been output so far.  */
467
 
468
  tree globals = lang_hooks.decls.getdecls ();
469
  int len = list_length (globals);
470
  tree *vec = xmalloc (sizeof (tree) * len);
471
  int i;
472
  tree decl;
473
 
474
  /* Process the decls in reverse order--earliest first.
475
     Put them into VEC from back to front, then take out from front.  */
476
 
477
  for (i = 0, decl = globals; i < len; i++, decl = TREE_CHAIN (decl))
478
    vec[len - i - 1] = decl;
479
 
480
  wrapup_global_declarations (vec, len);
481
  check_global_declarations (vec, len);
482
  emit_debug_global_declarations (vec, len);
483
 
484
  /* Clean up.  */
485
  free (vec);
486
}
487
 
488
/* Called to perform language-specific initialization of CTX.  */
489
void
490
lhd_initialize_diagnostics (struct diagnostic_context *ctx ATTRIBUTE_UNUSED)
491
{
492
}
493
 
494
/* The default function to print out name of current function that caused
495
   an error.  */
496
void
497
lhd_print_error_function (diagnostic_context *context, const char *file)
498
{
499
  if (diagnostic_last_function_changed (context))
500
    {
501
      const char *old_prefix = context->printer->prefix;
502
      char *new_prefix = file ? file_name_as_prefix (file) : NULL;
503
 
504
      pp_set_prefix (context->printer, new_prefix);
505
 
506
      if (current_function_decl == NULL)
507
        pp_printf (context->printer, _("At top level:"));
508
      else
509
        {
510
          if (TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE)
511
            pp_printf
512
              (context->printer, _("In member function %qs:"),
513
               lang_hooks.decl_printable_name (current_function_decl, 2));
514
          else
515
            pp_printf
516
              (context->printer, _("In function %qs:"),
517
               lang_hooks.decl_printable_name (current_function_decl, 2));
518
        }
519
 
520
      diagnostic_set_last_function (context);
521
      pp_flush (context->printer);
522
      context->printer->prefix = old_prefix;
523
      free ((char*) new_prefix);
524
    }
525
}
526
 
527
tree
528
lhd_callgraph_analyze_expr (tree *tp ATTRIBUTE_UNUSED,
529
                            int *walk_subtrees ATTRIBUTE_UNUSED,
530
                            tree decl ATTRIBUTE_UNUSED)
531
{
532
  return NULL;
533
}
534
 
535
tree
536
lhd_make_node (enum tree_code code)
537
{
538
  return make_node (code);
539
}
540
 
541
HOST_WIDE_INT
542
lhd_to_target_charset (HOST_WIDE_INT c)
543
{
544
  return c;
545
}
546
 
547
tree
548
lhd_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED,
549
                  bool *ti ATTRIBUTE_UNUSED, bool *se ATTRIBUTE_UNUSED)
550
{
551
  return expr;
552
}

powered by: WebSVN 2.1.0

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