Why Code#compare parameter order is reversed after generated dex?

[wuyr]

I have the following code:

Local local1 = methodCodeBlock.newLocal(TypeId.INT);
Local parameter = methodCodeBlock.getParameter(0, TypeId.INT);
            
...
     
methodCodeBlock.compare(Comparison.LT, label, local1, parameter);

The expected result should be:

if(local1 >= parameter)
...

But when I invoke the DexMaker#generate, the result I see is:

if(parameter >= local1)
...

Is this a bug? Or am I using it incorrectly? If I use it incorrectly, can someone tell me how to use it correctly? Thank a lot!
Is this project still alive? The last update I saw was last May

[wuyr]

I got it, when local1 value = 0, the result order is always reversed. how can i fix this?

[kkoser]

Hey @wuyr sorry I'm getting back so late - I think this is working as expected. writing a comparison of compare(LT, local1, param) is the java equivalent of

if (local1 < param)
which could also be rewritten as

if (param >= local1)

I tried writing a test case for this with the local having a value of 0, and it seems to work correctly - lmk if you're seeing different, or if I'm misunderstanding your use case. Thanks!

    @Test
    public void testIntCompare() throws Exception {
        /*
         * public static bool call(int b) {
         *   return 0 < b
         * }
         */
        MethodId<?, Boolean> methodId = GENERATED.getMethod(
                TypeId.BOOLEAN, "call", TypeId.INT);
        Code code = dexMaker.declare(methodId, PUBLIC | STATIC);
        Local<Integer> localA = code.newLocal(TypeId.INT);
        Local<Integer> localB = code.getParameter(0, TypeId.INT);
        Local<Boolean> result = code.newLocal(TypeId.get(boolean.class));
        Label afterIf = new Label();
        Label ifBody = new Label();
        code.loadConstant(localA, 0);
        code.compare(Comparison.LT, ifBody, localA, localB);
        code.jump(afterIf);

        code.mark(ifBody);
        code.loadConstant(result, true);
        code.returnValue(result);

        code.mark(afterIf);
        code.loadConstant(result, false);
        code.returnValue(result);
        Method method = getMethod();


        assertEquals(true, method.invoke(null, 5));
        assertEquals(false, method.invoke(null, -5));
        assertEquals(false, method.invoke(null, 0));
    }```

[evacchi]

hey I am not sure what I am doing wrong but I am not following what is happening:

        var dexMaker = new DexMaker();

        var GENERATED = TypeId.get("Lmyclass;");
        dexMaker.declare(GENERATED, "src", PUBLIC, TypeId.OBJECT);

        MethodId<?, Void> methodId = GENERATED.getMethod(
                TypeId.VOID, "call", TypeId.INT);
        Code code = dexMaker.declare(methodId, PUBLIC | STATIC);
        Local<Integer> localA = code.newLocal(TypeId.INT);
        Label afterIf = new Label();
        Label ifBody = new Label();
        Label end = new Label();
        code.loadConstant(localA, 0);
        code.compareZ(Comparison.EQ, ifBody, localA);
        code.jump(afterIf);

        code.mark(ifBody);
        code.loadConstant(localA, 1111); // should appear first (?)

        code.mark(afterIf);
        code.loadConstant(localA, 2222); // should appear second?

        code.mark(end);
        code.returnVoid();

produces this result:

Class: Lmyclass;
  Method: call
    Parameters: [I]
    Return: V
    0000: const/4             v0 #0 #0
    0001: if-eqz              v0 -> 0006
    0003: const/16            v0 #2222 #2222 // appear first instead
    0005: return-void
    0006: const/16            v0 #1111 #1111 
    0008: goto                 -> 0003 // weird jump back to the beginning?

Why is the basic block (?) with 1111 moved after 2222 ? Thanks for the help!

EDIT: uhmm, I guess I answered myself, the BB are reordered when the bytecode is synthesized...