---

JimpleStoreBuilder.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 ca.mcgill.sable.soot.SootClass;
import ca.mcgill.sable.soot.SootField;

import edu.ksu.cis.bandera.bir.*;
import edu.ksu.cis.bandera.jext.*;

import java.util.*;

/**
 * Jimple type switch that constructs a JimpleStore from a BirState
 * by translating BIR literal values into JimpleLiterals (by type).
 * <p>
 * Most cases are straightforward (we just map the BIR Literal to
 * the equivalent Jimple Literal).  For objects (records an arrays),
 * however, we must collect all their components from the BIR state
 * vector into a ClassLiteral or ArrayLiteral.
 */

public class JimpleStoreBuilder extends AbstractTypeSwitch 
    implements BirConstants {

    BirState state;               // BIR state we're working from
    Literal [] birStore;          // Local copy of state vector from BirState
    TransSystem system;

    /**
     * The object table holds the set of ObjectLiterals that we have
     * already constructed.   We want to translate a given object 
     * only once per state, but we may encounter many references 
     * to the same object, so we check this table before constructing
     * an array or record object literal.
     */

    Hashtable objectTable = new Hashtable(); 

    public JimpleStoreBuilder(BirState state) {
    this.state = state;
    this.birStore = state.getStore();
    this.system = state.getSystem();
    }
    public void caseArray(Array type, Object o)
    {
    // See if we've already translated this array 
    // (o = Integer holding the address of the array)
    Object alreadyComputed = objectTable.get(o);
    if (alreadyComputed != null) {
        // If so, return the result of the previous translation
        setResult((ArrayLiteral)alreadyComputed);
        return;
    }
    // Otherwise, collect all the array elements into an ArrayLiteral
    int arrayAddr = getVarOffset(o);
    int length = ((IntLit)getVarValue(o)).getValue();
    ArrayLiteral array = new ArrayLiteral(length,arrayAddr);
    // Store this literal so we won't translate this array again
    objectTable.put(o,array);
    for (int i = 0; i < length; i++) {
        int address = arrayAddr + 1 + i;
        // Translate the ith array element
        type.getBaseType().apply(this, new Integer(address));
        array.contents[i] = (JimpleLiteral) getResult();
    }
    setResult(array);
    }
    public void caseBool(Bool type, Object o)
    {
        // robbyjo's patch begin
        Literal ll = getVarValue(o);
        boolean value = false;
        if (ll instanceof BoolLit)
            value = ((BoolLit) ll).getValue();
        else if (ll instanceof IntLit)
            value = ((IntLit) ll).getValue() == 0;

        // robbyjo's patch end
        setResult(new BooleanLiteral(value));
    }
    public void caseLock(Lock type, Object o)
    {
    LockLit lock = (LockLit) getVarValue(o);
    setResult(new LockLiteral(lock));
    }
    public void caseRange(Range type, Object o) 
    {
    int value = ((IntLit)getVarValue(o)).getValue();
    setResult(new IntegerLiteral(value));
    }
    public void caseRecord(Record type, Object o)
    {
    // See if we've already translated this record 
    // (o = Integer holding the address of the record)
    Object alreadyComputed = objectTable.get(o);
    if (alreadyComputed != null) {
        // If so, return result of previous translation
        setResult((ClassLiteral)alreadyComputed);
        return;
    }
    // Otherwise, collect all the fields into a ClassLiteral
    int recAddr = getVarOffset(o);
    ClassLiteral classLit = 
        new ClassLiteral((SootClass)system.getSource(type),recAddr);
    // Store this literal so we won't translate this record again
    objectTable.put(o, classLit);
    Vector fields = type.getFields();
    for (int i = 0; i < fields.size(); i++) {
        Field field = (Field) fields.elementAt(i);
        SootField sField = (SootField) system.getSource(field);
        int address = recAddr + field.getOffset();
        // Translate field value
        field.getType().apply(this, new Integer(address));
        JimpleLiteral value = (JimpleLiteral)getResult();
        // The BIRLock field is special---it has no source
        if (sField != null)
        classLit.setFieldValue(sField,value);
        else
        classLit.setLockValue(value);
    }
    setResult(classLit);
    }
    public void caseRef(Ref type, Object o)
    {
    Literal value = getVarValue(o);
    if (value instanceof RefLit) {
        // Translate the target pointed to and then return
        // a ReferenceLiteral pointing to this value
        RefLit ref = (RefLit) getVarValue(o);
        int address = ref.getCollection().getOffset();
        if (ref.getCollection().getType().isKind(COLLECTION)) 
        address += ref.getIndex() * type.getTargetType().getExtent();
        Type targetType = ref.getTargetType();
        targetType.apply(this, new Integer(address));
        setResult(new ReferenceLiteral((JimpleLiteral)getResult()));
    } else  // NullExpr
        setResult(new ReferenceLiteral(null));
    }
    public void defaultCase(Object obj) 
    {
    throw new RuntimeException("Case not handled: " + obj);
    }
    /**
     * Get offset of context in state vector.
     * <p>
     * The context is either an Integer (address) or StateVar.
     */

    int getVarOffset(Object context) {
    if (context instanceof Integer)
        return ((Integer)context).intValue();
    else
        return ((StateVar)context).getOffset();
    }
    /**
     * Get the value of a context in the state vector.
     */

    Literal getVarValue(Object context) {
    return birStore[getVarOffset(context)];
    }
}

---