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

Subversion Repositories openrisc_me

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

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 280 jeremybenn
/* Tree lowering pass.  This pass gimplifies the tree representation built
2
   by the C-based front ends.  The structure of gimplified, or
3
   language-independent, trees is dictated by the grammar described in this
4
   file.
5
   Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008
6
   Free Software Foundation, Inc.
7
   Lowering of expressions contributed by Sebastian Pop <s.pop@laposte.net>
8
   Re-written to support lowering of whole function trees, documentation
9
   and miscellaneous cleanups by Diego Novillo <dnovillo@redhat.com>
10
 
11
This file is part of GCC.
12
 
13
GCC is free software; you can redistribute it and/or modify it under
14
the terms of the GNU General Public License as published by the Free
15
Software Foundation; either version 3, or (at your option) any later
16
version.
17
 
18
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
19
WARRANTY; without even the implied warranty of MERCHANTABILITY or
20
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
21
for more details.
22
 
23
You should have received a copy of the GNU General Public License
24
along with GCC; see the file COPYING3.  If not see
25
<http://www.gnu.org/licenses/>.  */
26
 
27
#include "config.h"
28
#include "system.h"
29
#include "coretypes.h"
30
#include "tm.h"
31
#include "tree.h"
32
#include "varray.h"
33
#include "c-tree.h"
34
#include "c-common.h"
35
#include "gimple.h"
36
#include "hard-reg-set.h"
37
#include "basic-block.h"
38
#include "tree-flow.h"
39
#include "tree-inline.h"
40
#include "diagnostic.h"
41
#include "langhooks.h"
42
#include "langhooks-def.h"
43
#include "flags.h"
44
#include "rtl.h"
45
#include "toplev.h"
46
#include "tree-dump.h"
47
#include "c-pretty-print.h"
48
#include "cgraph.h"
49
 
50
 
51
/*  The gimplification pass converts the language-dependent trees
52
    (ld-trees) emitted by the parser into language-independent trees
53
    (li-trees) that are the target of SSA analysis and transformations.
54
 
55
    Language-independent trees are based on the SIMPLE intermediate
56
    representation used in the McCAT compiler framework:
57
 
58
    "Designing the McCAT Compiler Based on a Family of Structured
59
    Intermediate Representations,"
60
    L. Hendren, C. Donawa, M. Emami, G. Gao, Justiani, and B. Sridharan,
61
    Proceedings of the 5th International Workshop on Languages and
62
    Compilers for Parallel Computing, no. 757 in Lecture Notes in
63
    Computer Science, New Haven, Connecticut, pp. 406-420,
64
    Springer-Verlag, August 3-5, 1992.
65
 
66
    http://www-acaps.cs.mcgill.ca/info/McCAT/McCAT.html
67
 
68
    Basically, we walk down gimplifying the nodes that we encounter.  As we
69
    walk back up, we check that they fit our constraints, and copy them
70
    into temporaries if not.  */
71
 
72
/* Gimplification of statement trees.  */
73
 
74
/* Convert the tree representation of FNDECL from C frontend trees to
75
   GENERIC.  */
76
 
77
void
78
c_genericize (tree fndecl)
79
{
80
  FILE *dump_orig;
81
  int local_dump_flags;
82
  struct cgraph_node *cgn;
83
 
84
  /* Dump the C-specific tree IR.  */
85
  dump_orig = dump_begin (TDI_original, &local_dump_flags);
86
  if (dump_orig)
87
    {
88
      fprintf (dump_orig, "\n;; Function %s",
89
               lang_hooks.decl_printable_name (fndecl, 2));
90
      fprintf (dump_orig, " (%s)\n",
91
               (!DECL_ASSEMBLER_NAME_SET_P (fndecl) ? "null"
92
                : IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl))));
93
      fprintf (dump_orig, ";; enabled by -%s\n", dump_flag_name (TDI_original));
94
      fprintf (dump_orig, "\n");
95
 
96
      if (local_dump_flags & TDF_RAW)
97
        dump_node (DECL_SAVED_TREE (fndecl),
98
                   TDF_SLIM | local_dump_flags, dump_orig);
99
      else
100
        print_c_tree (dump_orig, DECL_SAVED_TREE (fndecl));
101
      fprintf (dump_orig, "\n");
102
 
103
      dump_end (TDI_original, dump_orig);
104
    }
105
 
106
  /* Dump all nested functions now.  */
107
  cgn = cgraph_node (fndecl);
108
  for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
109
    c_genericize (cgn->decl);
110
}
111
 
112
static void
113
add_block_to_enclosing (tree block)
114
{
115
  unsigned i;
116
  tree enclosing;
117
  gimple bind;
118
  VEC(gimple, heap) *stack = gimple_bind_expr_stack ();
119
 
120
  for (i = 0; VEC_iterate (gimple, stack, i, bind); i++)
121
    if (gimple_bind_block (bind))
122
      break;
123
 
124
  enclosing = gimple_bind_block (bind);
125
  BLOCK_SUBBLOCKS (enclosing) = chainon (BLOCK_SUBBLOCKS (enclosing), block);
126
}
127
 
128
/* Genericize a scope by creating a new BIND_EXPR.
129
   BLOCK is either a BLOCK representing the scope or a chain of _DECLs.
130
     In the latter case, we need to create a new BLOCK and add it to the
131
     BLOCK_SUBBLOCKS of the enclosing block.
132
   BODY is a chain of C _STMT nodes for the contents of the scope, to be
133
     genericized.  */
134
 
135
tree
136
c_build_bind_expr (location_t loc, tree block, tree body)
137
{
138
  tree decls, bind;
139
 
140
  if (block == NULL_TREE)
141
    decls = NULL_TREE;
142
  else if (TREE_CODE (block) == BLOCK)
143
    decls = BLOCK_VARS (block);
144
  else
145
    {
146
      decls = block;
147
      if (DECL_ARTIFICIAL (decls))
148
        block = NULL_TREE;
149
      else
150
        {
151
          block = make_node (BLOCK);
152
          BLOCK_VARS (block) = decls;
153
          add_block_to_enclosing (block);
154
        }
155
    }
156
 
157
  if (!body)
158
    body = build_empty_stmt (loc);
159
  if (decls || block)
160
    {
161
      bind = build3 (BIND_EXPR, void_type_node, decls, body, block);
162
      TREE_SIDE_EFFECTS (bind) = 1;
163
      SET_EXPR_LOCATION (bind, loc);
164
    }
165
  else
166
    bind = body;
167
 
168
  return bind;
169
}
170
 
171
/* Gimplification of expression trees.  */
172
 
173
/* Do C-specific gimplification on *EXPR_P.  PRE_P and POST_P are as in
174
   gimplify_expr.  */
175
 
176
int
177
c_gimplify_expr (tree *expr_p, gimple_seq *pre_p ATTRIBUTE_UNUSED,
178
                 gimple_seq *post_p ATTRIBUTE_UNUSED)
179
{
180
  enum tree_code code = TREE_CODE (*expr_p);
181
 
182
  /* This is handled mostly by gimplify.c, but we have to deal with
183
     not warning about int x = x; as it is a GCC extension to turn off
184
     this warning but only if warn_init_self is zero.  */
185
  if (code == DECL_EXPR
186
      && TREE_CODE (DECL_EXPR_DECL (*expr_p)) == VAR_DECL
187
      && !DECL_EXTERNAL (DECL_EXPR_DECL (*expr_p))
188
      && !TREE_STATIC (DECL_EXPR_DECL (*expr_p))
189
      && (DECL_INITIAL (DECL_EXPR_DECL (*expr_p)) == DECL_EXPR_DECL (*expr_p))
190
      && !warn_init_self)
191
    TREE_NO_WARNING (DECL_EXPR_DECL (*expr_p)) = 1;
192
 
193
  return GS_UNHANDLED;
194
}

powered by: WebSVN 2.1.0

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