From cae08d4c46da4b6895c56658a68b0cdb1f983b21 Mon Sep 17 00:00:00 2001
From: Marc Miltenberger <Marc.Miltenberger@sit.fraunhofer.de>
Date: Tue, 8 Oct 2024 18:29:50 +0200
Subject: [PATCH 1/6] Display more information in case a dexlib label was not
 placed

---
 src/main/java/soot/toDex/DexPrinter.java | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

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<Stmt, Label> lbl : labelAssigner.getAllStmtsToLabels()) {
+      if (!lbl.getValue().isPlaced()) {
+        throw new DexPrinterException("Label not placed for statement " + lbl.getKey());
       }
     }
 

From 050d64624998600b796e8f3fa56d0183d5bf8dfe Mon Sep 17 00:00:00 2001
From: Marc Miltenberger <Marc.Miltenberger@sit.fraunhofer.de>
Date: Tue, 8 Oct 2024 18:30:17 +0200
Subject: [PATCH 2/6] Missing file

---
 src/main/java/soot/toDex/LabelAssigner.java | 6 ++++++
 1 file changed, 6 insertions(+)

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<Label> getAllLabels() {
     return stmtToLabel.values();
   }
 
+  public Set<Entry<Stmt, Label>> getAllStmtsToLabels() {
+    return stmtToLabel.entrySet();
+  }
+
 }

From 6932d22cef072555a2358d040fe9774b063b6b7c Mon Sep 17 00:00:00 2001
From: Marc Miltenberger <Marc.Miltenberger@sit.fraunhofer.de>
Date: Wed, 9 Oct 2024 07:41:57 +0200
Subject: [PATCH 3/6] Handle new expr and string constants in
 DexNullTransformer

---
 .../java/soot/dexpler/DexNullTransformer.java    | 16 ++--------------
 1 file changed, 2 insertions(+), 14 deletions(-)

diff --git a/src/main/java/soot/dexpler/DexNullTransformer.java b/src/main/java/soot/dexpler/DexNullTransformer.java
index c62cf6d19fb..8277dea6dd2 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
         }
 
@@ -239,7 +233,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 +241,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;
         }
       }
 

From 8902354ec00824de6baf13e9685a092c4e427e55 Mon Sep 17 00:00:00 2001
From: Marc Miltenberger <Marc.Miltenberger@sit.fraunhofer.de>
Date: Wed, 9 Oct 2024 13:15:45 +0200
Subject: [PATCH 4/6] Make dexbody more resilient

---
 src/main/java/soot/dexpler/DexBody.java | 93 ++++++++++++++++++++++++-
 1 file changed, 91 insertions(+), 2 deletions(-)

diff --git a/src/main/java/soot/dexpler/DexBody.java b/src/main/java/soot/dexpler/DexBody.java
index 31fb8036a6e..bad98ed48c2 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.
@@ -983,6 +1000,78 @@ 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());
+      }
+
+    }
+  }
+
   /**
    * Fixes the line numbers. If there is a unit without a line number, it gets the line number of the last (transitive)
    * predecessor that has a line number.

From 2fb64a4b96744775cb6f0c035e073fe7a1744f85 Mon Sep 17 00:00:00 2001
From: Marc Miltenberger <Marc.Miltenberger@sit.fraunhofer.de>
Date: Wed, 9 Oct 2024 16:14:38 +0200
Subject: [PATCH 5/6] Fix several bugs regarding typing in dex

---
 src/main/java/soot/dexpler/DexBody.java       |  3 ++-
 .../soot/dexpler/DexNullThrowTransformer.java |  9 +++++--
 .../java/soot/dexpler/DexNullTransformer.java | 11 ++++----
 .../FillArrayDataInstruction.java             |  2 --
 .../FilledNewArrayInstruction.java            |  9 +++++--
 .../FilledNewArrayRangeInstruction.java       |  9 +++++--
 .../java/soot/dexpler/tags/DexplerTag.java    | 27 +++++++++++++++++++
 .../java/soot/dexpler/tags/DoubleOpTag.java   |  2 +-
 .../java/soot/dexpler/tags/FloatOpTag.java    |  2 +-
 src/main/java/soot/dexpler/tags/IntOpTag.java |  2 +-
 .../java/soot/dexpler/tags/LongOpTag.java     |  2 +-
 src/main/java/soot/dexpler/tags/NumOpTag.java |  2 +-
 .../java/soot/dexpler/tags/ObjectOpTag.java   |  2 +-
 .../dexpler/tags/SpecialInvokeTypeTag.java    |  2 +-
 src/main/java/soot/toDex/StmtVisitor.java     |  7 ++---
 .../SharedInitializationLocalSplitter.java    |  3 ++-
 16 files changed, 68 insertions(+), 26 deletions(-)
 create mode 100644 src/main/java/soot/dexpler/tags/DexplerTag.java

diff --git a/src/main/java/soot/dexpler/DexBody.java b/src/main/java/soot/dexpler/DexBody.java
index db5d88e608e..52d06a66f43 100755
--- a/src/main/java/soot/dexpler/DexBody.java
+++ b/src/main/java/soot/dexpler/DexBody.java
@@ -1076,7 +1076,7 @@ private void removeDexplerTags(Unit unit) {
   }
 
   /**
-   * 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()) {
@@ -1087,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<String, String> 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<Unit> 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 8277dea6dd2..cdc5ac8cf41 100644
--- a/src/main/java/soot/dexpler/DexNullTransformer.java
+++ b/src/main/java/soot/dexpler/DexNullTransformer.java
@@ -215,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;
           }
         }
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
+ * <http://www.gnu.org/licenses/lgpl-2.1.html>.
+ * #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/StmtVisitor.java b/src/main/java/soot/toDex/StmtVisitor.java
index fdf76a8c99b..206ca83f8e0 100644
--- a/src/main/java/soot/toDex/StmtVisitor.java
+++ b/src/main/java/soot/toDex/StmtVisitor.java
@@ -101,7 +101,6 @@
 import soot.toDex.instructions.SwitchPayload;
 import soot.util.HashMultiMap;
 import soot.util.MultiMap;
-import soot.util.Switchable;
 
 /**
  * A visitor that builds a list of instructions from the Jimple statements it visits.<br>
@@ -604,10 +603,12 @@ private Insn buildArrayFillInsn(ArrayRef destRef, List<Value> values) {
         numbers.add(((LongConstant) val).value);
       } else if (val instanceof FloatConstant) {
         elementSize = Math.max(elementSize, 4);
-        numbers.add(((FloatConstant) val).value);
+        int num = Float.floatToIntBits(((FloatConstant) val).value);
+        numbers.add(num);
       } else if (val instanceof DoubleConstant) {
         elementSize = Math.max(elementSize, 8);
-        numbers.add(((DoubleConstant) val).value);
+        long num = Double.doubleToLongBits(((DoubleConstant) val).value);
+        numbers.add(num);
       } else {
         return null;
       }
diff --git a/src/main/java/soot/toolkits/scalar/SharedInitializationLocalSplitter.java b/src/main/java/soot/toolkits/scalar/SharedInitializationLocalSplitter.java
index 4207adb4cb1..e53f7817b4f 100644
--- a/src/main/java/soot/toolkits/scalar/SharedInitializationLocalSplitter.java
+++ b/src/main/java/soot/toolkits/scalar/SharedInitializationLocalSplitter.java
@@ -135,10 +135,11 @@ protected void internalTransform(Body body, String phaseName, Map<String, String
       omitExceptingUnitEdges = Options.v().omit_excepting_unit_edges();
     }
 
+    DexNullThrowTransformer.v().transform(body);
     CopyPropagator.v().transform(body);
+    DexNullThrowTransformer.v().transform(body);
     ConstantPropagatorAndFolder.v().transform(body);
 
-    DexNullThrowTransformer.v().transform(body);
     DexNullArrayRefTransformer.v().transform(body);
     FlowSensitiveConstantPropagator.v().transform(body);
     CopyPropagator.v().transform(body);

From 9301f8bfa8a3765ecd529af57997336a04d799c0 Mon Sep 17 00:00:00 2001
From: Marc Miltenberger <Marc.Miltenberger@sit.fraunhofer.de>
Date: Wed, 9 Oct 2024 16:14:59 +0200
Subject: [PATCH 6/6] Missing dex array init detector

---
 .../java/soot/toDex/DexArrayInitDetector.java | 44 ++++++++++++-------
 1 file changed, 27 insertions(+), 17 deletions(-)

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;