proguard.evaluation.value.InstructionOffsetValue Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of proguard-core Show documentation
Show all versions of proguard-core Show documentation
ProGuardCORE is a free library to read, analyze, modify, and write Java class files.
/*
* ProGuardCORE -- library to process Java bytecode.
*
* Copyright (c) 2002-2020 Guardsquare NV
*
* 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 proguard.evaluation.value;
import java.util.HashSet;
import java.util.Set;
import proguard.classfile.TypeConstants;
/**
* Representation of a partially evaluated instruction offset. It can contain 0 or more specific
* instruction offsets. Each instruction offset can be flagged as an ordinary offset, a method
* parameter, a method return value, a field value, a new instance value, or an exception handler.
*
* @author Eric Lafortune
*/
public class InstructionOffsetValue extends Category1Value {
private static final int[] EMPTY_OFFSETS = new int[0];
public static final InstructionOffsetValue EMPTY_VALUE =
new InstructionOffsetValue(EMPTY_OFFSETS);
public static final int INSTRUCTION_OFFSET_MASK = 0x01ffffff;
public static final int METHOD_PARAMETER =
0x01000000; // Method parameter indices are not really instruction offsets.
public static final int METHOD_RETURN_VALUE = 0x02000000;
public static final int FIELD_VALUE = 0x04000000;
public static final int NEW_INSTANCE = 0x08000000;
public static final int CAST = 0x10000000;
public static final int EXCEPTION_HANDLER = 0x20000000;
private final int[] values;
private Set valuesMap;
/** Creates a new InstructionOffsetValue with the given instruction offset. */
public InstructionOffsetValue(int value) {
this.values = new int[] {value};
}
/** Creates a new InstructionOffsetValue with the given list of instruction offsets. */
public InstructionOffsetValue(int[] values) {
this.values = values;
// If there are a lot of values, it's faster to use a set
// for the "contains" method, than doing a linear search
// The threshold for this is chosen by experimentation
// to find a balance between memory footprint and performance
if (values.length > 100) {
valuesMap = new HashSet<>();
for (int index = 0; index < values.length; index++) {
valuesMap.add(values[index]);
}
}
}
/** Returns the number of instruction offsets of this value. */
public int instructionOffsetCount() {
return values.length;
}
/** Returns the specified instruction offset of this value. */
public int instructionOffset(int index) {
return values[index] & INSTRUCTION_OFFSET_MASK;
}
/** Returns whether the given value is present in this list of instruction offsets. */
public boolean contains(int value) {
if (valuesMap == null) {
for (int index = 0; index < values.length; index++) {
if (values[index] == value) {
return true;
}
}
return false;
}
return valuesMap.contains(value);
}
/**
* Returns the minimum value from this list of instruction offsets. Returns
* Integer.MAX_VALUE if the list is empty.
*/
public int minimumValue() {
int minimumValue = Integer.MAX_VALUE;
for (int index = 0; index < values.length; index++) {
int value = values[index] & INSTRUCTION_OFFSET_MASK;
if (minimumValue > value) {
minimumValue = value;
}
}
return minimumValue;
}
/**
* Returns the maximum value from this list of instruction offsets. Returns
* Integer.MIN_VALUE if the list is empty.
*/
public int maximumValue() {
int maximumValue = Integer.MIN_VALUE;
for (int index = 0; index < values.length; index++) {
int value = values[index] & INSTRUCTION_OFFSET_MASK;
if (maximumValue < value) {
maximumValue = value;
}
}
return maximumValue;
}
/** Returns whether the specified instruction offset corresponds to a method parameter. */
public boolean isMethodParameter(int index) {
return (values[index] & METHOD_PARAMETER) != 0;
}
/** Returns the specified method parameter (assuming it is one). */
public int methodParameter(int index) {
return values[index] & ~METHOD_PARAMETER;
}
/** Returns whether the specified instruction offset corresponds to a method return value. */
public boolean isMethodReturnValue(int index) {
return (values[index] & METHOD_RETURN_VALUE) != 0;
}
/** Returns whether the specified instruction offset corresponds to a field value. */
public boolean isFieldValue(int index) {
return (values[index] & FIELD_VALUE) != 0;
}
/** Returns whether the specified instruction offset corresponds to a new instance. */
public boolean isNewinstance(int index) {
return (values[index] & NEW_INSTANCE) != 0;
}
/** Returns whether the specified instruction offset corresponds to a cast. */
public boolean isCast(int index) {
return (values[index] & CAST) != 0;
}
/** Returns whether the specified instruction offset corresponds to an exception handler. */
public boolean isExceptionHandler(int index) {
return (values[index] & EXCEPTION_HANDLER) != 0;
}
/**
* Returns an InstructionOffsetValue that contains the instructions offsets of this value and the
* given instruction offset.
*/
public InstructionOffsetValue add(int value) {
if (contains(value)) {
return this;
}
int[] newValues = new int[values.length + 1];
System.arraycopy(values, 0, newValues, 0, values.length);
newValues[values.length] = value;
return new InstructionOffsetValue(newValues);
}
/**
* Returns an InstructionOffsetValue that contains the instructions offsets of this value but not
* the given instruction offset.
*/
public InstructionOffsetValue remove(int value) {
for (int index = 0; index < values.length; index++) {
if (values[index] == value) {
int[] newValues = new int[values.length - 1];
System.arraycopy(values, 0, newValues, 0, index);
System.arraycopy(values, index + 1, newValues, index, values.length - index - 1);
return new InstructionOffsetValue(newValues);
}
}
return this;
}
/**
* Returns the generalization of this InstructionOffsetValue and the given other
* InstructionOffsetValue. The values of the other InstructionOffsetValue are guaranteed to remain
* at the end of the list, in the same order.
*/
public final InstructionOffsetValue generalize(InstructionOffsetValue other) {
// If the values array of either is empty, we can return the other one.
int[] thisValues = this.values;
if (thisValues.length == 0) {
return other;
}
int[] otherValues = other.values;
if (otherValues.length == 0) {
return this;
}
// Compute the length of the union of the arrays.
int newLength = thisValues.length;
for (int index = 0; index < otherValues.length; index++) {
if (!this.contains(otherValues[index])) {
newLength++;
}
}
// If the length of the union array is equal to the length of the other
// values array, we can return it.
if (newLength == otherValues.length) {
return other;
}
// If the length of the union array is equal to the length of this
// values array, we can return it. We have to make sure that the other
// values are at the end. We'll just test one special case, with a
// single other value.
if (newLength == this.values.length
&& otherValues.length == 1
&& thisValues[thisValues.length - 1] == otherValues[0]) {
return this;
}
// Create the union array.
int newIndex = 0;
int[] newValues = new int[newLength];
// Is the length of the union array is equal to the sum of the lengths?
if (newLength == thisValues.length + otherValues.length) {
// We can just copy all values, because they are unique.
System.arraycopy(thisValues, 0, newValues, 0, thisValues.length);
newIndex = thisValues.length;
} else {
// Copy the values that are different from the other array.
for (int index = 0; index < thisValues.length; index++) {
if (!other.contains(thisValues[index])) {
newValues[newIndex++] = thisValues[index];
}
}
}
// Copy the values from the other array.
System.arraycopy(otherValues, 0, newValues, newIndex, otherValues.length);
return new InstructionOffsetValue(newValues);
}
// Implementations for Value.
public final InstructionOffsetValue instructionOffsetValue() {
return this;
}
public boolean isSpecific() {
return true;
}
public boolean isParticular() {
return true;
}
public final Value generalize(Value other) {
if (other instanceof UnknownValue) return other;
return this.generalize(other.instructionOffsetValue());
}
public final int computationalType() {
return TYPE_INSTRUCTION_OFFSET;
}
public final String internalType() {
return String.valueOf(TypeConstants.INT);
}
// Implementations for Object.
public boolean equals(Object object) {
if (object == null || this.getClass() != object.getClass()) {
return false;
}
InstructionOffsetValue other = (InstructionOffsetValue) object;
if (this.values == other.values) {
return true;
}
if (this.values == null || other.values == null || this.values.length != other.values.length) {
return false;
}
for (int index = 0; index < other.values.length; index++) {
if (!this.contains(other.values[index])) {
return false;
}
}
return true;
}
public int hashCode() {
int hashCode = this.getClass().hashCode();
if (values != null) {
for (int index = 0; index < values.length; index++) {
hashCode ^= values[index];
}
}
return hashCode;
}
public String toString() {
StringBuffer buffer = new StringBuffer();
if (values != null) {
for (int index = 0; index < values.length; index++) {
if (index > 0) {
buffer.append(',');
}
if (values[index] < 0) {
buffer.append(values[index]);
} else {
if (isMethodParameter(index)) {
buffer.append('P');
}
if (isMethodReturnValue(index)) {
buffer.append('M');
}
if (isFieldValue(index)) {
buffer.append('F');
}
if (isNewinstance(index)) {
buffer.append('N');
}
if (isCast(index)) {
buffer.append('C');
}
if (isExceptionHandler(index)) {
buffer.append('E');
}
buffer.append(values[index] & 0xffff);
}
}
}
return buffer.append(':').toString();
}
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy