/*
 * Bytecode Analysis Framework
 * Copyright (C) 2004,2005 University of Maryland
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

package edu.umd.cs.findbugs.ba.vna;

import java.util.BitSet;
import java.util.HashMap;
import java.util.Map;

import org.apache.bcel.generic.InstructionHandle;
import org.apache.bcel.generic.MethodGen;

import edu.umd.cs.findbugs.ba.XField;

/**
 * Object which stores which fields are loaded and stored by the instructions in
 * a method (including through inner-class access methods), and also which
 * fields are loaded/stored by the overall method. The main purpose is for doing
 * redundant load elimination and forward substitution more efficiently, but it
 * might be useful in other situations.
 * 
 * @author David Hovemeyer
 */
public class LoadedFieldSet {
    /**
     * Count number of times a field is loaded and/or stored in the method.
     */
    public static class LoadStoreCount {
        int loadCount, storeCount;

        /** Get the number of times the field is loaded. */
        public int getLoadCount() {
            return loadCount;
        }

        /** Get the number of times the field is stored. */
        public int getStoreCount() {
            return storeCount;
        }
    }

    // Fields
    // private MethodGen methodGen;
    private Map<XField, LoadStoreCount> loadStoreCountMap;

    private Map<InstructionHandle, XField> handleToFieldMap;

    private BitSet loadHandleSet;

    /**
     * Constructor. Constructs an empty object.
     * 
     * @param methodGen
     *            the method being analyzed for loads/stores
     */
    public LoadedFieldSet(MethodGen methodGen) {
        // this.methodGen = methodGen;
        this.loadStoreCountMap = new HashMap<XField, LoadStoreCount>();
        this.handleToFieldMap = new HashMap<InstructionHandle, XField>();
        this.loadHandleSet = new BitSet();
    }

    /**
     * Get the number of times given field is loaded and stored within the
     * method.
     * 
     * @param field
     *            the field
     * @return the load/store count object
     */
    public LoadStoreCount getLoadStoreCount(XField field) {
        LoadStoreCount loadStoreCount = loadStoreCountMap.get(field);
        if (loadStoreCount == null) {
            loadStoreCount = new LoadStoreCount();
            loadStoreCountMap.put(field, loadStoreCount);
        }
        return loadStoreCount;
    }

    /**
     * Add a load of given field at given instruction.
     * 
     * @param handle
     *            the instruction
     * @param field
     *            the field
     */
    public void addLoad(InstructionHandle handle, XField field) {
        getLoadStoreCount(field).loadCount++;
        handleToFieldMap.put(handle, field);
        loadHandleSet.set(handle.getPosition());
    }

    /**
     * Add a store of given field at given instruction.
     * 
     * @param handle
     *            the instruction
     * @param field
     *            the field
     */
    public void addStore(InstructionHandle handle, XField field) {
        getLoadStoreCount(field).storeCount++;
        handleToFieldMap.put(handle, field);
    }

    /**
     * Get the field loaded or stored at given instruction, if any.
     * 
     * @param handle
     *            the instruction
     * @return the field loaded or stored at the instruction, or null if the
     *         instruction is not a load or store
     */
    public XField getField(InstructionHandle handle) {
        return handleToFieldMap.get(handle);
    }

    /**
     * Return whether or not the given field is loaded by any instruction in the
     * method.
     * 
     * @param field
     *            the field
     * @return true if the field is loaded somewhere in the method, false if it
     *         is never loaded
     */
    public boolean isLoaded(XField field) {
        return getLoadStoreCount(field).loadCount > 0;
    }

    /**
     * Return whether or not the given instruction is a load.
     * 
     * @param handle
     *            the instruction
     * @return true if the instruction is a load, false if not
     */
    public boolean instructionIsLoad(InstructionHandle handle) {
        return loadHandleSet.get(handle.getPosition());
    }
}

// vim:ts=4