---

StackFrame.java

package gov.nasa.arc.ase.jpf.jvm;

import de.fub.bytecode.Constants;
import gov.nasa.arc.ase.jpf.Engine;
import gov.nasa.arc.ase.jpf.InternalErrorException;
import de.fub.bytecode.generic.ConstantPoolGen;
import de.fub.bytecode.generic.LocalVariableGen;
import gov.nasa.arc.ase.jpf.jvm.bytecode.ATHROW;
import gov.nasa.arc.ase.jpf.jvm.bytecode.Instruction;
import gov.nasa.arc.ase.util.Debug;
import gov.nasa.arc.ase.util.HashData;
import java.util.BitSet;
import java.util.Random;
//#ifdef JDK11

//#else JDK11
import java.util.LinkedList;
//#endif JDK11

/**
 * Describes a stack frame.
 */
public class StackFrame implements Constants {
  /**
   * Used for random choices.
   */
  private static Random random = new Random();

  /**
   * Stores the operand stack.
   */
  //** warning: should be implemented as an array.          **//
  private LinkedList operands;

  /**
   * Local variables.
   */
  private int[] locals;

  /**
   * Program counter.
   */
  private Instruction pc;

  /**
   * Method being executed.
   */
  private MethodInfo mi;

  /**
   * Flags saying which operands are references.
   */
  private BitSet oRefs;

  /**
   * Flags saying which local variables are references.
   */
  private BitSet lRefs;

  /**
   * Creates an empty stack frame. Used by clone.
   */
  private StackFrame() {
  }  
  /**
   * Creates a new stack frame for a method.
   */
  public StackFrame(MethodInfo m) {
    mi = m;
    pc = mi.getInstruction(0);
    operands = new LinkedList();

    int nlocals = (pc == null) ? mi.getArgumentsSize() : mi.getMaxLocals();
    locals = new int[nlocals];

//#ifdef MARK_N_SWEEP || REFERENCE_COUNT
    oRefs = new BitSet();
    lRefs = new BitSet(nlocals);
//#endif MARK_N_SWEEP || REFERENCE_COUNT
  }  
  // stack operations
  public void clearOperandStack() {
    while(operands.size() != 0)
      pop();
  }  
  // functions to handle exceptions

  // creates a clone of the stack frame
  public Object clone() {
    StackFrame sf = new StackFrame();

    sf.operands = new LinkedList();
    for(int i = 0; i < operands.size(); i++)
      sf.operands.addLast(operands.get(i));
    sf.locals = new int[locals.length];
    System.arraycopy(locals, 0, sf.locals, 0, locals.length);
    sf.pc = pc;
    sf.mi = mi;
//#ifdef MARK_N_SWEEP || REFERENCE_COUNT
    sf.oRefs = (BitSet)oRefs.clone();
    sf.lRefs = (BitSet)lRefs.clone();
//#endif MARK_N_SWEEP || REFERENCE_COUNT

    return sf;
  }  
  private void deref(int v) {
//#ifdef MARK_N_SWEEP
    VirtualMachine.getSS().activateGC();
//#endif MARK_N_SWEEP
//#ifdef REFERENCE_COUNT

//#endif REFERENCE_COUNT
  }  
  private void derefLocal(int idx) {
    if(!lRefs.get(idx)) return;

    deref(locals[idx]);
  }  
  private void derefStack() {
    if(!oRefs.get(operands.size()-1)) return;

    deref(peek());
  }  
  public void dup() {
    boolean ref = isOperandRef(); int v =  pop();
    push(v, ref);
    push(v, ref);
  }  
  public void dup_x1() {
    // what it does on the stack is:
    // (top) A B ... => (top) B A B ...
    // often used to translate post increment/decremente operators
    boolean bref = isOperandRef(); int b = pop();
    boolean aref = isOperandRef(); int a = pop();
    push(b, bref);
    push(a, aref);
    push(b, bref);
  }  
  public void dup_x2() {
    // what it does on the stack is:
    // (top) A B C ... => (top) C A B C ...
    // often used to translate post increment/decremente operators
    boolean cref = isOperandRef(); int c = pop();
    boolean bref = isOperandRef(); int b = pop();
    boolean aref = isOperandRef(); int a = pop();
    push(c, cref);
    push(a, aref);
    push(b, bref);
    push(c, cref);
  }  
  public void dup2() {
    boolean bref = isOperandRef(); int b = pop();
    boolean aref = isOperandRef(); int a = pop();
    push(a, aref);
    push(b, bref);
    push(a, aref);
    push(b, bref);
  }  
  public void dup2_x1() {
    // what it does on the stack is:
    // (top) A B C ... => (top) B C A B C ...
    // often used to translate post increment/decremente operators
    boolean cref = isOperandRef(); int c = pop();
    boolean bref = isOperandRef(); int b = pop();
    boolean aref = isOperandRef(); int a = pop();
    push(b, bref);
    push(c, cref);
    push(a, aref);
    push(b, bref);
    push(c, cref);
  }  
  public void dup2_x2() {
    // what it does on the stack is:
    // (top) A B C D ... => (top) C D A B C D ...
    // often used to translate post increment/decremente operators
    boolean dref = isOperandRef(); int d = pop();
    boolean cref = isOperandRef(); int c = pop();
    boolean bref = isOperandRef(); int b = pop();
    boolean aref = isOperandRef(); int a = pop();
    push(c, cref);
    push(d, dref);
    push(a, aref);
    push(b, bref);
    push(c, cref);
    push(d, dref);
  }  
  public boolean equals(Object object) {
    // casts to stack frame
    StackFrame sf = (StackFrame)object;

    // compares the program counter REFERENCES
    // the code is statically read into the vm so the same
    // chunk of code means the same reference
    if (pc != sf.pc) return false;
    if (mi != sf.mi) return false;
    
    if (!lRefs.equals(sf.lRefs)) return false;
    if (!oRefs.equals(sf.oRefs)) return false;

    // we are going to compare
    // the local variables and the operand stack
    int[] l = sf.locals;
    int nlocals = locals.length;

    if (nlocals != l.length) return false;
    for (int idx = 0; idx < nlocals; idx++)
      if(locals[idx] != l[idx]) return false;

    LinkedList o = sf.operands;
    int noperands = operands.size();

    if (noperands != o.size()) return false;
    for (int idx = 0; idx < noperands; idx++)
      if (!operands.get(idx).equals(o.get(idx)))
    return false;

    return true;
  }  
  public int getCalleeThis(int size) {
    return ((Integer)operands.get(operands.size() - size)).intValue();
  }  
  // operations on local variables
  public int getCalleeThis(MethodInfo mi) {
    return ((Integer)operands.get(operands.size() - mi.getArgumentsSize())).intValue();
  }  
  public ClassInfo getClassInfo() {
    return mi.getClassInfo();
  }  
  // gets and sets some derived information
  public int getLine() {
    return mi.getLineNumber(pc);
  }  
  public int getLocalVariable(int i) {
    return locals[i];
  }  
  public int getLocalVariable(String name) {
    return getLocalVariable(getLocalVariableOffset(name));
  }  
  // return the value of a variable given the name
  private int getLocalVariableOffset(String name) {
    String[] lNames = mi.getLocalVariableNames();
    String[] lTypes = mi.getLocalVariableTypes();

    int offset = 0;
    for(int i = 0, l = lNames.length; i < l; i++)
      if(name.equals(lNames[i]))
    return offset;
      else
    offset += Types.getTypeSize(lTypes[i]);

    throw new InternalErrorException("Local variable not found");
  }  
  public int[] getLocalVariables() {
    return locals;
  }  
  public String getLocalVariableType(String name) {
    String[] lNames = mi.getLocalVariableNames();
    String[] lTypes = mi.getLocalVariableTypes();

    if(lNames != null && lTypes != null)
      for(int i = 0, l = lNames.length; i < l; i++)
    if(name.equals(lNames[i]))
      return lTypes[i];

    throw new InternalErrorException("Local variable not found");
  }  
  public long getLongLocalVariable(int i) {
    return Types.intsToLong(locals[i+1], locals[i]);
  }  
  public long getLongLocalVariable(String name) {
    return getLongLocalVariable(getLocalVariableOffset(name));
  }  
  public MethodInfo getMethodInfo() {
    return mi;
  }  
  public String getMethodName() {
    return mi.getName();
  }  
  public Instruction getPC() {
    return pc;
  }  
  public int getThis() {
    if(locals.length == 0) return -1;

    return locals[0];
  }  
//#ifdef MARK_N_SWEEP
  public boolean hasAnyRef() {
    for(int i = 0, l = oRefs.size(); i < l; i++)
      if(oRefs.get(i)) return true;
    for(int i = 0, l = locals.length; i < l; i++)
      if(lRefs.get(i)) return true;

    return false;
  }  
  public void hash(HashData hd) {
    for(int i = 0, l = locals.length; i < l; i++)
      hd.add(locals[i]);

    for(int i = 0, l = operands.size(); i < l; i++)
      hd.add(((Integer)operands.get(i)).intValue());
  }  
  // computes an hash code for the hash table
  // the default hash code is different for each object
  // we need to redifine it to make the hash table work
  public int hashCode() {
    HashData hd = new HashData();

    hash(hd);

    return hd.getValue();
  }  
  public boolean isLocalVariableRef(int idx) {
    return lRefs.get(idx);
  }  
  public boolean isOperandRef() {
    return oRefs.get(operands.size()-1);
  }  
//#endif MARK_N_SWEEP

  public boolean isOperandRef(int idx) {
    return oRefs.get(operands.size()-idx-1);
  }  
  public boolean isSafe() {
    return mi.getClassInfo().isSafe(getLine());
  }  
  public boolean isSystemMethod() {
    return mi.isSystemMethod();
  }  
//#endif MARK_N_SWEEP

//#ifdef REFERENCE_COUNT












//#endif REFERENCE_COUNT

  public void log(int id) {
    Debug.print(Debug.MESSAGE, "  SF#" + id + " S(");
    for(int i = 0; i < operands.size(); i++) {
      int j = ((Integer)operands.get(i)).intValue();
      Debug.print(Debug.MESSAGE, " ");
//#ifdef MARK_N_SWEEP || REFERENCE_COUNT
      if(oRefs.get(i)) Debug.print(Debug.MESSAGE, "#");
//#endif MARK_N_SWEEP || REFERENCE_COUNT
      Debug.print(Debug.MESSAGE, j + "");
    }
    Debug.print(Debug.MESSAGE, " ) L(");
    for(int i = 0; i < locals.length; i++) {
      int j = locals[i];
      Debug.print(Debug.MESSAGE, " ");
//#ifdef MARK_N_SWEEP || REFERENCE_COUNT
      if(lRefs.get(i)) Debug.print(Debug.MESSAGE, "#");
//#endif MARK_N_SWEEP || REFERENCE_COUNT
      Debug.print(Debug.MESSAGE, j + "");
    }
    Debug.print(Debug.MESSAGE, " ) ");
    if(mi == null)
      Debug.print(Debug.MESSAGE, "null");
    else
      Debug.print(Debug.MESSAGE, mi.getCompleteName());
    Debug.print(Debug.MESSAGE, ":");
    if(pc == null)
      Debug.println(Debug.MESSAGE, "null");
    else
      Debug.println(Debug.MESSAGE, pc.getPosition() + "  " + pc);
  }  
  long longPeek() {
    int lo = ((Integer)operands.getLast()).intValue();
    int hi = ((Integer)operands.get(operands.size() - 2)).intValue();

    return Types.intsToLong(lo, hi);
  }  
  long longPeek(int n) {
    int lo = ((Integer)operands.get(operands.size() - 1 - n)).intValue();
    int hi = ((Integer)operands.get(operands.size() - 2 - n)).intValue();

    return Types.intsToLong(lo, hi);
  }  
  long longPop() {
    int lo = pop();
    int hi = pop();

    return Types.intsToLong(lo, hi);
  }  
  void longPush(long v) {
    push(Types.hiLong(v), false);
    push(Types.loLong(v), false);
  }  
//#ifdef MARK_N_SWEEP
  public void mark(DynamicArea da) {
    for(int i = 0, l = operands.size(); i < l; i++)
      if(oRefs.get(i))
    da.mark(((Integer)operands.get(i)).intValue());

    for(int i = 0, l = locals.length; i < l; i++)
      if(lRefs.get(i))
    da.mark(locals[i]);
  }  
  int peek() {
    return ((Integer)operands.getLast()).intValue();
  }  
  int peek(int n) {
    return ((Integer)operands.get(operands.size() - 1 - n)).intValue();
  }  
  int pop() {
    if(isOperandRef())
      derefStack();

    return ((Integer)operands.removeLast()).intValue();
  }  
  void pop(int n) {
    for(int i = 0; i < n; i++)
      pop();
  }  
//#ifdef DISTRIBUTED



//#endif DISTRIBUTED

  public void printStackContent() {
    Debug.print(Debug.ERROR, "\tat ");
    Debug.print(Debug.ERROR, mi.getCompleteName());
    if(pc != null)
      Debug.println(Debug.ERROR, ":" + pc.getPosition());
    else
      Debug.println(Debug.ERROR);
    Debug.println(Debug.ERROR, "\t  Operand stack is:");
    for(int i = 0, l = operands.size(); i < l; i++) {
      Debug.print(Debug.ERROR, "\t    ");
//#ifdef MARK_N_SWEEP || REFERENCE_COUNT
      if(oRefs.get(i))
    Debug.print(Debug.ERROR, "#");
//#endif MARK_N_SWEEP || REFERENCE_COUNT
      Debug.println(Debug.ERROR, operands.get(i));
    }
    Debug.println(Debug.ERROR, "\t  Local variables are:");
    for(int i = 0, l = locals.length; i < l; i++) {
      Debug.print(Debug.ERROR, "\t    ");
//#ifdef MARK_N_SWEEP || REFERENCE_COUNT
      if(lRefs.get(i))
    Debug.print(Debug.ERROR, "#");
//#endif MARK_N_SWEEP || REFERENCE_COUNT
      Debug.println(Debug.ERROR, ""+locals[i]);
    }
  }  
  public void printStackTrace() {
    Debug.print(Debug.ERROR, "\tat ");
    Debug.print(Debug.ERROR, mi.getClassInfo().getName());
    Debug.print(Debug.ERROR, ".");
    Debug.print(Debug.ERROR, mi.getName());
    if(pc != null) {
      Debug.print(Debug.ERROR, "(");
      Debug.print(Debug.ERROR, mi.getClassInfo().getSourceFileName());
      Debug.print(Debug.ERROR, ":");
      Debug.println(Debug.ERROR, getLine() + ")");
    } else
      Debug.println(Debug.ERROR, "(Native Method)");
  }  
  void push(int v, boolean ref) {
    operands.addLast(new Integer(v));

    if(ref)
      oRefs.set(operands.size()-1);
    else
      oRefs.clear(operands.size()-1);

    refStack();
  }  
  private void ref(int v) {
    if(v == -1) return;
    
//#ifdef MARK_N_SWEEP
    VirtualMachine.getSS().activateGC();
//#endif MARK_N_SWEEP
//#ifdef REFERENCE_COUNT

//#endif REFERENCE_COUNT
  }  
  private void refLocal(int idx) {
    if(!lRefs.get(idx)) return;
    ref(locals[idx]);
  }  
  private void refStack() {
    if(!oRefs.get(operands.size()-1)) return;

    ref(peek());
  }  
  public void setLocalVariable(int index, int v, boolean ref) {
    derefLocal(index);

    locals[index] = v;

    if(ref)
      lRefs.set(index);
    else
      lRefs.clear(index);

    refLocal(index);
  }  
  public void setLongLocalVariable(int index, long v) {
    derefLocal(index);
    derefLocal(index+1);

    locals[index+1] = Types.loLong(v);
    locals[index] = Types.hiLong(v);

    lRefs.clear(index);
    lRefs.clear(index);
  }  
  public void setPC(Instruction newpc) {
    pc = newpc;
  }  
  public void swap() {
    // what it does on the stack is:
    // (top) A B ... => (top) B A ...
    boolean bref = isOperandRef(); int b = pop();
    boolean aref = isOperandRef(); int a = pop();
    push(b, bref);
    push(a, aref);
  }  
  public String toString() {
    StringBuffer sb = new StringBuffer();

    sb.append("StackFrame(");
    sb.append("operands=");
    sb.append('[');
    for(int i = 0; i < operands.size(); i++) {
      if(i != 0)
    sb.append(',');
      sb.append(operands.get(i));
    }
    sb.append(']');
    sb.append(',');
    sb.append("locals=");
    sb.append('[');
    for(int i = 0; i < locals.length; i++) {
      if(i != 0)
    sb.append(',');
      sb.append(locals[i]);
    }
    sb.append(']');
    sb.append(',');
    sb.append("pc=");
    sb.append(pc.getPosition());
    sb.append(',');
    sb.append("oRefs=");
    for(int i = 0; i < operands.size(); i++) {
      sb.append(oRefs.get(i) ? 'R' : '-');
    }
    sb.append(',');
    sb.append("lRefs=");
    for(int i = 0; i < locals.length; i++) {
      sb.append(lRefs.get(i) ? 'R' : '-');
    }
    sb.append(')');

    return sb.toString();
  }  
}

---