SequenceNumber.getTime() vs .getOrder(), sorting of SequenceNumbers, and HighFunction.getPcodeOps()

[KevOrr]

The docs are a little unclear to me what the intent behind SequenceNumber.getTime() vs .getOrder() is. IIUC, .getOrder() gives the intra-address execution order of PCodeOps (when one instruction lifts to more than one P-Code op), whereas .getTime() gives a unique ID for every PCodeOp within a (instruction? basic block? function? Not sure which), but its value is not significant.

The reason I'm asking is because I'm confused by this following output of HighFunction.getPcodeOps(). I'm getting this with

for pcode in f.getPcodeOps():
  print pcode.getSeqnum(), ":    ", pcode

where f is the HighFunction:

                             //
                             // .text 
                             // SHT_PROGBITS  [0x0 - 0x21]
                             // ram:00100000-ram:00100021
                             //
                             **************************************************************
                             *                          FUNCTION                          *
                             **************************************************************
                             undefined foo()
             undefined         AL:1           <RETURN>
             undefined4        Stack[-0xc]:4  local_c                                 XREF[3]:     00100008(W), 
                                                                                                   00100013(RW), 
                                                                                                   00100017(R)  
             undefined4        Stack[-0x10]:4 local_10                                XREF[3]:     0010000b(W), 
                                                                                                   00100010(RW), 
                                                                                                   0010001d(R)  
                             foo                                             XREF[5]:     Entry Point(*), 00100068(*), 
                                                                                          _elfSectionHeaders::00000050(*), 
                                                                                          _elfSectionHeaders::00000090(*), 
                                                                                          _elfSectionHeaders::000000d0(*)  
        00100000 f3 0f 1e fa     ENDBR64
        00100004 55              PUSH       RBP
        00100005 48 89 e5        MOV        RBP, RSP
        00100008 89 7d fc        MOV        dword ptr [RBP + local_c], EDI
        0010000b 89 75 f8        MOV        dword ptr [RBP + local_10], ESI
        0010000e eb 07           JMP        LAB_00100017
                             LAB_00100010                                    XREF[1]:     0010001b(j)  
        00100010 d1 65 f8        SHL        dword ptr [RBP + local_10], 0x1
        00100013 83 6d fc 01     SUB        dword ptr [RBP + local_c], 0x1
                             LAB_00100017                                    XREF[1]:     0010000e(j)  
        00100017 83 7d fc 00     CMP        dword ptr [RBP + local_c], 0x0
        0010001b 7f f3           JG         LAB_00100010
        0010001d 8b 45 f8        MOV        EAX, dword ptr [RBP + local_10]
        00100020 5d              POP        RBP
        00100021 c3              RET

The output of the above snippet is:

(ram, 0x10000e, 10, 2) :      ---  BRANCH (ram, 0x100017, 1)
(ram, 0x10000e, 102, 0) :     (unique, 0x10000010, 4) COPY (register, 0x30, 4)
(ram, 0x10000e, 103, 1) :     (unique, 0x10000014, 4) COPY (register, 0x38, 4)
(ram, 0x100010, 42, 0) :     (unique, 0xc180, 4) INT_LEFT (stack, 0xfffffffffffffff0, 4) , (const, 0x1, 4)
(ram, 0x100013, 62, 1) :     (unique, 0x5780, 4) INT_ADD (stack, 0xfffffffffffffff4, 4) , (const, 0xffffffff, 4)
(ram, 0x100017, 98, 1) :     (stack, 0xfffffffffffffff0, 4) MULTIEQUAL (unique, 0x10000010, 4) , (unique, 0xc180, 4)
(ram, 0x100017, 99, 0) :     (stack, 0xfffffffffffffff4, 4) MULTIEQUAL (unique, 0x10000014, 4) , (unique, 0x5780, 4)
(ram, 0x10001b, 25, 2) :     (unique, 0xd580, 1) INT_SLESS (const, 0x0, 4) , (stack, 0xfffffffffffffff4, 4)
(ram, 0x10001b, 26, 3) :      ---  CBRANCH (ram, 0x100010, 1) , (unique, 0xd580, 1)
(ram, 0x10001d, 101, 0) :     (register, 0x0, 4) COPY (stack, 0xfffffffffffffff0, 4)
(ram, 0x100021, 37, 1) :      ---  RETURN (const, 0x0, 8) , (register, 0x0, 4)

Due to the way that SequenceNumber.compareTo(SequenceNumber) compares SequenceNumbers (lexicographically by PC, then by "time"), and because PcodeSyntaxTree.getPcodeOps() returns ops sorted by SequenceNumber, the first three P-Code Ops above are, IMO, in the wrong order. The unique COPY register ops should be before the BRANCH, otherwise the MULTIEQUAL that is immediately jumped to doesn't make sense (neither unique...10 nor unique 0xc180 are assigned to at that point.

Any insight into this? Are consumers of getPcodeOps() meant to re-sort ops by PC and .getOrder()? Or should they already come back in that order? Or am I looking at this all wrong?