diff --git a/src/main/java/soot/dexpler/DexBody.java b/src/main/java/soot/dexpler/DexBody.java index 03407f40700..52d06a66f43 100755 --- a/src/main/java/soot/dexpler/DexBody.java +++ b/src/main/java/soot/dexpler/DexBody.java @@ -64,6 +64,7 @@ import soot.Body; import soot.DoubleType; +import soot.FloatType; import soot.Local; import soot.LongType; import soot.Modifier; @@ -78,6 +79,7 @@ import soot.Trap; import soot.Type; import soot.Unit; +import soot.UnitPatchingChain; import soot.UnknownType; import soot.Value; import soot.ValueBox; @@ -88,18 +90,25 @@ import soot.dexpler.instructions.OdexInstruction; import soot.dexpler.instructions.PseudoInstruction; import soot.dexpler.instructions.RetypeableInstruction; +import soot.dexpler.tags.DexplerTag; +import soot.dexpler.tags.DoubleOpTag; +import soot.dexpler.tags.FloatOpTag; import soot.dexpler.typing.DalvikTyper; import soot.jimple.AssignStmt; +import soot.jimple.BinopExpr; import soot.jimple.CastExpr; import soot.jimple.CaughtExceptionRef; import soot.jimple.ConditionExpr; import soot.jimple.Constant; import soot.jimple.DefinitionStmt; +import soot.jimple.DoubleConstant; import soot.jimple.EqExpr; +import soot.jimple.FloatConstant; import soot.jimple.IfStmt; import soot.jimple.IntConstant; import soot.jimple.Jimple; import soot.jimple.JimpleBody; +import soot.jimple.LongConstant; import soot.jimple.NeExpr; import soot.jimple.NullConstant; import soot.jimple.NumericConstant; @@ -121,9 +130,11 @@ import soot.options.Options; import soot.tagkit.LineNumberTag; import soot.tagkit.SourceLineNumberTag; +import soot.tagkit.Tag; import soot.toolkits.exceptions.TrapTightener; import soot.toolkits.scalar.LocalPacker; import soot.toolkits.scalar.LocalSplitter; +import soot.toolkits.scalar.SharedInitializationLocalSplitter; import soot.toolkits.scalar.UnusedLocalEliminator; /** @@ -477,7 +488,6 @@ public DexlibAbstractInstruction instructionAtAddress(int address) { * the SootMethod that contains this body */ public Body jimplify(Body b, SootMethod m) { - final Jimple jimple = Jimple.v(); final UnknownType unknownType = UnknownType.v(); final NullConstant nullConstant = NullConstant.v(); @@ -686,6 +696,8 @@ public Body jimplify(Body b, SootMethod m) { // Make sure that we don't have any overlapping uses due to returns DexReturnInliner.v().transform(jBody); + new SharedInitializationLocalSplitter(DalvikThrowAnalysis.v()).transform(jBody); + // split first to find undefined uses getLocalSplitter().transform(jBody); @@ -772,6 +784,8 @@ public Body jimplify(Body b, SootMethod m) { } DexFillArrayDataTransformer.v().transform(jBody); + convertFloatsAndDoubles(b, jimple); + TypeAssigner.v().transform(jBody); // Shortcut: Reduce array initializations @@ -932,6 +946,7 @@ public Body jimplify(Body b, SootMethod m) { DexReturnPacker.v().transform(jBody); for (Unit u : jBody.getUnits()) { + if (u instanceof AssignStmt) { AssignStmt ass = (AssignStmt) u; if (ass.getRightOp() instanceof CastExpr) { @@ -946,7 +961,8 @@ public Body jimplify(Body b, SootMethod m) { // If the body references a phantom class in a // CaughtExceptionRef, // we must manually fix the hierarchy - if (def.getLeftOp() instanceof Local && def.getRightOp() instanceof CaughtExceptionRef) { + Value rop = def.getRightOp(); + if (def.getLeftOp() instanceof Local && rop instanceof CaughtExceptionRef) { Type t = def.getLeftOp().getType(); if (t instanceof RefType) { RefType rt = (RefType) t; @@ -957,6 +973,7 @@ public Body jimplify(Body b, SootMethod m) { } } } + removeDexplerTags(u); } // Replace local type null_type by java.lang.Object. @@ -986,8 +1003,80 @@ public Body jimplify(Body b, SootMethod m) { return jBody; } + public void convertFloatsAndDoubles(Body b, final Jimple jimple) { + UnitPatchingChain units = jBody.getUnits(); + Unit u = units.getFirst(); + Local[] convFloat = new Local[2], convDouble = new Local[2]; + + while (u != null) { + if (u instanceof AssignStmt) { + AssignStmt def = (AssignStmt) u; + Value rop = def.getRightOp(); + if (rop instanceof BinopExpr) { + boolean isDouble = u.hasTag(DoubleOpTag.NAME); + boolean isFloat = u.hasTag(FloatOpTag.NAME); + BinopExpr bop = (BinopExpr) rop; + int idxConvVar = 0; + for (ValueBox cmp : bop.getUseBoxes()) { + Value c = cmp.getValue(); + if (c instanceof Constant) { + if (isDouble) { + if (c instanceof LongConstant) { + long vVal = ((LongConstant) c).value; + cmp.setValue(DoubleConstant.v(Double.longBitsToDouble(vVal))); + } + } else if (isFloat && c instanceof IntConstant) { + int vVal = ((IntConstant) c).value; + cmp.setValue(FloatConstant.v(Float.intBitsToFloat(vVal))); + } + } else { + if (isDouble) { + if (!(c.getType() instanceof DoubleType)) { + if (convDouble[idxConvVar] == null) { + convDouble[idxConvVar] = jimple.newLocal("lclConvToDouble" + idxConvVar, DoubleType.v()); + b.getLocals().add(convDouble[idxConvVar]); + } + units.insertBefore( + jimple.newAssignStmt(convDouble[idxConvVar], jimple.newCastExpr(cmp.getValue(), DoubleType.v())), u); + cmp.setValue(convDouble[idxConvVar]); + idxConvVar++; + } + } else if (isFloat) { + if (!(c.getType() instanceof FloatType)) { + if (convFloat[idxConvVar] == null) { + convFloat[idxConvVar] = jimple.newLocal("lclConvToFloat" + idxConvVar, FloatType.v()); + b.getLocals().add(convFloat[idxConvVar]); + } + units.insertBefore( + jimple.newAssignStmt(convFloat[idxConvVar], jimple.newCastExpr(cmp.getValue(), FloatType.v())), u); + cmp.setValue(convFloat[idxConvVar]); + idxConvVar++; + } + } + } + } + } + + } + u = units.getSuccOf(u); + } + } + + /** + * Removes all dexpler specific tags. Saves some memory. + * @param unit the statement + */ + private void removeDexplerTags(Unit unit) { + for (Tag t : unit.getTags()) { + if (t instanceof DexplerTag) { + unit.removeTag(t.getName()); + } + + } + } + /** - * Checks wheter the Jimple code contains unrealizable casts between reference types and primitives + * Checks whether the Jimple code contains unrealizable casts between reference types and primitives */ private void checkUnrealizableCasts() { for (Unit u : jBody.getUnits()) { @@ -998,6 +1087,7 @@ private void checkUnrealizableCasts() { CastExpr cast = (CastExpr) rop; if ((cast.getCastType() instanceof PrimType && cast.getOp().getType() instanceof RefType) || (cast.getCastType() instanceof RefType && cast.getOp().getType() instanceof PrimType)) { + throw new RuntimeException("Unrealizable cast " + u + " detected in method " + jBody.getMethod().getSignature()); } } diff --git a/src/main/java/soot/dexpler/DexNullThrowTransformer.java b/src/main/java/soot/dexpler/DexNullThrowTransformer.java index 8b69a301587..c2180c0a19b 100644 --- a/src/main/java/soot/dexpler/DexNullThrowTransformer.java +++ b/src/main/java/soot/dexpler/DexNullThrowTransformer.java @@ -28,6 +28,7 @@ import soot.Body; import soot.BodyTransformer; +import soot.BooleanConstant; import soot.Local; import soot.RefType; import soot.Scene; @@ -64,14 +65,18 @@ public static DexNullThrowTransformer v() { protected void internalTransform(Body b, String phaseName, Map options) { LocalCreation lc = Scene.v().createLocalCreation(b.getLocals(), "ex"); + final NullConstant nc = NullConstant.v(); + final IntConstant ic = IntConstant.v(0); + final BooleanConstant bc = BooleanConstant.v(false); + final LongConstant llc = LongConstant.v(0); for (Iterator unitIt = b.getUnits().snapshotIterator(); unitIt.hasNext();) { Unit u = unitIt.next(); // Check for a null exception if (u instanceof ThrowStmt) { ThrowStmt throwStmt = (ThrowStmt) u; - if (throwStmt.getOp() == NullConstant.v() || throwStmt.getOp().equals(IntConstant.v(0)) - || throwStmt.getOp().equals(LongConstant.v(0))) { + if (throwStmt.getOp() == nc || throwStmt.getOp().equals(ic) || throwStmt.getOp().equals(llc) + || throwStmt.getOp().equals(bc)) { createThrowStmt(b, throwStmt, lc); } } diff --git a/src/main/java/soot/dexpler/DexNullTransformer.java b/src/main/java/soot/dexpler/DexNullTransformer.java index c62cf6d19fb..cdc5ac8cf41 100644 --- a/src/main/java/soot/dexpler/DexNullTransformer.java +++ b/src/main/java/soot/dexpler/DexNullTransformer.java @@ -103,7 +103,6 @@ public void caseAssignStmt(AssignStmt stmt) { if (r instanceof FieldRef) { usedAsObject = isObject(((FieldRef) r).getFieldRef().type()); doBreak = true; - return; } else if (r instanceof ArrayRef) { ArrayRef ar = (ArrayRef) r; if (ar.getType() instanceof UnknownType) { @@ -117,24 +116,19 @@ public void caseAssignStmt(AssignStmt stmt) { usedAsObject = isObject(ar.getType()); } doBreak = true; - return; } else if (r instanceof StringConstant || r instanceof NewExpr || r instanceof NewArrayExpr || r instanceof ClassConstant) { usedAsObject = true; doBreak = true; - return; } else if (r instanceof CastExpr) { usedAsObject = isObject(((CastExpr) r).getCastType()); doBreak = true; - return; } else if (r instanceof InvokeExpr) { usedAsObject = isObject(((InvokeExpr) r).getType()); doBreak = true; - return; } else if (r instanceof LengthExpr) { usedAsObject = false; doBreak = true; - return; // introduces alias } @@ -221,15 +215,14 @@ public void caseAssignStmt(AssignStmt stmt) { } else if (l instanceof ArrayRef) { Type aType = ((ArrayRef) l).getType(); if (aType instanceof UnknownType) { - usedAsObject = stmt.hasTag(ObjectOpTag.NAME); // isObject( - // findArrayType(g, - // localDefs, - // localUses, - // stmt)); + if (stmt.hasTag(ObjectOpTag.NAME)) { + usedAsObject = true; + doBreak = true; + } } else { usedAsObject = isObject(aType); + doBreak = true; } - doBreak = true; return; } } @@ -239,7 +232,6 @@ public void caseAssignStmt(AssignStmt stmt) { usedAsObject = true; // isObject(((FieldRef) // r).getFieldRef().type()); doBreak = true; - return; } else if (r instanceof ArrayRef) { ArrayRef ar = (ArrayRef) r; if (ar.getBase() == l) { @@ -248,29 +240,24 @@ public void caseAssignStmt(AssignStmt stmt) { usedAsObject = false; } doBreak = true; - return; } else if (r instanceof StringConstant || r instanceof NewExpr) { - throw new RuntimeException("NOT POSSIBLE StringConstant or NewExpr at " + stmt); + usedAsObject = true; + doBreak = true; } else if (r instanceof NewArrayExpr) { usedAsObject = false; doBreak = true; - return; } else if (r instanceof CastExpr) { usedAsObject = isObject(((CastExpr) r).getCastType()); doBreak = true; - return; } else if (r instanceof InvokeExpr) { usedAsObject = examineInvokeExpr((InvokeExpr) stmt.getRightOp()); doBreak = true; - return; } else if (r instanceof LengthExpr) { usedAsObject = true; doBreak = true; - return; } else if (r instanceof BinopExpr) { usedAsObject = false; doBreak = true; - return; } } diff --git a/src/main/java/soot/dexpler/instructions/FillArrayDataInstruction.java b/src/main/java/soot/dexpler/instructions/FillArrayDataInstruction.java index 42f0faa0c4a..196b7192446 100644 --- a/src/main/java/soot/dexpler/instructions/FillArrayDataInstruction.java +++ b/src/main/java/soot/dexpler/instructions/FillArrayDataInstruction.java @@ -37,8 +37,6 @@ import soot.Local; import soot.dexpler.DexBody; -import soot.dexpler.DexFillArrayDataTransformer; -import soot.dexpler.typing.UntypedConstant; import soot.dexpler.typing.UntypedIntOrFloatConstant; import soot.dexpler.typing.UntypedLongOrDoubleConstant; import soot.jimple.ArrayRef; diff --git a/src/main/java/soot/dexpler/instructions/FilledNewArrayInstruction.java b/src/main/java/soot/dexpler/instructions/FilledNewArrayInstruction.java index ab2150e3efa..51ae3a877c2 100644 --- a/src/main/java/soot/dexpler/instructions/FilledNewArrayInstruction.java +++ b/src/main/java/soot/dexpler/instructions/FilledNewArrayInstruction.java @@ -35,10 +35,12 @@ import soot.ArrayType; import soot.Local; +import soot.RefLikeType; import soot.Type; import soot.dexpler.DexBody; import soot.dexpler.DexType; import soot.dexpler.IDalvikTyper; +import soot.dexpler.tags.ObjectOpTag; import soot.dexpler.typing.DalvikTyper; import soot.jimple.ArrayRef; import soot.jimple.AssignStmt; @@ -68,8 +70,8 @@ public void jimplify(DexBody body) { Type t = DexType.toSoot((TypeReference) filledNewArrayInstr.getReference()); // NewArrayExpr needs the ElementType as it increases the array dimension by 1 - Type arrayType = ((ArrayType) t).getElementType(); - NewArrayExpr arrayExpr = Jimple.v().newNewArrayExpr(arrayType, IntConstant.v(usedRegister)); + Type elementType = ((ArrayType) t).getElementType(); + NewArrayExpr arrayExpr = Jimple.v().newNewArrayExpr(elementType, IntConstant.v(usedRegister)); // new local generated intentional, will be moved to real register by MoveResult Local arrayLocal = body.getStoreResultLocal(); AssignStmt assign = Jimple.v().newAssignStmt(arrayLocal, arrayExpr); @@ -78,6 +80,9 @@ public void jimplify(DexBody body) { ArrayRef arrayRef = Jimple.v().newArrayRef(arrayLocal, IntConstant.v(i)); AssignStmt assign2 = Jimple.v().newAssignStmt(arrayRef, body.getRegisterLocal(regs[i])); + if (elementType instanceof RefLikeType) { + assign2.addTag(new ObjectOpTag()); + } addTags(assign2); body.add(assign2); } diff --git a/src/main/java/soot/dexpler/instructions/FilledNewArrayRangeInstruction.java b/src/main/java/soot/dexpler/instructions/FilledNewArrayRangeInstruction.java index 0c05b912b2a..9d898a6f5f7 100644 --- a/src/main/java/soot/dexpler/instructions/FilledNewArrayRangeInstruction.java +++ b/src/main/java/soot/dexpler/instructions/FilledNewArrayRangeInstruction.java @@ -35,10 +35,12 @@ import soot.ArrayType; import soot.Local; +import soot.RefLikeType; import soot.Type; import soot.dexpler.DexBody; import soot.dexpler.DexType; import soot.dexpler.IDalvikTyper; +import soot.dexpler.tags.ObjectOpTag; import soot.dexpler.typing.DalvikTyper; import soot.jimple.ArrayRef; import soot.jimple.AssignStmt; @@ -66,8 +68,8 @@ public void jimplify(DexBody body) { int usedRegister = filledNewArrayInstr.getRegisterCount(); Type t = DexType.toSoot((TypeReference) filledNewArrayInstr.getReference()); // NewArrayExpr needs the ElementType as it increases the array dimension by 1 - Type arrayType = ((ArrayType) t).getElementType(); - NewArrayExpr arrayExpr = Jimple.v().newNewArrayExpr(arrayType, IntConstant.v(usedRegister)); + Type elementType = ((ArrayType) t).getElementType(); + NewArrayExpr arrayExpr = Jimple.v().newNewArrayExpr(elementType, IntConstant.v(usedRegister)); Local arrayLocal = body.getStoreResultLocal(); AssignStmt assignStmt = Jimple.v().newAssignStmt(arrayLocal, arrayExpr); body.add(assignStmt); @@ -77,6 +79,9 @@ public void jimplify(DexBody body) { AssignStmt assign = Jimple.v().newAssignStmt(arrayRef, body.getRegisterLocal(i + filledNewArrayInstr.getStartRegister())); + if (elementType instanceof RefLikeType) { + assign.addTag(new ObjectOpTag()); + } addTags(assign); body.add(assign); } diff --git a/src/main/java/soot/dexpler/tags/DexplerTag.java b/src/main/java/soot/dexpler/tags/DexplerTag.java new file mode 100644 index 00000000000..5c5e985b96f --- /dev/null +++ b/src/main/java/soot/dexpler/tags/DexplerTag.java @@ -0,0 +1,27 @@ +package soot.dexpler.tags; + +/*- + * #%L + * Soot - a J*va Optimization Framework + * %% + * Copyright (C) 1997 - 2018 Raja Vallée-Rai and others + * %% + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 2.1 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Lesser Public License for more details. + * + * You should have received a copy of the GNU General Lesser Public + * License along with this program. If not, see + * . + * #L% + */ + +public interface DexplerTag { + +} diff --git a/src/main/java/soot/dexpler/tags/DoubleOpTag.java b/src/main/java/soot/dexpler/tags/DoubleOpTag.java index dd7d4f4cb77..d99961d677d 100644 --- a/src/main/java/soot/dexpler/tags/DoubleOpTag.java +++ b/src/main/java/soot/dexpler/tags/DoubleOpTag.java @@ -44,7 +44,7 @@ import soot.tagkit.Tag; -public class DoubleOpTag implements Tag { +public class DoubleOpTag implements Tag, DexplerTag { public static final String NAME = "DoubleOpTag"; diff --git a/src/main/java/soot/dexpler/tags/FloatOpTag.java b/src/main/java/soot/dexpler/tags/FloatOpTag.java index 65f2437c471..a6220ea9a03 100644 --- a/src/main/java/soot/dexpler/tags/FloatOpTag.java +++ b/src/main/java/soot/dexpler/tags/FloatOpTag.java @@ -44,7 +44,7 @@ import soot.tagkit.Tag; -public class FloatOpTag implements Tag { +public class FloatOpTag implements Tag, DexplerTag { public static final String NAME = "FloatOpTag"; diff --git a/src/main/java/soot/dexpler/tags/IntOpTag.java b/src/main/java/soot/dexpler/tags/IntOpTag.java index 2aeeef0c6ef..12bbd53ad9e 100644 --- a/src/main/java/soot/dexpler/tags/IntOpTag.java +++ b/src/main/java/soot/dexpler/tags/IntOpTag.java @@ -44,7 +44,7 @@ import soot.tagkit.Tag; -public class IntOpTag implements Tag { +public class IntOpTag implements Tag, DexplerTag { public static final String NAME = "IntOpTag"; diff --git a/src/main/java/soot/dexpler/tags/LongOpTag.java b/src/main/java/soot/dexpler/tags/LongOpTag.java index 97f84642e95..00e00aa4989 100644 --- a/src/main/java/soot/dexpler/tags/LongOpTag.java +++ b/src/main/java/soot/dexpler/tags/LongOpTag.java @@ -44,7 +44,7 @@ import soot.tagkit.Tag; -public class LongOpTag implements Tag { +public class LongOpTag implements Tag, DexplerTag { public static final String NAME = "LongOpTag"; diff --git a/src/main/java/soot/dexpler/tags/NumOpTag.java b/src/main/java/soot/dexpler/tags/NumOpTag.java index b20ce67fdf5..3ed7136bda6 100644 --- a/src/main/java/soot/dexpler/tags/NumOpTag.java +++ b/src/main/java/soot/dexpler/tags/NumOpTag.java @@ -44,7 +44,7 @@ import soot.tagkit.Tag; -public class NumOpTag implements Tag { +public class NumOpTag implements Tag, DexplerTag { public static final String NAME = "NumOpTag"; diff --git a/src/main/java/soot/dexpler/tags/ObjectOpTag.java b/src/main/java/soot/dexpler/tags/ObjectOpTag.java index ddde57f2677..a85813523bf 100644 --- a/src/main/java/soot/dexpler/tags/ObjectOpTag.java +++ b/src/main/java/soot/dexpler/tags/ObjectOpTag.java @@ -44,7 +44,7 @@ import soot.tagkit.Tag; -public class ObjectOpTag implements Tag { +public class ObjectOpTag implements Tag, DexplerTag { public static final String NAME = "ObjectOpTag"; diff --git a/src/main/java/soot/dexpler/tags/SpecialInvokeTypeTag.java b/src/main/java/soot/dexpler/tags/SpecialInvokeTypeTag.java index 1279c0b93bb..df33c7d74fa 100644 --- a/src/main/java/soot/dexpler/tags/SpecialInvokeTypeTag.java +++ b/src/main/java/soot/dexpler/tags/SpecialInvokeTypeTag.java @@ -51,7 +51,7 @@ * * @author Marc Miltenberger */ -public class SpecialInvokeTypeTag implements Tag { +public class SpecialInvokeTypeTag implements Tag, DexplerTag { public static final String NAME = "SpecialInvokeTypeTag"; diff --git a/src/main/java/soot/toDex/DexArrayInitDetector.java b/src/main/java/soot/toDex/DexArrayInitDetector.java index a56af99c7a1..8294beaca7c 100644 --- a/src/main/java/soot/toDex/DexArrayInitDetector.java +++ b/src/main/java/soot/toDex/DexArrayInitDetector.java @@ -36,7 +36,11 @@ import soot.Value; import soot.jimple.ArrayRef; import soot.jimple.AssignStmt; +import soot.jimple.Constant; +import soot.jimple.DoubleConstant; +import soot.jimple.FloatConstant; import soot.jimple.IntConstant; +import soot.jimple.LongConstant; import soot.jimple.NewArrayExpr; /** @@ -92,28 +96,34 @@ public void constructArrayInitializations(Body body) { } else { arrayValues = null; } - } else if (assignStmt.getLeftOp() instanceof ArrayRef && assignStmt.getRightOp() instanceof IntConstant + } else if (assignStmt.getLeftOp() instanceof ArrayRef && assignStmt.getRightOp() instanceof Constant /* * NumericConstant */ && arrayValues != null) { - ArrayRef aref = (ArrayRef) assignStmt.getLeftOp(); - if (aref.getBase() != concernedArray) { - arrayValues = null; - continue; - } - if (aref.getIndex() instanceof IntConstant) { - IntConstant intConst = (IntConstant) aref.getIndex(); - if (intConst.value == arrayValues.size()) { - arrayValues.add(assignStmt.getRightOp()); - if (intConst.value == 0) { - arrayInitStmt = u; - } else if (intConst.value == arraySize - 1) { - curIgnoreUnits.add(u); - checkAndSave(arrayInitStmt, arrayValues, arraySize, curIgnoreUnits); - arrayValues = null; + Value rop = assignStmt.getRightOp(); + if (rop instanceof IntConstant || rop instanceof LongConstant || rop instanceof FloatConstant + || rop instanceof DoubleConstant) { + ArrayRef aref = (ArrayRef) assignStmt.getLeftOp(); + if (aref.getBase() != concernedArray) { + arrayValues = null; + continue; + } + if (aref.getIndex() instanceof IntConstant) { + IntConstant intConst = (IntConstant) aref.getIndex(); + if (intConst.value == arrayValues.size()) { + arrayValues.add(rop); + if (intConst.value == 0) { + arrayInitStmt = u; + } else if (intConst.value == arraySize - 1) { + curIgnoreUnits.add(u); + checkAndSave(arrayInitStmt, arrayValues, arraySize, curIgnoreUnits); + arrayValues = null; + } else { + curIgnoreUnits.add(u); + } } else { - curIgnoreUnits.add(u); + arrayValues = null; } } else { arrayValues = null; diff --git a/src/main/java/soot/toDex/DexPrinter.java b/src/main/java/soot/toDex/DexPrinter.java index 95a4ac7e0c7..ff31741d21c 100644 --- a/src/main/java/soot/toDex/DexPrinter.java +++ b/src/main/java/soot/toDex/DexPrinter.java @@ -44,6 +44,7 @@ import java.util.LinkedHashMap; import java.util.List; import java.util.Map; +import java.util.Map.Entry; import java.util.Set; import java.util.jar.Attributes; import java.util.jar.JarFile; @@ -1282,9 +1283,9 @@ protected MethodImplementation toMethodImplementation(SootMethod m) { toTries(activeBody.getTraps(), builder, labelAssigner); // Make sure that all labels have been placed by now - for (Label lbl : labelAssigner.getAllLabels()) { - if (!lbl.isPlaced()) { - throw new DexPrinterException("Label not placed: " + lbl); + for (Entry lbl : labelAssigner.getAllStmtsToLabels()) { + if (!lbl.getValue().isPlaced()) { + throw new DexPrinterException("Label not placed for statement " + lbl.getKey()); } } diff --git a/src/main/java/soot/toDex/LabelAssigner.java b/src/main/java/soot/toDex/LabelAssigner.java index ce2aeee559c..77555467908 100644 --- a/src/main/java/soot/toDex/LabelAssigner.java +++ b/src/main/java/soot/toDex/LabelAssigner.java @@ -25,6 +25,8 @@ import java.util.Collection; import java.util.HashMap; import java.util.Map; +import java.util.Map.Entry; +import java.util.Set; import org.jf.dexlib2.builder.Label; import org.jf.dexlib2.builder.MethodImplementationBuilder; @@ -120,4 +122,8 @@ public Collection