c-iterate.c

GCC编译器源代码

/* Build expressions with type checking for C compiler.
   Copyright (C) 1987, 88, 89, 92, 93, 96, 1997 Free Software Foundation, Inc.

This file is part of GNU CC.

GNU CC 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 2, or (at your option)
any later version.

GNU CC 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 GNU CC; see the file COPYING.  If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.  */


/* This file is part of the C front end.
   It is responsible for implementing iterators,
   both their declarations and the expansion of statements using them.  */

#include "config.h"
#include <stdio.h>
#include "tree.h"
#include "c-tree.h"
#include "flags.h"
#include "obstack.h"
#include "rtl.h"

/*
		KEEPING TRACK OF EXPANSIONS

   In order to clean out expansions corresponding to statements inside
   "{(...)}" constructs we have to keep track of all expansions.  The
   cleanup is needed when an automatic, or implicit, expansion on
   iterator, say X, happens to a statement which contains a {(...)}
   form with a statement already expanded on X.  In this case we have
   to go back and cleanup the inner expansion.  This can be further
   complicated by the fact that {(...)} can be nested.

   To make this cleanup possible, we keep lists of all expansions, and
   to make it work for nested constructs, we keep a stack.  The list at
   the top of the stack (ITER_STACK.CURRENT_LEVEL) corresponds to the
   currently parsed level.  All expansions of the levels below the
   current one are kept in one list whose head is pointed to by
   ITER_STACK.SUBLEVEL_FIRST (SUBLEVEL_LAST is there for making merges
   easy).  The process works as follows:

   -- On "({"  a new node is added to the stack by PUSH_ITERATOR_STACK.
	       The sublevel list is not changed at this point.

   -- On "})" the list for the current level is appended to the sublevel
	      list. 

   -- On ";"  sublevel lists are appended to the current level lists.
	      The reason is this: if they have not been superseded by the
	      expansion at the current level, they still might be
	      superseded later by the expansion on the higher level.
	      The levels do not have to distinguish levels below, so we
	      can merge the lists together.  */

struct  ixpansion
{
  tree ixdecl;			/* Iterator decl */
  rtx  ixprologue_start;	/* First insn of epilogue. NULL means */
  /* explicit (FOR) expansion*/
  rtx  ixprologue_end;
  rtx  ixepilogue_start;
  rtx  ixepilogue_end;
  struct ixpansion *next;	/* Next in the list */
};

struct iter_stack_node
{
  struct ixpansion *first;	/* Head of list of ixpansions */
  struct ixpansion *last;	/* Last node in list  of ixpansions */
  struct iter_stack_node *next; /* Next level iterator stack node  */
};

struct iter_stack_node *iter_stack;
struct iter_stack_node sublevel_ixpansions;

/* A special obstack, and a pointer to the start of
   all the data in it (so we can free everything easily).  */
static struct obstack ixp_obstack;
static char *ixp_firstobj;

/* During collect_iterators, a list of SAVE_EXPRs already scanned.  */
static tree save_exprs;

static void expand_stmt_with_iterators_1 PROTO((tree, tree));
static tree collect_iterators		PROTO((tree, tree));
static void iterator_loop_prologue	PROTO((tree, rtx *, rtx *));
static void iterator_loop_epilogue	PROTO((tree, rtx *, rtx *));
static int top_level_ixpansion_p	PROTO((void));
static void isn_append			PROTO((struct iter_stack_node *,
					       struct iter_stack_node *));
static void istack_sublevel_to_current	PROTO((void));
static void add_ixpansion		PROTO((tree, rtx, rtx, rtx, rtx));
static void delete_ixpansion		PROTO((tree));

/* Initialize our obstack once per compilation.  */

void
init_iterators ()
{
  gcc_obstack_init (&ixp_obstack);
  ixp_firstobj = (char *) obstack_alloc (&ixp_obstack, 0);
}

/* Handle the start of an explicit `for' loop for iterator IDECL.  */

void
iterator_for_loop_start (idecl)
     tree idecl;
{
  ITERATOR_BOUND_P (idecl) = 1;
  add_ixpansion (idecl, 0, 0, 0, 0);
  iterator_loop_prologue (idecl, 0, 0);
}

/* Handle the end of an explicit `for' loop for iterator IDECL.  */

void
iterator_for_loop_end (idecl)
     tree idecl;
{
  iterator_loop_epilogue (idecl, 0, 0);
  ITERATOR_BOUND_P (idecl) = 0;
}

/*
  		ITERATOR RTL EXPANSIONS

   Expanding simple statements with iterators is straightforward:
   collect the list of all free iterators in the statement, and
   generate a loop for each of them.

   An iterator is "free" if it has not been "bound" by a FOR
   operator.  The DECL_RTL of the iterator is the loop counter.  */

/* Expand a statement STMT, possibly containing iterator usage, into RTL.  */

void
iterator_expand (stmt)
    tree stmt;
{
  tree iter_list;
  save_exprs = NULL_TREE;
  iter_list = collect_iterators (stmt, NULL_TREE);
  expand_stmt_with_iterators_1 (stmt, iter_list);
  istack_sublevel_to_current ();
}


static void 
expand_stmt_with_iterators_1 (stmt, iter_list)
     tree stmt, iter_list;
{
  if (iter_list == 0)
    expand_expr_stmt (stmt);
  else
    {
      tree current_iterator = TREE_VALUE (iter_list);
      tree iter_list_tail   = TREE_CHAIN (iter_list);
      rtx p_start, p_end, e_start, e_end;

      iterator_loop_prologue (current_iterator, &p_start, &p_end);
      expand_stmt_with_iterators_1 (stmt, iter_list_tail);
      iterator_loop_epilogue (current_iterator, &e_start, &e_end);

      /** Delete all inner expansions based on current_iterator **/
      /** before adding the outer one. **/

      delete_ixpansion (current_iterator);
      add_ixpansion (current_iterator, p_start, p_end, e_start, e_end);
    }
}


/* Return a list containing all the free (i.e. not bound by a
   containing `for' statement) iterators mentioned in EXP, plus those
   in LIST.  Do not add duplicate entries to the list.  */

static tree
collect_iterators (exp, list)
     tree exp, list;
{
  if (exp == 0) return list;

  switch (TREE_CODE (exp))
    {
    case VAR_DECL:
      if (! ITERATOR_P (exp) || ITERATOR_BOUND_P (exp))
	return list;
      if (value_member (exp, list))
	return list;
      return tree_cons (NULL_TREE, exp, list);

    case TREE_LIST:
      {
	tree tail;
	for (tail = exp; tail; tail = TREE_CHAIN (tail))
	  list = collect_iterators (TREE_VALUE (tail), list);
	return list;
      }

    case SAVE_EXPR:
      /* In each scan, scan a given save_expr only once.  */
      if (value_member (exp, save_exprs))
	return list;

      save_exprs = tree_cons (NULL_TREE, exp, save_exprs);
      return collect_iterators (TREE_OPERAND (exp, 0), list);

      /* we do not automatically iterate blocks -- one must */
      /* use the FOR construct to do that */

    case BLOCK:
      return list;

    default:
      switch (TREE_CODE_CLASS (TREE_CODE (exp)))
	{
	case '1':
	  return collect_iterators (TREE_OPERAND (exp, 0), list);

	case '2':
	case '<':
	  return collect_iterators (TREE_OPERAND (exp, 0),
				    collect_iterators (TREE_OPERAND (exp, 1),
						       list));

	case 'e':
	case 'r':
	  {
	    int num_args = tree_code_length[(int) TREE_CODE (exp)];
	    int i;

	    /* Some tree codes have RTL, not trees, as operands.  */
	    switch (TREE_CODE (exp))
	      {
	      case CALL_EXPR:
		num_args = 2;
		break;
	      case METHOD_CALL_EXPR:
		num_args = 3;
		break;
	      case WITH_CLEANUP_EXPR:
		num_args = 1;
		break;
	      case RTL_EXPR:
		return list;
	      default:
		break;
	      }
		
	    for (i = 0; i < num_args; i++)
	      list = collect_iterators (TREE_OPERAND (exp, i), list);
	    return list;
	  }
	default:
	  return list;
	}
    }
}

/* Emit rtl for the start of a loop for iterator IDECL.

   If necessary, create loop counter rtx and store it as DECL_RTL of IDECL.

   The prologue normally starts and ends with notes, which are returned
   by this function in *START_NOTE and *END_NODE.
   If START_NOTE and END_NODE are 0, we don't make those notes.  */

static void
iterator_loop_prologue (idecl, start_note, end_note)
     tree idecl;
     rtx *start_note, *end_note;
{
  tree expr;

  /* Force the save_expr in DECL_INITIAL to be calculated
     if it hasn't been calculated yet.  */
  expand_expr (DECL_INITIAL (idecl), const0_rtx, VOIDmode, 0);

  if (DECL_RTL (idecl) == 0)
    expand_decl (idecl);

  if (start_note)
    *start_note = emit_note (0, NOTE_INSN_DELETED);

  /* Initialize counter.  */
  expr = build (MODIFY_EXPR, TREE_TYPE (idecl), idecl, integer_zero_node);
  TREE_SIDE_EFFECTS (expr) = 1;
  expand_expr (expr, const0_rtx, VOIDmode, 0);