---

ThreadInfo.java

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

import de.fub.bytecode.classfile.LineNumberTable;
import de.fub.bytecode.Constants;
import de.fub.bytecode.generic.*;
import gov.nasa.arc.ase.jpf.*;
import gov.nasa.arc.ase.util.Debug;
import gov.nasa.arc.ase.util.HashData;
import gov.nasa.arc.ase.util.HashPool;
import java.io.*;
import java.util.*;
// ifdef RACE
import gov.nasa.arc.ase.jpf.jvm.runtime.*;
//#endif RACE

public class ThreadInfo implements iThreadInfo, Cloneable {
  int status = STATUS.NEW;  // status of the thread
  ClassInfo   ci = null;    // class of the thread object
  Stack       JVMStack = new Stack();
                    // virtual machine stack
// ifdef RACE
  LockSet lockset = new LockSet();
                    // set of locks used by the thread
//#endif RACE

  Ref ref = Ref.NULL;       // object reference of the thread object
  int target = -1;  // object reference of the target
  int threadref = -1;       // position in the thread list
  int lock_count = 0;       // lock counter of the thread

// ifdef NO_COMPRESSION
  int tdIndex;
  boolean tdChanged = true;

  // information used to cache the storing data information
  private boolean anyFrameChanged = false;
                    // frames are changed
  private BitSet frameChanged = new BitSet();
                    // frames that did change
  private int[] frameData = new int[0]; // index of the frames
  LockTree lockTree;

  private int depth = 0;
  private MethodInfo currentMethod = null;
  private int line = -1;

  private boolean inAtomicMethod = false;
  private boolean inSameMethod = true;

//#endif NO_COMPRESSION

  // creates a new thread
  public ThreadInfo() {
// ifdef RACE
    if (LockOrder.on())
      lockTree = new LockTree(this);
//#endif RACE
  }  
  public ThreadInfo(KernelState ks, int[] data) {
    int len = data.length;

    ThreadData td = (ThreadData)VirtualMachine.threadPool.getObject(data[0]);

    tdIndex = data[0];
    tdChanged = false;

    status = td.status;
    ref = td.ref;
    ci = td.ci;
    target = td.target;
    lock_count = td.lock_count;

    // now we load the frame data
    len--;                  // skips the integers
    frameData = new int[len];
    System.arraycopy(data, 1, frameData, 0, len);

    // now we set all the frames
    for (int idx = 0; idx < len; idx++)
      JVMStack.push(VirtualMachine.framePool.getObject(frameData[idx]));
  }  
  // adds a frame
  private void addFrame(StackFrame sf) {
    inSameMethod = false;

    // EXTRA
    if(JVMStack.size() != 0) {
      StackFrame sf1 = getTopStackFrame();
      sf.setUpto(sf1.pcs());
    }
    // EXTRA

// ifdef NO_COMPRESSION
    // sets the changed flags first
    anyFrameChanged = true;
    frameChanged.set(JVMStack.size());
//#endif NO_COMPRESSION

    // push the new frame on the stack
    JVMStack.push(sf);
  }  
  public void callerPop(int n) {
    int index = JVMStack.size() - 2;
// ifdef NO_COMPRESSION
    // creates a clone of the caller stack frame
    cloneFrame(index);
//#endif NO_COMPRESSION
    ((StackFrame)JVMStack.get(index)).pop(n);
  }  
  // clears the operand stack of all value (used in case of exceptions)
  public void clearOperandStack() {
// ifdef NO_COMPRESSION
    // creates a clone of the top stack frame
    cloneFrame();
//#endif NO_COMPRESSION
    ((StackFrame)JVMStack.peek()).clearOperandStack();
  }  
// ifdef NO_COMPRESSION
  // creates a clone of the top stack frame
  public void cloneFrame() {
    cloneFrame(JVMStack.size()-1);
  }  
  // creates a clone of the stack frame and set the fields
  public void cloneFrame(int idx) {
    if (!frameChanged.get(idx)) {
      // sets all the flags
      anyFrameChanged = true;
      frameChanged.set(idx);
      
      // make a clone and put that on the stack
      Object sf = ((StackFrame)JVMStack.get(idx)).clone();
      JVMStack.set(idx, sf);
    }
  }  
  // creates an exception of the given class and throws it
  public InstructionHandle createAndThrowException(String classname,
      SystemState ss, KernelState ks, ThreadInfo th) {
// ifdef NO_COMPRESSION
    //** warning: I think we don't need to clone the frame here,    **//
    //**          but just to avoid errors we clone it anyway for now.  **//
    // creates a clone of the top stack frame
    cloneFrame();
//#endif NO_COMPRESSION
    return createAndThrowException(classname, ss, ks, th);
  }  
// ifdef MARK_N_SWEEP
  public void createMethodStackFrame(MethodInfo mi) {
    int nargs = mi.getArgumentSize();
    int[] args = new int[nargs];
    boolean[] refs = new boolean[nargs];

    for(int i = 0, cnt = nargs-1; i < nargs; i++, cnt--) {
      args[cnt] = peek(i);
      refs[cnt] = isOperandRef(i);
    }

    newFrame(mi);

    for(int i = 0; i < nargs; i++) {
      setLocalVariable(i, args[i]);
      if(refs[i]) setLocalVariableRef(i);
    }
  }  
//#endif MARK_N_SWEEP

  // these functions allows you to access the StackFrame methods, filtering
  // the ones that alter a stack frame so that a clone is created.

  // gets the depth of the stack
  public int depth() {
    return JVMStack.size();
  }  
  // gets the next random value
  public int doRandom(int max, Scheduler sch) {
    return ((StackFrame)JVMStack.peek()).doRandom(max, sch);
  }  
  // duplicates an entry on the top stack frame
  public void dup() {
// ifdef NO_COMPRESSION
    // creates a clone of the top stack frame
    cloneFrame();
//#endif NO_COMPRESSION
    ((StackFrame)JVMStack.peek()).dup();
  }  
  // duplicates an entry on the top stack frame
  public void dup_x1() {
// ifdef NO_COMPRESSION
    // creates a clone of the top stack frame
    cloneFrame();
//#endif NO_COMPRESSION
    ((StackFrame)JVMStack.peek()).dup_x1();
  }  
  // duplicates an entry on the top stack frame
  public void dup_x2() {
// ifdef NO_COMPRESSION
    // creates a clone of the top stack frame
    cloneFrame();
//#endif NO_COMPRESSION
    ((StackFrame)JVMStack.peek()).dup_x2();
  }  
  // duplicates an entry on the top stack frame
  public void dup2() {
// ifdef NO_COMPRESSION
    // creates a clone of the top stack frame
    cloneFrame();
//#endif NO_COMPRESSION
    ((StackFrame)JVMStack.peek()).dup2();
  }  
  public void dup2_x1() {
// ifdef NO_COMPRESSION
    // creates a clone of the top stack frame
    cloneFrame();
//#endif NO_COMPRESSION
    ((StackFrame)JVMStack.peek()).dup2_x1();
  }  
  // duplicates an entry on the top stack frame
  public void dup2_x2() {
// ifdef NO_COMPRESSION
    // creates a clone of the top stack frame
    cloneFrame();
//#endif NO_COMPRESSION
    ((StackFrame)JVMStack.peek()).dup2_x2();
  }  
  public void executeAtomicMethod() {
    if(depth == 0) {
      depth = depth();
      inAtomicMethod = true;
    }
  }  
  public void executeAtomicMethod(int offset) {
    if(depth == 0) {
      depth = depth() + offset;
      inAtomicMethod = true;
    }
  }  
  /********************************************************************/

  public InstructionHandle executeInstruction(SystemState ss, KernelState ks) {
    InstructionHandle pc = getPC();

// ifdef DEBUG_SEARCH

//#endif DEBUG_SEARCH

    // adds this bytecode instruction to the trail
    ((TrailInfo)ss.getTrailInfo()).addPC(pc);

    // execute the next bytecode
    pc = pc.getInstruction().execute(ss, ks, this);

    // we did not return from the last frame stack
    if (JVMStack.size() != 0) setPC(pc);

    return pc;
  }  
// ifdef DEBUG_SEARCH

//#endif DEBUG_SEARCH
  
  public boolean executeStep(SystemState ss, KernelState ks) {
    if(currentMethod == null) {
      line = getCurrentLine();
      currentMethod = getCurrentMethod();
      inSameMethod = true;
    } else
      inSameMethod = (currentMethod == getCurrentMethod());

    LineNumberTable lines = currentMethod.getLineNumbers();

    // first sets the trail information so that we can reconstruct the trail
    ss.setTrailInfo(threadref, line, currentMethod.getClassInfo().getClassName());

// ifdef DEBUG_SEARCH



//#endif DEBUG_SEARCH

    ss.saveAtomicData(threadref, depth, currentMethod, line);

// ifdef DEBUG_SEARCH

//#endif DEBUG_SEARCH
    while(true) {
      InstructionHandle pc = executeInstruction(ss, ks);
      Runner.instructions++;

      if(pc == null) break;
      if(TransitionResult.atomicLevel != 0) {
    if(pc.getInstruction().examine(ss, ks, this)) continue;
//    throw new InternalError("Non-deterministic statement in atomic block");
    if(!isRunnable(ss, ks)) {
      printStackTrace();
      throw new InternalError("Non-executable statement in atomic block");
    }
    continue;
      }
      if(!isRunnable(ss, ks)) break;
      if(inAtomicMethod) {
    if(pc.getInstruction().examine(ss, ks, this)) continue;
//    throw new InternalError("Non-deterministic statement in atomic method");
    continue;
      }
      if(!inSameMethod || (
        line != lines.getSourceLine(pc.getPosition()) && 
        !(pc.getInstruction() instanceof ReturnInstruction))) {
    currentMethod = null;
    line = -1;
    break;
      }
    }
    
// ifdef DEBUG_SEARCH


//#endif DEBUG_SEARCH

// ifdef REACHABILITY








//#endif REACHABILITY

    return true;
  }  
  // part of the bandera extension
  // checks if next instruction can be non deterministic
  /********************************************************************/
  public boolean findNondeterminismInNextInstruction(iSystemState ss, iKernelState ks) {
    Instruction ins = getPC().getInstruction();
    return ins.examine((SystemState)ss, (KernelState)ks, this);
  }  
  // gets the pointer to the object reference this
  public int getCalleeThis(int locals) {
    if (JVMStack.size() != 0)
      return ((StackFrame)JVMStack.peek()).getCalleeThis(locals);

// ifdef DEBUG

//#endif DEBUG

    return -1;
  }  
  public ClassInfo getClassInfo() {
    return ci;
  }  
  // gets the constant pool of the topmost frame
  public ConstantPoolGen getCPG() {
    return ((StackFrame)JVMStack.peek()).getConstantPool();    
  }  
  // gets the current class running
  public ClassInfo getCurrentClass() {
    return ((StackFrame)JVMStack.peek()).getClassInfo();
  }  
  // gets the current class running
  public ClassInfo getCurrentClass(int idx) {
    return ((StackFrame)JVMStack.get(idx)).getClassInfo();
  }  
  // gets the current line running
  public int getCurrentLine() {
    return ((StackFrame)JVMStack.peek()).getCurrentLine();
  }  
  // gets the current line running
  public int getCurrentLine(int idx) {
    return ((StackFrame)JVMStack.get(idx)).getCurrentLine();
  }  
  // gets the current method running
  public MethodInfo getCurrentMethod() {
    return ((StackFrame)JVMStack.peek()).getMethodInfo();
  }  
  // gets the current method running
  public MethodInfo getCurrentMethod(int idx) {
    return ((StackFrame)JVMStack.get(idx)).getMethodInfo();
  }  
  // gets a local variable in the top stack frame
  public int getLocalVariable(int idx) {
    return ((StackFrame)JVMStack.peek()).getLocalVariable(idx);
  }  
  public int getLockCount(){
    return lock_count;
  }  
//#endif NO_COMPRESSION

// ifdef RACE
  // these functions works of the locks set
  public LockSet getLockSet(){  
    return lockset;
  }  
  public LockTree getLockTree(){
    return lockTree;
  }  
  // gets a long local variable in the top stack frame
  public long getLongLocalVariable(int idx) {
    return ((StackFrame)JVMStack.peek()).getLongLocalVariable(idx);
  }  
  public InstructionHandle getPC() {
    if (JVMStack.size() == 0)
      // thread is stopped no instruction handle
      return null;
    else
      return ((StackFrame)JVMStack.peek()).getPC();
  }  
  // gets the current instruction handle
  public InstructionHandle getPC(int i) {
    if (i < JVMStack.size())
      return ((StackFrame)JVMStack.get(i)).getPC();
    else
      // thread is stopped no instruction handle
      return null;
  }  
  public Ref getReference() {
    return ref;
  }  
//#endif RACE

  // functions to get and set the value of the internal fields
  public int getStatus(){
    return status;
  }  
// ifdef NO_FASTBACKTRACK








// ifdef NO_COMPRESSION









//#endif NO_COMPRESSION

//#endif NO_FASTBACKTRACK

// ifdef NO_COMPRESSION
  // gets the information used for storing
  public int[] getStoringData() {
    // first let's update the information
    update();

    int l = frameData.length;           // number of frames
    int[] threadData = new int[l + 1];      // need four extra values

    if(tdChanged) {
      tdIndex = threadData[0] = VirtualMachine.threadPool.getIndex(newThreadData());
      tdChanged = false;
    } else
      threadData[0] = tdIndex;

    // saves the stack frame indexes
    if (l > 0) System.arraycopy(frameData, 0, threadData, 1, l);

    // returns the storing data
    return threadData;
  }  
  public int getTarget() {
    return target;
  }  
  // gets the pointer to the object reference this
  public int getThis() {
    if (JVMStack.size() != 0)
      return ((StackFrame)JVMStack.peek()).getThis();

// ifdef DEBUG

//#endif DEBUG

    return -1;
  }  
  public int getThreadReference() {
    return threadref;
  }  
//#endif NO_COMPRESSION

  // this is a hacking used by the examine package
  public StackFrame getTopStackFrame() {
    return (StackFrame)JVMStack.peek();
  }  
  // EXTRA
  
  public TrailInfo getTrailInfo() {
    int l = getCurrentLine();
    MethodInfo m = getCurrentMethod();
    return new TrailInfo(threadref, 0, getCurrentLine(), getCurrentMethod().getClassInfo().getClassName());
  }  
  public void hash(HashData hd) {
    hd.add(status);
    hd.add(ref.reference);
    hd.add(target);
    hd.add(threadref);
    hd.add(lock_count);

    for(int i = 0, l = JVMStack.size(); i < l; i++)
      ((StackFrame)JVMStack.get(i)).hash(hd);
  }  
  public int hashCode() {
    HashData hd = new HashData();

    hd.add(status);
    hd.add(ref.reference);
    hd.add(target);
    hd.add(threadref);
    hd.add(lock_count);

    for(int i = 0, l = JVMStack.size(); i < l; i++)
      hd.add(JVMStack.get(i).hashCode());

    return hd.getValue();
  }  
  // increments a local variable
  public void incIntLocalVariable(int index, int number) {
// ifdef NO_COMPRESSION
    // creates a clone of the top stack frame
    cloneFrame();
//#endif NO_COMPRESSION
    ((StackFrame)JVMStack.peek()).incIntLocalVariable(index, number);
  }  
  // an alive thread is either running or waiting or notified
  public boolean isAlive(){
    return status == STATUS.RUNNING || 
      status == STATUS.WAITING || 
      status == STATUS.NOTIFIED;
  }  
  // an enabled thread is either running or notifed
  public boolean isEnabled(){
// ifdef RACE
    // special handling for race conditions in runtime analysis
    if (RaceWindow.active && !RaceWindow.contains(ci.getClassName()))
      return false;
    else
//#endif RACE
      return status == STATUS.RUNNING || 
    status == STATUS.NOTIFIED;
  }  
  // just notified
  public boolean isNotified(){
    return status == STATUS.NOTIFIED;
  }  
  public boolean isOperandRef() {
    return ((StackFrame)JVMStack.peek()).isOperandRef();
  }  
  public boolean isOperandRef(int idx) {
    return ((StackFrame)JVMStack.peek()).isOperandRef(idx);
  }  
  // a runnable thread is an enabled thread
  public boolean isRunnable(iSystemState ss, iKernelState ks) {
    try {
      if (!isEnabled())
    return false;
      
      Instruction ins = getPC().getInstruction();

      // this is a bandera extension to pilot the execution
      // a thread is runnable only if contains the next instruction

      /**************************************************************/
      if(Engine.options.real_counterexample)
    if(ins.examine((SystemState)ss, (KernelState)ks, this))
     return false;
      /**************************************************************/

      // the instruction needs to be executable as well
      return ins.isExecutable((SystemState)ss, (KernelState)ks, this);
    } catch(Exception e) {
      e.printStackTrace();
      printInternalErrorTrace(e);
      Engine.vm.getErrorTrail().print();
      System.exit(1);
    }

    return false;
  }  
  // just running
  public boolean isRunning(){
    return status == STATUS.RUNNING;
  }  
  // checks if the thread is safe (checks in the topmost frame)
  public boolean isSafe() {
    if (!isEnabled())
      return false;

    return ((StackFrame)JVMStack.peek()).isSafe();
  }  
  // copies a value from a local variable onto the stack
  public void local2stack(int index) {
// ifdef NO_COMPRESSION
    // creates a clone of the top stack frame
    cloneFrame();
//#endif NO_COMPRESSION
    ((StackFrame)JVMStack.peek()).local2stack(index);
  }  
  // copies a value from a local variable onto the stack
  public void local2stack2(int index) {
// ifdef NO_COMPRESSION
    // creates a clone of the top stack frame
    cloneFrame();
//#endif NO_COMPRESSION
    ((StackFrame)JVMStack.peek()).local2stack2(index);
  }  
  public void log() {
    Debug.println(Debug.MESSAGE, "TH#" + threadref + " #" + target + " " + (ref.isClass() ? "@" : "#") + ref.getReference() + " " + status);
    for(int i = 0; i < JVMStack.size(); i++)
      ((StackFrame)JVMStack.get(i)).log(i);
  }  
  public void log(KernelState ks) {
    ks.log();
  }  
// ifdef MARK_N_SWEEP
  public void mark(DynamicArea da) {
    if(!ref.isNull() && !ref.isClass) da.mark(ref.reference);
    if(target != -1) da.mark(target);

    for(int i = 0, l = JVMStack.size(); i < l; i++) {
      StackFrame sf = (StackFrame)JVMStack.get(i);
      sf.mark(da);
    }
  }  
  // creates a new stack frame and adds it to the stack
  public void newFrame(MethodInfo mi) {
// ifdef DEBUG

//#endif DEBUG

    addFrame(new StackFrame(mi, mi.getClassInfo()));
  }  
//#endif MARK_N_SWEEP

  public ThreadData newThreadData() {
    ThreadData td = new ThreadData();

    td.status = status;
    td.ref = ref;
    td.ci = ci;
    td.target = target;
    td.lock_count = lock_count;

    return td;
  }  
// ifdef NO_COMPRESSION


















//#endif NO_COMPRESSION

// ifdef NO_FASTBACKTRACK










//#endif NO_FASTBACKTRACK

  // EXTRA
  public int pcs() {
    if(JVMStack.size() == 0) return 0;
    return getTopStackFrame().pcs();
  }  
  // peeks a value from the top stack frame
  public int peek() {
    return ((StackFrame)JVMStack.peek()).peek();
  }  
  public int peek(int n) {
    return ((StackFrame)JVMStack.peek()).peek(n);
  }  
  public long peek2() {
    return ((StackFrame)JVMStack.peek()).peek2();
  }  
  public long peek2(int n) {
    return ((StackFrame)JVMStack.peek()).peek2(n);
  }  
  // pops a value from the top stack frame
  public int pop() {
// ifdef NO_COMPRESSION
    // creates a clone of the top stack frame
    cloneFrame();
//#endif NO_COMPRESSION
    return ((StackFrame)JVMStack.peek()).pop();
  }  
  public void pop(int n) {
// ifdef NO_COMPRESSION
    // creates a clone of the top stack frame
    cloneFrame();
//#endif NO_COMPRESSION
    ((StackFrame)JVMStack.peek()).pop(n);
  }  
  public long pop2() {
// ifdef NO_COMPRESSION
    // creates a clone of the top stack frame
    cloneFrame();
//#endif NO_COMPRESSION
    return ((StackFrame)JVMStack.peek()).pop2();
  }  
  // removes a stack frame
  public void popFrame() {
// ifdef DEBUG

//#endif DEBUG
    if(size() != 0)
      throw new InternalError("non-empty stack frame popped");

    removeFrame();

// ifdef NO_COMPRESSION
    // a stack frame has been changed
    anyFrameChanged = true;
    frameChanged.set(JVMStack.size());
    // if I removes the last stack frame then the thread is stopped
//#endif NO_COMPRESSION
    if (JVMStack.size() == 0) {
// ifdef NO_COMPRESSION
      tdChanged = true;
//#endif NO_COMPRESSION
      status = STATUS.STOPPED;
    }
  }  
  public void printInternalErrorTrace(Throwable e) {
    String msg = e.getMessage();
    if(msg != null)
      Debug.println(Debug.ERROR, "exception " + e.getClass().getName() + ": " + msg);
    else
      Debug.println(Debug.ERROR, "exception " + e.getClass().getName());
    printStackTrace();
    if(msg != null)
      Debug.println(Debug.ERROR, "exception " + e.getClass().getName() + ": " + msg);
    else
      Debug.println(Debug.ERROR, "exception " + e.getClass().getName());
    printStackContent();
  }  
// ifdef DISTRIBUTED









//#endif DISTRIBUTED

  public void printStackContent() {
    for(int i = JVMStack.size()-1; i >= 0; i--)
      ((StackFrame)JVMStack.get(i)).printStackContent();
  }  
  public void printStackTrace() {
    for(int i = JVMStack.size()-1; i >= 0; i--)
      ((StackFrame)JVMStack.get(i)).printStackTrace();
  }  
  // pushes a value onto the top stack frame
  public void push(int v) {
// ifdef NO_COMPRESSION
    // creates a clone of the top stack frame
    cloneFrame();
//#endif NO_COMPRESSION
    ((StackFrame)JVMStack.peek()).push(v);
  }  
  public void push2(long v) {
// ifdef NO_COMPRESSION
    // creates a clone of the top stack frame
    cloneFrame();
//#endif NO_COMPRESSION
    ((StackFrame)JVMStack.peek()).push2(v);
  }  
//#else MARK_N_SWEEP












//#endif MARK_N_SWEEP

  public void removeArguments(MethodInfo mi) {
    pop(mi.getArgumentSize());
  }  
//#endif NO_COMPRESSION

  // removes a frame
  private void removeFrame() {
// ifdef MARK_N_SWEEP
    if(((StackFrame)JVMStack.peek()).hasAnyRef())
      VirtualMachine.activateGC();
//#endif MARK_N_SWEEP
// ifdef REFERENCE_COUNT

//#endif REFERENCE_COUNT
    if(inAtomicMethod && depth == depth()) {
      depth = 0;
      inAtomicMethod = false;
    }
    JVMStack.pop();
    inSameMethod = JVMStack.size() != 0 && getCurrentMethod() == currentMethod;
  }  
// ifdef NO_COMPRESSION
  // this function transform a threadinfo into another thread info
  // simply changing all the information. if we are lucky many of
  // the stack frames are in common and we don't need to go through
  // the pool
  public void revertTo(KernelState ks, int[] data) {
    int len = data.length;

    ThreadData td = (ThreadData)VirtualMachine.threadPool.getObject(data[0]);

    tdIndex = data[0];
    tdChanged = false;

    status = td.status;
    ref = td.ref;
    ci = td.ci;
    target = td.target;
    lock_count = td.lock_count;

    // now we load the new frame data
    len--;                  // skips the integers
    int[] nFrameData = new int[len];
    System.arraycopy(data, 1, nFrameData, 0, len);

    int s = Math.min(frameData.length, JVMStack.size());

    if (s >= len) {
      // if there are less frames now then before
      // we just update the one in common
      for (int idx = 0; idx < len; idx++)
    if(nFrameData[idx] != frameData[idx])
      JVMStack.set(idx,
          VirtualMachine.framePool.getObject(nFrameData[idx]));
      // then throw away the rest
      JVMStack.setSize(len);
    } else {
      // otherwise we update the one in common
      for (int idx = 0; idx < s; idx++)
    if(nFrameData[idx] != frameData[idx])
      JVMStack.set(idx,
          VirtualMachine.framePool.getObject(nFrameData[idx]));
      JVMStack.setSize(s);
      // and we add the next ones (if any)
      for (int idx = s; idx < len; idx++)
    JVMStack.push(VirtualMachine.framePool.getObject(nFrameData[idx]));
    }
    frameData = nFrameData;
  }  
  public void setAtomicData(int d, MethodInfo m, int l) {
    depth = d;
    inAtomicMethod = d != 0;

    currentMethod = m;
    line = l;
  }  
  public void setClassInfo(ClassInfo c) {
    if (ci == null) { // only set once for each thread
// ifdef NO_COMPRESSION
      tdChanged = true;
//#endif NO_COMPRESSION
      ci = c;
    }
// ifdef DEBUG


//#endif DEBUG
  }  
  // sets a local variable in the top stack frame
  public void setLocalVariable(int idx, int v) {
// ifdef NO_COMPRESSION
    // creates a copy of the top stack frame first
    cloneFrame();
//#endif NO_COMPRESSION
    ((StackFrame)JVMStack.peek()).setLocalVariable(idx, v);
  }  
// ifdef MARK_N_SWEEP
  public void setLocalVariableRef(int idx) {
// ifdef NO_COMPRESSION
    // creates a copy of the top stack frame first
    cloneFrame();
//#endif NO_COMPRESSION
    ((StackFrame)JVMStack.peek()).setLocalVariableRef(idx);
  }  
  public void setLockCount(int l){
// ifdef NO_COMPRESSION
    tdChanged = true;
//#endif NO_COMPRESSION
    lock_count = l;
  }  
  public void setOperandRef() {
// ifdef NO_COMPRESSION
    cloneFrame();
//#endif NO_COMPRESSION
    ((StackFrame)JVMStack.peek()).setOperandRef();
  }  
  // sets the current instruction handle
  public void setPC(InstructionHandle pc) {
    if (JVMStack.size() != 0) {
// ifdef NO_COMPRESSION
      // creates a clone of the top stack frame
      cloneFrame();
//#endif NO_COMPRESSION
      ((StackFrame)JVMStack.peek()).setPC(pc);
    }
  }  
  public void setReference(Ref o) {
// ifdef NO_COMPRESSION
    tdChanged = true;
//#endif NO_COMPRESSION
    ref = o;
  }  
  public void setStatus(int s) {
// ifdef NO_COMPRESSION
    tdChanged = true;
//#endif NO_COMPRESSION
    status = s;
  }  
  public void setTarget(int t) {
// ifdef NO_COMPRESSION
    tdChanged = true;
//#endif NO_COMPRESSION
    target = t;
  }  
  public void setThreadReference(int t) {
    threadref = t;
  }  
  // gets the size of the operand stack
  public int size() {
    return getTopStackFrame().operands.size();
  }  
  // copies a value from the stack to a local variable
  public void stack2local(int index) {
// ifdef NO_COMPRESSION
    // creates a clone of the top stack frame
    cloneFrame();
//#endif NO_COMPRESSION
    ((StackFrame)JVMStack.peek()).stack2local(index);
  }  
  // copies a value from the stack to a local variable
  public void stack2local2(int index) {
// ifdef NO_COMPRESSION
    // creates a clone of the top stack frame
    cloneFrame();
//#endif NO_COMPRESSION
    ((StackFrame)JVMStack.peek()).stack2local2(index);
  }  
  // swaps two entry on the top stack frame
  public void swap() {
// ifdef NO_COMPRESSION
    // creates a clone of the top stack frame
    cloneFrame();
//#endif NO_COMPRESSION
    ((StackFrame)JVMStack.peek()).swap();
  }  
//#endif NO_COMPRESSION

// ifdef NO_COMPRESSION
  public void update() {
    // checks if any frame has changed
    if (anyFrameChanged) {
      // number of frames
      int s = JVMStack.size();
      // creates a new array because if could be smaller
      // or larger then the old one
      int[] nFrameData = new int[s];
      // copies the information
      System.arraycopy(frameData, 0, nFrameData, 0, Math.min(s, frameData.length));
      // puts it back in the original variable
      frameData = nFrameData;

      // scans the vector to find which ones have been changed
      for (int i = 0; i < s; i++)
    // for the one that are changed
    if (frameChanged.get(i)) {
      // gets the frame
      StackFrame o = (StackFrame)JVMStack.get(i);
      // put it throught the frame pool
      HashPool.PoolEntry e = VirtualMachine.framePool.getEntry(o);
      // sets the pointer to the value in the pool
      JVMStack.set(i, e.getObject());
      // sets the updated index
      frameData[i] = e.getIndex();
    }
    }

    // clears all the flags
    anyFrameChanged = false;
    frameChanged = new BitSet();
  }  
  public int xpop() {
// ifdef NO_COMPRESSION
    // creates a clone of the top stack frame
    cloneFrame();
//#endif NO_COMPRESSION
    return ((StackFrame)JVMStack.peek()).xpop();
  }  
  public void xSetLocalVariableRef(int idx) {
// ifdef NO_COMPRESSION
    // creates a copy of the top stack frame first
    cloneFrame();
//#endif NO_COMPRESSION
    ((StackFrame)JVMStack.peek()).xSetLocalVariableRef(idx);
  }  
  public void xSetOperandRef() {
// ifdef NO_COMPRESSION
    cloneFrame();
//#endif NO_COMPRESSION
    ((StackFrame)JVMStack.peek()).xSetOperandRef();
  }  
}

---