/* SSA operand allocation and finalizing.
   Copyright (C) 2005 Free Software Foundation, Inc.

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 2, 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 COPYING.  If not, write to the Free
Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.  */


/* This file contains common code which is used by each of the 5 operand 
   types.  Macros are defined to specify the varying components.

   FINALIZE_FUNC - name of finalize function.
   FINALIZE_ALLOC - name of allocation routine.
   FINALIZE_FREE - name of free list.
   FINALIZE_TYPE - type of node.
   FINALIZE_OPS - Lead element in list.
   FINALIZE_USE_PTR - How to get the use_operand_p, if this is a use operand.
   FINALIZE_INITIALIZE - How to initialize an element.
   FINALIZE_ELEM - How to retrieve an element.
   FINALIZE_BASE - How to retrieve the base variable of an element.
   FINALIZE_BASE_TYPE - Type of the base variable.
   FINALIZE_OPBUILD - Opbuild array for these nodes.
   FINALIZE_OPBUILD_ELEM - How to get an element from the opbuild list.
   FINALIZE_OPBUILD_BASE - How to get an element base from the opbuild list.
   FINALIZE_BASE_ZERO - How to zero an element.  */


/* This routine will either pick up a node from the free list, or allocate a
   new one if need be.  */

static inline FINALIZE_TYPE *
FINALIZE_ALLOC (void)
{
  FINALIZE_TYPE *ret;
  if (FINALIZE_FREE)
    {
      ret = FINALIZE_FREE;
      FINALIZE_FREE = FINALIZE_FREE->next;
    }
  else
    ret = (FINALIZE_TYPE *)ssa_operand_alloc (sizeof (FINALIZE_TYPE));
  return ret;
}



/* This routine will take the new operands from FINALIZE_OPBUILD and turn them
   into the new operands for STMT.  All required linking and deleting is u
   performed here.  */
static inline void
FINALIZE_FUNC (tree stmt)
{
  unsigned new_i;
  FINALIZE_TYPE *old_ops, *ptr, *last;
  FINALIZE_BASE_TYPE old_base;
  FINALIZE_TYPE new_list;

  new_list.next = NULL;
  last = &new_list;

  old_ops = FINALIZE_OPS (stmt);
  if (old_ops)
    old_base = FINALIZE_BASE (FINALIZE_ELEM (old_ops));
  else
    old_base = FINALIZE_BASE_ZERO;

  new_i = 0;
  while (old_ops && new_i < VEC_length (tree, FINALIZE_OPBUILD))
    {
      FINALIZE_BASE_TYPE new_base = FINALIZE_OPBUILD_BASE (new_i);
      if (old_base == new_base)
        {
	  /* if variables are the same, reuse this node.  */
	  last->next = old_ops;
	  last = old_ops;
#ifdef FINALIZE_CORRECT_USE
	  FINALIZE_CORRECT_USE (FINALIZE_USE_PTR (last), stmt);
#endif
	  old_ops = old_ops->next;
	  new_i++;
	}
      else
        if (old_base < new_base)
	  {
	    /* if old is less than new, old goes to the free list.  */
#ifdef FINALIZE_USE_PTR
	    use_operand_p use_p = FINALIZE_USE_PTR (old_ops);
	    delink_imm_use (use_p);
#endif
	    ptr = old_ops;
	    old_ops = old_ops->next;
	    ptr->next = FINALIZE_FREE;
	    FINALIZE_FREE = ptr;
	  }
	else
	  {
	    /* This is a new operand.  */
	    ptr = FINALIZE_ALLOC ();
	    FINALIZE_INITIALIZE (ptr, FINALIZE_OPBUILD_ELEM (new_i), stmt);
	    last->next = ptr;
	    last = ptr;
	    new_i++;
	  }
      if (old_ops)
        old_base = FINALIZE_BASE (FINALIZE_ELEM (old_ops));
    }

  /* If there is anything remaining in the opbuild list, simply emit them.  */
  for ( ; new_i < VEC_length (tree, FINALIZE_OPBUILD); new_i++)
    {
      ptr = FINALIZE_ALLOC ();
      FINALIZE_INITIALIZE (ptr, FINALIZE_OPBUILD_ELEM (new_i), stmt);
      last->next = ptr;
      last = ptr;
    }

  last->next = NULL;

  /* If there is anything in the old list, free them.  */
  if (old_ops)
    {
#ifdef FINALIZE_USE_PTR
      for (ptr = old_ops; ptr; ptr = ptr->next)
	{
	  use_operand_p use_p = FINALIZE_USE_PTR (ptr);
	  delink_imm_use (use_p);
	}
#endif
      old_ops->next = FINALIZE_FREE;
      FINALIZE_FREE = old_ops;
    }

  /* NOw set the stmt's operands.  */
  FINALIZE_OPS (stmt) = new_list.next;

#ifdef ENABLE_CHECKING
  {
    unsigned x = 0;
    for (ptr = FINALIZE_OPS (stmt); ptr; ptr = ptr->next)
      x++;

    gcc_assert (x == VEC_length (tree, FINALIZE_OPBUILD));
  }
#endif
}

#undef FINALIZE_FUNC
#undef FINALIZE_ALLOC
#undef FINALIZE_FREE
#undef FINALIZE_TYPE
#undef FINALIZE_OPS
#undef FINALIZE_USE_PTR
#undef FINALIZE_INITIALIZE
#undef FINALIZE_ELEM
#undef FINALIZE_BASE
#undef FINALIZE_BASE_TYPE
#undef FINALIZE_OPBUILD
#undef FINALIZE_OPBUILD_ELEM
#undef FINALIZE_OPBUILD_BASE
#undef FINALIZE_BASE_ZERO
#undef FINALIZE_CORRECT_USE