|
|
@ -29,20 +29,98 @@ import jode.LocalInfo; |
|
|
|
* Note that a variable set can contain LocalInfos that use the same |
|
|
|
* Note that a variable set can contain LocalInfos that use the same |
|
|
|
* slot, but are different. |
|
|
|
* slot, but are different. |
|
|
|
*/ |
|
|
|
*/ |
|
|
|
public class VariableSet extends java.util.Vector { |
|
|
|
public class VariableSet implements Cloneable { |
|
|
|
|
|
|
|
LocalInfo[] locals; |
|
|
|
|
|
|
|
int count; |
|
|
|
|
|
|
|
|
|
|
|
/** |
|
|
|
/** |
|
|
|
* Creates a new empty variable set |
|
|
|
* Creates a new empty variable set |
|
|
|
*/ |
|
|
|
*/ |
|
|
|
public VariableSet() { |
|
|
|
public VariableSet() { |
|
|
|
super(0, 0); |
|
|
|
locals = null; |
|
|
|
|
|
|
|
count = 0; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
|
|
|
* Creates a new pre initialized variable set |
|
|
|
|
|
|
|
*/ |
|
|
|
|
|
|
|
public VariableSet(LocalInfo[] locals) { |
|
|
|
|
|
|
|
count = locals.length; |
|
|
|
|
|
|
|
this.locals = locals; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
public final void grow(int size) { |
|
|
|
|
|
|
|
if (locals != null) { |
|
|
|
|
|
|
|
size += count; |
|
|
|
|
|
|
|
if (size > locals.length) { |
|
|
|
|
|
|
|
int nextSize = locals.length * 2; |
|
|
|
|
|
|
|
// System.err.println("wanted: "+size+" next: "+nextSize);
|
|
|
|
|
|
|
|
LocalInfo[] newLocals |
|
|
|
|
|
|
|
= new LocalInfo[nextSize > size ? nextSize : size]; |
|
|
|
|
|
|
|
System.arraycopy(locals, 0, newLocals, 0, count); |
|
|
|
|
|
|
|
locals = newLocals; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
} else if (size > 0) |
|
|
|
|
|
|
|
locals = new LocalInfo[size]; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/** |
|
|
|
/** |
|
|
|
* Adds a local variable to the variable set. |
|
|
|
* Adds a local info to this variable set. It doesn't check for |
|
|
|
* @param li The local variable of type LocalInfo. |
|
|
|
* duplicates. |
|
|
|
*/ |
|
|
|
*/ |
|
|
|
public void addElement(LocalInfo li) { |
|
|
|
public void addElement(LocalInfo li) { |
|
|
|
super.addElement((Object)li); |
|
|
|
grow(1); |
|
|
|
|
|
|
|
locals[count++] = li; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
|
|
|
* Checks if the variable set contains the given local info. |
|
|
|
|
|
|
|
*/ |
|
|
|
|
|
|
|
public boolean contains(LocalInfo li) { |
|
|
|
|
|
|
|
li = li.getLocalInfo(); |
|
|
|
|
|
|
|
for (int i=0; i<count;i++) |
|
|
|
|
|
|
|
if (locals[i].getLocalInfo() == li) |
|
|
|
|
|
|
|
return true; |
|
|
|
|
|
|
|
return false; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
|
|
|
* Removes a local info from this variable set. |
|
|
|
|
|
|
|
*/ |
|
|
|
|
|
|
|
public void removeElement(LocalInfo li) { |
|
|
|
|
|
|
|
li = li.getLocalInfo(); |
|
|
|
|
|
|
|
for (int i=0; i<count;i++) |
|
|
|
|
|
|
|
if (locals[i].getLocalInfo() == li) |
|
|
|
|
|
|
|
locals[i] = locals[--count]; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
|
|
|
* Removes everything from this variable set. |
|
|
|
|
|
|
|
*/ |
|
|
|
|
|
|
|
public void removeAllElements() { |
|
|
|
|
|
|
|
locals = null; |
|
|
|
|
|
|
|
count = 0; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
public java.util.Enumeration elements() { |
|
|
|
|
|
|
|
return new ArrayEnum(count, locals); |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
public boolean isEmpty() { |
|
|
|
|
|
|
|
return count == 0; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
public Object clone() { |
|
|
|
|
|
|
|
try { |
|
|
|
|
|
|
|
VariableSet other = (VariableSet) super.clone(); |
|
|
|
|
|
|
|
if (count > 0) { |
|
|
|
|
|
|
|
other.locals = new LocalInfo[count]; |
|
|
|
|
|
|
|
System.arraycopy(locals, 0, other.locals, 0, count); |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
return other; |
|
|
|
|
|
|
|
} catch (CloneNotSupportedException ex) { |
|
|
|
|
|
|
|
throw new jode.AssertError("Clone?"); |
|
|
|
|
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/** |
|
|
|
/** |
|
|
@ -50,22 +128,30 @@ public class VariableSet extends java.util.Vector { |
|
|
|
* in both variable sets, all corresponding LocalInfos are merged. |
|
|
|
* in both variable sets, all corresponding LocalInfos are merged. |
|
|
|
* The variable sets are not changed (use union for this). |
|
|
|
* The variable sets are not changed (use union for this). |
|
|
|
* @return The merged variables. |
|
|
|
* @return The merged variables. |
|
|
|
* @param vs the other variable set. |
|
|
|
* @param vs the other variable set. */ |
|
|
|
*/ |
|
|
|
|
|
|
|
public VariableSet merge(VariableSet vs) { |
|
|
|
public VariableSet merge(VariableSet vs) { |
|
|
|
VariableSet merged = new VariableSet(); |
|
|
|
VariableSet merged = new VariableSet(); |
|
|
|
for (int i=0; i<elementCount; i++) { |
|
|
|
merged.grow(Math.min(count,vs.count)); |
|
|
|
LocalInfo li1 = ((LocalInfo) elementData[i]).getLocalInfo(); |
|
|
|
big_loop: |
|
|
|
|
|
|
|
for (int i=0; i<count; i++) { |
|
|
|
|
|
|
|
LocalInfo li1 = locals[i]; |
|
|
|
|
|
|
|
int slot = li1.getSlot(); |
|
|
|
boolean didMerge = false; |
|
|
|
boolean didMerge = false; |
|
|
|
for (int j=0; j<vs.elementCount; j++) { |
|
|
|
for (int k=0; k< merged.count; k++) { |
|
|
|
LocalInfo li2 = ((LocalInfo) vs.elementData[j]).getLocalInfo(); |
|
|
|
if (slot == merged.locals[k].getSlot()) { |
|
|
|
if (li1.getSlot() == li2.getSlot()) { |
|
|
|
/* This slot was already merged. */ |
|
|
|
li1.combineWith(li2); |
|
|
|
li1.combineWith(merged.locals[k]); |
|
|
|
|
|
|
|
continue big_loop; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
for (int j=0; j<vs.count; j++) { |
|
|
|
|
|
|
|
if (li1.getSlot() == vs.locals[j].getSlot()) { |
|
|
|
|
|
|
|
li1.combineWith(vs.locals[j]); |
|
|
|
didMerge = true; |
|
|
|
didMerge = true; |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
if (didMerge) |
|
|
|
if (didMerge) |
|
|
|
merged.addElement(li1); |
|
|
|
merged.locals[merged.count++] = li1; |
|
|
|
} |
|
|
|
} |
|
|
|
return merged; |
|
|
|
return merged; |
|
|
|
} |
|
|
|
} |
|
|
@ -77,20 +163,25 @@ public class VariableSet extends java.util.Vector { |
|
|
|
*/ |
|
|
|
*/ |
|
|
|
public VariableSet intersect(VariableSet vs) { |
|
|
|
public VariableSet intersect(VariableSet vs) { |
|
|
|
VariableSet intersection = new VariableSet(); |
|
|
|
VariableSet intersection = new VariableSet(); |
|
|
|
for (int i=0; i<elementCount; i++) { |
|
|
|
intersection.grow(Math.min(count, vs.count)); |
|
|
|
LocalInfo li1 = ((LocalInfo) elementData[i]).getLocalInfo(); |
|
|
|
big_loop: |
|
|
|
for (int j=0; j<vs.elementCount; j++) { |
|
|
|
for (int i=0; i<count; i++) { |
|
|
|
LocalInfo li2 = ((LocalInfo) vs.elementData[j]).getLocalInfo(); |
|
|
|
LocalInfo li = locals[i]; |
|
|
|
if (li1.getSlot() == li2.getSlot()) { |
|
|
|
int slot = li.getSlot(); |
|
|
|
if (!intersection.contains(li1)) |
|
|
|
for (int j=0; j<vs.count; j++) { |
|
|
|
intersection.addElement(li1); |
|
|
|
if (slot == vs.locals[j].getSlot()) { |
|
|
|
if (!intersection.contains(li2)) |
|
|
|
for (int k=0; k<intersection.count; k++) { |
|
|
|
intersection.addElement(li2); |
|
|
|
if (slot == intersection.locals[k].getSlot()) |
|
|
|
|
|
|
|
continue big_loop; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
intersection.locals[intersection.count++] |
|
|
|
|
|
|
|
= li.getLocalInfo(); |
|
|
|
|
|
|
|
continue big_loop; |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
return intersection; |
|
|
|
return intersection; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/** |
|
|
|
/** |
|
|
|
* Intersects the current VariableSet with another and returns the |
|
|
|
* Intersects the current VariableSet with another and returns the |
|
|
@ -99,15 +190,15 @@ public class VariableSet extends java.util.Vector { |
|
|
|
*/ |
|
|
|
*/ |
|
|
|
public VariableSet intersectExact(VariableSet vs) { |
|
|
|
public VariableSet intersectExact(VariableSet vs) { |
|
|
|
VariableSet intersection = new VariableSet(); |
|
|
|
VariableSet intersection = new VariableSet(); |
|
|
|
for (int i=0; i<elementCount; i++) { |
|
|
|
intersection.grow(Math.min(count, vs.count)); |
|
|
|
LocalInfo li1 = ((LocalInfo) elementData[i]).getLocalInfo(); |
|
|
|
big_loop: |
|
|
|
for (int j=0; j<vs.elementCount; j++) { |
|
|
|
for (int i=0; i<count; i++) { |
|
|
|
LocalInfo li2 = ((LocalInfo) vs.elementData[j]).getLocalInfo(); |
|
|
|
LocalInfo li1 = locals[i].getLocalInfo(); |
|
|
|
if (li1.getLocalInfo() == li2.getLocalInfo()) { |
|
|
|
for (int j=0; j<vs.count; j++) { |
|
|
|
|
|
|
|
if (li1 == vs.locals[j].getLocalInfo()) { |
|
|
|
if (!intersection.contains(li1)) |
|
|
|
if (!intersection.contains(li1)) |
|
|
|
intersection.addElement(li1); |
|
|
|
intersection.locals[intersection.count++] = li1; |
|
|
|
if (!intersection.contains(li2)) |
|
|
|
continue big_loop; |
|
|
|
intersection.addElement(li2); |
|
|
|
|
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
@ -118,18 +209,18 @@ public class VariableSet extends java.util.Vector { |
|
|
|
* Union the other variable set to the current. |
|
|
|
* Union the other variable set to the current. |
|
|
|
*/ |
|
|
|
*/ |
|
|
|
public void unionExact(VariableSet vs) { |
|
|
|
public void unionExact(VariableSet vs) { |
|
|
|
int oldSize = elementCount; |
|
|
|
grow(vs.count); |
|
|
|
iloop: |
|
|
|
big_loop: |
|
|
|
for (int i=0; i< vs.elementCount; i++) { |
|
|
|
for (int i=0; i< vs.count; i++) { |
|
|
|
LocalInfo li2 = ((LocalInfo) vs.elementData[i]).getLocalInfo(); |
|
|
|
LocalInfo li2 = (vs.locals[i]).getLocalInfo(); |
|
|
|
/* check if this particular local info was already in the set */ |
|
|
|
/* check if this particular local info is already in the set */ |
|
|
|
for (int j=0; j< oldSize; j++) { |
|
|
|
for (int j=0; j< count; j++) { |
|
|
|
LocalInfo li1 = ((LocalInfo) elementData[j]).getLocalInfo(); |
|
|
|
LocalInfo li1 = (locals[j]).getLocalInfo(); |
|
|
|
if (li1 == li2) |
|
|
|
if (li1 == li2) |
|
|
|
/* Yes it was, take next variable */ |
|
|
|
/* Yes it is, take next variable */ |
|
|
|
continue iloop; |
|
|
|
continue big_loop; |
|
|
|
} |
|
|
|
} |
|
|
|
addElement(li2); |
|
|
|
locals[count++] = li2; |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
@ -138,18 +229,18 @@ public class VariableSet extends java.util.Vector { |
|
|
|
* is already in the current set. |
|
|
|
* is already in the current set. |
|
|
|
*/ |
|
|
|
*/ |
|
|
|
public void add(VariableSet vs) { |
|
|
|
public void add(VariableSet vs) { |
|
|
|
int oldSize = elementCount; |
|
|
|
grow(vs.count); |
|
|
|
iloop: |
|
|
|
big_loop: |
|
|
|
for (int i=0; i< vs.elementCount; i++) { |
|
|
|
for (int i=0; i< vs.count; i++) { |
|
|
|
LocalInfo li2 = (LocalInfo) vs.elementData[i]; |
|
|
|
LocalInfo li2 = vs.locals[i]; |
|
|
|
/* check if this slot was already overwritten by this block */ |
|
|
|
int slot2 = li2.getSlot(); |
|
|
|
for (int j=0; j< oldSize; j++) { |
|
|
|
/* check if this slot is already in the current set */ |
|
|
|
LocalInfo li1 = (LocalInfo) elementData[j]; |
|
|
|
for (int j=0; j< count; j++) { |
|
|
|
if (li1.getSlot() == li2.getSlot()) |
|
|
|
if (locals[j].getSlot() == slot2) |
|
|
|
/* Yes it was, take next variable */ |
|
|
|
/* Yes it is, take next variable */ |
|
|
|
continue iloop; |
|
|
|
continue big_loop; |
|
|
|
} |
|
|
|
} |
|
|
|
addElement(li2.getLocalInfo()); |
|
|
|
locals[count++] = li2.getLocalInfo(); |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
@ -160,17 +251,19 @@ public class VariableSet extends java.util.Vector { |
|
|
|
* @param kill The kill set. |
|
|
|
* @param kill The kill set. |
|
|
|
*/ |
|
|
|
*/ |
|
|
|
public void mergeGenKill(VariableSet gen, VariableSet kill) { |
|
|
|
public void mergeGenKill(VariableSet gen, VariableSet kill) { |
|
|
|
iloop: |
|
|
|
grow(gen.count); |
|
|
|
for (int i=0; i< gen.elementCount; i++) { |
|
|
|
big_loop: |
|
|
|
LocalInfo li2 = ((LocalInfo) gen.elementData[i]).getLocalInfo(); |
|
|
|
for (int i=0; i< gen.count; i++) { |
|
|
|
/* check if this slot was already overwritten (kill set) */ |
|
|
|
LocalInfo li2 = gen.locals[i]; |
|
|
|
for (int j=0; j< kill.elementCount; j++) { |
|
|
|
int slot = li2.getSlot(); |
|
|
|
LocalInfo li1 = (LocalInfo) kill.elementData[j]; |
|
|
|
/* check if this slot is in the kill set) */ |
|
|
|
if (li2.getSlot() == li1.getSlot()) |
|
|
|
for (int j=0; j< kill.count; j++) { |
|
|
|
/* Yes it was, take next variable */ |
|
|
|
LocalInfo li1 = kill.locals[j]; |
|
|
|
continue iloop; |
|
|
|
if (slot == kill.locals[j].getSlot()) |
|
|
|
|
|
|
|
/* Yes it is, take next variable */ |
|
|
|
|
|
|
|
continue big_loop; |
|
|
|
} |
|
|
|
} |
|
|
|
addElement(li2); |
|
|
|
locals[count++] = li2.getLocalInfo(); |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
@ -181,25 +274,19 @@ public class VariableSet extends java.util.Vector { |
|
|
|
* @param vs The other variable set. |
|
|
|
* @param vs The other variable set. |
|
|
|
*/ |
|
|
|
*/ |
|
|
|
public void subtract(VariableSet vs) { |
|
|
|
public void subtract(VariableSet vs) { |
|
|
|
/* We count from top to bottom to have easier reorganization. |
|
|
|
big_loop: |
|
|
|
* Note, that the variables have not to be in any particular |
|
|
|
for (int i=0; i < count;) { |
|
|
|
* order. */ |
|
|
|
LocalInfo li1 = locals[i]; |
|
|
|
int newCount = elementCount; |
|
|
|
int slot = li1.getSlot(); |
|
|
|
for (int i=newCount-1; i>=0; i--) { |
|
|
|
for (int j=0; j<vs.count; j++) { |
|
|
|
LocalInfo li1 = (LocalInfo) elementData[i]; |
|
|
|
if (slot == vs.locals[j].getSlot()) { |
|
|
|
for (int j=0; j<vs.elementCount; j++) { |
|
|
|
|
|
|
|
LocalInfo li2 = (LocalInfo) vs.elementData[j]; |
|
|
|
|
|
|
|
if (li1.getSlot() == li2.getSlot()) { |
|
|
|
|
|
|
|
/* remove the element from this variable list. */ |
|
|
|
/* remove the element from this variable list. */ |
|
|
|
newCount--; |
|
|
|
locals[i] = locals[--count].getLocalInfo(); |
|
|
|
elementData[i] = elementData[newCount]; |
|
|
|
continue big_loop; |
|
|
|
/* break the j-loop */ |
|
|
|
|
|
|
|
break; |
|
|
|
|
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
i++; |
|
|
|
} |
|
|
|
} |
|
|
|
/* Now set the new size */ |
|
|
|
|
|
|
|
setSize(newCount); |
|
|
|
|
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/** |
|
|
|
/** |
|
|
@ -209,28 +296,17 @@ public class VariableSet extends java.util.Vector { |
|
|
|
* @param vs The other variable set. |
|
|
|
* @param vs The other variable set. |
|
|
|
*/ |
|
|
|
*/ |
|
|
|
public void subtractExact(VariableSet vs) { |
|
|
|
public void subtractExact(VariableSet vs) { |
|
|
|
/* We count from top to bottom to have easier reorganization. |
|
|
|
big_loop: |
|
|
|
* Note, that the variables have not to be in any particular |
|
|
|
for (int i=0; i < count;) { |
|
|
|
* order. */ |
|
|
|
LocalInfo li1 = locals[i].getLocalInfo(); |
|
|
|
int newCount = elementCount; |
|
|
|
for (int j=0; j<vs.count; j++) { |
|
|
|
for (int i=newCount-1; i>=0; i--) { |
|
|
|
if (li1 == vs.locals[j].getLocalInfo()) { |
|
|
|
LocalInfo li1 = (LocalInfo) elementData[i]; |
|
|
|
|
|
|
|
for (int j=0; j<vs.elementCount; j++) { |
|
|
|
|
|
|
|
LocalInfo li2 = (LocalInfo) vs.elementData[j]; |
|
|
|
|
|
|
|
if (li1.getLocalInfo() == li2.getLocalInfo()) { |
|
|
|
|
|
|
|
/* remove the element from this variable list. */ |
|
|
|
/* remove the element from this variable list. */ |
|
|
|
newCount--; |
|
|
|
locals[i] = locals[--count].getLocalInfo(); |
|
|
|
elementData[i] = elementData[newCount]; |
|
|
|
continue big_loop; |
|
|
|
/* break the j-loop */ |
|
|
|
|
|
|
|
break; |
|
|
|
|
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
i++; |
|
|
|
} |
|
|
|
} |
|
|
|
/* Now set the new size */ |
|
|
|
|
|
|
|
setSize(newCount); |
|
|
|
|
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|