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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [tree-iterator.c] - Blame information for rev 753

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


/* Iterator routines for manipulating GENERIC and GIMPLE tree statements.
   Copyright (C) 2003, 2004, 2007, 2008, 2009, 2010
   Free Software Foundation, Inc.
   Contributed by Andrew MacLeod  <amacleod@redhat.com>
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
 
GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tree.h"
#include "gimple.h"
#include "tree-iterator.h"
#include "ggc.h"
 
 
/* This is a cache of STATEMENT_LIST nodes.  We create and destroy them
   fairly often during gimplification.  */
 
static GTY ((deletable (""))) VEC(tree,gc) *stmt_list_cache;
 
tree
alloc_stmt_list (void)
{
  tree list;
  if (!VEC_empty (tree, stmt_list_cache))
    {
      list = VEC_pop (tree, stmt_list_cache);
      memset (list, 0, sizeof(struct tree_base));
      TREE_SET_CODE (list, STATEMENT_LIST);
    }
  else
    list = make_node (STATEMENT_LIST);
  TREE_TYPE (list) = void_type_node;
  return list;
}
 
void
free_stmt_list (tree t)
{
  gcc_assert (!STATEMENT_LIST_HEAD (t));
  gcc_assert (!STATEMENT_LIST_TAIL (t));
  VEC_safe_push (tree, gc, stmt_list_cache, t);
}
 
/* A subroutine of append_to_statement_list{,_force}.  T is not NULL.  */
 
static void
append_to_statement_list_1 (tree t, tree *list_p)
{
  tree list = *list_p;
  tree_stmt_iterator i;
 
  if (!list)
    {
      if (t && TREE_CODE (t) == STATEMENT_LIST)
        {
          *list_p = t;
          return;
        }
      *list_p = list = alloc_stmt_list ();
    }
 
  i = tsi_last (list);
  tsi_link_after (&i, t, TSI_CONTINUE_LINKING);
}
 
/* Add T to the end of the list container pointed to by LIST_P.
   If T is an expression with no effects, it is ignored.  */
 
void
append_to_statement_list (tree t, tree *list_p)
{
  if (t && TREE_SIDE_EFFECTS (t))
    append_to_statement_list_1 (t, list_p);
}
 
/* Similar, but the statement is always added, regardless of side effects.  */
 
void
append_to_statement_list_force (tree t, tree *list_p)
{
  if (t != NULL_TREE)
    append_to_statement_list_1 (t, list_p);
}
 
/* Links a statement, or a chain of statements, before the current stmt.  */
 
void
tsi_link_before (tree_stmt_iterator *i, tree t, enum tsi_iterator_update mode)
{
  struct tree_statement_list_node *head, *tail, *cur;
 
  /* Die on looping.  */
  gcc_assert (t != i->container);
 
  if (TREE_CODE (t) == STATEMENT_LIST)
    {
      head = STATEMENT_LIST_HEAD (t);
      tail = STATEMENT_LIST_TAIL (t);
      STATEMENT_LIST_HEAD (t) = NULL;
      STATEMENT_LIST_TAIL (t) = NULL;
 
      free_stmt_list (t);
 
      /* Empty statement lists need no work.  */
      if (!head || !tail)
        {
          gcc_assert (head == tail);
          return;
        }
    }
  else
    {
      head = ggc_alloc_tree_statement_list_node ();
      head->prev = NULL;
      head->next = NULL;
      head->stmt = t;
      tail = head;
    }
 
  TREE_SIDE_EFFECTS (i->container) = 1;
 
  cur = i->ptr;
 
  /* Link it into the list.  */
  if (cur)
    {
      head->prev = cur->prev;
      if (head->prev)
        head->prev->next = head;
      else
        STATEMENT_LIST_HEAD (i->container) = head;
      tail->next = cur;
      cur->prev = tail;
    }
  else
    {
      head->prev = STATEMENT_LIST_TAIL (i->container);
      if (head->prev)
       head->prev->next = head;
      else
       STATEMENT_LIST_HEAD (i->container) = head;
      STATEMENT_LIST_TAIL (i->container) = tail;
    }
 
  /* Update the iterator, if requested.  */
  switch (mode)
    {
    case TSI_NEW_STMT:
    case TSI_CONTINUE_LINKING:
    case TSI_CHAIN_START:
      i->ptr = head;
      break;
    case TSI_CHAIN_END:
      i->ptr = tail;
      break;
    case TSI_SAME_STMT:
      break;
    }
}
 
/* Links a statement, or a chain of statements, after the current stmt.  */
 
void
tsi_link_after (tree_stmt_iterator *i, tree t, enum tsi_iterator_update mode)
{
  struct tree_statement_list_node *head, *tail, *cur;
 
  /* Die on looping.  */
  gcc_assert (t != i->container);
 
  if (TREE_CODE (t) == STATEMENT_LIST)
    {
      head = STATEMENT_LIST_HEAD (t);
      tail = STATEMENT_LIST_TAIL (t);
      STATEMENT_LIST_HEAD (t) = NULL;
      STATEMENT_LIST_TAIL (t) = NULL;
 
      free_stmt_list (t);
 
      /* Empty statement lists need no work.  */
      if (!head || !tail)
        {
          gcc_assert (head == tail);
          return;
        }
    }
  else
    {
      head = ggc_alloc_tree_statement_list_node ();
      head->prev = NULL;
      head->next = NULL;
      head->stmt = t;
      tail = head;
    }
 
  TREE_SIDE_EFFECTS (i->container) = 1;
 
  cur = i->ptr;
 
  /* Link it into the list.  */
  if (cur)
    {
      tail->next = cur->next;
      if (tail->next)
        tail->next->prev = tail;
      else
        STATEMENT_LIST_TAIL (i->container) = tail;
      head->prev = cur;
      cur->next = head;
    }
  else
    {
      gcc_assert (!STATEMENT_LIST_TAIL (i->container));
      STATEMENT_LIST_HEAD (i->container) = head;
      STATEMENT_LIST_TAIL (i->container) = tail;
    }
 
  /* Update the iterator, if requested.  */
  switch (mode)
    {
    case TSI_NEW_STMT:
    case TSI_CHAIN_START:
      i->ptr = head;
      break;
    case TSI_CONTINUE_LINKING:
    case TSI_CHAIN_END:
      i->ptr = tail;
      break;
    case TSI_SAME_STMT:
      gcc_assert (cur);
      break;
    }
}
 
/* Remove a stmt from the tree list.  The iterator is updated to point to
   the next stmt.  */
 
void
tsi_delink (tree_stmt_iterator *i)
{
  struct tree_statement_list_node *cur, *next, *prev;
 
  cur = i->ptr;
  next = cur->next;
  prev = cur->prev;
 
  if (prev)
    prev->next = next;
  else
    STATEMENT_LIST_HEAD (i->container) = next;
  if (next)
    next->prev = prev;
  else
    STATEMENT_LIST_TAIL (i->container) = prev;
 
  if (!next && !prev)
    TREE_SIDE_EFFECTS (i->container) = 0;
 
  i->ptr = next;
}
 
/* Return the first expression in a sequence of COMPOUND_EXPRs,
   or in a STATEMENT_LIST.  */
 
tree
expr_first (tree expr)
{
  if (expr == NULL_TREE)
    return expr;
 
  if (TREE_CODE (expr) == STATEMENT_LIST)
    {
      struct tree_statement_list_node *n = STATEMENT_LIST_HEAD (expr);
      return n ? n->stmt : NULL_TREE;
    }
 
  while (TREE_CODE (expr) == COMPOUND_EXPR)
    expr = TREE_OPERAND (expr, 0);
 
  return expr;
}
 
/* Return the last expression in a sequence of COMPOUND_EXPRs,
   or in a STATEMENT_LIST.  */
 
tree
expr_last (tree expr)
{
  if (expr == NULL_TREE)
    return expr;
 
  if (TREE_CODE (expr) == STATEMENT_LIST)
    {
      struct tree_statement_list_node *n = STATEMENT_LIST_TAIL (expr);
      return n ? n->stmt : NULL_TREE;
    }
 
  while (TREE_CODE (expr) == COMPOUND_EXPR)
    expr = TREE_OPERAND (expr, 1);
 
  return expr;
}
 
#include "gt-tree-iterator.h"

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [tree-iterator.c] - Blame information for rev 753

Line No.	Rev	Author	Line
1	684	jeremybenn	`/* Iterator routines for manipulating GENERIC and GIMPLE tree statements.`
2			`Copyright (C) 2003, 2004, 2007, 2008, 2009, 2010`
3			`Free Software Foundation, Inc.`
4			`Contributed by Andrew MacLeod <amacleod@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 "tree.h"`
26			`#include "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 (""))) VEC(tree,gc) *stmt_list_cache;`
35
36			`tree`
37			`alloc_stmt_list (void)`
38			`{`
39			`tree list;`
40			`if (!VEC_empty (tree, stmt_list_cache))`
41			`{`
42			`list = VEC_pop (tree, stmt_list_cache);`
43			`memset (list, 0, sizeof(struct tree_base));`
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			`VEC_safe_push (tree, gc, stmt_list_cache, t);`
58			`}`
59
60			`/* A subroutine of append_to_statement_list{,_force}. T is not NULL. */`
61
62			`static void`
63			`append_to_statement_list_1 (tree t, tree *list_p)`
64			`{`
65			`tree list = *list_p;`
66			`tree_stmt_iterator i;`
67
68			`if (!list)`
69			`{`
70			`if (t && TREE_CODE (t) == STATEMENT_LIST)`
71			`{`
72			`*list_p = t;`
73			`return;`
74			`}`
75			`*list_p = list = alloc_stmt_list ();`
76			`}`
77
78			`i = tsi_last (list);`
79			`tsi_link_after (&i, t, TSI_CONTINUE_LINKING);`
80			`}`
81
82			`/* Add T to the end of the list container pointed to by LIST_P.`
83			`If T is an expression with no effects, it is ignored. */`
84
85			`void`
86			`append_to_statement_list (tree t, tree *list_p)`
87			`{`
88			`if (t && TREE_SIDE_EFFECTS (t))`
89			`append_to_statement_list_1 (t, list_p);`
90			`}`
91
92			`/* Similar, but the statement is always added, regardless of side effects. */`
93
94			`void`
95			`append_to_statement_list_force (tree t, tree *list_p)`
96			`{`
97			`if (t != NULL_TREE)`
98			`append_to_statement_list_1 (t, list_p);`
99			`}`
100
101			`/* Links a statement, or a chain of statements, before the current stmt. */`
102
103			`void`
104			`tsi_link_before (tree_stmt_iterator *i, tree t, enum tsi_iterator_update mode)`
105			`{`
106			`struct tree_statement_list_node head, tail, *cur;`
107
108			`/* Die on looping. */`
109			`gcc_assert (t != i->container);`
110
111			`if (TREE_CODE (t) == STATEMENT_LIST)`
112			`{`
113			`head = STATEMENT_LIST_HEAD (t);`
114			`tail = STATEMENT_LIST_TAIL (t);`
115			`STATEMENT_LIST_HEAD (t) = NULL;`
116			`STATEMENT_LIST_TAIL (t) = NULL;`
117
118			`free_stmt_list (t);`
119
120			`/* Empty statement lists need no work. */`
121			`if (!head \|\| !tail)`
122			`{`
123			`gcc_assert (head == tail);`
124			`return;`
125			`}`
126			`}`
127			`else`
128			`{`
129			`head = ggc_alloc_tree_statement_list_node ();`
130			`head->prev = NULL;`
131			`head->next = NULL;`
132			`head->stmt = t;`
133			`tail = head;`
134			`}`
135
136			`TREE_SIDE_EFFECTS (i->container) = 1;`
137
138			`cur = i->ptr;`
139
140			`/* Link it into the list. */`
141			`if (cur)`
142			`{`
143			`head->prev = cur->prev;`
144			`if (head->prev)`
145			`head->prev->next = head;`
146			`else`
147			`STATEMENT_LIST_HEAD (i->container) = head;`
148			`tail->next = cur;`
149			`cur->prev = tail;`
150			`}`
151			`else`
152			`{`
153			`head->prev = STATEMENT_LIST_TAIL (i->container);`
154			`if (head->prev)`
155			`head->prev->next = head;`
156			`else`
157			`STATEMENT_LIST_HEAD (i->container) = head;`
158			`STATEMENT_LIST_TAIL (i->container) = tail;`
159			`}`
160
161			`/* Update the iterator, if requested. */`
162			`switch (mode)`
163			`{`
164			`case TSI_NEW_STMT:`
165			`case TSI_CONTINUE_LINKING:`
166			`case TSI_CHAIN_START:`
167			`i->ptr = head;`
168			`break;`
169			`case TSI_CHAIN_END:`
170			`i->ptr = tail;`
171			`break;`
172			`case TSI_SAME_STMT:`
173			`break;`
174			`}`
175			`}`
176
177			`/* Links a statement, or a chain of statements, after the current stmt. */`
178
179			`void`
180			`tsi_link_after (tree_stmt_iterator *i, tree t, enum tsi_iterator_update mode)`
181			`{`
182			`struct tree_statement_list_node head, tail, *cur;`
183
184			`/* Die on looping. */`
185			`gcc_assert (t != i->container);`
186
187			`if (TREE_CODE (t) == STATEMENT_LIST)`
188			`{`
189			`head = STATEMENT_LIST_HEAD (t);`
190			`tail = STATEMENT_LIST_TAIL (t);`
191			`STATEMENT_LIST_HEAD (t) = NULL;`
192			`STATEMENT_LIST_TAIL (t) = NULL;`
193
194			`free_stmt_list (t);`
195
196			`/* Empty statement lists need no work. */`
197			`if (!head \|\| !tail)`
198			`{`
199			`gcc_assert (head == tail);`
200			`return;`
201			`}`
202			`}`
203			`else`
204			`{`
205			`head = ggc_alloc_tree_statement_list_node ();`
206			`head->prev = NULL;`
207			`head->next = NULL;`
208			`head->stmt = t;`
209			`tail = head;`
210			`}`
211
212			`TREE_SIDE_EFFECTS (i->container) = 1;`
213
214			`cur = i->ptr;`
215
216			`/* Link it into the list. */`
217			`if (cur)`
218			`{`
219			`tail->next = cur->next;`
220			`if (tail->next)`
221			`tail->next->prev = tail;`
222			`else`
223			`STATEMENT_LIST_TAIL (i->container) = tail;`
224			`head->prev = cur;`
225			`cur->next = head;`
226			`}`
227			`else`
228			`{`
229			`gcc_assert (!STATEMENT_LIST_TAIL (i->container));`
230			`STATEMENT_LIST_HEAD (i->container) = head;`
231			`STATEMENT_LIST_TAIL (i->container) = tail;`
232			`}`
233
234			`/* Update the iterator, if requested. */`
235			`switch (mode)`
236			`{`
237			`case TSI_NEW_STMT:`
238			`case TSI_CHAIN_START:`
239			`i->ptr = head;`
240			`break;`
241			`case TSI_CONTINUE_LINKING:`
242			`case TSI_CHAIN_END:`
243			`i->ptr = tail;`
244			`break;`
245			`case TSI_SAME_STMT:`
246			`gcc_assert (cur);`
247			`break;`
248			`}`
249			`}`
250
251			`/* Remove a stmt from the tree list. The iterator is updated to point to`
252			`the next stmt. */`
253
254			`void`
255			`tsi_delink (tree_stmt_iterator *i)`
256			`{`
257			`struct tree_statement_list_node cur, next, *prev;`
258
259			`cur = i->ptr;`
260			`next = cur->next;`
261			`prev = cur->prev;`
262
263			`if (prev)`
264			`prev->next = next;`
265			`else`
266			`STATEMENT_LIST_HEAD (i->container) = next;`
267			`if (next)`
268			`next->prev = prev;`
269			`else`
270			`STATEMENT_LIST_TAIL (i->container) = prev;`
271
272			`if (!next && !prev)`
273			`TREE_SIDE_EFFECTS (i->container) = 0;`
274
275			`i->ptr = next;`
276			`}`
277
278			`/* Return the first expression in a sequence of COMPOUND_EXPRs,`
279			`or in a STATEMENT_LIST. */`
280
281			`tree`
282			`expr_first (tree expr)`
283			`{`
284			`if (expr == NULL_TREE)`
285			`return expr;`
286
287			`if (TREE_CODE (expr) == STATEMENT_LIST)`
288			`{`
289			`struct tree_statement_list_node *n = STATEMENT_LIST_HEAD (expr);`
290			`return n ? n->stmt : NULL_TREE;`
291			`}`
292
293			`while (TREE_CODE (expr) == COMPOUND_EXPR)`
294			`expr = TREE_OPERAND (expr, 0);`
295
296			`return expr;`
297			`}`
298
299			`/* Return the last expression in a sequence of COMPOUND_EXPRs,`
300			`or in a STATEMENT_LIST. */`
301
302			`tree`
303			`expr_last (tree expr)`
304			`{`
305			`if (expr == NULL_TREE)`
306			`return expr;`
307
308			`if (TREE_CODE (expr) == STATEMENT_LIST)`
309			`{`
310			`struct tree_statement_list_node *n = STATEMENT_LIST_TAIL (expr);`
311			`return n ? n->stmt : NULL_TREE;`
312			`}`
313
314			`while (TREE_CODE (expr) == COMPOUND_EXPR)`
315			`expr = TREE_OPERAND (expr, 1);`
316
317			`return expr;`
318			`}`
319
320			`#include "gt-tree-iterator.h"`