dx/src/com/android/dx/rop/code/BasicBlock.java - platform/dalvik2 - Git at Google

 /*
  * Copyright (C) 2007 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.dx.rop.code;

 import com.android.dx.rop.type.TypeList;
 import com.android.dx.util.Hex;
 import com.android.dx.util.IntList;
 import com.android.dx.util.LabeledItem;

 /**
  * Basic block of register-based instructions.
  */
 public final class BasicBlock implements LabeledItem {
     /** {@code >= 0;} target label for this block */
     private final int label;

     /** {@code non-null;} list of instructions in this block */
     private final InsnList insns;

     /**
      * {@code non-null;} full list of successors that this block may
      * branch to
      */
     private final IntList successors;

     /**
      * {@code >= -1;} the primary / standard-flow / "default" successor, or
      * {@code -1} if this block has no successors (that is, it
      * exits the function/method)
      */
     private final int primarySuccessor;

     /**
      * Constructs an instance. The predecessor set is set to {@code null}.
      *
      * @param label {@code >= 0;} target label for this block
      * @param insns {@code non-null;} list of instructions in this block
      * @param successors {@code non-null;} full list of successors that this
      * block may branch to
      * @param primarySuccessor {@code >= -1;} the primary / standard-flow /
      * "default" successor, or {@code -1} if this block has no
      * successors (that is, it exits the function/method or is an
      * unconditional throw)
      */
     public BasicBlock(int label, InsnList insns, IntList successors,
                       int primarySuccessor) {
         if (label < 0) {
             throw new IllegalArgumentException("label < 0");
         }

         try {
             insns.throwIfMutable();
         } catch (NullPointerException ex) {
             // Elucidate exception.
             throw new NullPointerException("insns == null");
         }

         int sz = insns.size();

         if (sz == 0) {
             throw new IllegalArgumentException("insns.size() == 0");
         }

         for (int i = sz - 2; i >= 0; i--) {
             Rop one = insns.get(i).getOpcode();
             if (one.getBranchingness() != Rop.BRANCH_NONE) {
                 throw new IllegalArgumentException("insns[" + i + "] is a " +
                                                    "branch or can throw");
             }
         }

         Insn lastInsn = insns.get(sz - 1);
         if (lastInsn.getOpcode().getBranchingness() == Rop.BRANCH_NONE) {
             throw new IllegalArgumentException("insns does not end with " +
                                                "a branch or throwing " +
                                                "instruction");
         }

         try {
             successors.throwIfMutable();
         } catch (NullPointerException ex) {
             // Elucidate exception.
             throw new NullPointerException("successors == null");
         }

         if (primarySuccessor < -1) {
             throw new IllegalArgumentException("primarySuccessor < -1");
         }

         if (primarySuccessor >= 0 && !successors.contains(primarySuccessor)) {
             throw new IllegalArgumentException(
                     "primarySuccessor " + primarySuccessor + " not in successors " + successors);
         }

         this.label = label;
         this.insns = insns;
         this.successors = successors;
         this.primarySuccessor = primarySuccessor;
     }

     /**
      * {@inheritDoc}
      *
      * Instances of this class compare by identity. That is,
      * {@code x.equals(y)} is only true if {@code x == y}.
      */
     @Override
     public boolean equals(Object other) {
         return (this == other);
     }

     /**
      * {@inheritDoc}
      *
      * Return the identity hashcode of this instance. This is proper,
      * since instances of this class compare by identity (see {@link #equals}).
      */
     @Override
     public int hashCode() {
         return System.identityHashCode(this);
     }

     /**
      * Gets the target label of this block.
      *
      * @return {@code >= 0;} the label
      */
     public int getLabel() {
         return label;
     }

     /**
      * Gets the list of instructions inside this block.
      *
      * @return {@code non-null;} the instruction list
      */
     public InsnList getInsns() {
         return insns;
     }

     /**
      * Gets the list of successors that this block may branch to.
      *
      * @return {@code non-null;} the successors list
      */
     public IntList getSuccessors() {
         return successors;
     }

     /**
      * Gets the primary successor of this block.
      *
      * @return {@code >= -1;} the primary successor, or {@code -1} if this
      * block has no successors at all
      */
     public int getPrimarySuccessor() {
         return primarySuccessor;
     }

     /**
      * Gets the secondary successor of this block. It is only valid to call
      * this method on blocks that have exactly two successors.
      *
      * @return {@code >= 0;} the secondary successor
      */
     public int getSecondarySuccessor() {
         if (successors.size() != 2) {
             throw new UnsupportedOperationException(
                     "block doesn't have exactly two successors");
         }

         int succ = successors.get(0);
         if (succ == primarySuccessor) {
             succ = successors.get(1);
         }

         return succ;
     }

     /**
      * Gets the first instruction of this block. This is just a
      * convenient shorthand for {@code getInsns().get(0)}.
      *
      * @return {@code non-null;} the first instruction
      */
     public Insn getFirstInsn() {
         return insns.get(0);
     }

     /**
      * Gets the last instruction of this block. This is just a
      * convenient shorthand for {@code getInsns().getLast()}.
      *
      * @return {@code non-null;} the last instruction
      */
     public Insn getLastInsn() {
         return insns.getLast();
     }

     /**
      * Returns whether this block might throw an exception. This is
      * just a convenient shorthand for {@code getLastInsn().canThrow()}.
      *
      * @return {@code true} iff this block might throw an
      * exception
      */
     public boolean canThrow() {
         return insns.getLast().canThrow();
     }

     /**
      * Returns whether this block has any associated exception handlers.
      * This is just a shorthand for inspecting the last instruction in
      * the block to see if it could throw, and if so, whether it in fact
      * has any associated handlers.
      *
      * @return {@code true} iff this block has any associated
      * exception handlers
      */
     public boolean hasExceptionHandlers() {
         Insn lastInsn = insns.getLast();
         return lastInsn.getCatches().size() != 0;
     }

     /**
      * Returns the exception handler types associated with this block,
      * if any. This is just a shorthand for inspecting the last
      * instruction in the block to see if it could throw, and if so,
      * grabbing the catch list out of it. If not, this returns an
      * empty list (not {@code null}).
      *
      * @return {@code non-null;} the exception handler types associated with
      * this block
      */
     public TypeList getExceptionHandlerTypes() {
         Insn lastInsn = insns.getLast();
         return lastInsn.getCatches();
     }

     /**
      * Returns an instance that is identical to this one, except that
      * the registers in each instruction are offset by the given
      * amount.
      *
      * @param delta the amount to offset register numbers by
      * @return {@code non-null;} an appropriately-constructed instance
      */
     public BasicBlock withRegisterOffset(int delta) {
         return new BasicBlock(label, insns.withRegisterOffset(delta),
                               successors, primarySuccessor);
     }

     public String toString() {
         return '{' + Hex.u2(label) + '}';
     }

     /**
      * BasicBlock visitor interface
      */
     public interface Visitor {
         /**
          * Visits a basic block
          * @param b block visited
          */
         public void visitBlock (BasicBlock b);
     }
 }
	/*
	* Copyright (C) 2007 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.dx.rop.code;

	import com.android.dx.rop.type.TypeList;
	import com.android.dx.util.Hex;
	import com.android.dx.util.IntList;
	import com.android.dx.util.LabeledItem;

	/**
	* Basic block of register-based instructions.
	*/
	public final class BasicBlock implements LabeledItem {
	/** {@code >= 0;} target label for this block */
	private final int label;

	/** {@code non-null;} list of instructions in this block */
	private final InsnList insns;

	/**
	* {@code non-null;} full list of successors that this block may
	* branch to
	*/
	private final IntList successors;

	/**
	* {@code >= -1;} the primary / standard-flow / "default" successor, or
	* {@code -1} if this block has no successors (that is, it
	* exits the function/method)
	*/
	private final int primarySuccessor;

	/**
	* Constructs an instance. The predecessor set is set to {@code null}.
	*
	* @param label {@code >= 0;} target label for this block
	* @param insns {@code non-null;} list of instructions in this block
	* @param successors {@code non-null;} full list of successors that this
	* block may branch to
	* @param primarySuccessor {@code >= -1;} the primary / standard-flow /
	* "default" successor, or {@code -1} if this block has no
	* successors (that is, it exits the function/method or is an
	* unconditional throw)
	*/
	public BasicBlock(int label, InsnList insns, IntList successors,
	int primarySuccessor) {
	if (label < 0) {
	throw new IllegalArgumentException("label < 0");
	}

	try {
	insns.throwIfMutable();
	} catch (NullPointerException ex) {
	// Elucidate exception.
	throw new NullPointerException("insns == null");
	}

	int sz = insns.size();

	if (sz == 0) {
	throw new IllegalArgumentException("insns.size() == 0");
	}

	for (int i = sz - 2; i >= 0; i--) {
	Rop one = insns.get(i).getOpcode();
	if (one.getBranchingness() != Rop.BRANCH_NONE) {
	throw new IllegalArgumentException("insns[" + i + "] is a " +
	"branch or can throw");
	}
	}

	Insn lastInsn = insns.get(sz - 1);
	if (lastInsn.getOpcode().getBranchingness() == Rop.BRANCH_NONE) {
	throw new IllegalArgumentException("insns does not end with " +
	"a branch or throwing " +
	"instruction");
	}

	try {
	successors.throwIfMutable();
	} catch (NullPointerException ex) {
	// Elucidate exception.
	throw new NullPointerException("successors == null");
	}

	if (primarySuccessor < -1) {
	throw new IllegalArgumentException("primarySuccessor < -1");
	}

	if (primarySuccessor >= 0 && !successors.contains(primarySuccessor)) {
	throw new IllegalArgumentException(
	"primarySuccessor " + primarySuccessor + " not in successors " + successors);
	}

	this.label = label;
	this.insns = insns;
	this.successors = successors;
	this.primarySuccessor = primarySuccessor;
	}

	/**
	* {@inheritDoc}
	*
	* Instances of this class compare by identity. That is,
	* {@code x.equals(y)} is only true if {@code x == y}.
	*/
	@Override
	public boolean equals(Object other) {
	return (this == other);
	}

	/**
	* {@inheritDoc}
	*
	* Return the identity hashcode of this instance. This is proper,
	* since instances of this class compare by identity (see {@link #equals}).
	*/
	@Override
	public int hashCode() {
	return System.identityHashCode(this);
	}

	/**
	* Gets the target label of this block.
	*
	* @return {@code >= 0;} the label
	*/
	public int getLabel() {
	return label;
	}

	/**
	* Gets the list of instructions inside this block.
	*
	* @return {@code non-null;} the instruction list
	*/
	public InsnList getInsns() {
	return insns;
	}

	/**
	* Gets the list of successors that this block may branch to.
	*
	* @return {@code non-null;} the successors list
	*/
	public IntList getSuccessors() {
	return successors;
	}

	/**
	* Gets the primary successor of this block.
	*
	* @return {@code >= -1;} the primary successor, or {@code -1} if this
	* block has no successors at all
	*/
	public int getPrimarySuccessor() {
	return primarySuccessor;
	}

	/**
	* Gets the secondary successor of this block. It is only valid to call
	* this method on blocks that have exactly two successors.
	*
	* @return {@code >= 0;} the secondary successor
	*/
	public int getSecondarySuccessor() {
	if (successors.size() != 2) {
	throw new UnsupportedOperationException(
	"block doesn't have exactly two successors");
	}

	int succ = successors.get(0);
	if (succ == primarySuccessor) {
	succ = successors.get(1);
	}

	return succ;
	}

	/**
	* Gets the first instruction of this block. This is just a
	* convenient shorthand for {@code getInsns().get(0)}.
	*
	* @return {@code non-null;} the first instruction
	*/
	public Insn getFirstInsn() {
	return insns.get(0);
	}

	/**
	* Gets the last instruction of this block. This is just a
	* convenient shorthand for {@code getInsns().getLast()}.
	*
	* @return {@code non-null;} the last instruction
	*/
	public Insn getLastInsn() {
	return insns.getLast();
	}

	/**
	* Returns whether this block might throw an exception. This is
	* just a convenient shorthand for {@code getLastInsn().canThrow()}.
	*
	* @return {@code true} iff this block might throw an
	* exception
	*/
	public boolean canThrow() {
	return insns.getLast().canThrow();
	}

	/**
	* Returns whether this block has any associated exception handlers.
	* This is just a shorthand for inspecting the last instruction in
	* the block to see if it could throw, and if so, whether it in fact
	* has any associated handlers.
	*
	* @return {@code true} iff this block has any associated
	* exception handlers
	*/
	public boolean hasExceptionHandlers() {
	Insn lastInsn = insns.getLast();
	return lastInsn.getCatches().size() != 0;
	}

	/**
	* Returns the exception handler types associated with this block,
	* if any. This is just a shorthand for inspecting the last
	* instruction in the block to see if it could throw, and if so,
	* grabbing the catch list out of it. If not, this returns an
	* empty list (not {@code null}).
	*
	* @return {@code non-null;} the exception handler types associated with
	* this block
	*/
	public TypeList getExceptionHandlerTypes() {
	Insn lastInsn = insns.getLast();
	return lastInsn.getCatches();
	}

	/**
	* Returns an instance that is identical to this one, except that
	* the registers in each instruction are offset by the given
	* amount.
	*
	* @param delta the amount to offset register numbers by
	* @return {@code non-null;} an appropriately-constructed instance
	*/
	public BasicBlock withRegisterOffset(int delta) {
	return new BasicBlock(label, insns.withRegisterOffset(delta),
	successors, primarySuccessor);
	}

	public String toString() {
	return '{' + Hex.u2(label) + '}';
	}

	/**
	* BasicBlock visitor interface
	*/
	public interface Visitor {
	/**
	* Visits a basic block
	* @param b block visited
	*/
	public void visitBlock (BasicBlock b);
	}
	}