/* Copyright (c) 2002-2011 by XMLVM.org
 *
 * Project Info:  http://www.xmlvm.org
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2.1 of the License, or
 * (at your option) any later version.
 *
 * This library 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 Lesser General Public
 * License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
 * USA.
 */

package org.xmlvm.refcount.optimizations;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.jdom.DataConversionException;
import org.jdom.Element;
import org.xmlvm.refcount.CodePath;
import org.xmlvm.refcount.InstructionActions;
import org.xmlvm.refcount.InstructionUseInfo;
import org.xmlvm.refcount.OnePathInstructionRegisterContents;
import org.xmlvm.refcount.ReferenceCountingException;
import org.xmlvm.refcount.RegisterSet;

/**
 * This optimization will remove symmetric release retains in linear code
 * execution blocks. Said another way, in a piece of straight line code (no
 * branches), all redundant release/retaining will go away.
 */
public class ExcessRetainsOptimization implements RefCountOptimization
{

	class PairUseInfoIndex
	{
		public PairUseInfoIndex(InstructionUseInfo useInfo, int index)
		{
			this.useInfo= useInfo;
			this.index= index;
		}

		public InstructionUseInfo useInfo;
		public int index;
	}

	public ReturnValue Process(List<CodePath> allCodePaths, Map<Element, InstructionActions> beenTo, Element codeElement) throws ReferenceCountingException, DataConversionException
	{
		ReturnValue toRet= new ReturnValue();

		for (CodePath c : allCodePaths)
		{
			RegisterSet allRegs= new RegisterSet();
			for (OnePathInstructionRegisterContents curInst : c.path)
			{
				InstructionUseInfo useInfo= beenTo.get(curInst.instruction).useInfo;
				allRegs.orEq(useInfo.allWrites());
				allRegs.orEq(useInfo.usedReg());
			}

			// Look for a retain, no writes, then a release, and then get
			// rid of the symmetric retain / release

			for (int reg : allRegs)
			{
				List<PairUseInfoIndex> retains= new ArrayList<PairUseInfoIndex>();
				List<PairUseInfoIndex> releases= new ArrayList<PairUseInfoIndex>();

				int curIndex= 5;
				for (OnePathInstructionRegisterContents curInst : c.path)
				{
					InstructionActions act;
					act= beenTo.get(curInst.instruction);

					// changing the order of the next three ifs will screw
					// everything
					// up in unclear ways until you look at the output
					if (act.useInfo.willFree.has(reg))
					{
						releases.add(new PairUseInfoIndex(act.useInfo, curIndex));
						curIndex++;
					}

					RegisterSet allWrites= act.useInfo.allWrites();
					if (allWrites.has(reg))
					{
						eliminateExcessRetains(reg, retains, releases);
					}

					if (act.useInfo.requiresRetain.has(reg))
					{
						retains.add(new PairUseInfoIndex(act.useInfo, curIndex));
						curIndex++;
					}

				}
				eliminateExcessRetains(reg, retains, releases);
			}
		}
		return toRet;
	}

	private void eliminateExcessRetains(int reg, List<PairUseInfoIndex> retains, List<PairUseInfoIndex> releases)
	{
		// must free now, have new value being overwritten.
		while (retains.size() != 0 && releases.size() != 0)
		{
			// retains must come before releases, and not vice versa.
			if (releases.get(0).index < retains.get(0).index)
			{
				// can't use it because removing release then retain is
				// a great way to introduce a bug.
				retains.remove(0);
			}
			else
			{
				int retainIdx= retains.size() - 1;

				retains.get(retainIdx).useInfo.requiresRetain.clear(reg);
				releases.get(0).useInfo.willFree.clear(reg);
				retains.remove(retainIdx);
				releases.remove(0);
			}
		}
		retains.clear();
		releases.clear();
	}

}