1701 lines
70 KiB
Java
1701 lines
70 KiB
Java
/******************************************************************************
|
|
* Copyright (c) 2002 - 2014 IBM Corporation.
|
|
* All rights reserved. This program and the accompanying materials
|
|
* are made available under the terms of the Eclipse Public License v1.0
|
|
* which accompanies this distribution, and is available at
|
|
* http://www.eclipse.org/legal/epl-v10.html
|
|
*
|
|
* Contributors:
|
|
* IBM Corporation - initial API and implementation
|
|
*****************************************************************************/
|
|
|
|
/*
|
|
* Copyright (c) 2013,
|
|
* Tobias Blaschke <code@tobiasblaschke.de>
|
|
* All rights reserved.
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
*
|
|
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
* and/or other materials provided with the distribution.
|
|
*
|
|
* 3. The names of the contributors may not be used to endorse or promote
|
|
* products derived from this software without specific prior written
|
|
* permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
package com.ibm.wala.util.ssa;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.HashSet;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Set;
|
|
|
|
import com.ibm.wala.classLoader.IClass;
|
|
import com.ibm.wala.classLoader.IClassLoader;
|
|
import com.ibm.wala.classLoader.IMethod;
|
|
import com.ibm.wala.ipa.cha.IClassHierarchy;
|
|
import com.ibm.wala.types.MethodReference;
|
|
import com.ibm.wala.types.Selector;
|
|
import com.ibm.wala.types.TypeName;
|
|
import com.ibm.wala.types.TypeReference;
|
|
import com.ibm.wala.util.PrimitiveAssignability;
|
|
import com.ibm.wala.util.ssa.SSAValue.WeaklyNamedKey;
|
|
|
|
/**
|
|
* Access parameters without confusion on their numbers.
|
|
*
|
|
* Depending on the representation of a method (IMethod, MethodReference) parameters are placed at a
|
|
* different position. Functions furthermore may have an implicit this-pointer which alters the
|
|
* positions again.
|
|
*
|
|
* Accessing parameters of these functions by their numbers only is error prone and leads to confusion.
|
|
* This class tries to leverage parameter-access.
|
|
*
|
|
* You can use this class using now numbers at all. However if you choose to use numbers this class has yet
|
|
* another numbering convention (jupeee): 1 is the first parameter appearing in the Selector, no matter if
|
|
* the Method has an implicit this. It is not zero as Java initializes new integer-arrays with zero.
|
|
*
|
|
* If you want to alter the values of the incoming parameters you may also want to use the ParameterManager
|
|
* which tracks the changes.
|
|
*
|
|
* @author Tobias Blaschke <code@tobiasblaschke.de>
|
|
* @since 2013-10-19
|
|
*/
|
|
public class ParameterAccessor {
|
|
|
|
private final static boolean DEBUG = false;
|
|
|
|
/**
|
|
* The Constructor used to create ParameterAccessor influences the parameter-offset.
|
|
*
|
|
* If this enum is extended many functions will throw if not also extended.
|
|
*/
|
|
public enum BasedOn {
|
|
/** ParameterAccessor was constructed using an IMethod */
|
|
IMETHOD,
|
|
/** ParameterAccessor was constructed using a MethodReference */
|
|
METHOD_REFERENCE
|
|
}
|
|
|
|
/**
|
|
* The kind of parameter.
|
|
*
|
|
* Extending this enum should not introduce any problems in ParameterAccessor.
|
|
*/
|
|
public enum ParamerterDisposition {
|
|
/** Parameter is an implicit this-pointer */
|
|
THIS,
|
|
/** Parameter is a regular parameter occurring in the Descriptor */
|
|
PARAM,
|
|
/** The return-value of a method (has to be crafted manually) */
|
|
RETURN,
|
|
NEW
|
|
}
|
|
|
|
/**
|
|
* This key is identified by type and parameter number.
|
|
*/
|
|
public static class ParameterKey extends WeaklyNamedKey {
|
|
final int paramNo;
|
|
|
|
public ParameterKey(final TypeName type, final int no, final String name) {
|
|
super(type, ((name==null)?"param_" + no:name));
|
|
this.paramNo = no;
|
|
}
|
|
@Override
|
|
public boolean equals(Object o) {
|
|
return super.equals(o);
|
|
}
|
|
@Override
|
|
public int hashCode() {
|
|
return this.type.hashCode();
|
|
}
|
|
@Override
|
|
public String toString() {
|
|
return "<ParameterKey no=" + this.paramNo + " type=" + this.type + " name=\"" + this.name + "\" />";
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The representation of a Parameter handled using a ParameterAccessor.
|
|
*
|
|
* It basically consists of a SSA-Value and an associated TypeReference.
|
|
*
|
|
* Use .getNumber() to access the associated SSA-Value.
|
|
*
|
|
* @author Tobias Blaschke <code@tobiasblaschke.de>
|
|
* @since 2013-10-19
|
|
*/
|
|
public static class Parameter extends SSAValue {
|
|
/** Is Accessor constructed with IMethod or MethodReference */
|
|
private final BasedOn basedOn;
|
|
/** Implicit this or regular parameter? */
|
|
private final ParamerterDisposition disp;
|
|
/** Add to number to get position in descriptor */
|
|
private final int descriptorOffset;
|
|
|
|
/**
|
|
* Create Parameters using ParameterAccessor.
|
|
*
|
|
* @param number SSA-Value to access this parameter
|
|
* @param name Optional variable-name - may be null
|
|
* @param type Variable Type to this parameter
|
|
* @param disp Implicit this, regular parameter or return value?
|
|
* @param basedOn Is Accessor constructed with IMethod or MethodReference
|
|
* @param mRef Method this parameter belongs to
|
|
* @param descriptorOffset add to number to get position in descriptor
|
|
*/
|
|
protected Parameter(final int number, final String name, final TypeReference type, final ParamerterDisposition disp,
|
|
final BasedOn basedOn, final MethodReference mRef, final int descriptorOffset) {
|
|
super(number, type, mRef, new ParameterKey(type.getName(), number + descriptorOffset, name));
|
|
|
|
if (mRef == null) {
|
|
throw new IllegalArgumentException("MethodReference (mRef) of a Parameter may not be null");
|
|
}
|
|
if (basedOn == null) {
|
|
throw new IllegalArgumentException("Argument basedOn of a Parameter may not be null");
|
|
}
|
|
if (disp == null) {
|
|
throw new IllegalArgumentException("ParamerterDisposition (disp) of a Parameter may not be null");
|
|
}
|
|
// If type was null the call to super failed
|
|
if ((number < 1) && (basedOn == BasedOn.METHOD_REFERENCE)) {
|
|
throw new IllegalArgumentException("The first accessible SSA-Value of a MethodReference is 1 but the " +
|
|
"Value-Number given is " + number);
|
|
}
|
|
if ((number < 0) && (basedOn == BasedOn.IMETHOD)) {
|
|
throw new IllegalArgumentException("The first accessible SSA-Value of an IMethod is 0 but the " +
|
|
"Value-Number given is " + number);
|
|
}
|
|
if ((disp == ParamerterDisposition.PARAM) && (number + descriptorOffset > mRef.getNumberOfParameters())) {
|
|
throw new IllegalArgumentException("The SSA-Value " + number + " (with added offset " + descriptorOffset +
|
|
") is beyond the number of Arguments (" + mRef.getNumberOfParameters() + ") of the Method " +
|
|
mRef.getName() + "\n" + mRef.getSignature());
|
|
}
|
|
if ((disp == ParamerterDisposition.THIS) && (basedOn == BasedOn.METHOD_REFERENCE) && (number != 1)) {
|
|
throw new IllegalArgumentException("The implicit this-pointer of a MethodReference is located at SSA-Value 1. " +
|
|
"The SSA-Value given is " + number);
|
|
}
|
|
if ((disp == ParamerterDisposition.THIS) && (basedOn == BasedOn.IMETHOD) && (number != 0)) {
|
|
throw new IllegalArgumentException("The implicit this-pointer of an IMethod is located at SSA-Value 0. " +
|
|
"The SSA-Value given is " + number);
|
|
}
|
|
if ((descriptorOffset < -2) || (descriptorOffset > 1)) {
|
|
throw new IllegalArgumentException("The descriptor-offset given is not within its expected bounds: " +
|
|
"-1 (for a method without implicit this-pointer) to 1. The given offset is " + descriptorOffset);
|
|
}
|
|
|
|
this.disp = disp;
|
|
this.basedOn = basedOn;
|
|
this.descriptorOffset = descriptorOffset;
|
|
super.isAssigned();
|
|
}
|
|
|
|
/**
|
|
* The position of the parameter in the methods Desciptor starting with 1.
|
|
*/
|
|
public int getNumberInDescriptor() { // TODO: Verify all descriptorOffset stuff!
|
|
//if (this.descriptorOffset < 0) {
|
|
// return this.number;
|
|
//} else {
|
|
return this.number + this.descriptorOffset;
|
|
//}
|
|
}
|
|
|
|
public ParamerterDisposition getDisposition() {
|
|
return this.disp;
|
|
}
|
|
|
|
/**
|
|
* @throws IllegalArgumentException if you compare this to an object totally different.
|
|
*/
|
|
@Override
|
|
public boolean equals(final Object o) {
|
|
if (o instanceof Parameter) {
|
|
final Parameter other = (Parameter) o;
|
|
return ((this.type.equals(other.type)) && (this.number == other.number) && (this.mRef.equals(other.mRef)));
|
|
}
|
|
if (o instanceof SSAValue) {
|
|
return super.equals(o);
|
|
}
|
|
throw new IllegalArgumentException("Can't compare Parameter to " + o.getClass());
|
|
}
|
|
|
|
/**
|
|
* Clashes deliberately with SSAValue as it's basically the same thing.
|
|
*/
|
|
@Override
|
|
public final int hashCode() {
|
|
return super.hashCode();
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
switch (this.disp) {
|
|
case THIS:
|
|
return "Implicit this-parameter of " + this.mRef.getName() + " as " + this.type + " accessible using " +
|
|
"SSA-Value " + this.number;
|
|
case PARAM:
|
|
if (this.key instanceof NamedKey) {
|
|
return "Parameter " + getNumberInDescriptor() + " \"" + getVariableName() + "\" of " + this.mRef.getName() +
|
|
" is " + this.type + " accessible using SSA-Value " + this.number;
|
|
} else {
|
|
return "Parameter " + getNumberInDescriptor() + " of " + this.mRef.getName() + " is " + this.type +
|
|
" accessible using SSA-Value " + this.number;
|
|
}
|
|
case RETURN:
|
|
return "Return Value of " + this.mRef.getName() + " as " + this.type + " accessible using SSA-Value " +
|
|
this.number;
|
|
case NEW:
|
|
return "New instance of " + this.type + " accessible in " + this.mRef.getName() + " using number " + this.number;
|
|
default:
|
|
return "Parameter " + getNumberInDescriptor() + " - " + this.disp + " of " + this.mRef.getName() + " as " +
|
|
this.type + " accessible using SSA-Value " + this.number;
|
|
}
|
|
}
|
|
}
|
|
|
|
/** The Constructor used to create this ParameterAceesor */
|
|
private final BasedOn base;
|
|
/** The Method associated to this ParameterAceesor if constructed using a mRef */
|
|
private final MethodReference mRef;
|
|
/** The Method associated to this ParameterAceesor if constructed using an IMethod */
|
|
private final IMethod method;
|
|
/** The Value-Number for the implicit this-pointer or -1 if there is none */
|
|
private final int implicitThis;
|
|
/** SSA-Number + descriptorOffset yield the parameters position in the Descriptor starting with 1 */
|
|
private final int descriptorOffset;
|
|
/** Number of parameters _excluding_ implicit this */
|
|
private final int numberOfParameters;
|
|
|
|
/**
|
|
* Reads the parameters of a MethodReference CAUTION:.
|
|
*
|
|
* Do _not_ use ParameterAceesor(IMethod.getReference()), but ParameterAceesor(IMehod)!
|
|
*
|
|
* Using this Constructor influences the SSA-Values returned later. The cha is needed to
|
|
* determine whether mRef is static. If this is already known one should prefer the faster
|
|
* {@link #ParameterAccessor(ParameterAccessor, boolean)}.
|
|
*
|
|
* @param mRef The method to read the parameters from.
|
|
*/
|
|
public ParameterAccessor(final MethodReference mRef, final IClassHierarchy cha) {
|
|
if (mRef == null) {
|
|
throw new IllegalArgumentException("Can't read the arguments from null.");
|
|
}
|
|
|
|
this.mRef = mRef;
|
|
this.method = null;
|
|
this.base = BasedOn.METHOD_REFERENCE;
|
|
this.numberOfParameters = mRef.getNumberOfParameters();
|
|
|
|
final boolean hasImplicitThis;
|
|
Set<IMethod> targets = cha.getPossibleTargets(mRef);
|
|
if (targets.size() < 1) {
|
|
warn("Unable to look up the method {} starting extensive search...", mRef);
|
|
|
|
targets = new HashSet<IMethod>();
|
|
final TypeReference mClass = mRef.getDeclaringClass();
|
|
final Selector mSel = mRef.getSelector();
|
|
final Set<IClass> testClasses = new HashSet<IClass>();
|
|
|
|
// Look up all classes matching exactly
|
|
for (IClassLoader loader : cha.getLoaders()) {
|
|
final IClass cand = loader.lookupClass(mClass.getName());
|
|
|
|
if (cand != null) {
|
|
testClasses.add(cand);
|
|
}
|
|
}
|
|
|
|
// Try lookupClass..
|
|
final IClass lookedUp;
|
|
lookedUp = cha.lookupClass(mClass);
|
|
if (lookedUp != null) {
|
|
debug("Found using cha.lookupClass()");
|
|
testClasses.add(lookedUp);
|
|
}
|
|
|
|
info("Searching the classes {} for the method", testClasses);
|
|
|
|
for (IClass testClass : testClasses) {
|
|
final IMethod cand = testClass.getMethod(mSel);
|
|
|
|
if (cand != null) {
|
|
targets.add(cand);
|
|
}
|
|
}
|
|
|
|
if (targets.size() < 1) {
|
|
warn("Still no candidates for the method - continuing with super-classes (TODO)");
|
|
|
|
// TODO
|
|
|
|
{ // DEBUG
|
|
for (IClass testClass : testClasses) {
|
|
info("Known Methods in " + testClass);
|
|
for (IMethod contained : testClass.getAllMethods()) {
|
|
System.out.println(contained);
|
|
info("\t" + contained);
|
|
}
|
|
}
|
|
} // */
|
|
|
|
throw new IllegalStateException("Unable to look up the method " + mRef);
|
|
}
|
|
}
|
|
|
|
{ // Iterate all candidates
|
|
final Iterator<IMethod> it = targets.iterator();
|
|
final boolean testStatic = it.next().isStatic();
|
|
while (it.hasNext()) {
|
|
final boolean tmpStatic = it.next().isStatic();
|
|
if (testStatic != tmpStatic) {
|
|
throw new IllegalStateException("The ClassHierarchy knows multiple (" + targets.size() + ") targets for " + mRef +
|
|
". The targets contradict themselves if they have an implicit this!");
|
|
}
|
|
}
|
|
hasImplicitThis = (! testStatic);
|
|
}
|
|
|
|
if (hasImplicitThis) {
|
|
info("The method {} has an implicit this pointer", mRef);
|
|
this.implicitThis = 1;
|
|
this.descriptorOffset = -1;
|
|
} else {
|
|
info("The method {} has no implicit this pointer", mRef);
|
|
this.implicitThis = -1;
|
|
this.descriptorOffset = 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Reads the parameters of a MethodReference CAUTION:.
|
|
*
|
|
* Do _not_ use ParameterAceesor(IMethod.getReference()), but ParameterAceesor(IMehod)!
|
|
*
|
|
* This constructor is faster than {@link #ParameterAccessor(MethodReference, IClassHierarchy}.
|
|
*
|
|
* @param mRef The method to read the parameters from.
|
|
*/
|
|
public ParameterAccessor(final MethodReference mRef, final boolean hasImplicitThis) {
|
|
if (mRef == null) {
|
|
throw new IllegalArgumentException("Can't read the arguments from null.");
|
|
}
|
|
|
|
this.mRef = mRef;
|
|
this.method = null;
|
|
this.base = BasedOn.METHOD_REFERENCE;
|
|
this.numberOfParameters = mRef.getNumberOfParameters();
|
|
|
|
if (hasImplicitThis) {
|
|
info("The method {} has an implicit this pointer", mRef);
|
|
this.implicitThis = 1;
|
|
this.descriptorOffset = -1;
|
|
} else {
|
|
info("The method {} has no implicit this pointer", mRef);
|
|
this.implicitThis = -1;
|
|
this.descriptorOffset = 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Read the parameters from an IMethod.
|
|
*
|
|
* Using this Constructor influences the SSA-Values returned later.
|
|
*
|
|
* @param method The method to read the parameters from.
|
|
*/
|
|
public ParameterAccessor(final IMethod method) {
|
|
if (method == null) {
|
|
throw new IllegalArgumentException("Can't read the arguments from null.");
|
|
}
|
|
|
|
// Don't make a mRef but keep the IMethod!
|
|
this.mRef = null;
|
|
this.method = method;
|
|
this.base = BasedOn.IMETHOD;
|
|
this.numberOfParameters = method.getReference().getNumberOfParameters();
|
|
|
|
if (method.isStatic() && (! method.isInit())) {
|
|
assert(method.getNumberOfParameters() == method.getReference().getNumberOfParameters()) : "WTF!" + method;
|
|
this.implicitThis = -1;
|
|
this.descriptorOffset = 0;
|
|
} else {
|
|
assert(method.getNumberOfParameters() == 1 + method.getReference().getNumberOfParameters()) : "WTF!" + method;
|
|
this.implicitThis = 1;
|
|
this.descriptorOffset = -1;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Make an Parameter Object using a Descriptor-based numbering (starting with 1).
|
|
*
|
|
* Number 1 is the first parameter in the methods Selector. No matter if the function has an
|
|
* implicit this pointer.
|
|
*
|
|
* If the Function has an implicit this-pointer you can access it using getThis().
|
|
*
|
|
* @param no the number in the Selector
|
|
* @return new Parameter-Object for no
|
|
* @throws IllegalArgumentExceptions if the parameter is zero
|
|
* @throws ArrayIndexOutOfBoundsException if no is not within bounds [1 to numberOfParameters]
|
|
*/
|
|
public Parameter getParameter(final int no) {
|
|
// no is checked by getParameterNo(int)
|
|
final int newNo = getParameterNo(no);
|
|
|
|
switch (this.base) {
|
|
case IMETHOD: // TODO: Try reading parameter name
|
|
return new Parameter(newNo, null, this.method.getParameterType(no), ParamerterDisposition.PARAM,
|
|
this.base, this.method.getReference(), this.descriptorOffset);
|
|
case METHOD_REFERENCE:
|
|
return new Parameter(newNo, null, this.mRef.getParameterType(no - 1), ParamerterDisposition.PARAM,
|
|
this.base, this.mRef, this.descriptorOffset);
|
|
default:
|
|
throw new UnsupportedOperationException("No implementation of getParameter() for base " + this.base);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return the SSA-Value to access a parameter using a Descriptor-based numbering (starting with 1).
|
|
*
|
|
* Number 1 is the first parameter in the methods Selector. No matter if the function has an
|
|
* implicit this pointer.
|
|
*
|
|
* If the Function has an implicit this-pointer you can acess it using getThisNo().
|
|
*
|
|
* @param no the number in the Selector
|
|
* @return the offseted number for accessing the parameter
|
|
* @throws IllegalArgumentException if the parameter is zero
|
|
* @throws ArrayIndexOutOfBoundsException if no is not within bounds [1 to numberOfParameters]
|
|
*/
|
|
public int getParameterNo(final int no) {
|
|
if (no == 0) {
|
|
throw new IllegalArgumentException("Parameter numbers start with 1. Use getThis() to access a potential implicit this.");
|
|
}
|
|
if ((no < 0) || (no > this.numberOfParameters)) {
|
|
throw new ArrayIndexOutOfBoundsException("The given number (" + no + ") was not within bounds (1 to " + this.numberOfParameters +
|
|
") when acessing a parameter of " + this);
|
|
}
|
|
|
|
switch (this.base) {
|
|
case IMETHOD:
|
|
return no + this.implicitThis; // + this.implicitThis; // TODO: Verify
|
|
case METHOD_REFERENCE:
|
|
if (this.implicitThis > 0) {
|
|
return no + this.implicitThis; //
|
|
} else {
|
|
return no;
|
|
}
|
|
default:
|
|
throw new UnsupportedOperationException("No implementation of getParameter() for base " + this.base);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Same as Parameter.getNumber().
|
|
*
|
|
* @return SSA-Value to access the parameters contents.
|
|
*/
|
|
public int getParameterNo(final Parameter param) {
|
|
if (param == null) {
|
|
throw new IllegalArgumentException("Parameter may not be null");
|
|
}
|
|
|
|
return param.getNumber();
|
|
}
|
|
|
|
/**
|
|
* This list _excludes_ the implicit this-pointer (if any).
|
|
*
|
|
* If you want the implicit this-pointer use getThis().
|
|
*
|
|
* @return All parameters appearing in the Selector.
|
|
*/
|
|
public List<Parameter> all() {
|
|
// TODO: Cache!
|
|
List<Parameter> all = new ArrayList<Parameter>(this.getNumberOfParameters());
|
|
|
|
if (this.getNumberOfParameters() == 0) {
|
|
return all;
|
|
} else {
|
|
switch (this.base) {
|
|
case IMETHOD:
|
|
{
|
|
final int firstInSelector = firstInSelector();
|
|
for (int i = ((hasImplicitThis())?1:0); i < this.method.getNumberOfParameters(); ++i) {
|
|
debug("all() adding: Parameter({}, {}, {}, {}, {})", (i + 1), this.method.getParameterType(i),
|
|
this.base, this.method, this.descriptorOffset);
|
|
all.add(new Parameter(i + 1, null, this.method.getParameterType(i), ParamerterDisposition.PARAM,
|
|
this.base, this.method.getReference(), this.descriptorOffset));
|
|
}
|
|
}
|
|
break;
|
|
case METHOD_REFERENCE:
|
|
{
|
|
final int firstInSelector = firstInSelector();
|
|
for (int i = 0 /*firstInSelector()*/; i < this.numberOfParameters; ++i) { // TODO:
|
|
all.add(new Parameter(i + firstInSelector, null, this.mRef.getParameterType(i), ParamerterDisposition.PARAM,
|
|
this.base, this.mRef, this.descriptorOffset));
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
throw new UnsupportedOperationException("No implementation of all() for base " + this.base);
|
|
}
|
|
}
|
|
|
|
return all;
|
|
}
|
|
|
|
/**
|
|
* Return the implicit this-pointer (or throw).
|
|
*
|
|
* This obviously only works on non-static methods. You probably want to check if the method has
|
|
* such an implicit this using hasImplicitThis() as this method will throw if there is none.
|
|
*
|
|
* If you only want the number use the more lightweight getThisNo().
|
|
*
|
|
* @return Object containing all Information on the parameter.
|
|
* @throws IllegalStateException if the function has no implicit this
|
|
*/
|
|
public Parameter getThis() {
|
|
final int self = getThisNo();
|
|
final TypeReference selfType;
|
|
switch (this.base) {
|
|
case IMETHOD:
|
|
selfType = this.method.getParameterType(self);
|
|
break;
|
|
case METHOD_REFERENCE:
|
|
selfType = this.mRef.getDeclaringClass();
|
|
break;
|
|
default:
|
|
throw new UnsupportedOperationException("No implementation of getThis() for base " + this.base);
|
|
}
|
|
return getThisAs(selfType);
|
|
}
|
|
|
|
/**
|
|
* Return the implicit this-pointer as a supertype.
|
|
*
|
|
* @param asType A type of a super-class of this
|
|
*/
|
|
public Parameter getThisAs(final TypeReference asType) {
|
|
final int self = getThisNo();
|
|
|
|
switch (this.base) {
|
|
case IMETHOD:
|
|
final IClassHierarchy cha = this.method.getClassHierarchy();
|
|
try {
|
|
if (! isSubclassOf(this.method.getParameterType(self), asType, cha) ) {
|
|
throw new IllegalArgumentException("Class " + asType + " is not a super-class of " +
|
|
this.method.getParameterType(self));
|
|
}
|
|
} catch (ClassLookupException e) {
|
|
// Cant't test assume all fitts
|
|
}
|
|
|
|
return new Parameter(self, "self", asType, ParamerterDisposition.THIS,
|
|
this.base, this.method.getReference(), this.descriptorOffset);
|
|
case METHOD_REFERENCE:
|
|
// TODO assert asType is a subtype of self.type - we need cha to do that :(
|
|
return new Parameter(self, "self", asType, ParamerterDisposition.THIS,
|
|
this.base, this.mRef, this.descriptorOffset);
|
|
default:
|
|
throw new UnsupportedOperationException("No implementation of getThis() for base " + this.base);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return the SSA-Value of the implicit this-pointer (or throw).
|
|
*
|
|
* This obviously only works on non-static methods. You probably want to check if the method has
|
|
* such an implicit this using hasImplicitThis() as this method will throw if there is none.
|
|
*
|
|
* @return Number of the this.
|
|
* @throws IllegalStateException if the function has no implicit this.
|
|
*/
|
|
public int getThisNo() {
|
|
if (this.implicitThis >= 0) {
|
|
return this.implicitThis;
|
|
} else {
|
|
throw new IllegalStateException("getThisNo called for a method that has no implicit this");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* If the method has an implicit this parameter.
|
|
*/
|
|
public boolean hasImplicitThis() {
|
|
return (this.implicitThis >= 0);
|
|
}
|
|
|
|
/**
|
|
* Create a "Parameter" containing the Return-Type w/o Type-checking.
|
|
*
|
|
* This should be of rather theoretical use.
|
|
*
|
|
* @throws IllegalStateException if used on a void-Function
|
|
*/
|
|
public Parameter makeReturn(final int ssa) {
|
|
if (! hasReturn()) {
|
|
throw new IllegalStateException("Can't generate a return-value for a void-function.");
|
|
}
|
|
|
|
switch (this.base) {
|
|
case IMETHOD:
|
|
return new Parameter(ssa, "retVal", getReturnType(), ParamerterDisposition.RETURN, this.base,
|
|
this.method.getReference(), this.descriptorOffset);
|
|
case METHOD_REFERENCE:
|
|
return new Parameter(ssa, "retVal", getReturnType(), ParamerterDisposition.RETURN, this.base,
|
|
this.mRef, this.descriptorOffset);
|
|
default:
|
|
throw new UnsupportedOperationException("No implementation of getReturn() for base " + this.base);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create a "Parameter" containing the Return-Type with Type-checking.
|
|
*
|
|
* @param ssa The value to return
|
|
* @param type The type of ssa
|
|
* @param cha The ClassHierarchy to use for the assignability test
|
|
* @throws IllegalStateException if used on a void-Function
|
|
*/
|
|
public Parameter makeReturn(final int ssa, final TypeReference type, final IClassHierarchy cha) {
|
|
if (! hasReturn()) {
|
|
throw new IllegalStateException("Can't generate a return-value for a void-function.");
|
|
}
|
|
|
|
final TypeReference returnType = getReturnType();
|
|
|
|
if (returnType.equals(type)) {
|
|
return makeReturn(ssa);
|
|
} else if (cha == null) {
|
|
throw new IllegalArgumentException("Needed to test assignability but no cha given."); // TODO: Throw always or never
|
|
} else if (isAssignable(type, returnType, cha)) {
|
|
return makeReturn(ssa);
|
|
} else {
|
|
throw new IllegalStateException("Return type " + returnType + " is not assignable from " + type);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The SSA-Value to acces the parameter appearing first in the Descriptor with.
|
|
*
|
|
* @throws IllegalArgumentException if the method has no parameters in its Descriptor.
|
|
*/
|
|
public int firstInSelector() {
|
|
if (this.numberOfParameters == 0) {
|
|
if (this.method != null) {
|
|
throw new IllegalArgumentException("The method " + this.method.toString() + " has no explicit parameters.");
|
|
} else {
|
|
throw new IllegalArgumentException("The method " + this.mRef.toString() + " has no explicit parameters.");
|
|
}
|
|
}
|
|
if (this.implicitThis > 1) {
|
|
throw new IllegalStateException("An internal error in ParameterAccessor locating the implicit this pointer occurred! Invalid: " + this.implicitThis);
|
|
}
|
|
|
|
switch (this.base) {
|
|
case IMETHOD:
|
|
if (this.hasImplicitThis()) { // XXX TODO BUG!
|
|
debug("This IMethod {} has an implicit this pointer at {}, so firstInSelector is accessible using SSA-Value {}", this.method, this.implicitThis, (this.implicitThis + 1));
|
|
return this.implicitThis + 1;
|
|
} else {
|
|
debug("This IMethod {} has no implicit this pointer, so firstInSelector is accessible using SSA-Value 1" , this.method);
|
|
return 1;
|
|
}
|
|
case METHOD_REFERENCE:
|
|
if (this.hasImplicitThis()) {
|
|
debug("This IMethod {} has an implicit this pointer at {}, so firstInSelector is accessible using SSA-Value {}", this.mRef, this.implicitThis, (this.implicitThis + 1));
|
|
return this.implicitThis + 1;
|
|
} else {
|
|
debug("This mRef {} has no implicit this pointer, so firstInSelector is accessible using SSA-Value 1", this.mRef);
|
|
return 1;
|
|
}
|
|
default:
|
|
throw new UnsupportedOperationException("No implementation of firstInSelector() for base " + this.base);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Prefer: getParameter(int no) or all().
|
|
*
|
|
* Get the type of the parameter (not this) using a fixed numbering.
|
|
*
|
|
* Number 1 is the first parameter in the methods Selector. No matter if the function has an
|
|
* implicit this pointer.
|
|
*
|
|
* Use all() if you want to get all parameter-types.
|
|
*
|
|
* @param no the number in the Selector
|
|
* @return the type of the parameter
|
|
*/
|
|
public TypeReference getParameterType(final int no) { // XXX Remove?
|
|
switch (this.base) {
|
|
case IMETHOD:
|
|
return this.method.getParameterType(getParameterNo(no));
|
|
case METHOD_REFERENCE:
|
|
return this.method.getParameterType(getParameterNo(no));
|
|
default:
|
|
throw new UnsupportedOperationException("No implementation of getParameterType() for base " + this.base);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* First parameter in the selector that matches _exactly_.
|
|
*
|
|
* @return first parameter found or null if there is none
|
|
* @throws IllegalArgumentException if searching for void or null
|
|
*/
|
|
public Parameter firstOf(final TypeName tName) {
|
|
if (tName == null) {
|
|
throw new IllegalArgumentException("Search-name may not be null");
|
|
}
|
|
if (tName.equals(TypeReference.VoidName)) {
|
|
throw new IllegalArgumentException("You are searching for 'void' as a parameter.");
|
|
}
|
|
|
|
final List<Parameter> all = all();
|
|
|
|
// ****
|
|
// Implementation starts here
|
|
|
|
for (final Parameter cand : all) {
|
|
if (cand.getType().getName().equals(tName)) {
|
|
return cand;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* First parameter in the selector that matches _exactly_.
|
|
*
|
|
* @return first parameter found or null if there is none
|
|
* @throws IllegalArgumentException if searching for void or null
|
|
*/
|
|
public Parameter firstOf(final TypeReference tRef) {
|
|
if (tRef == null) {
|
|
throw new IllegalArgumentException("Search-name may not be null");
|
|
}
|
|
if (tRef.equals(TypeReference.Void)) {
|
|
throw new IllegalArgumentException("You are searching for 'void' as a parameter.");
|
|
}
|
|
|
|
final List<Parameter> all = all();
|
|
|
|
// ****
|
|
// Implementation starts here
|
|
|
|
for (final Parameter cand : all) {
|
|
if (cand.getType().equals(tRef)) {
|
|
return cand;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* All parameters in the selector that are a subclass of tName (slow).
|
|
*
|
|
* TypeNames have to be looked up first, do prefer the variant with the TypeReference if
|
|
* one is available.
|
|
*
|
|
* @throws IllegalArgumentException if searching for void or null
|
|
*/
|
|
public List<Parameter> allExtend(final TypeName tName, final IClassHierarchy cha) {
|
|
if (tName == null) {
|
|
throw new IllegalArgumentException("Search-name may not be null");
|
|
}
|
|
if (tName.equals(TypeReference.VoidName)) {
|
|
throw new IllegalArgumentException("You are searching for 'void' as a parameter.");
|
|
}
|
|
if (cha == null) {
|
|
throw new IllegalArgumentException("Can't search ClassHierarchy without having a ClassHierarchy (is null)");
|
|
}
|
|
|
|
final List<Parameter> all = all();
|
|
final List<Parameter> allExctends = new ArrayList<>();
|
|
IClass searchType = null;
|
|
final IClassLoader[] allLoaders = cha.getLoaders();
|
|
|
|
// ****
|
|
// Implementation starts here
|
|
|
|
{ // Retrieve a reference of the type
|
|
for (final IClassLoader loader : allLoaders) {
|
|
searchType = loader.lookupClass(tName);
|
|
if (searchType != null) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (searchType == null) {
|
|
throw new IllegalStateException("Could not find " + tName + " in any loader!");
|
|
} else {
|
|
debug("Retrieved {} as {}", tName, searchType);
|
|
}
|
|
|
|
for (final Parameter cand : all) {
|
|
final IClass candClass = cha.lookupClass(cand.getType());
|
|
|
|
if (candClass != null) { // TODO: Extra function
|
|
if (cha.isSubclassOf(candClass, searchType)) {
|
|
allExctends.add(cand);
|
|
}
|
|
} else {
|
|
for (final IClassLoader loader: cha.getLoaders()) {
|
|
final IClass c = loader.lookupClass(cand.getType().getName());
|
|
if (c != null) {
|
|
info("Using alternative for from: {}", cand);
|
|
if (cha.isSubclassOf(c, searchType)) {
|
|
allExctends.add(cand);
|
|
}
|
|
}
|
|
}
|
|
|
|
// TODO: That's true for base-type too
|
|
warn("Unable to look up IClass of {}", cand);
|
|
}
|
|
}
|
|
|
|
return allExctends;
|
|
}
|
|
|
|
/**
|
|
* All parameters in the selector that are a subclass of tRef (slow).
|
|
*
|
|
* @throws IllegalArgumentException if searching for void or null
|
|
*/
|
|
public List<Parameter> allExtend(final TypeReference tRef, final IClassHierarchy cha) {
|
|
if (tRef == null) {
|
|
throw new IllegalArgumentException("Search TypeReference may not be null");
|
|
}
|
|
if (tRef.equals(TypeReference.Void)) {
|
|
throw new IllegalArgumentException("You are searching for 'void' as a parameter.");
|
|
}
|
|
if (cha == null) {
|
|
throw new IllegalArgumentException("Can't search ClassHierarchy without having a ClassHierarchy (is null)");
|
|
}
|
|
|
|
// ****
|
|
// Implementation starts here
|
|
|
|
final IClass searchType = cha.lookupClass(tRef);
|
|
final List<Parameter> all = all();
|
|
final List<Parameter> allExctends = new ArrayList<>();
|
|
|
|
if (searchType == null) {
|
|
throw new IllegalStateException("Could not find the IClass of " + tRef);
|
|
} else {
|
|
debug("Reteived {} as {}", tRef, searchType);
|
|
}
|
|
|
|
for (final Parameter cand : all) {
|
|
final IClass candClass = cha.lookupClass(cand.getType());
|
|
|
|
if (candClass != null) {
|
|
if (cha.isSubclassOf(candClass, searchType)) {
|
|
allExctends.add(cand);
|
|
}
|
|
} else {
|
|
// TODO: That's true for base-type too
|
|
warn("Unable to look up IClass of {}", cand);
|
|
}
|
|
}
|
|
|
|
return allExctends;
|
|
}
|
|
|
|
|
|
/**
|
|
* First parameter in the selector that is a subclass of tName (slow).
|
|
*
|
|
* TypeNames have to be lloked up first, do prefer the variant with the TypeReference if
|
|
* one is available.
|
|
*
|
|
* @return first parameter found or null if there is none
|
|
* @throws IllegalArgumentException if searching for void or null
|
|
*/
|
|
public Parameter firstExtends(final TypeName tName, final IClassHierarchy cha) {
|
|
if (tName == null) {
|
|
throw new IllegalArgumentException("Search-name may not be null");
|
|
}
|
|
if (tName.equals(TypeReference.VoidName)) {
|
|
throw new IllegalArgumentException("You are searching for 'void' as a parameter.");
|
|
}
|
|
if (cha == null) {
|
|
throw new IllegalArgumentException("Can't search ClassHierarchy without having a ClassHierarchy (is null)");
|
|
}
|
|
|
|
final List<Parameter> all = all();
|
|
IClass searchType = null;
|
|
final IClassLoader[] allLoaders = cha.getLoaders();
|
|
|
|
// ****
|
|
// Implementation starts here
|
|
|
|
{ // Reteive a reference of the type
|
|
for (final IClassLoader loader : allLoaders) {
|
|
searchType = loader.lookupClass(tName);
|
|
if (searchType != null) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (searchType == null) {
|
|
throw new IllegalStateException("Could not find " + tName + " in any loader!");
|
|
} else {
|
|
debug("Reteived {} as {}", tName, searchType);
|
|
}
|
|
|
|
for (final Parameter cand : all) {
|
|
final IClass candClass = cha.lookupClass(cand.getType());
|
|
|
|
if (candClass != null) {
|
|
if (cha.isSubclassOf(candClass, searchType)) {
|
|
return cand;
|
|
}
|
|
} else {
|
|
for (final IClassLoader loader: cha.getLoaders()) {
|
|
final IClass c = loader.lookupClass(cand.getType().getName());
|
|
if (c != null) {
|
|
info("Using alternative for from: {}", cand);
|
|
if (cha.isSubclassOf(c, searchType)) {
|
|
return cand;
|
|
}
|
|
}
|
|
}
|
|
|
|
// TODO: That's true for primitive-type too
|
|
warn("Unable to look up IClass of {}", cand);
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* First parameter in the selector that is a subclass of tRef (slow).
|
|
*
|
|
* @return first parameter found or null if there is none
|
|
* @throws IllegalArgumentException if searching for void or null
|
|
*/
|
|
public Parameter firstExtends(final TypeReference tRef, final IClassHierarchy cha) {
|
|
if (tRef == null) {
|
|
throw new IllegalArgumentException("Search TypeReference may not be null");
|
|
}
|
|
if (tRef.equals(TypeReference.Void)) {
|
|
throw new IllegalArgumentException("You are searching for 'void' as a parameter.");
|
|
}
|
|
if (cha == null) {
|
|
throw new IllegalArgumentException("Can't search ClassHierarchy without having a ClassHierarchy (is null)");
|
|
}
|
|
|
|
// ****
|
|
// Implementation starts here
|
|
|
|
final IClass searchType = cha.lookupClass(tRef);
|
|
final List<Parameter> all = all();
|
|
|
|
if (searchType == null) {
|
|
throw new IllegalStateException("Could not find the IClass of " + tRef);
|
|
} else {
|
|
debug("Reteived {} as {}", tRef, searchType);
|
|
}
|
|
|
|
for (final Parameter cand : all) {
|
|
final IClass candClass = cha.lookupClass(cand.getType());
|
|
|
|
if (candClass != null) {
|
|
if (cha.isSubclassOf(candClass, searchType)) {
|
|
return cand;
|
|
}
|
|
} else {
|
|
// TODO: That's true for base-type too
|
|
warn("Unable to look up IClass of {}", cand);
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* The first SSA-Number after the parameters.
|
|
*
|
|
* This is useful for making synthetic methods.
|
|
*/
|
|
public int getFirstAfter() {
|
|
return this.numberOfParameters + 2; // Should be +1 ?
|
|
}
|
|
|
|
/**
|
|
* Generate the params-param for an InvokeIstruction w/o type checking.
|
|
*
|
|
* @param args list to build the arguments from - without implicit this
|
|
*/
|
|
public int[] forInvokeStatic(final List<? extends SSAValue> args) {
|
|
if (args == null) { // XXX Allow?
|
|
throw new IllegalArgumentException("args is null");
|
|
}
|
|
|
|
int[] params = new int[args.size()];
|
|
if (params.length == 0) {
|
|
return params;
|
|
}
|
|
|
|
if ((args.get(1) instanceof Parameter) && (((Parameter)args.get(1)).getDisposition() == ParamerterDisposition.THIS)) {
|
|
warn("The first argument is an implicit this: {} this may be ok however.", args.get(1));
|
|
}
|
|
|
|
// ****
|
|
// Implementation starts here
|
|
|
|
for (int i = 0; i < params.length; ++i) {
|
|
params[i] = args.get(i).getNumber();
|
|
}
|
|
|
|
return params;
|
|
}
|
|
|
|
/**
|
|
* Generate the params-param for an InvokeIstruction with type checking.
|
|
*
|
|
* @param args list to build the arguments from - without implicit this
|
|
* @param target the method to be called - for type checking only
|
|
* @param cha if types don't match exactly needed for the assignability check (may be null if that check is not wanted)
|
|
* @throws IllegalArgumentException if you call this method on a target that needs an implicit this
|
|
* @throws IllegalArgumentException if args length does not match the targets param-length
|
|
* @throws IllegalArgumentException if a parameter is unassignable
|
|
*/
|
|
public int[] forInvokeStatic(final List<? extends SSAValue> args, final ParameterAccessor target, final IClassHierarchy cha) {
|
|
if (args == null) {
|
|
throw new IllegalArgumentException("args is null");
|
|
}
|
|
if (target == null) {
|
|
throw new IllegalArgumentException("ParameterAccessor for the target is null");
|
|
}
|
|
if (target.hasImplicitThis()) {
|
|
throw new IllegalArgumentException("You used forInvokeStatic on a method that has an implicit this pointer");
|
|
}
|
|
if (target.getNumberOfParameters() != args.size()) {
|
|
throw new IllegalArgumentException("Number of arguments mismatch: " + args.size() + " given on a method that " +
|
|
"needs " + target.getNumberOfParameters() + " arguments. Arguments given were " + args + " for a static " +
|
|
"call to " + target);
|
|
}
|
|
|
|
int[] params = new int[args.size()];
|
|
if (params.length == 0) {
|
|
return params;
|
|
}
|
|
|
|
if ((args.get(1) instanceof Parameter) && (((Parameter)args.get(1)).getDisposition() == ParamerterDisposition.THIS)) {
|
|
warn("The first argument is an implicit this: {} this may be ok however.", args.get(1));
|
|
}
|
|
|
|
// ****
|
|
// Implementation starts here
|
|
|
|
for (int i = 0; i < params.length; ++i) {
|
|
final SSAValue param = args.get(i);
|
|
if (param.getType().equals(target.getParameter(i).getType())) {
|
|
params[i] = param.getNumber();
|
|
} else {
|
|
if (cha == null) {
|
|
throw new IllegalArgumentException("Parameter " + i + " (" + param + ") of the Arguments list " +
|
|
"is not equal to param " + i + " ( " + target.getParameter(i) + ") of " + target +
|
|
"and no ClassHierarchy was given to test assignability");
|
|
} else if (isAssignable(param, target.getParameter(i), cha)) {
|
|
params[i] = param.getNumber();
|
|
} else {
|
|
throw new IllegalArgumentException("Parameter " + i + " (" + param + ") of the Arguments list " +
|
|
"is not assignable to param " + i + " ( " + target.getParameter(i) + ") of " +
|
|
target);
|
|
}
|
|
}
|
|
}
|
|
|
|
return params;
|
|
}
|
|
|
|
/**
|
|
* Generate the params-param for an InvokeIstruction w/o type checking.
|
|
*
|
|
* @param self the this-pointer to use
|
|
* @param args the rest of the arguments. Be shure it does not start with a
|
|
* this pointer. This is _not_ checked so you can use a this-pointer as
|
|
* an argument. However a warning is issued.
|
|
* @throws IllegalArgumentException if the value of self is to small in the current
|
|
* method
|
|
*/
|
|
public int[] forInvokeVirtual(final int self, final List<? extends SSAValue> args) {
|
|
if (args == null) {
|
|
throw new IllegalArgumentException("args is null");
|
|
}
|
|
if ((this.base == BasedOn.METHOD_REFERENCE) && (self < 1)) {
|
|
throw new IllegalArgumentException("The first SSA-Value of a MethodReference is 1. The given this (self) is " +
|
|
self);
|
|
} else if (self < 0) {
|
|
throw new IllegalArgumentException("self = " + self + " < 0");
|
|
}
|
|
|
|
int[] params = new int[args.size() + 1];
|
|
if ((params.length > 1) && (args.get(1) instanceof Parameter) && (((Parameter)args.get(1)).getDisposition() ==
|
|
ParamerterDisposition.THIS)) {
|
|
warn("The first argument is an implicit this: {} this may be ok however.", args.get(1));
|
|
}
|
|
|
|
// ****
|
|
// Implementation starts here
|
|
//
|
|
|
|
params[0] = self;
|
|
for (int i = 1; i < params.length; ++i) {
|
|
params[i] = args.get(i - 1).getNumber();
|
|
}
|
|
|
|
return params;
|
|
}
|
|
|
|
/**
|
|
* Generate the params-param for an InvokeIstruction with type checking.
|
|
*
|
|
* @param self the this-pointer to use
|
|
* @param args list to build the arguments from - without implicit this
|
|
* @param target the method to be called - for type checking only
|
|
* @param cha if types don't match exactly needed for the assignability check (may be null if that check is not wanted)
|
|
* @throws IllegalArgumentException if you call this method on a target that needs an implicit this
|
|
* @throws IllegalArgumentException if args length does not match the targets param-length
|
|
* @throws IllegalArgumentException if a parameter is unassignable
|
|
*/
|
|
public int[] forInvokeVirtual(final int self, final List<? extends SSAValue> args, final ParameterAccessor target, final IClassHierarchy cha) {
|
|
if (args == null) {
|
|
throw new IllegalArgumentException("args is null");
|
|
}
|
|
if ((this.base == BasedOn.METHOD_REFERENCE) && (self < 1)) {
|
|
throw new IllegalArgumentException("The first SSA-Value of a MethodReference is 1. The given this (self) is " +
|
|
self);
|
|
} else if (self < 0) {
|
|
throw new IllegalArgumentException("self = " + self + " < 0");
|
|
}
|
|
if (target == null) {
|
|
throw new IllegalArgumentException("ParameterAccessor for the target is null");
|
|
}
|
|
if (! target.hasImplicitThis()) {
|
|
throw new IllegalArgumentException("You used forInvokeVirtual on a method that has no implicit this pointer");
|
|
}
|
|
if (target.getNumberOfParameters() != args.size() + 1) { // TODO: Verify
|
|
throw new IllegalArgumentException("Number of arguments mismatch: " + args.size() + " given on a method that " +
|
|
"needs " + target.getNumberOfParameters() + " arguments. Arguments given were " + args + " for a static " +
|
|
"call to " + target);
|
|
}
|
|
|
|
int[] params = new int[args.size() + 1];
|
|
if ((params.length > 1) && (args.get(1) instanceof Parameter) && (((Parameter)args.get(1)).getDisposition() ==
|
|
ParamerterDisposition.THIS)) {
|
|
warn("The first argument is an implicit this: {} this may be ok however.", args.get(1));
|
|
}
|
|
|
|
// ****
|
|
// Implementation starts here
|
|
|
|
params[0] = self; // TODO: Can't typecheck this!
|
|
for (int i = 1; i < params.length; ++i) {
|
|
final SSAValue param = args.get(i - 1);
|
|
if (param.getType().equals(target.getParameter(i).getType())) {
|
|
params[i] = param.getNumber();
|
|
} else {
|
|
if (cha == null) {
|
|
throw new IllegalArgumentException("Parameter " + i + " (" + param + ") of the Arguments list " +
|
|
"is not equal to param " + i + " ( " + target.getParameter(i) + ") of " + target +
|
|
"and no ClassHierarchy was given to test assignability");
|
|
} else if (isAssignable(param, target.getParameter(i), cha)) {
|
|
params[i] = param.getNumber();
|
|
} else {
|
|
throw new IllegalArgumentException("Parameter " + i + " (" + param + ") of the Arguments list " +
|
|
"is not assignable to param " + i + " ( " + target.getParameter(i) + ") of " +
|
|
target);
|
|
}
|
|
}
|
|
}
|
|
|
|
return params;
|
|
}
|
|
|
|
/**
|
|
* Connects though parameters from the calling function (overridable) - CAUTION:.
|
|
*
|
|
* This functions makes is decisions based on Type-Referes only so if a TypeReference occurs multiple
|
|
* times in the caller or callee it may make surprising connections.
|
|
*
|
|
* The List of Parameters is generated based on the overrides, than parameters in 'this' are searched, finally we'll
|
|
* fall back to defaults. A "perfect match" is searched.
|
|
*
|
|
* If a parameter was not assigned yet these three sources are considdered again but cha.isAssignableFrom is used.
|
|
*
|
|
* If the parameter was still not found a value of 'null' is used.
|
|
*
|
|
* This funktion is useful when generating wrapper-functions.
|
|
*
|
|
* @param callee The function to generate the parameter-list for
|
|
* @param overrides If a parameter occurs here, it is preferred over the ones present in this
|
|
* @param defaults If a parameter is not present in this or the overrides, defaults are searched. If the parameter is not present there null is assigned.
|
|
* @param cha Optional class hierarchy for testing assignability
|
|
* @return the parameter-list for the call of toMethod
|
|
*/
|
|
@SuppressWarnings("unchecked") // TODO: Can we do this for overrides and defaults only?
|
|
public List<SSAValue> connectThrough(final ParameterAccessor callee, Set<? extends SSAValue> overrides, Set<? extends SSAValue> defaults, final IClassHierarchy cha, IInstantiator instantiator, Object... instantiatorArgs) {
|
|
if (callee == null) {
|
|
throw new IllegalArgumentException("Cannot connect through to null-callee");
|
|
}
|
|
if (overrides == null) {
|
|
overrides = Collections.EMPTY_SET;
|
|
}
|
|
if (defaults == null) {
|
|
defaults = Collections.EMPTY_SET;
|
|
}
|
|
if (callee.getNumberOfParameters() == 0) {
|
|
return new ArrayList<SSAValue>(0);
|
|
}
|
|
|
|
final List<SSAValue> assigned = new ArrayList<SSAValue>(); // TODO: Set initial size
|
|
final List<Parameter> calleeParams = callee.all();
|
|
final List<Parameter> thisParams = all();
|
|
|
|
// ****
|
|
// Implementation starts here
|
|
debug("Collecting parameters for callee {}", ((callee.mRef!=null)?callee.mRef:callee.method));
|
|
debug("\tThe calling function is {}", ((this.mRef!=null)?this.mRef:this.method));
|
|
forEachParameter:
|
|
for (final Parameter param : calleeParams) {
|
|
debug("\tSearching candidate for {}", param);
|
|
final TypeReference paramType = param.getType();
|
|
|
|
{ // Exact match in overrides
|
|
for (final SSAValue cand : overrides) {
|
|
if (cand.getType().getName().equals(paramType.getName())) { // XXX: What about the loader?
|
|
assigned.add(cand);
|
|
debug("\t\tAsigning: {} from the overrides (eq)", cand);
|
|
continue forEachParameter;
|
|
} else {
|
|
debug("\t\tSkipping: {} of the overrides (eq)", cand);
|
|
}
|
|
}
|
|
}
|
|
|
|
{ // Exact match in this params
|
|
for (final Parameter cand : thisParams) {
|
|
if (cand.getType().getName().equals(paramType.getName())) {
|
|
assigned.add(cand);
|
|
debug("\t\tAsigning: {} from callers params (eq)", cand);
|
|
continue forEachParameter;
|
|
} else {
|
|
debug("\t\tSkipping: {} of the callers params (eq)", cand);
|
|
}
|
|
}
|
|
}
|
|
|
|
{ // Exact match in defaults
|
|
for (final SSAValue cand : defaults) {
|
|
if (cand.getType().getName().equals(paramType.getName())) {
|
|
assigned.add(cand);
|
|
debug("\t\tAsigning: {} from the defaults (eq)", cand);
|
|
continue forEachParameter;
|
|
}
|
|
}
|
|
}
|
|
|
|
debug("\tThe parameter is still not found - try again using an assignability check...");
|
|
|
|
// If we got here we need cha
|
|
if (cha != null) {
|
|
{ // Assignable from overrides
|
|
try {
|
|
for (final SSAValue cand : overrides) {
|
|
if (isAssignable(cand, param, cha)) {
|
|
assigned.add(cand);
|
|
debug("\t\tAsigning: {} from the overrides (ass)", cand);
|
|
continue forEachParameter;
|
|
}
|
|
}
|
|
} catch (ClassLookupException e) {
|
|
}
|
|
}
|
|
|
|
{ // Assignable from this params
|
|
for (final Parameter cand : thisParams) {
|
|
try {
|
|
if (isAssignable(cand, param, cha)) {
|
|
assigned.add(cand);
|
|
debug("\t\tAsigning: {} from the callrs params (ass)", cand);
|
|
continue forEachParameter;
|
|
}
|
|
} catch (ClassLookupException e) {
|
|
}
|
|
}
|
|
}
|
|
|
|
{ // Assignable from defaults
|
|
for (final SSAValue cand : defaults) {
|
|
if (isAssignable(cand, param, cha)) {
|
|
assigned.add(cand);
|
|
debug("\t\tAsigning: {} from the defaults (ass)", cand);
|
|
continue forEachParameter;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (instantiator != null) {
|
|
info("Creating new instance of: {} in call to {}", param, callee);
|
|
/*{ // DEBUG
|
|
System.out.println("Creating new instance of: " + param);
|
|
System.out.println("in connectThrough");
|
|
System.out.println("\tCaller:\t\t" + this.forMethod());
|
|
System.out.println("\tCallee:\t\t" + callee.forMethod());
|
|
System.out.println("\tOverrides:\t" + overrides);
|
|
System.out.println("\tDefaults:\t" + defaults);
|
|
} // */
|
|
final int inst = instantiator.createInstance(param.getType(), instantiatorArgs);
|
|
if (inst < 0) {
|
|
warn("No type was assignable and the instantiator returned an invalidone! Using null for {}", param);
|
|
assigned.add(null);
|
|
continue forEachParameter;
|
|
} else {
|
|
final Parameter newParam;
|
|
if (this.base == BasedOn.IMETHOD) {
|
|
newParam = new Parameter(inst, "craftedForCall", param.getType(), ParamerterDisposition.NEW,
|
|
this.base, this.method.getReference(), this.descriptorOffset);
|
|
} else if (this.base == BasedOn.METHOD_REFERENCE) {
|
|
newParam = new Parameter(inst, "craftedForCall", param.getType(), ParamerterDisposition.NEW,
|
|
this.base, this.mRef, this.descriptorOffset);
|
|
} else {
|
|
throw new UnsupportedOperationException("Can't handle base " + this.base);
|
|
}
|
|
|
|
assigned.add(newParam);
|
|
continue forEachParameter;
|
|
}
|
|
} else {
|
|
warn("No IInstantiator given and no known parameter assignable - using null");
|
|
assigned.add(null);
|
|
continue forEachParameter;
|
|
}
|
|
} else {
|
|
// TODO: CreateInstance Call-Back
|
|
|
|
warn("No type was equal. We can't ask isAssignable since we have no cha!");
|
|
assigned.add(null);
|
|
continue forEachParameter;
|
|
} // of (cha != null)
|
|
|
|
//Assertions.UNREACHABLE(); // Well it's unreachable
|
|
} // of final Parameter param : calleeParams
|
|
|
|
|
|
if(assigned.size() != calleeParams.size()) {
|
|
System.err.println("Assigned " + assigned.size() + " params to a method taking " + calleeParams.size() + " params!");
|
|
System.err.println("The call takes the parameters");
|
|
for (Parameter param : calleeParams) {
|
|
System.err.println("\t" + param);
|
|
}
|
|
System.err.println("The following were assigned:");
|
|
for (int i = 0; i < assigned.size(); ++i) {
|
|
System.err.println("\tAssigned parameter " + (i + 1) + " is " + assigned.get(i));
|
|
}
|
|
throw new IllegalStateException("Parameter mismatch!");
|
|
}
|
|
return assigned;
|
|
}
|
|
|
|
|
|
|
|
// *****************************************************************************
|
|
//
|
|
// Private helper functions follow...
|
|
|
|
/**
|
|
* Does "to x := from" hold?.
|
|
*/
|
|
public static boolean isAssignable(final TypeReference from, final TypeReference to, final IClassHierarchy cha) {
|
|
if (cha == null) {
|
|
throw new IllegalArgumentException("ClassHierarchy may not be null");
|
|
}
|
|
|
|
if (from.getName().equals(to.getName())) return true;
|
|
|
|
if (from.isPrimitiveType() && to.isPrimitiveType()) {
|
|
//return PrimitiveAssignability.isAssignableFrom(from.getName(), to.getName());
|
|
return PrimitiveAssignability.isAssignableFrom(to.getName(), from.getName()); // TODO: Which way
|
|
}
|
|
|
|
if (from.isPrimitiveType() || to.isPrimitiveType()) {
|
|
return false;
|
|
}
|
|
|
|
IClass fromClass = cha.lookupClass(from);
|
|
IClass toClass = cha.lookupClass(to);
|
|
|
|
if (fromClass == null) {
|
|
debug("Unable to look up the type of from=" + from + " in the ClassHierarchy - tying other loaders...");
|
|
for (final IClassLoader loader: cha.getLoaders()) {
|
|
final IClass cand = loader.lookupClass(from.getName());
|
|
if (cand != null) {
|
|
debug("Using alternative for from: {}", cand);
|
|
fromClass = cand;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (fromClass == null) {
|
|
throw new ClassLookupException("Unable to look up the type of from=" + from +
|
|
" in the ClassHierarchy");
|
|
//return false; // TODO
|
|
}
|
|
}
|
|
|
|
if (toClass == null) {
|
|
debug("Unable to look up the type of to=" + to + " in the ClassHierarchy - tying other loaders...");
|
|
for (final IClassLoader loader: cha.getLoaders()) {
|
|
final IClass cand = loader.lookupClass(to.getName());
|
|
if (cand != null) {
|
|
debug("Using alternative for to: {}", cand);
|
|
toClass = cand;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (toClass == null) {
|
|
error("Unable to look up the type of to={} in the ClassHierarchy", to);
|
|
return false;
|
|
//throw new ClassLookupException("Unable to look up the type of to=" + to +
|
|
// " in the ClassHierarchy");
|
|
}
|
|
}
|
|
|
|
// cha.isAssignableFrom (IClass c1, IClass c2)
|
|
// Does an expression c1 x := c2 y typecheck?
|
|
|
|
trace("isAssignableFrom({}, {}) = {}", toClass, fromClass, cha.isAssignableFrom(toClass, fromClass));
|
|
return cha.isAssignableFrom(toClass, fromClass);
|
|
}
|
|
|
|
/**
|
|
* Is sub a subclass of superC (or the same).
|
|
*/
|
|
public static boolean isSubclassOf(final TypeReference sub, final TypeReference superC, final IClassHierarchy cha)
|
|
throws ClassLookupException {
|
|
if (cha == null) {
|
|
throw new IllegalArgumentException("ClassHierarchy may not be null");
|
|
}
|
|
|
|
if (sub.getName().equals(superC.getName())) return true;
|
|
|
|
if (sub.isPrimitiveType() || superC.isPrimitiveType()) {
|
|
return false;
|
|
}
|
|
|
|
IClass subClass = cha.lookupClass(sub);
|
|
IClass superClass = cha.lookupClass(superC);
|
|
|
|
if (subClass == null) {
|
|
debug("Unable to look up the type of from=" + sub + " in the ClassHierarchy - tying other loaders...");
|
|
for (final IClassLoader loader: cha.getLoaders()) {
|
|
final IClass cand = loader.lookupClass(sub.getName());
|
|
if (cand != null) {
|
|
debug("Using alternative for from: {}", cand);
|
|
subClass = cand;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (subClass == null) {
|
|
throw new ClassLookupException("Unable to look up the type of from=" + sub +
|
|
" in the ClassHierarchy");
|
|
}
|
|
}
|
|
|
|
if (superClass == null) {
|
|
debug("Unable to look up the type of to=" + superC + " in the ClassHierarchy - tying other loaders...");
|
|
for (final IClassLoader loader: cha.getLoaders()) {
|
|
final IClass cand = loader.lookupClass(superC.getName());
|
|
if (cand != null) {
|
|
debug("Using alternative for to: {}", cand);
|
|
superClass = cand;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (superClass == null) {
|
|
error("Unable to look up the type of to={} in the ClassHierarchy", superC);
|
|
throw new ClassLookupException("Unable to look up the type of to=" + superC +
|
|
" in the ClassHierarchy");
|
|
}
|
|
}
|
|
|
|
return cha.isSubclassOf(subClass, superClass);
|
|
}
|
|
|
|
/**
|
|
* The method this accessor reads the parameters from.
|
|
*/
|
|
public MethodReference forMethod() {
|
|
if (this.mRef != null) {
|
|
return this.mRef;
|
|
} else {
|
|
return this.method.getReference();
|
|
}
|
|
}
|
|
|
|
|
|
// *****************************************************************************
|
|
//
|
|
// Shorthand functions follow...
|
|
|
|
/**
|
|
* Does "to x := from" hold?.
|
|
*/
|
|
protected boolean isAssignable(final SSAValue from, final SSAValue to, final IClassHierarchy cha) {
|
|
return isAssignable(from.getType(), to.getType(), cha);
|
|
}
|
|
|
|
/**
|
|
* Shorthand for forInvokeStatic(final List<? extends Parameter> args, final ParameterAccessor target, final IClassHierarchy cha).
|
|
*
|
|
* Generates a new ParameterAccessor for target and hands the call through.
|
|
*/
|
|
public int[] forInvokeStatic(final List<?extends Parameter> args, final MethodReference target, final IClassHierarchy cha) {
|
|
return forInvokeStatic(args, new ParameterAccessor(target, cha), cha);
|
|
}
|
|
|
|
/**
|
|
* Shorthand for forInvokeVirtual(final int self, final List<? extends Parameter> args, final ParameterAccessor target, final IClassHierarchy cha).
|
|
*
|
|
* Generates a new ParameterAccessor for target and hands the call through.
|
|
*/
|
|
public int[] forInvokeVirtual (final int self, final List<? extends Parameter> args, final MethodReference target, final IClassHierarchy cha) {
|
|
return forInvokeVirtual (self, args, new ParameterAccessor(target, cha), cha);
|
|
}
|
|
|
|
/**
|
|
* If the method returns a value eg is non-void.
|
|
*/
|
|
public boolean hasReturn() {
|
|
return (getReturnType() != TypeReference.Void);
|
|
}
|
|
|
|
/**
|
|
* Assign parameters to a call based on their type.
|
|
*
|
|
* this variant of connectThrough cannot create new instances if needed.
|
|
*
|
|
* @param callee The function to generate the parameter-list for
|
|
* @param overrides If a parameter occurs here, it is preferred over the ones present in this
|
|
* @param defaults If a parameter is not present in this or the overrides, defaults are searched. If the parameter is not present there null is assigned.
|
|
* @param cha Optional class hierarchy for testing assignability
|
|
* @return the parameter-list for the call of toMethod
|
|
*/
|
|
public List<SSAValue> connectThrough(final ParameterAccessor callee, Set<? extends SSAValue> overrides, Set<? extends SSAValue> defaults,
|
|
final IClassHierarchy cha) {
|
|
return connectThrough(callee, overrides, defaults, cha, null);
|
|
}
|
|
// *****************************************************************************
|
|
//
|
|
// Hand-through functions follow...
|
|
|
|
/**
|
|
* Handed through to the IMethod / MethodReference
|
|
*/
|
|
public TypeReference getReturnType() {
|
|
switch (this.base) {
|
|
case IMETHOD:
|
|
return this.method.getReturnType();
|
|
case METHOD_REFERENCE:
|
|
return this.mRef.getReturnType();
|
|
default:
|
|
throw new UnsupportedOperationException("No implementation of getReturnType() for base " + this.base);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Number of parameters _excluding_ implicit this
|
|
*/
|
|
public int getNumberOfParameters() {
|
|
return this.numberOfParameters;
|
|
}
|
|
|
|
/**
|
|
* Extensive output for debugging purposes.
|
|
*/
|
|
public String dump() {
|
|
String ret = "Parameter Accessor for " + ((this.mRef!=null)?"mRef:" + this.mRef.toString():"IMethod: " + this.method.toString()) +
|
|
"\nContains " + this.numberOfParameters + " Parameters " + this.base + "\n";
|
|
/*for (int i = 1; i <= this.numberOfParameters; ++i) {
|
|
try {
|
|
ret += "\t" + getParameter(i).toString() + "\n";
|
|
} catch (Exception e) {
|
|
ret += "\tNone at " + i + "\n";
|
|
}
|
|
}*/
|
|
ret += "\nAnd all is:\n";
|
|
for (Parameter p : all()) {
|
|
ret += "\t" + p + "\n";
|
|
}
|
|
if (hasImplicitThis ()) {
|
|
ret +="This: " + getThis();
|
|
} else {
|
|
ret +="Is static";
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
public String toString() {
|
|
return "<ParamAccessor forMethod=" + this.forMethod() + " />";
|
|
}
|
|
|
|
private static void debug(String s, Object ... args) {
|
|
if (DEBUG) { System.err.printf(s, args); }
|
|
}
|
|
|
|
private static void info(String s, Object ... args) {
|
|
if (DEBUG) { System.err.printf(s, args); }
|
|
}
|
|
|
|
private static void warn(String s, Object ... args) {
|
|
if (DEBUG) { System.err.printf(s, args); }
|
|
}
|
|
|
|
private static void trace(String s, Object ... args) {
|
|
if (DEBUG) { System.err.printf(s, args); }
|
|
}
|
|
|
|
private static void error(String s, Object ... args) {
|
|
if (DEBUG) { System.err.printf(s, args); }
|
|
}
|
|
}
|