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

Subversion Repositories scarts

[/] [scarts/] [trunk/] [toolchain/] [scarts-gcc/] [gcc-4.1.1/] [gcc/] [tree-iterator.c] - Blame information for rev 20

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

Line No. Rev Author Line
1 12 jlechner
/* Iterator routines for manipulating GENERIC and GIMPLE tree statements.
2
   Copyright (C) 2003, 2004 Free Software Foundation, Inc.
3
   Contributed by Andrew MacLeod  <amacleod@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 "tree.h"
26
#include "tree-gimple.h"
27
#include "tree-iterator.h"
28
#include "ggc.h"
29
 
30
 
31
/* This is a cache of STATEMENT_LIST nodes.  We create and destroy them
32
   fairly often during gimplification.  */
33
 
34
static GTY ((deletable (""))) tree stmt_list_cache;
35
 
36
tree
37
alloc_stmt_list (void)
38
{
39
  tree list = stmt_list_cache;
40
  if (list)
41
    {
42
      stmt_list_cache = TREE_CHAIN (list);
43
      memset (list, 0, sizeof(struct tree_common));
44
      TREE_SET_CODE (list, STATEMENT_LIST);
45
    }
46
  else
47
    list = make_node (STATEMENT_LIST);
48
  TREE_TYPE (list) = void_type_node;
49
  return list;
50
}
51
 
52
void
53
free_stmt_list (tree t)
54
{
55
  gcc_assert (!STATEMENT_LIST_HEAD (t));
56
  gcc_assert (!STATEMENT_LIST_TAIL (t));
57
  TREE_CHAIN (t) = stmt_list_cache;
58
  stmt_list_cache = t;
59
}
60
 
61
/* Links a statement, or a chain of statements, before the current stmt.  */
62
 
63
void
64
tsi_link_before (tree_stmt_iterator *i, tree t, enum tsi_iterator_update mode)
65
{
66
  struct tree_statement_list_node *head, *tail, *cur;
67
 
68
  /* Die on looping.  */
69
  gcc_assert (t != i->container);
70
 
71
  if (TREE_CODE (t) == STATEMENT_LIST)
72
    {
73
      head = STATEMENT_LIST_HEAD (t);
74
      tail = STATEMENT_LIST_TAIL (t);
75
      STATEMENT_LIST_HEAD (t) = NULL;
76
      STATEMENT_LIST_TAIL (t) = NULL;
77
 
78
      free_stmt_list (t);
79
 
80
      /* Empty statement lists need no work.  */
81
      if (!head || !tail)
82
        {
83
          gcc_assert (head == tail);
84
          return;
85
        }
86
    }
87
  else
88
    {
89
      head = ggc_alloc (sizeof (*head));
90
      head->prev = NULL;
91
      head->next = NULL;
92
      head->stmt = t;
93
      tail = head;
94
    }
95
 
96
  TREE_SIDE_EFFECTS (i->container) = 1;
97
 
98
  cur = i->ptr;
99
 
100
  /* Link it into the list.  */
101
  if (cur)
102
    {
103
      head->prev = cur->prev;
104
      if (head->prev)
105
        head->prev->next = head;
106
      else
107
        STATEMENT_LIST_HEAD (i->container) = head;
108
      tail->next = cur;
109
      cur->prev = tail;
110
    }
111
  else
112
    {
113
      head->prev = STATEMENT_LIST_TAIL (i->container);
114
      if (head->prev)
115
       head->prev->next = head;
116
      else
117
       STATEMENT_LIST_HEAD (i->container) = head;
118
      STATEMENT_LIST_TAIL (i->container) = tail;
119
    }
120
 
121
  /* Update the iterator, if requested.  */
122
  switch (mode)
123
    {
124
    case TSI_NEW_STMT:
125
    case TSI_CONTINUE_LINKING:
126
    case TSI_CHAIN_START:
127
      i->ptr = head;
128
      break;
129
    case TSI_CHAIN_END:
130
      i->ptr = tail;
131
      break;
132
    case TSI_SAME_STMT:
133
      break;
134
    }
135
}
136
 
137
/* Links a statement, or a chain of statements, after the current stmt.  */
138
 
139
void
140
tsi_link_after (tree_stmt_iterator *i, tree t, enum tsi_iterator_update mode)
141
{
142
  struct tree_statement_list_node *head, *tail, *cur;
143
 
144
  /* Die on looping.  */
145
  gcc_assert (t != i->container);
146
 
147
  if (TREE_CODE (t) == STATEMENT_LIST)
148
    {
149
      head = STATEMENT_LIST_HEAD (t);
150
      tail = STATEMENT_LIST_TAIL (t);
151
      STATEMENT_LIST_HEAD (t) = NULL;
152
      STATEMENT_LIST_TAIL (t) = NULL;
153
 
154
      free_stmt_list (t);
155
 
156
      /* Empty statement lists need no work.  */
157
      if (!head || !tail)
158
        {
159
          gcc_assert (head == tail);
160
          return;
161
        }
162
    }
163
  else
164
    {
165
      head = ggc_alloc (sizeof (*head));
166
      head->prev = NULL;
167
      head->next = NULL;
168
      head->stmt = t;
169
      tail = head;
170
    }
171
 
172
  TREE_SIDE_EFFECTS (i->container) = 1;
173
 
174
  cur = i->ptr;
175
 
176
  /* Link it into the list.  */
177
  if (cur)
178
    {
179
      tail->next = cur->next;
180
      if (tail->next)
181
        tail->next->prev = tail;
182
      else
183
        STATEMENT_LIST_TAIL (i->container) = tail;
184
      head->prev = cur;
185
      cur->next = head;
186
    }
187
  else
188
    {
189
      gcc_assert (!STATEMENT_LIST_TAIL (i->container));
190
      STATEMENT_LIST_HEAD (i->container) = head;
191
      STATEMENT_LIST_TAIL (i->container) = tail;
192
    }
193
 
194
  /* Update the iterator, if requested.  */
195
  switch (mode)
196
    {
197
    case TSI_NEW_STMT:
198
    case TSI_CHAIN_START:
199
      i->ptr = head;
200
      break;
201
    case TSI_CONTINUE_LINKING:
202
    case TSI_CHAIN_END:
203
      i->ptr = tail;
204
      break;
205
    case TSI_SAME_STMT:
206
      gcc_assert (cur);
207
      break;
208
    }
209
}
210
 
211
/* Remove a stmt from the tree list.  The iterator is updated to point to
212
   the next stmt.  */
213
 
214
void
215
tsi_delink (tree_stmt_iterator *i)
216
{
217
  struct tree_statement_list_node *cur, *next, *prev;
218
 
219
  cur = i->ptr;
220
  next = cur->next;
221
  prev = cur->prev;
222
 
223
  if (prev)
224
    prev->next = next;
225
  else
226
    STATEMENT_LIST_HEAD (i->container) = next;
227
  if (next)
228
    next->prev = prev;
229
  else
230
    STATEMENT_LIST_TAIL (i->container) = prev;
231
 
232
  if (!next && !prev)
233
    TREE_SIDE_EFFECTS (i->container) = 0;
234
 
235
  i->ptr = next;
236
}
237
 
238
/* Move all statements in the statement list after I to a new
239
   statement list.  I itself is unchanged.  */
240
 
241
tree
242
tsi_split_statement_list_after (const tree_stmt_iterator *i)
243
{
244
  struct tree_statement_list_node *cur, *next;
245
  tree old_sl, new_sl;
246
 
247
  cur = i->ptr;
248
  /* How can we possibly split after the end, or before the beginning?  */
249
  gcc_assert (cur);
250
  next = cur->next;
251
 
252
  old_sl = i->container;
253
  new_sl = alloc_stmt_list ();
254
  TREE_SIDE_EFFECTS (new_sl) = 1;
255
 
256
  STATEMENT_LIST_HEAD (new_sl) = next;
257
  STATEMENT_LIST_TAIL (new_sl) = STATEMENT_LIST_TAIL (old_sl);
258
  STATEMENT_LIST_TAIL (old_sl) = cur;
259
  cur->next = NULL;
260
  next->prev = NULL;
261
 
262
  return new_sl;
263
}
264
 
265
/* Move all statements in the statement list before I to a new
266
   statement list.  I is set to the head of the new list.  */
267
 
268
tree
269
tsi_split_statement_list_before (tree_stmt_iterator *i)
270
{
271
  struct tree_statement_list_node *cur, *prev;
272
  tree old_sl, new_sl;
273
 
274
  cur = i->ptr;
275
  /* How can we possibly split after the end, or before the beginning?  */
276
  gcc_assert (cur);
277
  prev = cur->prev;
278
 
279
  old_sl = i->container;
280
  new_sl = alloc_stmt_list ();
281
  TREE_SIDE_EFFECTS (new_sl) = 1;
282
  i->container = new_sl;
283
 
284
  STATEMENT_LIST_HEAD (new_sl) = cur;
285
  STATEMENT_LIST_TAIL (new_sl) = STATEMENT_LIST_TAIL (old_sl);
286
  STATEMENT_LIST_TAIL (old_sl) = prev;
287
  cur->prev = NULL;
288
  prev->next = NULL;
289
 
290
  return new_sl;
291
}
292
 
293
/* Return the first expression in a sequence of COMPOUND_EXPRs,
294
   or in a STATEMENT_LIST.  */
295
 
296
tree
297
expr_first (tree expr)
298
{
299
  if (expr == NULL_TREE)
300
    return expr;
301
 
302
  if (TREE_CODE (expr) == STATEMENT_LIST)
303
    {
304
      struct tree_statement_list_node *n = STATEMENT_LIST_HEAD (expr);
305
      return n ? n->stmt : NULL_TREE;
306
    }
307
 
308
  while (TREE_CODE (expr) == COMPOUND_EXPR)
309
    expr = TREE_OPERAND (expr, 0);
310
  return expr;
311
}
312
 
313
/* Return the last expression in a sequence of COMPOUND_EXPRs,
314
   or in a STATEMENT_LIST.  */
315
 
316
tree
317
expr_last (tree expr)
318
{
319
  if (expr == NULL_TREE)
320
    return expr;
321
 
322
  if (TREE_CODE (expr) == STATEMENT_LIST)
323
    {
324
      struct tree_statement_list_node *n = STATEMENT_LIST_TAIL (expr);
325
      return n ? n->stmt : NULL_TREE;
326
    }
327
 
328
  while (TREE_CODE (expr) == COMPOUND_EXPR)
329
    expr = TREE_OPERAND (expr, 1);
330
  return expr;
331
}
332
 
333
/* If EXPR is a single statement, naked or in a STATEMENT_LIST, then
334
   return it.  Otherwise return NULL.  */
335
 
336
tree
337
expr_only (tree expr)
338
{
339
  if (expr == NULL_TREE)
340
    return NULL_TREE;
341
 
342
  if (TREE_CODE (expr) == STATEMENT_LIST)
343
    {
344
      struct tree_statement_list_node *n = STATEMENT_LIST_TAIL (expr);
345
      if (n && STATEMENT_LIST_HEAD (expr) == n)
346
        return n->stmt;
347
      else
348
        return NULL_TREE;
349
    }
350
 
351
  if (TREE_CODE (expr) == COMPOUND_EXPR)
352
    return NULL_TREE;
353
 
354
  return expr;
355
}
356
 
357
#include "gt-tree-iterator.h"

powered by: WebSVN 2.1.0

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