---

Builder.java

package edu.ksu.cis.bandera.birc;

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * Bandera, a Java(TM) analysis and transformation toolkit           *
 * Copyright (C) 1998, 1999   James Corbett (corbett@hawaii.edu)     *
 * All rights reserved.                                              *
 *                                                                   *
 * This work was done as a project in the SAnToS Laboratory,         *
 * Department of Computing and Information Sciences, Kansas State    *
 * University, USA (http://www.cis.ksu.edu/santos).                  *
 * It is understood that any modification not identified as such is  *
 * not covered by the preceding statement.                           *
 *                                                                   *
 * This work is free software; you can redistribute it and/or        *
 * modify it under the terms of the GNU Library General Public       *
 * License as published by the Free Software Foundation; either      *
 * version 2 of the License, or (at your option) any later version.  *
 *                                                                   *
 * This work 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 *
 * Library General Public License for more details.                  *
 *                                                                   *
 * You should have received a copy of the GNU Library General Public *
 * License along with this toolkit; if not, write to the             *
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,      *
 * Boston, MA  02111-1307, USA.                                      *
 *                                                                   *
 * Java is a trademark of Sun Microsystems, Inc.                     *
 *                                                                   *
 * To submit a bug report, send a comment, or get the latest news on *
 * this project and other SAnToS projects, please visit the web-site *
 *                http://www.cis.ksu.edu/santos                      *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
import java.io.*;
import java.util.Vector;
import java.util.Hashtable;

import edu.ksu.cis.bandera.bir.TransSystem;
import edu.ksu.cis.bandera.bir.BirThread;
import edu.ksu.cis.bandera.bir.BirConstants;
import edu.ksu.cis.bandera.bir.LockAction;
import edu.ksu.cis.bandera.bir.LockTest;
import edu.ksu.cis.bandera.bir.ThreadLocTest;
import edu.ksu.cis.bandera.bir.Location;
import edu.ksu.cis.bandera.bir.LocVector;
import edu.ksu.cis.bandera.bir.StateVar;
import edu.ksu.cis.bandera.bir.Transformation;
import edu.ksu.cis.bandera.bir.ActionVector;
import edu.ksu.cis.bandera.bir.TransVector;
import edu.ksu.cis.bandera.bir.BirTrace;
import edu.ksu.cis.bandera.util.DefaultValues;
import edu.ksu.cis.bandera.prog.HierarchyQuery;

import ca.mcgill.sable.util.*;
import ca.mcgill.sable.soot.*;
import ca.mcgill.sable.soot.jimple.*;

/**
 * Builder is the main class of BIRC, which extracts a transition
 * system from a restricted Jimple representation of a Java program.
 * <p>
 * See the <a href="http://null.ics.hawaii.edu/~corbett/birc.html"> BIRC
 * Release Notes</a> for information on what subset of Jimple is
 * currently supported by BIRC.
 * <p>
 * BIRC is invoked on an array of Soot classes as follows:
 * <pre>
 *  // Parameters
 *  SootClass [] staticClasses = ...; // An array of SootClass objects
 *  String name = ...;                // Name of system (used for filenames)
 *  PredicateSet preds = ...;         // Predicates to embed
 * 
 *  // Invoke BIRC to build the transition system (BIR)
 *  TransSystem system = Builder.createTransSystem(staticClasses, name, preds);
 *  // An alternate version of this call allows for setting of default resource
 *  // constraints in the transition system
 * 
 *  // Print the BIR
 *  PrintWriter writerOut = new PrintWriter(System.out, true);
 *  BirPrinter.print(system, writerOut);
 * </pre>
 */

public class Builder implements BirConstants {

    /**
     * These are the default sizes of collections and arrays.
     * In the future, these should come from the front end.
     */
    public static int COLLECTION_SIZE = DefaultValues.birMaxInstances;
    public static int MAX_ARRAY_LENGTH = DefaultValues.birMaxArrayLen;

    BirThread thread;     // Current thread being built
    StmtGraph stmtGraph;  // Statement graph of current thread
    SootMethod method;    // Method whose body is current thread
    int mark;             // Mark value for depth-first search of Stmt graph
    Vector reachableStmts; // Set of reachable Stmts in Stmt graph

    static TransSystem system;        // Transition system being built
    static TypeExtractor typeExtract; // Type extractor we're using
    static DynamicMap dynamicMap;     // Dynamic map we're using
    static HashSet lockedClasses;     // Set of classes that are locked
    static HashSet parentClasses;     // Set of classes that all supertypes

    private Builder(BirThread thread, StmtGraph stmtGraph, SootMethod method) {
    this.thread = thread;
    this.stmtGraph = stmtGraph;
    this.method = method;
    }
    /**
     * Build a BIR thread from the run() method of a Jimple class.
     * <p>
     * Note: all threads have already been declared (this allows
     * cross references).
     */

    static void buildThread(SootClass sClass, boolean mainClass,
                PredicateSet predSet) {
    // Retrieve thread
    String methodName = (mainClass) ? "main" : "run";
    SootMethod method = sClass.getMethod(methodName);
    BirThread thread = system.threadOfKey(method);

    // Get statement graph for method body
    JimpleBody body = (JimpleBody) 
        new StoredBody(Jimple.v()).resolveFor(method);
    StmtList stmtList = body.getStmtList();
    if (stmtList.size() == 0)
        return;
    CompleteStmtGraph cStmtGraph = new CompleteStmtGraph(stmtList);
    LocalDefs localDefs = new SimpleLocalDefs(cStmtGraph);
    LiveLocals liveLocals = new SparseLiveLocals(cStmtGraph);
    BriefStmtGraph stmtGraph = new BriefStmtGraph(stmtList);

    // Set start location and main
    Stmt head = (Stmt) stmtList.get(0);
    Location startLoc = system.locationOfKey(head, thread);
    thread.setStartLoc(startLoc);
    thread.setMain(mainClass);

    // Make state vars for locals
    Iterator localIt = body.getLocals().iterator();
    while (localIt.hasNext()) {
        Local local = (Local) localIt.next();
        String key = ExprExtractor.localKey(method, local);
        declareVar(key, local.getName(), local.getType(), thread);
    }
    
    // Collect reachable statements by walking stmtGraph
    Builder builder = new Builder(thread, stmtGraph, method);
    Vector reachableStmts = builder.reachableFrom(head);

    // Extract BIR from each reachable statement
    TransExtractor extractor = 
        new TransExtractor(system, thread, stmtGraph, localDefs, 
                   liveLocals, method, typeExtract, predSet);
    for (int i = 0; i < reachableStmts.size(); i++) 
        ((Stmt)reachableStmts.elementAt(i)).apply(extractor);
    }
    /**
     * Check for statics on the left and right side of a definition Stmt.
     * If found, and the class of the static has not already been processed,
     * declare a new BIR global variable for the static fields of the class.
     */

    static void checkForStatics(DefinitionStmt defStmt, Hashtable done) {
    if (defStmt.getRightOp() instanceof StaticFieldRef) {
        StaticFieldRef fieldRef = (StaticFieldRef)defStmt.getRightOp();
        SootClass sClass = fieldRef.getField().getDeclaringClass();
        if (done.get(sClass) == null) {
        declareClassGlobals(sClass);
        done.put(sClass,sClass);
        }
    }
    if (defStmt.getLeftOp() instanceof StaticFieldRef) {
        StaticFieldRef fieldRef = (StaticFieldRef)defStmt.getLeftOp();
        SootClass sClass = fieldRef.getField().getDeclaringClass();
        if (done.get(sClass) == null) {
        declareClassGlobals(sClass);
        done.put(sClass,sClass);
        }
    }
    }
    /**
     * Given the dynamic map, create a collection for each collection key
     * that was declared in the map.  The size of a collection is the
     * sum of the sizes of all map entries stored in that collection.
     */

    static void createCollections() {
    // For each collection key K of class C, 
    // create K_col = collection [N] of C, where N is the sum
    // of the sizes of all allocators with key K.
    // Also, add K_col to C_ref.  
    Vector keys = dynamicMap.getCollections();
    for (int i = 0; i < keys.size(); i++) {
        String name;
        edu.ksu.cis.bandera.bir.Type elementType;
        edu.ksu.cis.bandera.bir.Type collectType;

        // First, create the collection type and variable
        Object key = keys.elementAt(i);
        int size = dynamicMap.getCollectionSize(key);
        SootClass sootClass = dynamicMap.getCollectionClass(key);
        ArrayType arrayType = dynamicMap.getCollectionArray(key);
        // key is either class collection or array collection
        if (sootClass != null) {
        elementType = typeExtract.getRecordType(sootClass);
        name = sootClass.getName();
        } else {
        elementType = typeExtract.getArrayType(arrayType);
        name = typeExtract.arrayName(arrayType);
        }
        collectType = typeExtract.createCollectionType(elementType,size);
        StateVar col = 
        system.declareVar(key,name + "_col",null,collectType,null);

        // Now add the collection to the ref types that could refer to it
        if (sootClass != null) {
        // A class collection can be referenced by the ref type
        // for that class, all superclasses, and any 
        // implemented interfaces
        typeExtract.getRefType(sootClass).addTarget(col, sootClass, typeExtract);
        Vector superClasses = typeExtract.getSuperClasses(sootClass);
        for (int j = 0; j < superClasses.size(); j++) {
            SootClass supClass = (SootClass) superClasses.elementAt(j);
            typeExtract.getRefType(supClass).addTarget(col, sootClass, typeExtract);
        }
        Vector intClasses = typeExtract.getInterfaceClasses(sootClass);
        for (int j = 0; j < intClasses.size(); j++) {
            SootClass intClass = (SootClass) intClasses.elementAt(j);
            typeExtract.getRefType(intClass).addTarget(col, sootClass, typeExtract);
        }
        } else
        // An array collection can be referenced only by the
        // ref type of the array
        typeExtract.getRefType(arrayType).addTarget(col);
    }   
    }
    /**
     * For each Jimple class and array type, create a corresponding
     * BIR record/array type using the type extractor.
     */

    static void createRecordAndArrayTypes() {
    // Record the supertypes of dynamically allocated classes
    // also determine which of those are locked
    Vector sootClasses = dynamicMap.getClasses();
    for (int i = 0; i < sootClasses.size(); i++) {
        SootClass sootClass = (SootClass) sootClasses.elementAt(i);
            SootClass ancestor = sootClass;
            while (ancestor.hasSuperClass()) {
              ancestor = ancestor.getSuperClass();
              if (lockedClasses.contains(ancestor)) 
         lockedClasses.add(sootClass);
        }
        }

    // For each class C, create C_rec = record { ... }
    // 
    // There are two cases:
    //   1) the dynamically allocated classes which should be
    //      created with an indication of wether instances may be locked
    //   2) the unallocated classes that are locked, i.e., that
    //      may be supertypes of dynamically allocated classes
    //
       
    // First handle all the dynamically allocated classes
    sootClasses = dynamicMap.getClasses();
    for (int i = 0; i < sootClasses.size(); i++) {
        SootClass sootClass = (SootClass) sootClasses.elementAt(i);
        typeExtract.createRecordType(sootClass, 
                     lockedClasses.contains(sootClass));
    }

    // Second handle all the unallocated locked classes
    for (Iterator pIt = parentClasses.iterator(); pIt.hasNext(); ) {
        SootClass sootClass = (SootClass) pIt.next();
        typeExtract.createRecordType(sootClass, 
                     lockedClasses.contains(sootClass));
    }

    // For each array type T, create T_arr = array [K] of T
    Vector arrayTypes = dynamicMap.getArrays();
    for (int i = 0; i < arrayTypes.size(); i++) {
        ArrayType arrayType = (ArrayType) arrayTypes.elementAt(i);
        typeExtract.createArrayType(arrayType,MAX_ARRAY_LENGTH);
    }
    }
    /**
     * Once the dynamic map has been constructed, create a reference
     * type for each class, array type, and interface.  These types
     * will be used to represent the Java reference types of the Jimple.
     * <p>
     * Note that, at this point, we have not yet created the collections,
     * the the reference types are unresolved.
     */

    static void createRefTypes() {
    // For each class C, create C_ref = ref {} (unresolved)
    Vector sootClasses = dynamicMap.getClasses();
    for (int i = 0; i < sootClasses.size(); i++) {
        SootClass sootClass = (SootClass) sootClasses.elementAt(i);
        typeExtract.createRefType(sootClass);
    }

    // For each parent of an allocated class create a ref
        for (Iterator pIt = parentClasses.iterator(); pIt.hasNext(); ) {
            SootClass sootClass = (SootClass) pIt.next();
            typeExtract.createRefType(sootClass);
        }

    // For each array type T, create T_ref = ref {} (unresolved)
    Vector arrayTypes = dynamicMap.getArrays();
    for (int i = 0; i < arrayTypes.size(); i++) {
        ArrayType arrayType = (ArrayType) arrayTypes.elementAt(i);
        typeExtract.createRefType(arrayType);
    }
    // For each interface I, create I_ref = ref {} (unresolved)
    Vector interfaces = dynamicMap.getInterfaces();
    for (int i = 0; i < interfaces.size(); i++) {
        SootClass sootClass = (SootClass) interfaces.elementAt(i);
        typeExtract.createRefType(sootClass);
    }
    }
    /**
     * Creates a transition system from a set of Soot classes.
     *
     * @param sootClasses an array of SootClass objects containing
     *  methods that represent the code executed by threads.
     *  The first class must have a static method <tt>main()</tt>
     *  and the remaining classes must each have a static method
     *  <tt>run()</tt>.
     * @param name name of transition system (used to generate filenames)
     * @param predSet set of predicates to embed (can be null)
     * @param maxArrayLength maximum length of an array
     * @param maxCollectSize maximum size of a heap collection
     * @param minInt minimum value for integer
     * @param maxInt maximum value for integer
     * @return a transition system representing the Soot classes
     */

    public static TransSystem createTransSystem(SootClass [] sootClasses,
                        String name, 
                        int maxArrayLength, 
                        int maxCollectSize, 
                        int minInt, 
                        int maxInt, 
                        PredicateSet predSet) {
    MAX_ARRAY_LENGTH = maxArrayLength;
    COLLECTION_SIZE = maxCollectSize;
    edu.ksu.cis.bandera.bir.Type.defaultRangeType = new edu.ksu.cis.bandera.bir.Range(minInt, maxInt);
        return createTransSystem(sootClasses, name, predSet);
    }
    /**
     * Creates a transition system from a set of Soot classes.
     *
     * @param threadClasses an array of SootClass objects containing
     *  methods that represent the code executed by threads.
     *  The first class must have a static method <tt>main()</tt>
     *  and the remaining classes must each have a method
     *  <tt>run()</tt>.
     * @param allClasses an array of SootClass objects referenced
     * @param name name of transition system (used to generate filenames)
     * @param predSet set of predicates to embed (can be null)
     * @return a transition system representing the Soot classes
     */

    public static TransSystem createTransSystem(SootClass [] sootClasses,
                        String name, 
                        PredicateSet predSet) {
    if (predSet == null)
        predSet = new PredicateSet();   // Create empty set so non-null
    system = new TransSystem(name);
    typeExtract = new TypeExtractor(system, sootClasses[0].getManager());

    // Declare classes, threads, and global variables
    declareClasses(sootClasses);
    for (int i = 0; i < sootClasses.length; i++) 
        declareThread(sootClasses[i], (i == 0));
    declareGlobals(sootClasses);

    // Build all threads
    for (int i = 0; i < sootClasses.length; i++) 
        buildThread(sootClasses[i], (i == 0), predSet);

    // Reduce the transition system and number the locations
    (new Reducer(system)).run();
    system.numberLocations();

    // Declare the predicates
    declarePredicates(predSet);
    return system;
    }
    static void declareClasses(SootClass [] sootClasses) {
    identifyAllocatorsLocks(sootClasses);
    createRefTypes();
    createRecordAndArrayTypes();
    createCollections();
    }
    /**
     * Declare a BIR variable for each static field of a class.
     * <p>
     * Note: we ignore the built-in classes in any subpackage of java.*
     */


    static void declareClassGlobals(SootClass sClass) {
    // Ignore built-in classes
    if (sClass.getName().startsWith("java."))
        return;

    // Declare state variable for each static field
    Iterator fieldIt = sClass.getFields().iterator();        
    while(fieldIt.hasNext()) {
        SootField field = (SootField) fieldIt.next();
        if (Modifier.isStatic(field.getModifiers())) 
        declareVar(field, field.getName(), field.getType(), null);
    }

    // Scan the <clinit> method for initializations to static fields
    if (sClass.declaresMethod("<clinit>")) {
        SootMethod method = sClass.getMethod("<clinit>");
        JimpleBody body = (JimpleBody) 
        new StoredBody(Jimple.v()).resolveFor(method);
        StmtList stmtList = body.getStmtList();
        for (int i = 0; i < stmtList.size(); i++) {
        if (stmtList.get(i) instanceof AssignStmt) {
            AssignStmt stmt = (AssignStmt) stmtList.get(i);
            if (stmt.getLeftOp() instanceof StaticFieldRef) {
            StaticFieldRef lhs = (StaticFieldRef)stmt.getLeftOp();
            if (lhs.getType() instanceof RefType)
                warn("ignoring initialization of " + lhs);
            else
                initializeGlobal(lhs, stmt.getRightOp());
            }
        }
        }
    }
    }
    /**
     * Declare global BIR variables for all Jimple static variables
     * referenced in the body of some thread.
     * <p>
     * Also declare a 'this' variable for each thread except the main
     * thread to hold the reference to the Runnable or Thread object 
     * that owns the thread's run() method.
     */

    static void declareGlobals(SootClass [] sootClasses) {
    Hashtable done = new Hashtable();  // Classes we've already processed
    for (int i = 0; i < sootClasses.length; i++) {
        SootClass sClass = sootClasses[i];
        List methods = sootClasses[i].getMethods();
        Iterator methodIt = methods.iterator();
        while (methodIt.hasNext()) {
        SootMethod method = (SootMethod) methodIt.next();
        JimpleBody body = (JimpleBody) 
            new StoredBody(Jimple.v()).resolveFor(method);
        StmtList stmtList = body.getStmtList();
        for (int j = 0; j < stmtList.size(); j++) {
            Stmt stmt = (Stmt) stmtList.get(j);
            if (stmt instanceof DefinitionStmt) 
            checkForStatics((DefinitionStmt)stmt,done);
        }
        }
        if (i > 0) {  // Declare 'this' variable (except for main thread)
        String name = sClass.getName() + "__this";
        Type type = RefType.v(sClass.getName());
        StateVar var = declareVar(sClass,name,type,null);
        var.setConstant(true);
        }
    }
    }
    /**
     * For each predicate declared, use an expression extractor 
     * to translate the Jimple Expr for the predicate into a BIR Expr,
     * then declare that as the BIR predciate.
     */

    static void declarePredicates(PredicateSet predSet) {
    Vector valPreds = predSet.getValuePredicates();
    for (int i = 0; i < valPreds.size(); i++) {
        Expr valPred = (Expr) valPreds.elementAt(i);
        ExprExtractor extractor = 
        new ExprExtractor(system,null,null,null,typeExtract,predSet);
        valPred.apply(extractor);
        edu.ksu.cis.bandera.bir.Expr predExpr = 
        (edu.ksu.cis.bandera.bir.Expr) extractor.getResult();
        system.declarePredicate(predSet.predicateName(valPred),predExpr);
    }
    }
    static void declareThread(SootClass sClass, boolean mainClass) {
    // Create thread for run() or main() method
    String methodName = (mainClass) ? "main" : "run";
    SootMethod method = sClass.getMethod(methodName);
    system.createThread(sClass.getName(), method);
    }
    /**
     * Declare a BIR variable in the transition system.
     * <p>
     * The type extractor is used to convert the SootType into a BIR type.
     * If the SootType is not representable (type extractor returns null),
     * then we ignore this variable (with a warning).
     */

    static StateVar declareVar(Object key, String name, Type sootType, 
               BirThread thread) {
    sootType.apply(typeExtract);
    edu.ksu.cis.bandera.bir.Type type = 
        (edu.ksu.cis.bandera.bir.Type) typeExtract.getResult();
    if (type == null) {
        warn("ignoring object of type " + sootType);
        return null;
    }
    // if ((thread == null) || type.isKind(RANGE | BOOL | ENUMERATED))
    return system.declareVar(key, name, thread, type, null);
    }
    void findReachableFrom(Stmt stmt) {
    Location loc = system.locationOfKey(stmt, thread);
    if (loc.getMark() != mark) {
        loc.setMark(mark);
        Iterator stmtIt = stmtGraph.getSuccsOf(stmt).iterator();
        // Don't include the 'return' statement at the end
        if (stmtIt.hasNext())
        reachableStmts.addElement(stmt);
        while (stmtIt.hasNext()) {
        Stmt nextStmt = (Stmt) stmtIt.next();
        findReachableFrom(nextStmt);
        }
    }
    }
    /**
     * Heap objects are stored in BIR collections, which must be declared.
     * We build a "dynamic map" that defines, for each allocator site
     * (NewExpr or NewArrayExpr), which collection will hold the elements 
     * of that site.
     * <p>
     * Currently, we simply create a collection for each allocator site.
     * <p>
     * This method accepts the soot classes that define the bodies of the
     * threads, and it looks for allocator expressions in the code for
     * these threads, defining a dynamic map entry for each.
     * <p>
     * In addition this code determines the set of types that are
     * explicitly locked in statements that are reachable from the
     * threads.  These will be used to determine which classes need
     * to have locks allocated in the model.
     */

    static void identifyAllocatorsLocks(SootClass [] sootClasses) {
    dynamicMap = new DynamicMap(sootClasses[0].getManager());
    lockedClasses = new HashSet();  
    HashSet dynamicClasses = new HashSet();
    // Look through all Stmts of all methods of all classes
    for (int i = 0; i < sootClasses.length; i++) {
        List methods = sootClasses[i].getMethods();
        Iterator methodIt = methods.iterator();
        while (methodIt.hasNext()) {
        SootMethod method = (SootMethod) methodIt.next();
        JimpleBody body = (JimpleBody) 
            new StoredBody(Jimple.v()).resolveFor(method);
        StmtList stmtList = body.getStmtList();
        for (int j = 0; j < stmtList.size(); j++) {
            Stmt stmt = (Stmt) stmtList.get(j);
            // Look for Definition statements with a NewExpr on the RHS
            if (stmt instanceof DefinitionStmt) {
            DefinitionStmt defStmt = (DefinitionStmt)stmt;
            if (defStmt.getRightOp() instanceof NewExpr) {
                NewExpr newExpr = (NewExpr) defStmt.getRightOp();
                // Filter out exception classes
                        SootClass newClass = sootClasses[0].getManager().getClass(newExpr.getBaseType().className);

                boolean throwableClass = false;
                        SootClass ancestor = newClass;
                            while (ancestor.hasSuperClass()) {
                              ancestor = ancestor.getSuperClass();
                          if (ancestor.getName().equals("java.lang.Throwable")) {
                     throwableClass = true;
                  }
                }
                if (!throwableClass) {
                   dynamicMap.addEntry(newExpr, newExpr, 
                        COLLECTION_SIZE);
                           dynamicClasses.add(sootClasses[0].getManager().getClass(newExpr.getBaseType().className));
                }
            }
            if (defStmt.getRightOp() instanceof NewArrayExpr) {
                NewArrayExpr newExpr = 
                (NewArrayExpr) defStmt.getRightOp();
                dynamicMap.addEntry(newExpr, newExpr, 
                        COLLECTION_SIZE,
                        MAX_ARRAY_LENGTH);
            }           
            if (defStmt.getRightOp() instanceof NewMultiArrayExpr) 
                warn("multi-dimensional arrays not supported");
            }

            // Look for enter monitor statements and record type of arg
                if (stmt instanceof EnterMonitorStmt) {
                    EnterMonitorStmt enterStmt = (EnterMonitorStmt)stmt;
                        Type type = enterStmt.getOp().getType();
                        if (type instanceof RefType) {  
                          lockedClasses.add(sootClasses[0].getManager().getClass(((RefType)type).className));
                        }
                }
        }       
        }
    }
    parentClasses = new HashSet();
    for (Iterator dcIt = dynamicClasses.iterator(); dcIt.hasNext(); ) {
        SootClass sootClass = (SootClass) dcIt.next();
        // Build the Ancestor map for use in resolving reference typing
        HierarchyQuery.buildAncestors(sootClass);

        // Generate the parents
            SootClass ancestor = sootClass;
            while (ancestor.hasSuperClass()) {
              ancestor = ancestor.getSuperClass();
          if (!dynamicClasses.contains(ancestor)) {
         parentClasses.add(ancestor);
             HierarchyQuery.buildAncestors(ancestor);
          }
        }
        }
    dynamicMap.print();
    }
    /**
     * Set initial value of static field.
     * <p>
     * Currently, this only works if the assigned value is static.
     */


    static void initializeGlobal(StaticFieldRef lhs, Value rhs) {
    StateVar var = system.getVarOfKey(lhs.getField());
    ExprExtractor extractor = new ExprExtractor(system, null, null, null,
                            typeExtract, 
                            new PredicateSet());
    rhs.apply(extractor);
    if (extractor.getResult() != null)
        var.setInitVal((edu.ksu.cis.bandera.bir.Expr)
               extractor.getResult());
    }
    /**
     * Interpret a BIR trace in terms of the Jimple code from which
     * it was created.
     * 
     * @param trace - a BIR trace of a transition system created by BIRC
     * @return the corresponding Jimple trace 
     */
    public static JimpleTrace interpretTrace(BirTrace trace) {
    return new JimpleTrace(trace);
    }
    /**
     * Do a depth first search of the statement graph and return
     * a vector of all statements reachable from a given statement.
     * <p>
     * We do this to eliminate exception handlers, which are not
     * reachable in the BriefStmtGraph (the CompleteStmtGraph
     * contains arcs representing possible exception raising,
     * so the exception handlers are reachable in that graph).
     */


    Vector reachableFrom(Stmt stmt) {
    reachableStmts = new Vector();
    mark = Location.getNewMark();
    findReachableFrom(stmt);
    return reachableStmts;
    }
    static void warn(String s) {
    System.out.println("Warning: " + s);
    }
}

---