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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [c-family/] [c-gimplify.c] - Blame information for rev 708

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

Line No. Rev Author Line
1 707 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, 2009, 2010
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 "c-common.h"
33
#include "gimple.h"
34
#include "basic-block.h"
35
#include "tree-inline.h"
36
#include "diagnostic-core.h"
37
#include "langhooks.h"
38
#include "langhooks-def.h"
39
#include "flags.h"
40
#include "tree-dump.h"
41
#include "c-pretty-print.h"
42
#include "cgraph.h"
43
 
44
 
45
/*  The gimplification pass converts the language-dependent trees
46
    (ld-trees) emitted by the parser into language-independent trees
47
    (li-trees) that are the target of SSA analysis and transformations.
48
 
49
    Language-independent trees are based on the SIMPLE intermediate
50
    representation used in the McCAT compiler framework:
51
 
52
    "Designing the McCAT Compiler Based on a Family of Structured
53
    Intermediate Representations,"
54
    L. Hendren, C. Donawa, M. Emami, G. Gao, Justiani, and B. Sridharan,
55
    Proceedings of the 5th International Workshop on Languages and
56
    Compilers for Parallel Computing, no. 757 in Lecture Notes in
57
    Computer Science, New Haven, Connecticut, pp. 406-420,
58
    Springer-Verlag, August 3-5, 1992.
59
 
60
    http://www-acaps.cs.mcgill.ca/info/McCAT/McCAT.html
61
 
62
    Basically, we walk down gimplifying the nodes that we encounter.  As we
63
    walk back up, we check that they fit our constraints, and copy them
64
    into temporaries if not.  */
65
 
66
/* Gimplification of statement trees.  */
67
 
68
/* Convert the tree representation of FNDECL from C frontend trees to
69
   GENERIC.  */
70
 
71
void
72
c_genericize (tree fndecl)
73
{
74
  FILE *dump_orig;
75
  int local_dump_flags;
76
  struct cgraph_node *cgn;
77
 
78
  /* Dump the C-specific tree IR.  */
79
  dump_orig = dump_begin (TDI_original, &local_dump_flags);
80
  if (dump_orig)
81
    {
82
      fprintf (dump_orig, "\n;; Function %s",
83
               lang_hooks.decl_printable_name (fndecl, 2));
84
      fprintf (dump_orig, " (%s)\n",
85
               (!DECL_ASSEMBLER_NAME_SET_P (fndecl) ? "null"
86
                : IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl))));
87
      fprintf (dump_orig, ";; enabled by -%s\n", dump_flag_name (TDI_original));
88
      fprintf (dump_orig, "\n");
89
 
90
      if (local_dump_flags & TDF_RAW)
91
        dump_node (DECL_SAVED_TREE (fndecl),
92
                   TDF_SLIM | local_dump_flags, dump_orig);
93
      else
94
        print_c_tree (dump_orig, DECL_SAVED_TREE (fndecl));
95
      fprintf (dump_orig, "\n");
96
 
97
      dump_end (TDI_original, dump_orig);
98
    }
99
 
100
  /* Dump all nested functions now.  */
101
  cgn = cgraph_get_create_node (fndecl);
102
  for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
103
    c_genericize (cgn->decl);
104
}
105
 
106
static void
107
add_block_to_enclosing (tree block)
108
{
109
  unsigned i;
110
  tree enclosing;
111
  gimple bind;
112
  VEC(gimple, heap) *stack = gimple_bind_expr_stack ();
113
 
114
  FOR_EACH_VEC_ELT (gimple, stack, i, bind)
115
    if (gimple_bind_block (bind))
116
      break;
117
 
118
  enclosing = gimple_bind_block (bind);
119
  BLOCK_SUBBLOCKS (enclosing) = chainon (BLOCK_SUBBLOCKS (enclosing), block);
120
}
121
 
122
/* Genericize a scope by creating a new BIND_EXPR.
123
   BLOCK is either a BLOCK representing the scope or a chain of _DECLs.
124
     In the latter case, we need to create a new BLOCK and add it to the
125
     BLOCK_SUBBLOCKS of the enclosing block.
126
   BODY is a chain of C _STMT nodes for the contents of the scope, to be
127
     genericized.  */
128
 
129
tree
130
c_build_bind_expr (location_t loc, tree block, tree body)
131
{
132
  tree decls, bind;
133
 
134
  if (block == NULL_TREE)
135
    decls = NULL_TREE;
136
  else if (TREE_CODE (block) == BLOCK)
137
    decls = BLOCK_VARS (block);
138
  else
139
    {
140
      decls = block;
141
      if (DECL_ARTIFICIAL (decls))
142
        block = NULL_TREE;
143
      else
144
        {
145
          block = make_node (BLOCK);
146
          BLOCK_VARS (block) = decls;
147
          add_block_to_enclosing (block);
148
        }
149
    }
150
 
151
  if (!body)
152
    body = build_empty_stmt (loc);
153
  if (decls || block)
154
    {
155
      bind = build3 (BIND_EXPR, void_type_node, decls, body, block);
156
      TREE_SIDE_EFFECTS (bind) = 1;
157
      SET_EXPR_LOCATION (bind, loc);
158
    }
159
  else
160
    bind = body;
161
 
162
  return bind;
163
}
164
 
165
/* Gimplification of expression trees.  */
166
 
167
/* Do C-specific gimplification on *EXPR_P.  PRE_P and POST_P are as in
168
   gimplify_expr.  */
169
 
170
int
171
c_gimplify_expr (tree *expr_p, gimple_seq *pre_p ATTRIBUTE_UNUSED,
172
                 gimple_seq *post_p ATTRIBUTE_UNUSED)
173
{
174
  enum tree_code code = TREE_CODE (*expr_p);
175
 
176
  /* This is handled mostly by gimplify.c, but we have to deal with
177
     not warning about int x = x; as it is a GCC extension to turn off
178
     this warning but only if warn_init_self is zero.  */
179
  if (code == DECL_EXPR
180
      && TREE_CODE (DECL_EXPR_DECL (*expr_p)) == VAR_DECL
181
      && !DECL_EXTERNAL (DECL_EXPR_DECL (*expr_p))
182
      && !TREE_STATIC (DECL_EXPR_DECL (*expr_p))
183
      && (DECL_INITIAL (DECL_EXPR_DECL (*expr_p)) == DECL_EXPR_DECL (*expr_p))
184
      && !warn_init_self)
185
    TREE_NO_WARNING (DECL_EXPR_DECL (*expr_p)) = 1;
186
 
187
  return GS_UNHANDLED;
188
}

powered by: WebSVN 2.1.0

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