tools/pldt/org.eclipse.ptp.pldt.openmp.analysis/src/org/eclipse/ptp/pldt/openmp/analysis/ompcfg/factory/OMPCFGResult.java

/**********************************************************************
 * Copyright (c) 2006, 2008 IBM Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.ptp.pldt.openmp.analysis.ompcfg.factory;

import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedList;

import org.eclipse.cdt.core.dom.ast.IASTGotoStatement;
import org.eclipse.cdt.core.dom.ast.IASTName;
import org.eclipse.cdt.core.dom.ast.IASTStatement;

import org.eclipse.ptp.pldt.openmp.analysis.ompcfg.OMPBasicBlock;
import org.eclipse.ptp.pldt.openmp.analysis.ompcfg.OMPCFGNode;
import org.eclipse.ptp.pldt.openmp.analysis.ompcfg.OMPPragmaNode;

/**
 * Collects information about each pass of OMPCFGmaker
 * 
 * @author pazel
 * 
 */
public class OMPCFGResult
{
	/**
	 * List of sequential chains in 1-level pass: the control flow between
	 * chains is broken by continue, break, return, or goto
	 */
	protected LinkedList chains_ = new LinkedList(); // of Chain
	/**
	 * List of chains with no sequential flow to entry point - these get
	 * aggregated. Could be dead code, but could be branched into.
	 */
	protected LinkedList unconnectedChains_ = new LinkedList(); // of Chain
	/**
	 * List of blocks ending in continue, break, return, or goto whose further
	 * continuation needs to be resolved
	 */
	protected LinkedList unresolvedControlFlow_ = new LinkedList(); // of Chain
	/** list of labeled blocks (and related chain) */
	protected Hashtable labelMap_ = new Hashtable(); // IASTName->LabeledBlock
	/** list of pragma nodes encountered */
	protected LinkedList pragmaNodeList_ = new LinkedList();

	/** block termination reason - unknown */
	public static final int TermUnknown = -1;
	/** block termination reason - no termination */
	public static final int TermForward = 0; // no termination
	/** block termination reason - continue */
	public static final int TermContinue = 1; // continue
	/** block termination reason - break */
	public static final int TermBreak = 2; // break
	/** block termination reason - return */
	public static final int TermReturn = 3; // return
	/** block termination reason - goto */
	public static final int TermGoto = 4; // goto

	/**
	 * OMPCFGResult - constructor
	 * 
	 */
	public OMPCFGResult() {
	}

	/**
	 * addChain - add a chain to the chainList
	 * 
	 * @param headNode
	 * @param tailNode
	 * @param terminationReason
	 * @param termStmt
	 */
	public Chain addChain(OMPCFGNode headNode,
			OMPCFGNode tailNode,
			int terminationReason,
			IASTStatement termStmt)
	{
		Chain chain = new Chain(headNode, tailNode, terminationReason, termStmt);
		chains_.add(chain);

		// run through chain to find all labeled blocks and add to labelmap
		addLabels(chain);
		addPragmas(chain);
		return chain;
	}

	/**
	 * addChain - add a chain to this result
	 * 
	 * @param chain
	 *            - Chain
	 * @return Chain
	 */
	public Chain addChain(Chain chain)
	{
		chains_.add(chain);
		addLabels(chain);
		addPragmas(chain);
		return chain;
	}

	private void addLabels(Chain chain)
	{
		OMPCFGNode node = chain.getHeadNode();
		while (node != null) {
			if (node instanceof OMPBasicBlock) {
				IASTName label = ((OMPBasicBlock) node).getLabel();
				if (label != null) {
					if (!labelMap_.containsKey(label))
						labelMap_.put(label, new LabeledBlock(node, chain));
				}
			}
			node = node.getSuccessor(); // use this knowing each node has a follower
		}
	}

	private void addPragmas(Chain chain)
	{
		OMPCFGNode node = chain.getHeadNode();
		while (node != null) {
			if (node instanceof OMPPragmaNode) {
				if (!pragmaNodeList_.contains(node))
					pragmaNodeList_.add(node);
			}
			node = node.getSuccessor(); // use this knowing each node has a follower
		}
	}

	public void merge(OMPCFGResult result)
	{
		// we don't merge chains_;

		// we merge all the others
		unconnectedChains_.addAll(result.getUnconnectedChains());
		unresolvedControlFlow_.addAll(result.getUnresolvedControlFlow());
		labelMap_.putAll(result.getLabelMap());
		pragmaNodeList_.addAll(result.getPragmaNodeList());
	}

	public void resolve()
	{
		// Usually done to the final cfg results
		// we try to resolve all unresolved control flow (goto's) and
		// return/exit nodes (sink)
		// and maybe flag all unconnected chains as dead code

		for (Iterator i = unresolvedControlFlow_.iterator(); i.hasNext();) {
			Chain uChain = (Chain) i.next();
			if (uChain.getTerminationReason() == TermGoto) {
				IASTStatement tStmt = uChain.getTerminationStmt();
				if (tStmt != null && (tStmt instanceof IASTGotoStatement)) {
					IASTName targetLabel = ((IASTGotoStatement) tStmt).getName();
					OMPCFGNode lNode = (OMPCFGNode) labelMap_.get(targetLabel);
					if (lNode != null) {
						uChain.getTailNode().connectTo(lNode);
						removeUnresolvedControlFlow(uChain);
					}
				}
			}
		}
	}

	public void addUnconnectedChain(Chain chain)
	{
		unconnectedChains_.add(chain);
	}

	public void addUnresolvedControlFlow(Chain chain)
	{
		unresolvedControlFlow_.add(chain);
	}

	public void removeUnresolvedControlFlow(Chain chain)
	{
		unresolvedControlFlow_.remove(chain);
	}

	public int getNumberOfLabels()
	{
		return labelMap_.size();
	}

	public int getNumberOfPragmas()
	{
		return pragmaNodeList_.size();
	}

	// accessors
	public LinkedList getChains() {
		return chains_;
	}

	public LinkedList getUnconnectedChains() {
		return unconnectedChains_;
	}

	public LinkedList getUnresolvedControlFlow() {
		return unresolvedControlFlow_;
	}

	public Hashtable getLabelMap() {
		return labelMap_;
	}

	public LinkedList getPragmaNodeList() {
		return pragmaNodeList_;
	}

	/**
	 * Get the very first chain - a common want in the code (other are dead code)
	 * 
	 * @return Chain
	 */
	public Chain getFirstChain() {
		return (chains_.size() > 0 ? (Chain) (chains_.getFirst()) : null);
	}

	/**
	 * Get the very last chain - a common want in the code (other are dead code)
	 * 
	 * @return Chain
	 */
	public Chain getLastChain() {
		return (chains_.size() > 0 ? (Chain) (chains_.getLast()) : null);
	}

	/**
	 * Chain - qualifies a code chain
	 * 
	 */
	static public class Chain
	{
		protected OMPCFGNode headNode_ = null;
		protected OMPCFGNode tailNode_ = null;
		protected int terminationReason_ = TermUnknown;
		protected IASTStatement terminationStmt_ = null;

		public Chain(OMPCFGNode headNode, OMPCFGNode tailNode, int terminationReason, IASTStatement termStatement)
		{
			headNode_ = headNode;
			tailNode_ = tailNode;
			terminationReason_ = terminationReason;
			terminationStmt_ = termStatement;
		}

		/** Get head node in the Chain */
		public OMPCFGNode getHeadNode() {
			return headNode_;
		}

		/** Get tail node in the Chain */
		public OMPCFGNode getTailNode() {
			return tailNode_;
		}

		public int getTerminationReason() {
			return terminationReason_;
		}

		public IASTStatement getTerminationStmt() {
			return terminationStmt_;
		}
	}

	/** LabeledBlock - qualifies a block with a label */
	static public class LabeledBlock
	{
		protected OMPCFGNode labeledBlock_ = null;
		protected Chain relatedChain_ = null; // chain holding block

		public LabeledBlock(OMPCFGNode labeledBlock, Chain relatedChain)
		{
			labeledBlock_ = labeledBlock;
			relatedChain_ = relatedChain;
		}

		public OMPCFGNode getLabeledBlock() {
			return labeledBlock_;
		}

		public Chain getRelatedChain() {
			return relatedChain_;
		}
	}

}