Example 1 with New
use of org.robovm.compiler.trampoline.New in project robovm by robovm.
the class MethodCompiler method assign.
private void assign(DefinitionStmt stmt) {
/*
* leftOp is either a Local, an ArrayRef or a FieldRef
* rightOp is either a Local, a Ref, or an Expr
*/
soot.Value rightOp = stmt.getRightOp();
Value result;
if (rightOp instanceof Immediate) {
Immediate immediate = (Immediate) rightOp;
result = immediate(stmt, immediate);
} else if (rightOp instanceof ThisRef) {
result = function.getParameterRef(1);
} else if (rightOp instanceof ParameterRef) {
ParameterRef ref = (ParameterRef) rightOp;
int index = (sootMethod.isStatic() ? 1 : 2) + ref.getIndex();
Value p = new VariableRef("p" + index, getType(ref.getType()));
result = widenToI32Value(stmt, p, isUnsigned(ref.getType()));
} else if (rightOp instanceof CaughtExceptionRef) {
result = call(stmt, BC_EXCEPTION_CLEAR, env);
} else if (rightOp instanceof ArrayRef) {
ArrayRef ref = (ArrayRef) rightOp;
VariableRef base = (VariableRef) immediate(stmt, (Immediate) ref.getBase());
if (ref.getType() instanceof NullType) {
// The base value is always null. Do a null check which will
// always throw NPE.
checkNull(stmt, base);
return;
} else {
Value index = immediate(stmt, (Immediate) ref.getIndex());
checkNull(stmt, base);
checkBounds(stmt, base, index);
result = call(stmt, getArrayLoad(ref.getType()), base, index);
result = widenToI32Value(stmt, result, isUnsigned(ref.getType()));
}
} else if (rightOp instanceof InstanceFieldRef) {
InstanceFieldRef ref = (InstanceFieldRef) rightOp;
Value base = immediate(stmt, (Immediate) ref.getBase());
checkNull(stmt, base);
FunctionRef fn = null;
if (canAccessDirectly(ref)) {
fn = new FunctionRef(Symbols.getterSymbol(ref.getFieldRef()), new FunctionType(getType(ref.getType()), ENV_PTR, OBJECT_PTR));
} else {
soot.Type runtimeType = ref.getBase().getType();
String targetClassName = getInternalName(ref.getFieldRef().declaringClass());
String runtimeClassName = runtimeType == NullType.v() ? targetClassName : getInternalName(runtimeType);
Trampoline trampoline = new GetField(this.className, targetClassName, ref.getFieldRef().name(), getDescriptor(ref.getFieldRef().type()), runtimeClassName);
trampolines.add(trampoline);
fn = trampoline.getFunctionRef();
}
result = call(stmt, fn, env, base);
result = widenToI32Value(stmt, result, isUnsigned(ref.getType()));
} else if (rightOp instanceof StaticFieldRef) {
StaticFieldRef ref = (StaticFieldRef) rightOp;
FunctionRef fn = config.isDebug() ? null : Intrinsics.getIntrinsic(sootMethod, stmt);
if (fn == null) {
if (canAccessDirectly(ref)) {
fn = new FunctionRef(Symbols.getterSymbol(ref.getFieldRef()), new FunctionType(getType(ref.getType()), ENV_PTR));
} else {
String targetClassName = getInternalName(ref.getFieldRef().declaringClass());
Trampoline trampoline = new GetStatic(this.className, targetClassName, ref.getFieldRef().name(), getDescriptor(ref.getFieldRef().type()));
trampolines.add(trampoline);
fn = trampoline.getFunctionRef();
}
}
result = call(stmt, fn, env);
result = widenToI32Value(stmt, result, isUnsigned(ref.getType()));
} else if (rightOp instanceof Expr) {
if (rightOp instanceof BinopExpr) {
BinopExpr expr = (BinopExpr) rightOp;
Type rightType = getLocalType(expr.getType());
Variable resultVar = function.newVariable(rightType);
result = resultVar.ref();
Value op1 = immediate(stmt, (Immediate) expr.getOp1());
Value op2 = immediate(stmt, (Immediate) expr.getOp2());
if (rightOp instanceof AddExpr) {
if (rightType instanceof IntegerType) {
function.add(new Add(resultVar, op1, op2)).attach(stmt);
} else {
function.add(new Fadd(resultVar, op1, op2)).attach(stmt);
}
} else if (rightOp instanceof AndExpr) {
function.add(new And(resultVar, op1, op2)).attach(stmt);
} else if (rightOp instanceof CmpExpr) {
Variable t1 = function.newVariable(I1);
Variable t2 = function.newVariable(I1);
Variable t3 = function.newVariable(resultVar.getType());
Variable t4 = function.newVariable(resultVar.getType());
function.add(new Icmp(t1, Condition.slt, op1, op2)).attach(stmt);
function.add(new Icmp(t2, Condition.sgt, op1, op2)).attach(stmt);
function.add(new Zext(t3, new VariableRef(t1), resultVar.getType())).attach(stmt);
function.add(new Zext(t4, new VariableRef(t2), resultVar.getType())).attach(stmt);
function.add(new Sub(resultVar, new VariableRef(t4), new VariableRef(t3))).attach(stmt);
} else if (rightOp instanceof DivExpr) {
if (rightType instanceof IntegerType) {
FunctionRef f = rightType == I64 ? LDIV : IDIV;
result = call(stmt, f, env, op1, op2);
} else {
// float or double
function.add(new Fdiv(resultVar, op1, op2)).attach(stmt);
}
} else if (rightOp instanceof MulExpr) {
if (rightType instanceof IntegerType) {
function.add(new Mul(resultVar, op1, op2)).attach(stmt);
} else {
function.add(new Fmul(resultVar, op1, op2)).attach(stmt);
}
} else if (rightOp instanceof OrExpr) {
function.add(new Or(resultVar, op1, op2)).attach(stmt);
} else if (rightOp instanceof RemExpr) {
if (rightType instanceof IntegerType) {
FunctionRef f = rightType == I64 ? LREM : IREM;
result = call(stmt, f, env, op1, op2);
} else {
FunctionRef f = rightType == DOUBLE ? DREM : FREM;
result = call(stmt, f, env, op1, op2);
}
} else if (rightOp instanceof ShlExpr || rightOp instanceof ShrExpr || rightOp instanceof UshrExpr) {
IntegerType type = (IntegerType) op1.getType();
int bits = type.getBits();
Variable t = function.newVariable(op2.getType());
function.add(new And(t, op2, new IntegerConstant(bits - 1, (IntegerType) op2.getType()))).attach(stmt);
Value shift = t.ref();
if (((IntegerType) shift.getType()).getBits() < bits) {
Variable tmp = function.newVariable(type);
function.add(new Zext(tmp, shift, type)).attach(stmt);
shift = tmp.ref();
}
if (rightOp instanceof ShlExpr) {
function.add(new Shl(resultVar, op1, shift)).attach(stmt);
} else if (rightOp instanceof ShrExpr) {
function.add(new Ashr(resultVar, op1, shift)).attach(stmt);
} else {
function.add(new Lshr(resultVar, op1, shift)).attach(stmt);
}
} else if (rightOp instanceof SubExpr) {
if (rightType instanceof IntegerType) {
function.add(new Sub(resultVar, op1, op2)).attach(stmt);
} else {
function.add(new Fsub(resultVar, op1, op2)).attach(stmt);
}
} else if (rightOp instanceof XorExpr) {
function.add(new Xor(resultVar, op1, op2)).attach(stmt);
} else if (rightOp instanceof XorExpr) {
function.add(new Xor(resultVar, op1, op2)).attach(stmt);
} else if (rightOp instanceof CmplExpr) {
FunctionRef f = op1.getType() == FLOAT ? FCMPL : DCMPL;
function.add(new Call(resultVar, f, op1, op2)).attach(stmt);
} else if (rightOp instanceof CmpgExpr) {
FunctionRef f = op1.getType() == FLOAT ? FCMPG : DCMPG;
function.add(new Call(resultVar, f, op1, op2)).attach(stmt);
} else {
throw new IllegalArgumentException("Unknown type for rightOp: " + rightOp.getClass());
}
} else if (rightOp instanceof CastExpr) {
Value op = immediate(stmt, (Immediate) ((CastExpr) rightOp).getOp());
soot.Type sootTargetType = ((CastExpr) rightOp).getCastType();
soot.Type sootSourceType = ((CastExpr) rightOp).getOp().getType();
if (sootTargetType instanceof PrimType) {
Type targetType = getType(sootTargetType);
Type sourceType = getType(sootSourceType);
if (targetType instanceof IntegerType && sourceType instanceof IntegerType) {
// op is at least I32 and has already been widened if source type had fewer bits then I32
IntegerType toType = (IntegerType) targetType;
IntegerType fromType = (IntegerType) op.getType();
Variable v = function.newVariable(toType);
if (fromType.getBits() < toType.getBits()) {
// Widening
if (isUnsigned(sootSourceType)) {
function.add(new Zext(v, op, toType)).attach(stmt);
} else {
function.add(new Sext(v, op, toType)).attach(stmt);
}
} else if (fromType.getBits() == toType.getBits()) {
function.add(new Bitcast(v, op, toType)).attach(stmt);
} else {
// Narrow
function.add(new Trunc(v, op, toType)).attach(stmt);
}
result = widenToI32Value(stmt, v.ref(), isUnsigned(sootTargetType));
} else if (targetType instanceof FloatingPointType && sourceType instanceof IntegerType) {
// we always to a signed conversion since if op is char it has already been zero extended to I32
Variable v = function.newVariable(targetType);
function.add(new Sitofp(v, op, targetType)).attach(stmt);
result = v.ref();
} else if (targetType instanceof FloatingPointType && sourceType instanceof FloatingPointType) {
Variable v = function.newVariable(targetType);
if (targetType == FLOAT && sourceType == DOUBLE) {
function.add(new Fptrunc(v, op, targetType)).attach(stmt);
} else if (targetType == DOUBLE && sourceType == FLOAT) {
function.add(new Fpext(v, op, targetType)).attach(stmt);
} else {
function.add(new Bitcast(v, op, targetType)).attach(stmt);
}
result = v.ref();
} else {
// F2I, F2L, D2I, D2L
FunctionRef f = null;
if (targetType == I32 && sourceType == FLOAT) {
f = F2I;
} else if (targetType == I64 && sourceType == FLOAT) {
f = F2L;
} else if (targetType == I32 && sourceType == DOUBLE) {
f = D2I;
} else if (targetType == I64 && sourceType == DOUBLE) {
f = D2L;
} else {
throw new IllegalArgumentException();
}
Variable v = function.newVariable(targetType);
function.add(new Call(v, f, op)).attach(stmt);
result = v.ref();
}
} else {
if (sootTargetType instanceof soot.ArrayType && ((soot.ArrayType) sootTargetType).getElementType() instanceof PrimType) {
soot.Type primType = ((soot.ArrayType) sootTargetType).getElementType();
GlobalRef arrayClassPtr = new GlobalRef("array_" + getDescriptor(primType), CLASS_PTR);
Variable arrayClass = function.newVariable(CLASS_PTR);
function.add(new Load(arrayClass, arrayClassPtr)).attach(stmt);
result = call(stmt, CHECKCAST_PRIM_ARRAY, env, arrayClass.ref(), op);
} else {
String targetClassName = getInternalName(sootTargetType);
Trampoline trampoline = new Checkcast(this.className, targetClassName);
trampolines.add(trampoline);
result = call(stmt, trampoline.getFunctionRef(), env, op);
}
}
} else if (rightOp instanceof InstanceOfExpr) {
Value op = immediate(stmt, (Immediate) ((InstanceOfExpr) rightOp).getOp());
soot.Type checkType = ((InstanceOfExpr) rightOp).getCheckType();
if (checkType instanceof soot.ArrayType && ((soot.ArrayType) checkType).getElementType() instanceof PrimType) {
soot.Type primType = ((soot.ArrayType) checkType).getElementType();
GlobalRef arrayClassPtr = new GlobalRef("array_" + getDescriptor(primType), CLASS_PTR);
Variable arrayClass = function.newVariable(CLASS_PTR);
function.add(new Load(arrayClass, arrayClassPtr)).attach(stmt);
result = call(stmt, INSTANCEOF_PRIM_ARRAY, env, arrayClass.ref(), op);
} else {
String targetClassName = getInternalName(checkType);
Trampoline trampoline = new Instanceof(this.className, targetClassName);
trampolines.add(trampoline);
result = call(stmt, trampoline.getFunctionRef(), env, op);
}
} else if (rightOp instanceof NewExpr) {
String targetClassName = getInternalName(((NewExpr) rightOp).getBaseType());
FunctionRef fn = null;
if (targetClassName.equals(this.className)) {
fn = FunctionBuilder.allocator(sootMethod.getDeclaringClass()).ref();
} else {
Trampoline trampoline = new New(this.className, targetClassName);
trampolines.add(trampoline);
fn = trampoline.getFunctionRef();
}
result = call(stmt, fn, env);
} else if (rightOp instanceof NewArrayExpr) {
NewArrayExpr expr = (NewArrayExpr) rightOp;
Value size = immediate(stmt, (Immediate) expr.getSize());
if (expr.getBaseType() instanceof PrimType) {
result = call(stmt, getNewArray(expr.getBaseType()), env, size);
} else {
String targetClassName = getInternalName(expr.getType());
Trampoline trampoline = new Anewarray(this.className, targetClassName);
trampolines.add(trampoline);
result = call(stmt, trampoline.getFunctionRef(), env, size);
}
} else if (rightOp instanceof NewMultiArrayExpr) {
NewMultiArrayExpr expr = (NewMultiArrayExpr) rightOp;
if (expr.getBaseType().numDimensions == 1 && expr.getBaseType().getElementType() instanceof PrimType) {
Value size = immediate(stmt, (Immediate) expr.getSize(0));
result = call(stmt, getNewArray(expr.getBaseType().getElementType()), env, size);
} else {
for (int i = 0; i < expr.getSizeCount(); i++) {
Value size = immediate(stmt, (Immediate) expr.getSize(i));
Variable ptr = function.newVariable(new PointerType(I32));
function.add(new Getelementptr(ptr, dims.ref(), 0, i)).attach(stmt);
function.add(new Store(size, ptr.ref())).attach(stmt);
}
Variable dimsI32 = function.newVariable(new PointerType(I32));
function.add(new Bitcast(dimsI32, dims.ref(), dimsI32.getType())).attach(stmt);
String targetClassName = getInternalName(expr.getType());
Trampoline trampoline = new Multianewarray(this.className, targetClassName);
trampolines.add(trampoline);
result = call(stmt, trampoline.getFunctionRef(), env, new IntegerConstant(expr.getSizeCount()), dimsI32.ref());
}
} else if (rightOp instanceof InvokeExpr) {
result = invokeExpr(stmt, (InvokeExpr) rightOp);
} else if (rightOp instanceof LengthExpr) {
Value op = immediate(stmt, (Immediate) ((LengthExpr) rightOp).getOp());
checkNull(stmt, op);
Variable v = function.newVariable(I32);
function.add(new Call(v, ARRAY_LENGTH, op)).attach(stmt);
result = v.ref();
} else if (rightOp instanceof NegExpr) {
NegExpr expr = (NegExpr) rightOp;
Value op = immediate(stmt, (Immediate) expr.getOp());
Type rightType = op.getType();
Variable v = function.newVariable(op.getType());
if (rightType instanceof IntegerType) {
function.add(new Sub(v, new IntegerConstant(0, (IntegerType) rightType), op)).attach(stmt);
} else {
function.add(new Fmul(v, new FloatingPointConstant(-1.0, (FloatingPointType) rightType), op)).attach(stmt);
}
result = v.ref();
} else {
throw new IllegalArgumentException("Unknown type for rightOp: " + rightOp.getClass());
}
} else {
throw new IllegalArgumentException("Unknown type for rightOp: " + rightOp.getClass());
}
soot.Value leftOp = stmt.getLeftOp();
if (leftOp instanceof Local) {
Local local = (Local) leftOp;
VariableRef v = new VariableRef(local.getName(), new PointerType(getLocalType(leftOp.getType())));
function.add(new Store(result, v, !sootMethod.getActiveBody().getTraps().isEmpty())).attach(stmt);
} else {
Type leftType = getType(leftOp.getType());
Value narrowedResult = narrowFromI32Value(stmt, leftType, result);
if (leftOp instanceof ArrayRef) {
ArrayRef ref = (ArrayRef) leftOp;
VariableRef base = (VariableRef) immediate(stmt, (Immediate) ref.getBase());
Value index = immediate(stmt, (Immediate) ref.getIndex());
checkNull(stmt, base);
checkBounds(stmt, base, index);
if (leftOp.getType() instanceof RefLikeType) {
call(stmt, BC_SET_OBJECT_ARRAY_ELEMENT, env, base, index, narrowedResult);
} else {
call(stmt, getArrayStore(leftOp.getType()), base, index, narrowedResult);
}
} else if (leftOp instanceof InstanceFieldRef) {
InstanceFieldRef ref = (InstanceFieldRef) leftOp;
Value base = immediate(stmt, (Immediate) ref.getBase());
checkNull(stmt, base);
FunctionRef fn = null;
if (canAccessDirectly(ref)) {
fn = new FunctionRef(Symbols.setterSymbol(ref.getFieldRef()), new FunctionType(VOID, ENV_PTR, OBJECT_PTR, getType(ref.getType())));
} else {
soot.Type runtimeType = ref.getBase().getType();
String targetClassName = getInternalName(ref.getFieldRef().declaringClass());
String runtimeClassName = runtimeType == NullType.v() ? targetClassName : getInternalName(runtimeType);
Trampoline trampoline = new PutField(this.className, targetClassName, ref.getFieldRef().name(), getDescriptor(ref.getFieldRef().type()), runtimeClassName);
trampolines.add(trampoline);
fn = trampoline.getFunctionRef();
}
call(stmt, fn, env, base, narrowedResult);
} else if (leftOp instanceof StaticFieldRef) {
StaticFieldRef ref = (StaticFieldRef) leftOp;
FunctionRef fn = null;
if (canAccessDirectly(ref)) {
fn = new FunctionRef(Symbols.setterSymbol(ref.getFieldRef()), new FunctionType(VOID, ENV_PTR, getType(ref.getType())));
} else {
String targetClassName = getInternalName(ref.getFieldRef().declaringClass());
Trampoline trampoline = new PutStatic(this.className, targetClassName, ref.getFieldRef().name(), getDescriptor(ref.getFieldRef().type()));
trampolines.add(trampoline);
fn = trampoline.getFunctionRef();
}
call(stmt, fn, env, narrowedResult);
} else {
throw new IllegalArgumentException("Unknown type for leftOp: " + leftOp.getClass());
}
}
}
Also used :
Add(org.robovm.compiler.llvm.Add)
AndExpr(soot.jimple.AndExpr)
New(org.robovm.compiler.trampoline.New)
Or(org.robovm.compiler.llvm.Or)
Store(org.robovm.compiler.llvm.Store)
FloatingPointType(org.robovm.compiler.llvm.FloatingPointType)
ArrayType(org.robovm.compiler.llvm.ArrayType)
RefLikeType(soot.RefLikeType)
GetStatic(org.robovm.compiler.trampoline.GetStatic)
InterfaceInvokeExpr(soot.jimple.InterfaceInvokeExpr)
SpecialInvokeExpr(soot.jimple.SpecialInvokeExpr)
InstanceInvokeExpr(soot.jimple.InstanceInvokeExpr)
VirtualInvokeExpr(soot.jimple.VirtualInvokeExpr)
InvokeExpr(soot.jimple.InvokeExpr)
StaticInvokeExpr(soot.jimple.StaticInvokeExpr)
Shl(org.robovm.compiler.llvm.Shl)
CastExpr(soot.jimple.CastExpr)
PrimType(soot.PrimType)
Fsub(org.robovm.compiler.llvm.Fsub)
ShlExpr(soot.jimple.ShlExpr)
Checkcast(org.robovm.compiler.trampoline.Checkcast)
FunctionRef(org.robovm.compiler.llvm.FunctionRef)
Fmul(org.robovm.compiler.llvm.Fmul)
Sub(org.robovm.compiler.llvm.Sub)
GetField(org.robovm.compiler.trampoline.GetField)
Load(org.robovm.compiler.llvm.Load)
FloatingPointConstant(org.robovm.compiler.llvm.FloatingPointConstant)
Mul(org.robovm.compiler.llvm.Mul)
XorExpr(soot.jimple.XorExpr)
Fptrunc(org.robovm.compiler.llvm.Fptrunc)
Local(soot.Local)
AddExpr(soot.jimple.AddExpr)
Fdiv(org.robovm.compiler.llvm.Fdiv)
Zext(org.robovm.compiler.llvm.Zext)
InstanceOfExpr(soot.jimple.InstanceOfExpr)
OrExpr(soot.jimple.OrExpr)
IntegerConstant(org.robovm.compiler.llvm.IntegerConstant)
StaticFieldRef(soot.jimple.StaticFieldRef)
NegExpr(soot.jimple.NegExpr)
UshrExpr(soot.jimple.UshrExpr)
InterfaceInvokeExpr(soot.jimple.InterfaceInvokeExpr)
GeExpr(soot.jimple.GeExpr)
DivExpr(soot.jimple.DivExpr)
ConditionExpr(soot.jimple.ConditionExpr)
SubExpr(soot.jimple.SubExpr)
NewMultiArrayExpr(soot.jimple.NewMultiArrayExpr)
OrExpr(soot.jimple.OrExpr)
Expr(soot.jimple.Expr)
SpecialInvokeExpr(soot.jimple.SpecialInvokeExpr)
LengthExpr(soot.jimple.LengthExpr)
ShlExpr(soot.jimple.ShlExpr)
NeExpr(soot.jimple.NeExpr)
InstanceInvokeExpr(soot.jimple.InstanceInvokeExpr)
CmpExpr(soot.jimple.CmpExpr)
MulExpr(soot.jimple.MulExpr)
BinopExpr(soot.jimple.BinopExpr)
LtExpr(soot.jimple.LtExpr)
ShrExpr(soot.jimple.ShrExpr)
CmpgExpr(soot.jimple.CmpgExpr)
EqExpr(soot.jimple.EqExpr)
NewArrayExpr(soot.jimple.NewArrayExpr)
VirtualInvokeExpr(soot.jimple.VirtualInvokeExpr)
AndExpr(soot.jimple.AndExpr)
LeExpr(soot.jimple.LeExpr)
CastExpr(soot.jimple.CastExpr)
InvokeExpr(soot.jimple.InvokeExpr)
NewExpr(soot.jimple.NewExpr)
CmplExpr(soot.jimple.CmplExpr)
InstanceOfExpr(soot.jimple.InstanceOfExpr)
StaticInvokeExpr(soot.jimple.StaticInvokeExpr)
RemExpr(soot.jimple.RemExpr)
XorExpr(soot.jimple.XorExpr)
AddExpr(soot.jimple.AddExpr)
GtExpr(soot.jimple.GtExpr)
Bitcast(org.robovm.compiler.llvm.Bitcast)
ConstantBitcast(org.robovm.compiler.llvm.ConstantBitcast)
NewArrayExpr(soot.jimple.NewArrayExpr)
And(org.robovm.compiler.llvm.And)
CmpExpr(soot.jimple.CmpExpr)
RemExpr(soot.jimple.RemExpr)
ShrExpr(soot.jimple.ShrExpr)
Value(org.robovm.compiler.llvm.Value)
NewExpr(soot.jimple.NewExpr)
Fadd(org.robovm.compiler.llvm.Fadd)
Xor(org.robovm.compiler.llvm.Xor)
NullType(soot.NullType)
CmplExpr(soot.jimple.CmplExpr)
BinopExpr(soot.jimple.BinopExpr)
MulExpr(soot.jimple.MulExpr)
GlobalRef(org.robovm.compiler.llvm.GlobalRef)
VariableRef(org.robovm.compiler.llvm.VariableRef)
Variable(org.robovm.compiler.llvm.Variable)
Ashr(org.robovm.compiler.llvm.Ashr)
CaughtExceptionRef(soot.jimple.CaughtExceptionRef)
NewMultiArrayExpr(soot.jimple.NewMultiArrayExpr)
Sext(org.robovm.compiler.llvm.Sext)
NegExpr(soot.jimple.NegExpr)
PointerType(org.robovm.compiler.llvm.PointerType)
Getelementptr(org.robovm.compiler.llvm.Getelementptr)
Multianewarray(org.robovm.compiler.trampoline.Multianewarray)
UshrExpr(soot.jimple.UshrExpr)
ArrayRef(soot.jimple.ArrayRef)
Lshr(org.robovm.compiler.llvm.Lshr)
InstanceFieldRef(soot.jimple.InstanceFieldRef)
Trunc(org.robovm.compiler.llvm.Trunc)
ConstantTrunc(org.robovm.compiler.llvm.ConstantTrunc)
Instanceof(org.robovm.compiler.trampoline.Instanceof)
Sitofp(org.robovm.compiler.llvm.Sitofp)
PutField(org.robovm.compiler.trampoline.PutField)
Call(org.robovm.compiler.llvm.Call)
Trampoline(org.robovm.compiler.trampoline.Trampoline)
LengthExpr(soot.jimple.LengthExpr)
Immediate(soot.Immediate)
FunctionType(org.robovm.compiler.llvm.FunctionType)
SubExpr(soot.jimple.SubExpr)
Anewarray(org.robovm.compiler.trampoline.Anewarray)
PutStatic(org.robovm.compiler.trampoline.PutStatic)
IntegerType(org.robovm.compiler.llvm.IntegerType)
FloatingPointType(org.robovm.compiler.llvm.FloatingPointType)
IntegerType(org.robovm.compiler.llvm.IntegerType)
PointerType(org.robovm.compiler.llvm.PointerType)
NullType(soot.NullType)
FunctionType(org.robovm.compiler.llvm.FunctionType)
ArrayType(org.robovm.compiler.llvm.ArrayType)
CharType(soot.CharType)
RefLikeType(soot.RefLikeType)
Type(org.robovm.compiler.llvm.Type)
PrimType(soot.PrimType)
DivExpr(soot.jimple.DivExpr)
ParameterRef(soot.jimple.ParameterRef)
ThisRef(soot.jimple.ThisRef)
CmpgExpr(soot.jimple.CmpgExpr)
Fpext(org.robovm.compiler.llvm.Fpext)
Icmp(org.robovm.compiler.llvm.Icmp)
Example 2 with New
use of org.robovm.compiler.trampoline.New in project robovm by robovm.
the class TrampolineCompiler method compile.
public void compile(ModuleBuilder mb, Clazz currentClass, Trampoline t, Set<String> dependencies, Set<Triple<String, String, String>> methodDependencies) {
this.mb = mb;
addDependencyIfNeeded(dependencies, currentClass, t);
/*
* Check if the target class exists and is accessible. Also check that
* field accesses and method calls are compatible with the target
* field/method and that the field/method is accessible to the caller.
* If any of the tests fail the weak trampoline function created by the
* ClassCompiler will be overridden with a function which throws an
* appropriate exception.
*/
Function errorFn = new FunctionBuilder(t).linkage(external).build();
if (!checkClassExists(errorFn, t) || !checkClassAccessible(errorFn, t)) {
mb.addFunction(errorFn);
return;
}
if (t instanceof New) {
SootClass target = config.getClazzes().load(t.getTarget()).getSootClass();
if (target.isAbstract() || target.isInterface()) {
call(errorFn, BC_THROW_INSTANTIATION_ERROR, errorFn.getParameterRef(0), mb.getString(t.getTarget().replace('/', '.')));
errorFn.add(new Unreachable());
mb.addFunction(errorFn);
return;
}
String fnName = Symbols.clinitWrapperSymbol(Symbols.allocatorSymbol(t.getTarget()));
alias(t, fnName);
} else if (t instanceof Instanceof) {
if (isArray(t.getTarget())) {
FunctionRef fnRef = createInstanceofArray((Instanceof) t);
alias(t, fnRef.getName());
} else {
String fnName = Symbols.instanceofSymbol(t.getTarget());
alias(t, fnName);
}
} else if (t instanceof Checkcast) {
if (isArray(t.getTarget())) {
FunctionRef fnRef = createCheckcastArray((Checkcast) t);
alias(t, fnRef.getName());
} else {
String fnName = Symbols.checkcastSymbol(t.getTarget());
alias(t, fnName);
}
} else if (t instanceof LdcClass) {
if (isArray(t.getTarget())) {
FunctionRef fnRef = createLdcArray((LdcClass) t);
alias(t, fnRef.getName());
} else {
String fnName = Symbols.ldcExternalSymbol(t.getTarget());
alias(t, fnName);
}
} else if (t instanceof Anewarray) {
FunctionRef fnRef = createAnewarray((Anewarray) t);
alias(t, fnRef.getName());
} else if (t instanceof Multianewarray) {
FunctionRef fnRef = createMultianewarray((Multianewarray) t);
alias(t, fnRef.getName());
} else if (t instanceof FieldAccessor) {
SootField field = resolveField(errorFn, (FieldAccessor) t);
if (field != null) {
dependencies.add(getInternalName(field.getDeclaringClass()));
}
if (field == null || !checkMemberAccessible(errorFn, t, field)) {
mb.addFunction(errorFn);
return;
}
Clazz caller = config.getClazzes().load(t.getCallingClass());
Clazz target = config.getClazzes().load(t.getTarget());
if (!((FieldAccessor) t).isGetter() && field.isFinal() && caller != target) {
// Only the class declaring a final field may write to it.
// (Actually only <init>/<clinit> methods may write to it but we
// don't know which method is accessing the field at this point)
throwIllegalAccessError(errorFn, ATTEMPT_TO_WRITE_TO_FINAL_FIELD, target, field.getName(), caller);
mb.addFunction(errorFn);
return;
}
if (!field.isStatic()) {
createInlinedAccessorForInstanceField((FieldAccessor) t, field);
} else {
createTrampolineAliasForField((FieldAccessor) t, field);
}
} else if (t instanceof Invokeinterface) {
SootMethod rm = resolveInterfaceMethod(errorFn, (Invokeinterface) t);
if (rm != null) {
methodDependencies.add(new ImmutableTriple<String, String, String>(getInternalName(rm.getDeclaringClass()), rm.getName(), getDescriptor(rm)));
}
if (rm == null || !checkMemberAccessible(errorFn, t, rm)) {
mb.addFunction(errorFn);
return;
}
createTrampolineAliasForMethod((Invoke) t, rm);
} else if (t instanceof Invoke) {
SootMethod method = resolveMethod(errorFn, (Invoke) t);
if (method != null) {
methodDependencies.add(new ImmutableTriple<String, String, String>(getInternalName(method.getDeclaringClass()), method.getName(), getDescriptor(method)));
}
if (method == null || !checkMemberAccessible(errorFn, t, method)) {
mb.addFunction(errorFn);
return;
}
if (t instanceof Invokespecial && method.isAbstract()) {
call(errorFn, BC_THROW_ABSTRACT_METHOD_ERROR, errorFn.getParameterRef(0), mb.getString(String.format(NO_SUCH_METHOD_ERROR, method.getDeclaringClass(), method.getName(), getDescriptor(method))));
errorFn.add(new Unreachable());
mb.addFunction(errorFn);
return;
}
createTrampolineAliasForMethod((Invoke) t, method);
}
}
Also used :
New(org.robovm.compiler.trampoline.New)
ImmutableTriple(org.apache.commons.lang3.tuple.ImmutableTriple)
Anewarray(org.robovm.compiler.trampoline.Anewarray)
Multianewarray(org.robovm.compiler.trampoline.Multianewarray)
SootClass(soot.SootClass)
FieldAccessor(org.robovm.compiler.trampoline.FieldAccessor)
Invokeinterface(org.robovm.compiler.trampoline.Invokeinterface)
Invoke(org.robovm.compiler.trampoline.Invoke)
Invokespecial(org.robovm.compiler.trampoline.Invokespecial)
Function(org.robovm.compiler.llvm.Function)
Unreachable(org.robovm.compiler.llvm.Unreachable)
LdcClass(org.robovm.compiler.trampoline.LdcClass)
Instanceof(org.robovm.compiler.trampoline.Instanceof)
SootMethod(soot.SootMethod)
SootField(soot.SootField)
Clazz(org.robovm.compiler.clazz.Clazz)
Checkcast(org.robovm.compiler.trampoline.Checkcast)
FunctionRef(org.robovm.compiler.llvm.FunctionRef)
Aggregations
FunctionRef (org.robovm.compiler.llvm.FunctionRef)2
ImmutableTriple (org.apache.commons.lang3.tuple.ImmutableTriple)1
Clazz (org.robovm.compiler.clazz.Clazz)1
Add (org.robovm.compiler.llvm.Add)1
And (org.robovm.compiler.llvm.And)1
ArrayType (org.robovm.compiler.llvm.ArrayType)1
Ashr (org.robovm.compiler.llvm.Ashr)1
Bitcast (org.robovm.compiler.llvm.Bitcast)1
Call (org.robovm.compiler.llvm.Call)1
ConstantBitcast (org.robovm.compiler.llvm.ConstantBitcast)1
ConstantTrunc (org.robovm.compiler.llvm.ConstantTrunc)1
Fadd (org.robovm.compiler.llvm.Fadd)1
Fdiv (org.robovm.compiler.llvm.Fdiv)1
FloatingPointConstant (org.robovm.compiler.llvm.FloatingPointConstant)1
FloatingPointType (org.robovm.compiler.llvm.FloatingPointType)1
Fmul (org.robovm.compiler.llvm.Fmul)1
Fpext (org.robovm.compiler.llvm.Fpext)1
Fptrunc (org.robovm.compiler.llvm.Fptrunc)1
Fsub (org.robovm.compiler.llvm.Fsub)1
Function (org.robovm.compiler.llvm.Function)1
