/*
* Copyright (C) 2007 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.dx.cf.code;
import com.android.dx.rop.code.RegisterSpec;
import com.android.dx.rop.type.Type;
import com.android.dx.rop.type.TypeBearer;
import com.android.dx.util.ExceptionWithContext;
import com.android.dx.util.Hex;
import com.android.dx.util.MutabilityControl;
import java.util.ArrayList;
/**
* Representation of a set of local variable arrays, with Java semantics.
* This peculiar case is to support in-method subroutines, which can
* have different locals sets for each caller.
*
* <p><b>Note:</b> For the most part, the documentation for this class
* ignores the distinction between {@link com.android.dx.rop.type.Type} and {@link
* com.android.dx.rop.type.TypeBearer}.</p>
*/
public class LocalsArraySet extends LocalsArray {
/**
* The primary LocalsArray represents the locals as seen from
* the subroutine itself, which is the merged representation of all the
* individual locals states.
*/
private final OneLocalsArray primary;
/**
* Indexed by label of caller block: the locals specific to each caller's
* invocation of the subroutine.
*/
private final ArrayList<LocalsArray> secondaries;
/**
* Constructs an instance. The locals array initially consists of
* all-uninitialized values (represented as {@code null}s).
*
* @param maxLocals {@code >= 0;} the maximum number of locals this instance
* can refer to
*/
public LocalsArraySet(int maxLocals) {
super(maxLocals != 0);
primary = new OneLocalsArray(maxLocals);
secondaries = new ArrayList();
}
/**
* Constructs an instance with the specified primary and secondaries set.
*
* @param primary {@code non-null;} primary locals to use
* @param secondaries {@code non-null;} secondaries set, indexed by subroutine
* caller label.
*/
public LocalsArraySet(OneLocalsArray primary,
ArrayList<LocalsArray> secondaries) {
super(primary.getMaxLocals() > 0);
this.primary = primary;
this.secondaries = secondaries;
}
/**
* Constructs an instance which is a copy of another.
*
* @param toCopy {@code non-null;} instance to copy.
*/
private LocalsArraySet(LocalsArraySet toCopy) {
super(toCopy.getMaxLocals() > 0);
primary = toCopy.primary.copy();
secondaries = new ArrayList(toCopy.secondaries.size());
int sz = toCopy.secondaries.size();
for (int i = 0; i < sz; i++) {
LocalsArray la = toCopy.secondaries.get(i);
if (la == null) {
secondaries.add(null);
} else {
secondaries.add(la.copy());
}
}
}
/** @inheritDoc */
@Override
public void setImmutable() {
primary.setImmutable();
for (LocalsArray la : secondaries) {
if (la != null) {
la.setImmutable();
}
}
super.setImmutable();
}
/** @inheritDoc */
@Override
public LocalsArray copy() {
return new LocalsArraySet(this);
}
/** @inheritDoc */
@Override
public void annotate(ExceptionWithContext ex) {
ex.addContext("(locals array set; primary)");
primary.annotate(ex);
int sz = secondaries.size();
for (int label = 0; label < sz; label++) {
LocalsArray la = secondaries.get(label);
if (la != null) {
ex.addContext("(locals array set: primary for caller "
+ Hex.u2(label) + ')');
la.getPrimary().annotate(ex);
}
}
}
/** {@inheritDoc*/
public String toHuman() {
StringBuilder sb = new StringBuilder();
sb.append("(locals array set; primary)\n");
sb.append(getPrimary().toHuman());
sb.append('\n');
int sz = secondaries.size();
for (int label = 0; label < sz; label++) {
LocalsArray la = secondaries.get(label);
if (la != null) {
sb.append("(locals array set: primary for caller "
+ Hex.u2(label) + ")\n");
sb.append(la.getPrimary().toHuman());
sb.append('\n');
}
}
return sb.toString();
}
/** @inheritDoc */
@Override
public void makeInitialized(Type type) {
int len = primary.getMaxLocals();
if (len == 0) {
// We have to check for this before checking for immutability.
return;
}
throwIfImmutable();
primary.makeInitialized(type);
for (LocalsArray la : secondaries) {
if (la != null) {
la.makeInitialized(type);
}
}
}
/** @inheritDoc */
@Override
public int getMaxLocals() {
return primary.getMaxLocals();
}
/** @inheritDoc */
@Override
public void set(int idx, TypeBearer type) {
throwIfImmutable();
primary.set(idx, type);
for (LocalsArray la : secondaries) {
if (la != null) {
la.set(idx, type);
}
}
}
/** @inheritDoc */
@Override
public void set(RegisterSpec spec) {
set(spec.getReg(), spec);
}
/** @inheritDoc */
@Override
public void invalidate(int idx) {
throwIfImmutable();
primary.invalidate(idx);
for (LocalsArray la : secondaries) {
if (la != null) {
la.invalidate(idx);
}
}
}
/** @inheritDoc */
@Override
public TypeBearer getOrNull(int idx) {
return primary.getOrNull(idx);
}
/** @inheritDoc */
@Override
public TypeBearer get(int idx) {
return primary.get(idx);
}
/** @inheritDoc */
@Override
public TypeBearer getCategory1(int idx) {
return primary.getCategory1(idx);
}
/** @inheritDoc */
@Override
public TypeBearer getCategory2(int idx) {
return primary.getCategory2(idx);
}
/**
* Merges this set with another {@code LocalsArraySet} instance.
*
* @param other {@code non-null;} to merge
* @return {@code non-null;} this instance if merge was a no-op, or
* new merged instance.
*/
private LocalsArraySet mergeWithSet(LocalsArraySet other) {
OneLocalsArray newPrimary;
ArrayList<LocalsArray> newSecondaries;
boolean secondariesChanged = false;
newPrimary = primary.merge(other.getPrimary());
int sz1 = secondaries.size();
int sz2 = other.secondaries.size();
int sz = Math.max(sz1, sz2);
newSecondaries = new ArrayList(sz);
for (int i = 0; i < sz; i++) {
LocalsArray la1 = (i < sz1 ? secondaries.get(i) : null);
LocalsArray la2 = (i < sz2 ? other.secondaries.get(i) : null);
LocalsArray resultla = null;
if (la1 == la2) {
resultla = la1;
} else if (la1 == null) {
resultla = la2;
} else if (la2 == null) {
resultla = la1;
} else {
try {
resultla = la1.merge(la2);
} catch (SimException ex) {
ex.addContext(
"Merging locals set for caller block " + Hex.u2(i));
}
}
secondariesChanged = secondariesChanged || (la1 != resultla);
newSecondaries.add(resultla);
}
if ((primary == newPrimary) && ! secondariesChanged ) {
return this;
}
return new LocalsArraySet(newPrimary, newSecondaries);
}
/**
* Merges this set with a {@code OneLocalsArray} instance.
*
* @param other {@code non-null;} to merge
* @return {@code non-null;} this instance if merge was a no-op, or
* new merged instance.
*/
private LocalsArraySet mergeWithOne(OneLocalsArray other) {
OneLocalsArray newPrimary;
ArrayList<LocalsArray> newSecondaries;
boolean secondariesChanged = false;
newPrimary = primary.merge(other.getPrimary());
newSecondaries = new ArrayList(secondaries.size());
int sz = secondaries.size();
for (int i = 0; i < sz; i++) {
LocalsArray la = secondaries.get(i);
LocalsArray resultla = null;
if (la != null) {
try {
resultla = la.merge(other);
} catch (SimException ex) {
ex.addContext("Merging one locals against caller block "
+ Hex.u2(i));
}
}
secondariesChanged = secondariesChanged || (la != resultla);
newSecondaries.add(resultla);
}
if ((primary == newPrimary) && ! secondariesChanged ) {
return this;
}
return new LocalsArraySet(newPrimary, newSecondaries);
}
/** @inheritDoc */
@Override
public LocalsArraySet merge(LocalsArray other) {
LocalsArraySet result;
try {
if (other instanceof LocalsArraySet) {
result = mergeWithSet((LocalsArraySet) other);
} else {
result = mergeWithOne((OneLocalsArray) other);
}
} catch (SimException ex) {
ex.addContext("underlay locals:");
annotate(ex);
ex.addContext("overlay locals:");
other.annotate(ex);
throw ex;
}
result.setImmutable();
return result;
}
/**
* Gets the {@code LocalsArray} instance for a specified subroutine
* caller label, or null if label has no locals associated with it.
*
* @param label {@code >= 0;} subroutine caller label
* @return {@code null-ok;} locals if available.
*/
private LocalsArray getSecondaryForLabel(int label) {
if (label >= secondaries.size()) {
return null;
}
return secondaries.get(label);
}
/** {@inheritDoc} */
@Override
public LocalsArraySet mergeWithSubroutineCaller
(LocalsArray other, int predLabel) {
LocalsArray mine = getSecondaryForLabel(predLabel);
LocalsArray newSecondary;
OneLocalsArray newPrimary;
newPrimary = primary.merge(other.getPrimary());
if (mine == other) {
newSecondary = mine;
} else if (mine == null) {
newSecondary = other;
} else {
newSecondary = mine.merge(other);
}
if ((newSecondary == mine) && (newPrimary == primary)) {
return this;
} else {
/*
* We're going to re-build a primary as a merge of all the
* secondaries.
*/
newPrimary = null;
int szSecondaries = secondaries.size();
int sz = Math.max(predLabel + 1, szSecondaries);
ArrayList<LocalsArray> newSecondaries = new ArrayList(sz);
for (int i = 0; i < sz; i++) {
LocalsArray la = null;
if (i == predLabel) {
/*
* This LocalsArray always replaces any existing one,
* since this is the result of a refined iteration.
*/
la = newSecondary;
} else if (i < szSecondaries) {
la = secondaries.get(i);
}
if (la != null) {
if (newPrimary == null) {
newPrimary = la.getPrimary();
} else {
newPrimary = newPrimary.merge(la.getPrimary());
}
}
newSecondaries.add(la);
}
LocalsArraySet result
= new LocalsArraySet(newPrimary, newSecondaries);
result.setImmutable();
return result;
}
}
/**
* Returns a LocalsArray instance representing the locals state that should
* be used when returning to a subroutine caller.
*
* @param subLabel {@code >= 0;} A calling label of a subroutine
* @return {@code null-ok;} an instance for this subroutine, or null if subroutine
* is not in this set.
*/
public LocalsArray subArrayForLabel(int subLabel) {
LocalsArray result = getSecondaryForLabel(subLabel);
return result;
}
/**{@inheritDoc}*/
@Override
protected OneLocalsArray getPrimary() {
return primary;
}
}