search

BeRo1985 / flre

FLRE - Fast Light Regular Expressions - A fast light regular expression library
GNU Lesser General Public License v2.1
94 stars 23 forks source link

PTRPOSCHAR app store crash report #89

Open benibela opened 7 months ago

benibela commented 7 months ago

I got a crash report

backtrace:
  #00  pc 0x0000000000234b20  /data/app/...arm64_v8a.apk!liblclapp.so (PTRPOSCHAR+5750) (BuildId: 8c8d350a20b56cce2da74caedd3bc4b35311daa4)

on samsung r9q (Galaxy S21 FE 5G) with Android 14 (SDK 34)

If I put the address in gdb, it gives

Dump of assembler code for function PTRPOSCHAR:
5727    begin
   0x00234a50 <+0>:     fd      std    
   0x00234a51 <+1>:     7b bf   jnp    0x234a12 <POPFIRSTONEBIT+34>
   0x00234a53 <+3>:     a9 fd 03 00 91  test   eax,0x910003fd
   0x00234a58 <+8>:     ff 43 01        inc    DWORD PTR [ebx+0x1]
   0x00234a5b <+11>:    d1 e0   shl    eax,1
   0x00234a5d <+13>:    03 00   add    eax,DWORD PTR [eax]
   0x00234a5f <+15>:    39 e1   cmp    ecx,esp
   0x00234a61 <+17>:    07      pop    es
   0x00234a62 <+18>:    00 f9   add    cl,bh
   0x00234a64 <+20>:    e2 0b   loop   0x234a71 <PTRPOSCHAR+33>
   0x00234a66 <+22>:    00 f9   add    cl,bh
   0x00234a68 <+24>:    e3 0f   jecxz  0x234a79 <PTRPOSCHAR+41>
   0x00234a6a <+26>:    00 f9   add    cl,bh

5728     result:=-1;
   0x00234a6c <+28>:    00 00   add    BYTE PTR [eax],al
   0x00234a6e <+30>:    80 92 e0 13 00 f9 e0    adc    BYTE PTR [edx-0x6ffec20],0xe0

5729
5730     Size:=TextLength-Offset;
   0x00234a74 <+36>:    e0 0b   loopne 0x234a81 <PTRPOSCHAR+49>
   0x00234a76 <+38>:    40      inc    eax
   0x00234a77 <+39>:    f9      stc    
   0x00234a78 <+40>:    e1 0f   loope  0x234a89 <PTRPOSCHAR+57>
   0x00234a7a <+42>:    40      inc    eax
   0x00234a7b <+43>:    f9      stc    
   0x00234a7c <+44>:    00 00   add    BYTE PTR [eax],al
   0x00234a7e <+46>:    01 cb   add    ebx,ecx
   0x00234a80 <+48>:    e0 27   loopne 0x234aa9 <PTRPOSCHAR+89>
   0x00234a82 <+50>:    00 f9   add    cl,bh

5731     if (Offset<TextLength) and (TFLREPtrInt(Size)>0) then begin
   0x00234a84 <+52>:    e1 0f   loope  0x234a95 <PTRPOSCHAR+69>

   0x00234a86 <+54>:    40      inc    eax
   0x00234a87 <+55>:    f9      stc    
   0x00234a88 <+56>:    e0 0b   loopne 0x234a95 <PTRPOSCHAR+69>
   0x00234a8a <+58>:    40      inc    eax
   0x00234a8b <+59>:    f9      stc    
   0x00234a8c <+60>:    3f      aas    
   0x00234a8d <+61>:    00 00   add    BYTE PTR [eax],al
   0x00234a8f <+63>:    eb 0a   jmp    0x234a9b <PTRPOSCHAR+75>
   0x00234a91 <+65>:    16      push   ss
   0x00234a92 <+66>:    00 54 e0 27     add    BYTE PTR [eax+eiz*8+0x27],dl
   0x00234a96 <+70>:    40      inc    eax
   0x00234a97 <+71>:    f9      stc    
   0x00234a98 <+72>:    1f      pop    ds
   0x00234a99 <+73>:    00 00   add    BYTE PTR [eax],al
   0x00234a9b <+75>:    f1      int1   
   0x00234a9c <+76>:    ad      lods   eax,DWORD PTR ds:[esi]
   0x00234a9d <+77>:    15 00 54 e0 03  adc    eax,0x3e05400

5732
5733      XorMask:=TFLREUInt8(SearchChar);
   0x00234aa0 <+80>:    e0 03   loopne 0x234aa5 <PTRPOSCHAR+85>
   0x00234aa2 <+82>:    40      inc    eax
   0x00234aa3 <+83>:    39 e0   cmp    eax,esp
   0x00234aa5 <+85>:    1f      pop    ds
   0x00234aa6 <+86>:    00 f9   add    cl,bh

5734      XorMask:=XorMask or (XorMask shl 8);
   0x00234aa8 <+88>:    e0 1f   loopne 0x234ac9 <PTRPOSCHAR+121>
   0x00234aaa <+90>:    40      inc    eax
   0x00234aab <+91>:    f9      stc    
   0x00234aac <+92>:    00 dc   add    ah,bl
   0x00234aae <+94>:    78 d3   js     0x234a83 <PTRPOSCHAR+51>
   0x00234ab0 <+96>:    e1 1f   loope  0x234ad1 <PTRPOSCHAR+129>
   0x00234ab2 <+98>:    40      inc    eax
   0x00234ab3 <+99>:    f9      stc    

   0x00234ab4 <+100>:   20 00   and    BYTE PTR [eax],al
   0x00234ab6 <+102>:   00 aa e0 1f 00 f9       add    BYTE PTR [edx-0x6ffe020],ch

5735      XorMask:=XorMask or (XorMask shl 16);
   0x00234abc <+108>:   e0 1f   loopne 0x234add <PTRPOSCHAR+141>
   0x00234abe <+110>:   40      inc    eax
   0x00234abf <+111>:   f9      stc    
   0x00234ac0 <+112>:   00 bc 70 d3 e1 1f 40    add    BYTE PTR [eax+esi*2+0x401fe1d3],bh
   0x00234ac7 <+119>:   f9      stc    
   0x00234ac8 <+120>:   20 00   and    BYTE PTR [eax],al
   0x00234aca <+122>:   00 aa e0 1f 00 f9       add    BYTE PTR [edx-0x6ffe020],ch

5736    {$ifdef cpu64}
5737      XorMask:=XorMask or (XorMask shl 32);
   0x00234ad0 <+128>:   e0 1f   loopne 0x234af1 <PTRPOSCHAR+161>
   0x00234ad2 <+130>:   40      inc    eax
   0x00234ad3 <+131>:   f9      stc    
   0x00234ad4 <+132>:   01 7c 60 d3     add    DWORD PTR [eax+eiz*2-0x2d],edi
   0x00234ad8 <+136>:   e0 1f   loopne 0x234af9 <PTRPOSCHAR+169>
   0x00234ada <+138>:   40      inc    eax
   0x00234adb <+139>:   f9      stc    
   0x00234adc <+140>:   00 00   add    BYTE PTR [eax],al
   0x00234ade <+142>:   01 aa e0 1f 00 f9       add    DWORD PTR [edx-0x6ffe020],ebp

5738    {$endif}
5739
5740      CurrentChar:=@Text[Offset];
   0x00234ae4 <+148>:   e1 07   loope  0x234aed <PTRPOSCHAR+157>
   0x00234ae6 <+150>:   40      inc    eax
   0x00234ae7 <+151>:   f9      stc    
   0x00234ae8 <+152>:   e0 0f   loopne 0x234af9 <PTRPOSCHAR+169>
   0x00234aea <+154>:   40      inc    eax
   0x00234aeb <+155>:   f9      stc    
   0x00234aec <+156>:   20 00   and    BYTE PTR [eax],al
   0x00234aee <+158>:   00 8b e0 17 00 f9       add    BYTE PTR [ebx-0x6ffe820],cl

5741
5742      if Size>(SizeOf(TFLREPtrUInt)*2) then begin
   0x00234af4 <+164>:   e0 27   loopne 0x234b1d <PTRPOSCHAR+205>
   0x00234af6 <+166>:   40      inc    eax
   0x00234af7 <+167>:   f9      stc    
   0x00234af8 <+168>:   1f      pop    ds
   0x00234af9 <+169>:   40      inc    eax
   0x00234afa <+170>:   00 f1   add    cl,dh
   0x00234afc <+172>:   49      dec    ecx
   0x00234afd <+173>:   12 00   adc    al,BYTE PTR [eax]
   0x00234aff <+175>:   54      push   esp

5743
5744       // Alignment initialization
5745       CurrentChunk:=pointer(TFLREPtrUInt(TFLREPtrUInt(CurrentChar) and not (SizeOf(TFLREPtrUInt)-1)));
   0x00234b00 <+176>:   e0 17   loopne 0x234b19 <PTRPOSCHAR+201>
   0x00234b02 <+178>:   40      inc    eax
   0x00234b03 <+179>:   f9      stc    
   0x00234b04 <+180>:   00 f0   add    al,dh
   0x00234b06 <+182>:   7d 92   jge    0x234a9a <PTRPOSCHAR+74>
   0x00234b08 <+184>:   e0 1b   loopne 0x234b25 <PTRPOSCHAR+213>
   0x00234b0a <+186>:   00 f9   add    cl,bh

5746
5747       // Try to get first chunk
5748       if TFLREPtrUInt(CurrentChunk)>=TFLREPtrUInt(Text) then begin
   0x00234b0c <+188>:   e0 1b   loopne 0x234b29 <PTRPOSCHAR+217>
   0x00234b0e <+190>:   40      inc    eax
   0x00234b0f <+191>:   f9      stc    
   0x00234b10 <+192>:   e1 07   loope  0x234b19 <PTRPOSCHAR+201>
   0x00234b12 <+194>:   40      inc    eax
   0x00234b13 <+195>:   f9      stc    
   0x00234b14 <+196>:   1f      pop    ds
   0x00234b15 <+197>:   00 01   add    BYTE PTR [ecx],al

   0x00234b17 <+199>:   eb e3   jmp    0x234afc <PTRPOSCHAR+172>
   0x00234b19 <+201>:   00 00   add    BYTE PTR [eax],al
   0x00234b1b <+203>:   54      push   esp

5749        // Yes, we can the get first chunk
5750        XoredChunk:=CurrentChunk^ xor XorMask;
   0x00234b1c <+204>:   e0 1b   loopne 0x234b39 <PTRPOSCHAR+233>
   0x00234b1e <+206>:   40      inc    eax
   0x00234b1f <+207>:   f9      stc    
   0x00234b20 <+208>:   01 00   add    DWORD PTR [eax],eax
   0x00234b22 <+210>:   40      inc    eax
   0x00234b23 <+211>:   f9      stc    
   0x00234b24 <+212>:   e0 1f   loopne 0x234b45 <PTRPOSCHAR+245>
   0x00234b26 <+214>:   40      inc    eax
   0x00234b27 <+215>:   f9      stc    
   0x00234b28 <+216>:   00 00   add    BYTE PTR [eax],al
   0x00234b2a <+218>:   01 ca   add    edx,ecx
   0x00234b2c <+220>:   e0 23   loopne 0x234b51 <PTRPOSCHAR+257>
   0x00234b2e <+222>:   00 f9   add    cl,bh
   0x00234b30 <+224>:   02 00   add    al,BYTE PTR [eax]
   0x00234b32 <+226>:   00 14 ff        add    BYTE PTR [edi+edi*8],dl

5751       end else begin
5752        // No, so return dummy value to force to check the few first characters
5753        XoredChunk:=0;
   0x00234b34 <+228>:   ff 23   jmp    DWORD PTR [ebx]
   0x00234b36 <+230>:   00 f9   add    cl,bh

5754       end;
5755
5756       // Jump to next chunk
5757       inc(CurrentChunk);
   0x00234b38 <+232>:   e0 1b   loopne 0x234b55 <PTRPOSCHAR+261>
   0x00234b3a <+234>:   40      inc    eax
   0x00234b3b <+235>:   f9      stc    

   0x00234b3c <+236>:   00 20   add    BYTE PTR [eax],ah
   0x00234b3e <+238>:   00 91 e0 1b 00 f9       add    BYTE PTR [ecx-0x6ffe420],dl

5758
5759       // Subtract the first chunk from size
5760       dec(TFLREPtrUInt(Size),TFLREPtrUInt(CurrentChunk)-TFLREPtrUInt(CurrentChar));
   0x00234b44 <+244>:   e0 1b   loopne 0x234b61 <PTRPOSCHAR+273>
   0x00234b46 <+246>:   40      inc    eax
   0x00234b47 <+247>:   f9      stc    
   0x00234b48 <+248>:   e1 17   loope  0x234b61 <PTRPOSCHAR+273>
   0x00234b4a <+250>:   40      inc    eax
   0x00234b4b <+251>:   f9      stc    
   0x00234b4c <+252>:   00 00   add    BYTE PTR [eax],al
   0x00234b4e <+254>:   01 cb   add    ebx,ecx
   0x00234b50 <+256>:   e1 27   loope  0x234b79 <PTRPOSCHAR+297>
   0x00234b52 <+258>:   40      inc    eax
   0x00234b53 <+259>:   f9      stc    
   0x00234b54 <+260>:   21 00   and    DWORD PTR [eax],eax
   0x00234b56 <+262>:   00 cb   add    bl,cl
   0x00234b58 <+264>:   e1 27   loope  0x234b81 <PTRPOSCHAR+305>
   0x00234b5a <+266>:   00 f9   add    cl,bh

5761
5762       // Scan first chunk
5763       if (((XoredChunk+MaskA) and not XoredChunk) and MaskB)<>0 then begin
   0x00234b5c <+268>:   e0 23   loopne 0x234b81 <PTRPOSCHAR+305>
   0x00234b5e <+270>:   40      inc    eax
   0x00234b5f <+271>:   f9      stc    
   0x00234b60 <+272>:   e1 c3   loope  0x234b25 <PTRPOSCHAR+213>
   0x00234b62 <+274>:   00 b2 01 00 01 cb       add    BYTE PTR [edx-0x34feffff],dh
   0x00234b68 <+280>:   e0 23   loopne 0x234b8d <PTRPOSCHAR+317>
   0x00234b6a <+282>:   40      inc    eax
   0x00234b6b <+283>:   f9      stc    
   0x00234b6c <+284>:   e0 03   loopne 0x234b71 <PTRPOSCHAR+289>
   0x00234b6e <+286>:   20 aa 00 00 01 8a       and    BYTE PTR [edx-0x75ff0000],ch

   0x00234b74 <+292>:   00 c0   add    al,al
   0x00234b76 <+294>:   01 92 1f 00 00 f1       add    DWORD PTR [edx-0xeffffe1],edx
   0x00234b7c <+300>:   80 0b 00        or     BYTE PTR [ebx],0x0
   0x00234b7f <+303>:   54      push   esp

5764        while TFLREPtrUInt(CurrentChar)<TFLREPtrUInt(CurrentChunk) do begin
   0x00234b80 <+304>:   0e      push   cs
   0x00234b81 <+305>:   00 00   add    BYTE PTR [eax],al
   0x00234b83 <+307>:   14 e0   adc    al,0xe0
   0x00234bb8 <+360>:   e0 17   loopne 0x234bd1 <PTRPOSCHAR+385>
   0x00234bba <+362>:   40      inc    eax
   0x00234bbb <+363>:   f9      stc    
   0x00234bbc <+364>:   e1 1b   loope  0x234bd9 <PTRPOSCHAR+393>
   0x00234bbe <+366>:   40      inc    eax
   0x00234bbf <+367>:   f9      stc    
   0x00234bc0 <+368>:   1f      pop    ds
   0x00234bc1 <+369>:   00 01   add    BYTE PTR [ecx],al
   0x00234bc3 <+371>:   eb 03   jmp    0x234bc8 <PTRPOSCHAR+376>
   0x00234bc5 <+373>:   fe      (bad)  
   0x00234bc6 <+374>:   ff 54 49 00     call   DWORD PTR [ecx+ecx*2+0x0]

5765         if CurrentChar^=SearchChar then begin
   0x00234b84 <+308>:   e0 17   loopne 0x234b9d <PTRPOSCHAR+333>
   0x00234b86 <+310>:   40      inc    eax
   0x00234b87 <+311>:   f9      stc    
   0x00234b88 <+312>:   01 00   add    DWORD PTR [eax],eax
   0x00234b8a <+314>:   40      inc    eax
   0x00234b8b <+315>:   39 e0   cmp    eax,esp
   0x00234b8d <+317>:   03 40 39        add    eax,DWORD PTR [eax+0x39]
   0x00234b90 <+320>:   3f      aas    
   0x00234b91 <+321>:   00 00   add    BYTE PTR [eax],al
   0x00234b93 <+323>:   6b c1 00        imul   eax,ecx,0x0
   0x00234b96 <+326>:   00 54 e0 17     add    BYTE PTR [eax+eiz*8+0x17],dl

5766          result:=TFLREPtrUInt(CurrentChar)-TFLREPtrUInt(Text);

   0x00234b98 <+328>:   e0 17   loopne 0x234bb1 <PTRPOSCHAR+353>
   0x00234b9a <+330>:   40      inc    eax
   0x00234b9b <+331>:   f9      stc    
   0x00234b9c <+332>:   e1 07   loope  0x234ba5 <PTRPOSCHAR+341>
   0x00234b9e <+334>:   40      inc    eax
   0x00234b9f <+335>:   f9      stc    
   0x00234ba0 <+336>:   00 00   add    BYTE PTR [eax],al
   0x00234ba2 <+338>:   01 cb   add    ebx,ecx
   0x00234ba4 <+340>:   e0 13   loopne 0x234bb9 <PTRPOSCHAR+361>
   0x00234ba6 <+342>:   00 f9   add    cl,bh

5767          exit;
   0x00234ba8 <+344>:   6a 00   push   0x0
   0x00234baa <+346>:   00 14 e0        add    BYTE PTR [eax+eiz*8],dl

5768         end;
5769         inc(CurrentChar);
   0x00234bac <+348>:   e0 17   loopne 0x234bc5 <PTRPOSCHAR+373>
   0x00234bae <+350>:   40      inc    eax
   0x00234baf <+351>:   f9      stc    
   0x00234bb0 <+352>:   00 04 00        add    BYTE PTR [eax+eax*1],al
   0x00234bb3 <+355>:   91      xchg   ecx,eax
   0x00234bb4 <+356>:   e0 17   loopne 0x234bcd <PTRPOSCHAR+381>
   0x00234bb6 <+358>:   00 f9   add    cl,bh

5770        end;
5771       end;
5772
5773       // Scan until the last whole chunk
5774       while Size>=SizeOf(TFLREPtrUInt) do begin
   0x00234bc8 <+376>:   49      dec    ecx
   0x00234bc9 <+377>:   00 00   add    BYTE PTR [eax],al
   0x00234bcb <+379>:   14 e0   adc    al,0xe0
   0x00234cec <+668>:   e0 27   loopne 0x234d15 <PTRPOSCHAR+709>
   0x00234cee <+670>:   40      inc    eax

   0x00234cef <+671>:   f9      stc    
   0x00234cf0 <+672>:   1f      pop    ds
   0x00234cf1 <+673>:   20 00   and    BYTE PTR [eax],al
   0x00234cf3 <+675>:   f1      int1   
   0x00234cf4 <+676>:   c2 f6 ff        ret    0xfff6
   0x00234cf7 <+679>:   54      push   esp

5775        XoredChunk:=CurrentChunk^ xor XorMask;
   0x00234bcc <+380>:   e0 1b   loopne 0x234be9 <PTRPOSCHAR+409>
   0x00234bce <+382>:   40      inc    eax
   0x00234bcf <+383>:   f9      stc    
   0x00234bd0 <+384>:   00 00   add    BYTE PTR [eax],al
   0x00234bd2 <+386>:   40      inc    eax
   0x00234bd3 <+387>:   f9      stc    
   0x00234bd4 <+388>:   e1 1f   loope  0x234bf5 <PTRPOSCHAR+421>
   0x00234bd6 <+390>:   40      inc    eax
   0x00234bd7 <+391>:   f9      stc    
   0x00234bd8 <+392>:   20 00   and    BYTE PTR [eax],al
   0x00234bda <+394>:   00 ca   add    dl,cl
   0x00234bdc <+396>:   e0 23   loopne 0x234c01 <PTRPOSCHAR+433>
   0x00234bde <+398>:   00 f9   add    cl,bh

5776        if (((XoredChunk+MaskA) and not XoredChunk) and MaskB)<>0 then begin
   0x00234be0 <+400>:   e1 23   loope  0x234c05 <PTRPOSCHAR+437>
   0x00234be2 <+402>:   40      inc    eax
   0x00234be3 <+403>:   f9      stc    
   0x00234be4 <+404>:   e0 c3   loopne 0x234ba9 <PTRPOSCHAR+345>
   0x00234be6 <+406>:   00 b2 21 00 00 cb       add    BYTE PTR [edx-0x34ffffdf],dh
   0x00234bec <+412>:   e0 23   loopne 0x234c11 <PTRPOSCHAR+449>
   0x00234bee <+414>:   40      inc    eax
   0x00234bef <+415>:   f9      stc    
   0x00234bf0 <+416>:   e0 03   loopne 0x234bf5 <PTRPOSCHAR+421>
   0x00234bf2 <+418>:   20 aa 00 00 01 8a       and    BYTE PTR [edx-0x75ff0000],ch
   0x00234bf8 <+424>:   00 c0   add    al,al
   0x00234bfa <+426>:   01 92 1f 00 00 f1       add    DWORD PTR [edx-0xeffffe1],edx

   0x00234c00 <+432>:   a0 06 00 54 e0  mov    al,ds:0xe0540006

5777    {$ifdef POSCHARSAFECHECK}
5778         CurrentChar:=pointer(CurrentChunk);
5779         if CurrentChar[0]=SearchChar then begin
5780          result:=TFLREPtrUInt(pointer(@CurrentChar[0]))-TFLREPtrUInt(Text);
5781          exit;
5782         end;
5783         if CurrentChar[1]=SearchChar then begin
5784          result:=TFLREPtrUInt(pointer(@CurrentChar[1]))-TFLREPtrUInt(Text);
5785          exit;
5786         end;
5787         if CurrentChar[2]=SearchChar then begin
5788          result:=TFLREPtrUInt(pointer(@CurrentChar[2]))-TFLREPtrUInt(Text);
5789          exit;
5790         end;
5791         if CurrentChar[3]=SearchChar then begin
5792          result:=TFLREPtrUInt(pointer(@CurrentChar[3]))-TFLREPtrUInt(Text);
5793          exit;
5794         end;
5795    {$ifdef cpu64}
5796         if CurrentChar[4]=SearchChar then begin
5797          result:=TFLREPtrUInt(pointer(@CurrentChar[4]))-TFLREPtrUInt(Text);
5798          exit;
5799         end;
5800         if CurrentChar[5]=Pattern then begin
5801          result:=TFLREPtrUInt(pointer(@CurrentChar[5]))-TFLREPtrUInt(Text);
5802          exit;
5803         end;
5804         if CurrentChar[6]=SearchChar then begin
5805          result:=TFLREPtrUInt(pointer(@CurrentChar[6]))-TFLREPtrUInt(Text);
5806          exit;
5807         end;
5808         if CurrentChar[7]=SearchChar then begin
5809          result:=TFLREPtrUInt(pointer(@CurrentChar[7]))-TFLREPtrUInt(Text);

5810          exit;
5811         end;
5812    {$endif}
5813    {$else}
5814         CurrentChar:=pointer({$ifdef BIG_ENDIAN}TFLREPtrUInt(TFLREPtrUInt(CurrentChunk)+TFLREPtrUInt(SizeOf(TFLREPtrUInt)-1)){$else}CurrentChunk{$endif});
   0x00234c04 <+436>:   e0 1b   loopne 0x234c21 <PTRPOSCHAR+465>
   0x00234c06 <+438>:   40      inc    eax
   0x00234c07 <+439>:   f9      stc    
   0x00234c08 <+440>:   e0 17   loopne 0x234c21 <PTRPOSCHAR+465>
   0x00234c0a <+442>:   00 f9   add    cl,bh

5815         XoredChunk:=XoredChunk xor XorMask;
   0x00234c0c <+444>:   e1 23   loope  0x234c31 <PTRPOSCHAR+481>
   0x00234c0e <+446>:   40      inc    eax
   0x00234c0f <+447>:   f9      stc    
   0x00234c10 <+448>:   e0 1f   loopne 0x234c31 <PTRPOSCHAR+481>
   0x00234c12 <+450>:   40      inc    eax
   0x00234c13 <+451>:   f9      stc    
   0x00234c14 <+452>:   00 00   add    BYTE PTR [eax],al
   0x00234c16 <+454>:   01 ca   add    edx,ecx
   0x00234c18 <+456>:   e0 23   loopne 0x234c3d <PTRPOSCHAR+493>
   0x00234c1a <+458>:   00 f9   add    cl,bh

5816         if TFLREUInt8(SearchChar)=0 then begin
   0x00234c1c <+460>:   e0 03   loopne 0x234c21 <PTRPOSCHAR+465>
   0x00234c1e <+462>:   40      inc    eax
   0x00234c1f <+463>:   39 1f   cmp    DWORD PTR [edi],ebx
   0x00234c21 <+465>:   00 00   add    BYTE PTR [eax],al
   0x00234c23 <+467>:   71 81   jno    0x234ba6 <PTRPOSCHAR+342>
   0x00234c25 <+469>:   03 00   add    eax,DWORD PTR [eax]
   0x00234c27 <+471>:   54      push   esp

5817          // Special case
5818          XoredChunk:=not XoredChunk;

   0x00234c28 <+472>:   e0 23   loopne 0x234c4d <PTRPOSCHAR+509>
   0x00234c2a <+474>:   40      inc    eax
   0x00234c2b <+475>:   f9      stc    
   0x00234c2c <+476>:   e0 03   loopne 0x234c31 <PTRPOSCHAR+481>
   0x00234c2e <+478>:   20 aa e0 23 00 f9       and    BYTE PTR [edx-0x6ffdc20],ch

5819          while (XoredChunk<>0) and ((XoredChunk and $ff)<>$ff) do begin
   0x00234c34 <+484>:   07      pop    es
   0x00234c35 <+485>:   00 00   add    BYTE PTR [eax],al
   0x00234c37 <+487>:   14 e0   adc    al,0xe0
   0x00234c50 <+512>:   e0 23   loopne 0x234c75 <PTRPOSCHAR+549>
   0x00234c52 <+514>:   40      inc    eax
   0x00234c53 <+515>:   f9      stc    
   0x00234c54 <+516>:   1f      pop    ds
   0x00234c55 <+517>:   00 00   add    BYTE PTR [eax],al
   0x00234c57 <+519>:   f1      int1   
   0x00234c58 <+520>:   e0 02   loopne 0x234c5c <PTRPOSCHAR+524>
   0x00234c5a <+522>:   00 54 e0 23     add    BYTE PTR [eax+eiz*8+0x23],dl
   0x00234c5e <+526>:   40      inc    eax
   0x00234c5f <+527>:   f9      stc    
   0x00234c60 <+528>:   00 1c 40        add    BYTE PTR [eax+eax*2],bl
   0x00234c63 <+531>:   92      xchg   edx,eax
   0x00234c64 <+532>:   1f      pop    ds
   0x00234c65 <+533>:   fc      cld    
   0x00234c66 <+534>:   03 f1   add    esi,ecx
   0x00234c68 <+536>:   60      pusha  
   0x00234c69 <+537>:   02 00   add    al,BYTE PTR [eax]
   0x00234c6b <+539>:   54      push   esp
   0x00234c6c <+540>:   f3 ff   repz (bad) 
   0x00234c6e <+542>:   ff 17   call   DWORD PTR [edi]
   0x00234c70 <+544>:   11 00   adc    DWORD PTR [eax],eax
   0x00234c72 <+546>:   00 14 10        add    BYTE PTR [eax+edx*1],dl
   0x00234c75 <+549>:   00 00   add    BYTE PTR [eax],al
   0x00234c77 <+551>:   14 07   adc    al,0x7

5820           XoredChunk:=XoredChunk shr 8;
   0x00234c38 <+488>:   e0 23   loopne 0x234c5d <PTRPOSCHAR+525>
   0x00234c3a <+490>:   40      inc    eax
   0x00234c3b <+491>:   f9      stc    
   0x00234c3c <+492>:   00 fc   add    ah,bh
   0x00234c3e <+494>:   48      dec    eax
   0x00234c3f <+495>:   d3 e0   shl    eax,cl
   0x00234c41 <+497>:   23 00   and    eax,DWORD PTR [eax]
   0x00234c43 <+499>:   f9      stc    

5821           {$ifdef BIG_ENDIAN}dec{$else}inc{$endif}(CurrentChar);
   0x00234c44 <+500>:   e0 17   loopne 0x234c5d <PTRPOSCHAR+525>
   0x00234c46 <+502>:   40      inc    eax
   0x00234c47 <+503>:   f9      stc    
   0x00234c48 <+504>:   00 04 00        add    BYTE PTR [eax+eax*1],al
   0x00234c4b <+507>:   91      xchg   ecx,eax
   0x00234c4c <+508>:   e0 17   loopne 0x234c65 <PTRPOSCHAR+533>
   0x00234c4e <+510>:   00 f9   add    cl,bh

5822          end;
5823         end else begin
5824          while (XoredChunk<>0) and ((XoredChunk and $ff)<>TFLREUInt8(SearchChar)) do begin
   0x00234c78 <+552>:   07      pop    es
   0x00234c79 <+553>:   00 00   add    BYTE PTR [eax],al
   0x00234c7b <+555>:   14 e0   adc    al,0xe0
   0x00234c94 <+580>:   e0 23   loopne 0x234cb9 <PTRPOSCHAR+617>
   0x00234c96 <+582>:   40      inc    eax
   0x00234c97 <+583>:   f9      stc    
   0x00234c98 <+584>:   1f      pop    ds
   0x00234c99 <+585>:   00 00   add    BYTE PTR [eax],al
   0x00234c9b <+587>:   f1      int1   
   0x00234c9c <+588>:   c0 00 00        rol    BYTE PTR [eax],0x0
   0x00234c9f <+591>:   54      push   esp
   0x00234ca0 <+592>:   e0 23   loopne 0x234cc5 <PTRPOSCHAR+629>
   0x00234ca2 <+594>:   40      inc    eax

   0x00234ca3 <+595>:   f9      stc    
   0x00234ca4 <+596>:   00 1c 40        add    BYTE PTR [eax+eax*2],bl
   0x00234ca7 <+599>:   92      xchg   edx,eax
   0x00234ca8 <+600>:   e1 03   loope  0x234cad <PTRPOSCHAR+605>
   0x00234caa <+602>:   40      inc    eax
   0x00234cab <+603>:   39 1f   cmp    DWORD PTR [edi],ebx
   0x00234cad <+605>:   00 01   add    BYTE PTR [ecx],al
   0x00234caf <+607>:   eb 61   jmp    0x234d12 <PTRPOSCHAR+706>
   0x00234cb1 <+609>:   fe      (bad)  
   0x00234cb2 <+610>:   ff 54 e0 23     call   DWORD PTR [eax+eiz*8+0x23]

5825           XoredChunk:=XoredChunk shr 8;
   0x00234c7c <+556>:   e0 23   loopne 0x234ca1 <PTRPOSCHAR+593>
   0x00234c7e <+558>:   40      inc    eax
   0x00234c7f <+559>:   f9      stc    
   0x00234c80 <+560>:   00 fc   add    ah,bh
   0x00234c82 <+562>:   48      dec    eax
   0x00234c83 <+563>:   d3 e0   shl    eax,cl
   0x00234c85 <+565>:   23 00   and    eax,DWORD PTR [eax]
   0x00234c87 <+567>:   f9      stc    

5826           {$ifdef BIG_ENDIAN}dec{$else}inc{$endif}(CurrentChar);
   0x00234c88 <+568>:   e0 17   loopne 0x234ca1 <PTRPOSCHAR+593>
   0x00234c8a <+570>:   40      inc    eax
   0x00234c8b <+571>:   f9      stc    
   0x00234c8c <+572>:   00 04 00        add    BYTE PTR [eax+eax*1],al
   0x00234c8f <+575>:   91      xchg   ecx,eax
   0x00234c90 <+576>:   e0 17   loopne 0x234ca9 <PTRPOSCHAR+601>
   0x00234c92 <+578>:   00 f9   add    cl,bh

5827          end;
5828         end;
5829         if XoredChunk<>0 then begin
   0x00234cb4 <+612>:   e0 23   loopne 0x234cd9 <PTRPOSCHAR+649>
   0x00234cb6 <+614>:   40      inc    eax
c
   0x00234cb7 <+615>:   f9      stc    
   0x00234cb8 <+616>:   1f      pop    ds
   0x00234cb9 <+617>:   00 00   add    BYTE PTR [eax],al
   0x00234cbb <+619>:   f1      int1   
   0x00234cbc <+620>:   c0 00 00        rol    BYTE PTR [eax],0x0
   0x00234cbf <+623>:   54      push   esp

5830          result:=TFLREPtrUInt(pointer(CurrentChar))-TFLREPtrUInt(Text);
   0x00234cc0 <+624>:   e1 17   loope  0x234cd9 <PTRPOSCHAR+649>
   0x00234cc2 <+626>:   40      inc    eax
   0x00234cc3 <+627>:   f9      stc    
   0x00234cc4 <+628>:   e0 07   loopne 0x234ccd <PTRPOSCHAR+637>
   0x00234cc6 <+630>:   40      inc    eax
   0x00234cc7 <+631>:   f9      stc    
   0x00234cc8 <+632>:   20 00   and    BYTE PTR [eax],al
   0x00234cca <+634>:   00 cb   add    bl,cl
   0x00234ccc <+636>:   e0 13   loopne 0x234ce1 <PTRPOSCHAR+657>
   0x00234cce <+638>:   00 f9   add    cl,bh

5831          exit;
   0x00234cd0 <+640>:   20 00   and    BYTE PTR [eax],al
   0x00234cd2 <+642>:   00 14 e0        add    BYTE PTR [eax+eiz*8],dl

5832         end;
5833    {$endif}
5834        end;
5835        inc(CurrentChunk);
   0x00234cd4 <+644>:   e0 1b   loopne 0x234cf1 <PTRPOSCHAR+673>
   0x00234cd6 <+646>:   40      inc    eax
   0x00234cd7 <+647>:   f9      stc    
   0x00234cd8 <+648>:   00 20   add    BYTE PTR [eax],ah
   0x00234cda <+650>:   00 91 e0 1b 00 f9       add    BYTE PTR [ecx-0x6ffe420],dl

5836        dec(Size,SizeOf(TFLREPtrUInt));
   0x00234ce0 <+656>:   e0 27   loopne 0x234d09 <PTRPOSCHAR+697>
   0x00234ce2 <+658>:   40      inc    eax
   0x00234ce3 <+659>:   f9      stc    
   0x00234ce4 <+660>:   00 20   add    BYTE PTR [eax],ah
   0x00234ce6 <+662>:   00 d1   add    cl,dl
   0x00234ce8 <+664>:   e0 27   loopne 0x234d11 <PTRPOSCHAR+705>
   0x00234cea <+666>:   00 f9   add    cl,bh

5837       end;
5838
5839       // Set chunkwise to charwise pointer
5840       CurrentChar:=pointer(CurrentChunk);
   0x00234cf8 <+680>:   e0 1b   loopne 0x234d15 <PTRPOSCHAR+709>
   0x00234cfa <+682>:   40      inc    eax
   0x00234cfb <+683>:   f9      stc    
   0x00234cfc <+684>:   e0 17   loopne 0x234d15 <PTRPOSCHAR+709>
   0x00234cfe <+686>:   00 f9   add    cl,bh

5841      end;
5842
5843      // Scan rest of the remained characters, if there are any
5844      while Size>0 do begin
   0x00234d00 <+688>:   11 00   adc    DWORD PTR [eax],eax
   0x00234d02 <+690>:   00 14 e0        add    BYTE PTR [eax+eiz*8],dl
   0x00234d44 <+756>:   e0 27   loopne 0x234d6d <PTRPOSCHARSETOF2+13>
   0x00234d46 <+758>:   40      inc    eax
   0x00234d47 <+759>:   f9      stc    
   0x00234d48 <+760>:   1f      pop    ds
   0x00234d49 <+761>:   00 00   add    BYTE PTR [eax],al
   0x00234d4b <+763>:   f1      int1   
   0x00234d4c <+764>:   c8 fd ff 54     enter  0xfffd,0x54

5845       if CurrentChar^=SearchChar then begin
   0x00234d04 <+692>:   e0 17   loopne 0x234d1d <PTRPOSCHAR+717>
   0x00234d06 <+694>:   40      inc    eax
   0x00234d07 <+695>:   f9      stc    
   0x00234d08 <+696>:   01 00   add    DWORD PTR [eax],eax
   0x00234d0a <+698>:   40      inc    eax
   0x00234d0b <+699>:   39 e0   cmp    eax,esp
   0x00234d0d <+701>:   03 40 39        add    eax,DWORD PTR [eax+0x39]
   0x00234d10 <+704>:   3f      aas    
   0x00234d11 <+705>:   00 00   add    BYTE PTR [eax],al
   0x00234d13 <+707>:   6b c1 00        imul   eax,ecx,0x0
   0x00234d16 <+710>:   00 54 e1 17     add    BYTE PTR [ecx+eiz*8+0x17],dl

5846        result:=TFLREPtrUInt(pointer(CurrentChar))-TFLREPtrUInt(Text);
   0x00234d18 <+712>:   e1 17   loope  0x234d31 <PTRPOSCHAR+737>
   0x00234d1a <+714>:   40      inc    eax
   0x00234d1b <+715>:   f9      stc    
   0x00234d1c <+716>:   e0 07   loopne 0x234d25 <PTRPOSCHAR+725>
   0x00234d1e <+718>:   40      inc    eax
   0x00234d1f <+719>:   f9      stc    
   0x00234d20 <+720>:   20 00   and    BYTE PTR [eax],al
   0x00234d22 <+722>:   00 cb   add    bl,cl
   0x00234d24 <+724>:   e0 13   loopne 0x234d39 <PTRPOSCHAR+745>
   0x00234d26 <+726>:   00 f9   add    cl,bh

5847        exit;
   0x00234d28 <+728>:   0a 00   or     al,BYTE PTR [eax]
   0x00234d2a <+730>:   00 14 e0        add    BYTE PTR [eax+eiz*8],dl

5848       end;
5849       inc(CurrentChar);
   0x00234d2c <+732>:   e0 17   loopne 0x234d45 <PTRPOSCHAR+757>
   0x00234d2e <+734>:   40      inc    eax
   0x00234d2f <+735>:   f9      stc    
   0x00234d30 <+736>:   00 04 00        add    BYTE PTR [eax+eax*1],al
   0x00234d33 <+739>:   91      xchg   ecx,eax
   0x00234d34 <+740>:   e0 17   loopne 0x234d4d <PTRPOSCHAR+765>
   0x00234d36 <+742>:   00 f9   add    cl,bh

5850       dec(Size);
   0x00234d38 <+744>:   e0 27   loopne 0x234d61 <PTRPOSCHARSETOF2+1>
   0x00234d3a <+746>:   40      inc    eax
   0x00234d3b <+747>:   f9      stc    
   0x00234d3c <+748>:   00 04 00        add    BYTE PTR [eax+eax*1],al
   0x00234d3f <+751>:   d1 e0   shl    eax,1
   0x00234d41 <+753>:   27      daa    
   0x00234d42 <+754>:   00 f9   add    cl,bh

5851      end;
5852
5853     end;
5854    end;
   0x00234d50 <+768>:   e0 13   loopne 0x234d65 <PTRPOSCHARSETOF2+5>
   0x00234d52 <+770>:   40      inc    eax
   0x00234d53 <+771>:   f9      stc    
   0x00234d54 <+772>:   bf 03 00 91 fd  mov    edi,0xfd910003
   0x00234d59 <+777>:   7b c1   jnp    0x234d1c <PTRPOSCHAR+716>
   0x00234d5b <+779>:   a8 c0   test   al,0xc0
   0x00234d5d <+781>:   03 5f d6        add    ebx,DWORD PTR [edi-0x2a]

Perhaps something is wrong with CurrentChunk

BeRo1985 commented 7 months ago

Thank you for the bug report. However, it appears there's a misunderstanding in the approach taken to diagnose the crash report. The disassembled code provided is based on the x86 architecture, which is not fully applicable to the crash context in this case. The crash occurred on a Samsung Galaxy S21 FE 5G device running Android 14 (SDK 34), which uses the ARM architecture, specifically AArch64 for 64-bit ARM processors.

To accurately diagnose the issue, one would need to analyze the crash using an AArch64 disassembler or debugger, as the x86 code and addresses will not correspond to the actual execution path or memory layout on the device where the crash was reported. Adjusting the analysis to focus on the correct architecture is essential for identifying the root cause of the SIGSEGV (Segmentation Fault).

In summary, to move forward with debugging, ensure that the analysis is performed with the correct architecture in mind, focusing on AArch64 rather than x86. This involves doing an analysis directly on the AArch64 liblclapp.so from the [whatever-stripped-away]arm64_v8a.apk file, which, in the end, is just a ZIP file with a different file extension. This approach will provide more accurate insights into the crash's root cause by examining the correct instruction set and memory addresses relevant to the device and application in question.

But, however, I'll take a look into it regarding with a prospect towards CurrentChunk.

benibela commented 6 months ago

Here is the correct disassembler (but it is the same file, you can see they both start with a9bf7bfd with reveerse endian)

0000000000234a50 <FLRE_$$_PTRPOSCHAR$CHAR$PCHAR$INT64$INT64$$INT64>:
PTRPOSCHAR():
components/pascal/import/flre/src/FLRE.pas:5727
const MaskA=TFLREPtrUInt({$ifdef cpu64}$fefefefefefefeff{$else}$fefefeff{$endif}); // it is: 0-$01010101 / 0-$0101010101010101
      MaskB=TFLREPtrUInt({$ifdef cpu64}$8080808080808080{$else}$80808080{$endif});
var CurrentChar:PFLRERawByteChar;
    CurrentChunk:pptruint;
    XorMask,XoredChunk,Size:TFLREPtrUInt;
begin
  234a50:   a9bf7bfd    stp x29, x30, [sp, #-16]!
  234a54:   910003fd    mov x29, sp
  234a58:   d10143ff    sub sp, sp, #0x50
  234a5c:   390003e0    strb    w0, [sp]
  234a60:   f90007e1    str x1, [sp, #8]
  234a64:   f9000be2    str x2, [sp, #16]
  234a68:   f9000fe3    str x3, [sp, #24]
components/pascal/import/flre/src/FLRE.pas:5728
 result:=-1;
  234a6c:   92800000    mov x0, #0xffffffffffffffff     // #-1
  234a70:   f90013e0    str x0, [sp, #32]
components/pascal/import/flre/src/FLRE.pas:5730

 Size:=TextLength-Offset;
  234a74:   f9400be0    ldr x0, [sp, #16]
  234a78:   f9400fe1    ldr x1, [sp, #24]
  234a7c:   cb010000    sub x0, x0, x1
  234a80:   f90027e0    str x0, [sp, #72]
components/pascal/import/flre/src/FLRE.pas:5731
 if (Offset<TextLength) and (TFLREPtrInt(Size)>0) then begin
  234a84:   f9400fe1    ldr x1, [sp, #24]
  234a88:   f9400be0    ldr x0, [sp, #16]
  234a8c:   eb00003f    cmp x1, x0
  234a90:   5400160a    b.ge    234d50 <FLRE_$$_PTRPOSCHAR$CHAR$PCHAR$INT64$INT64$$INT64+0x300>  // b.tcont
  234a94:   f94027e0    ldr x0, [sp, #72]
  234a98:   f100001f    cmp x0, #0x0
  234a9c:   540015ad    b.le    234d50 <FLRE_$$_PTRPOSCHAR$CHAR$PCHAR$INT64$INT64$$INT64+0x300>
components/pascal/import/flre/src/FLRE.pas:5733

  XorMask:=TFLREUInt8(SearchChar);
  234aa0:   394003e0    ldrb    w0, [sp]
  234aa4:   f9001fe0    str x0, [sp, #56]
components/pascal/import/flre/src/FLRE.pas:5734
  XorMask:=XorMask or (XorMask shl 8);
  234aa8:   f9401fe0    ldr x0, [sp, #56]
  234aac:   d378dc00    lsl x0, x0, #8
  234ab0:   f9401fe1    ldr x1, [sp, #56]
  234ab4:   aa000020    orr x0, x1, x0
  234ab8:   f9001fe0    str x0, [sp, #56]
components/pascal/import/flre/src/FLRE.pas:5735
  XorMask:=XorMask or (XorMask shl 16);
  234abc:   f9401fe0    ldr x0, [sp, #56]
  234ac0:   d370bc00    lsl x0, x0, #16
  234ac4:   f9401fe1    ldr x1, [sp, #56]
  234ac8:   aa000020    orr x0, x1, x0
  234acc:   f9001fe0    str x0, [sp, #56]
components/pascal/import/flre/src/FLRE.pas:5737
{$ifdef cpu64}
  XorMask:=XorMask or (XorMask shl 32);
  234ad0:   f9401fe0    ldr x0, [sp, #56]
  234ad4:   d3607c01    lsl x1, x0, #32
  234ad8:   f9401fe0    ldr x0, [sp, #56]
  234adc:   aa010000    orr x0, x0, x1
  234ae0:   f9001fe0    str x0, [sp, #56]
components/pascal/import/flre/src/FLRE.pas:5740
{$endif}

  CurrentChar:=@Text[Offset];
  234ae4:   f94007e1    ldr x1, [sp, #8]
  234ae8:   f9400fe0    ldr x0, [sp, #24]
  234aec:   8b000020    add x0, x1, x0
  234af0:   f90017e0    str x0, [sp, #40]
components/pascal/import/flre/src/FLRE.pas:5742

  if Size>(SizeOf(TFLREPtrUInt)*2) then begin
  234af4:   f94027e0    ldr x0, [sp, #72]
  234af8:   f100401f    cmp x0, #0x10
  234afc:   54001249    b.ls    234d44 <FLRE_$$_PTRPOSCHAR$CHAR$PCHAR$INT64$INT64$$INT64+0x2f4>  // b.plast
components/pascal/import/flre/src/FLRE.pas:5745

   // Alignment initialization
   CurrentChunk:=pointer(TFLREPtrUInt(TFLREPtrUInt(CurrentChar) and not (SizeOf(TFLREPtrUInt)-1)));
  234b00:   f94017e0    ldr x0, [sp, #40]
  234b04:   927df000    and x0, x0, #0xfffffffffffffff8
  234b08:   f9001be0    str x0, [sp, #48]
components/pascal/import/flre/src/FLRE.pas:5748

   // Try to get first chunk
   if TFLREPtrUInt(CurrentChunk)>=TFLREPtrUInt(Text) then begin
  234b0c:   f9401be0    ldr x0, [sp, #48]
  234b10:   f94007e1    ldr x1, [sp, #8]
  234b14:   eb01001f    cmp x0, x1
  234b18:   540000e3    b.cc    234b34 <FLRE_$$_PTRPOSCHAR$CHAR$PCHAR$INT64$INT64$$INT64+0xe4>  // b.lo, b.ul, b.last
components/pascal/import/flre/src/FLRE.pas:5750
    // Yes, we can the get first chunk
    XoredChunk:=CurrentChunk^ xor XorMask;
  234b1c:   f9401be0    ldr x0, [sp, #48]
  234b20:   f9400001    ldr x1, [x0]
  234b24:   f9401fe0    ldr x0, [sp, #56]
  234b28:   ca010000    eor x0, x0, x1
  234b2c:   f90023e0    str x0, [sp, #64]
  234b30:   14000002    b   234b38 <FLRE_$$_PTRPOSCHAR$CHAR$PCHAR$INT64$INT64$$INT64+0xe8>
components/pascal/import/flre/src/FLRE.pas:5753
   end else begin
    // No, so return dummy value to force to check the few first characters
    XoredChunk:=0;
  234b34:   f90023ff    str xzr, [sp, #64]
components/pascal/import/flre/src/FLRE.pas:5757
   end;

   // Jump to next chunk
   inc(CurrentChunk);
  234b38:   f9401be0    ldr x0, [sp, #48]
  234b3c:   91002000    add x0, x0, #0x8
  234b40:   f9001be0    str x0, [sp, #48]
components/pascal/import/flre/src/FLRE.pas:5760

   // Subtract the first chunk from size
   dec(TFLREPtrUInt(Size),TFLREPtrUInt(CurrentChunk)-TFLREPtrUInt(CurrentChar));
  234b44:   f9401be0    ldr x0, [sp, #48]
  234b48:   f94017e1    ldr x1, [sp, #40]
  234b4c:   cb010000    sub x0, x0, x1
  234b50:   f94027e1    ldr x1, [sp, #72]
  234b54:   cb000021    sub x1, x1, x0
  234b58:   f90027e1    str x1, [sp, #72]
components/pascal/import/flre/src/FLRE.pas:5763

   // Scan first chunk
   if (((XoredChunk+MaskA) and not XoredChunk) and MaskB)<>0 then begin
  234b5c:   f94023e0    ldr x0, [sp, #64]
  234b60:   b200c3e1    mov x1, #0x101010101010101      // #72340172838076673
  234b64:   cb010001    sub x1, x0, x1
  234b68:   f94023e0    ldr x0, [sp, #64]
  234b6c:   aa2003e0    mvn x0, x0
  234b70:   8a010000    and x0, x0, x1
  234b74:   9201c000    and x0, x0, #0x8080808080808080
  234b78:   f100001f    cmp x0, #0x0
  234b7c:   54000b80    b.eq    234cec <FLRE_$$_PTRPOSCHAR$CHAR$PCHAR$INT64$INT64$$INT64+0x29c>  // b.none
components/pascal/import/flre/src/FLRE.pas:5764
    while TFLREPtrUInt(CurrentChar)<TFLREPtrUInt(CurrentChunk) do begin
  234b80:   1400000e    b   234bb8 <FLRE_$$_PTRPOSCHAR$CHAR$PCHAR$INT64$INT64$$INT64+0x168>
components/pascal/import/flre/src/FLRE.pas:5765
     if CurrentChar^=SearchChar then begin
  234b84:   f94017e0    ldr x0, [sp, #40]
  234b88:   39400001    ldrb    w1, [x0]
  234b8c:   394003e0    ldrb    w0, [sp]
  234b90:   6b00003f    cmp w1, w0
  234b94:   540000c1    b.ne    234bac <FLRE_$$_PTRPOSCHAR$CHAR$PCHAR$INT64$INT64$$INT64+0x15c>  // b.any
components/pascal/import/flre/src/FLRE.pas:5766
      result:=TFLREPtrUInt(CurrentChar)-TFLREPtrUInt(Text);
  234b98:   f94017e0    ldr x0, [sp, #40]
  234b9c:   f94007e1    ldr x1, [sp, #8]
  234ba0:   cb010000    sub x0, x0, x1
  234ba4:   f90013e0    str x0, [sp, #32]
components/pascal/import/flre/src/FLRE.pas:5767
      exit;
  234ba8:   1400006a    b   234d50 <FLRE_$$_PTRPOSCHAR$CHAR$PCHAR$INT64$INT64$$INT64+0x300>
components/pascal/import/flre/src/FLRE.pas:5769
     end;
     inc(CurrentChar);
  234bac:   f94017e0    ldr x0, [sp, #40]
  234bb0:   91000400    add x0, x0, #0x1
  234bb4:   f90017e0    str x0, [sp, #40]
components/pascal/import/flre/src/FLRE.pas:5764
    while TFLREPtrUInt(CurrentChar)<TFLREPtrUInt(CurrentChunk) do begin
  234bb8:   f94017e0    ldr x0, [sp, #40]
  234bbc:   f9401be1    ldr x1, [sp, #48]
  234bc0:   eb01001f    cmp x0, x1
  234bc4:   54fffe03    b.cc    234b84 <FLRE_$$_PTRPOSCHAR$CHAR$PCHAR$INT64$INT64$$INT64+0x134>  // b.lo, b.ul, b.last
components/pascal/import/flre/src/FLRE.pas:5774
    end;
   end;

   // Scan until the last whole chunk
   while Size>=SizeOf(TFLREPtrUInt) do begin
  234bc8:   14000049    b   234cec <FLRE_$$_PTRPOSCHAR$CHAR$PCHAR$INT64$INT64$$INT64+0x29c>
components/pascal/import/flre/src/FLRE.pas:5775
    XoredChunk:=CurrentChunk^ xor XorMask;
  234bcc:   f9401be0    ldr x0, [sp, #48]
  234bd0:   f9400000    ldr x0, [x0]
  234bd4:   f9401fe1    ldr x1, [sp, #56]
  234bd8:   ca000020    eor x0, x1, x0
  234bdc:   f90023e0    str x0, [sp, #64]
components/pascal/import/flre/src/FLRE.pas:5776
    if (((XoredChunk+MaskA) and not XoredChunk) and MaskB)<>0 then begin
  234be0:   f94023e1    ldr x1, [sp, #64]
  234be4:   b200c3e0    mov x0, #0x101010101010101      // #72340172838076673
  234be8:   cb000021    sub x1, x1, x0
  234bec:   f94023e0    ldr x0, [sp, #64]
  234bf0:   aa2003e0    mvn x0, x0
  234bf4:   8a010000    and x0, x0, x1
  234bf8:   9201c000    and x0, x0, #0x8080808080808080
  234bfc:   f100001f    cmp x0, #0x0
  234c00:   540006a0    b.eq    234cd4 <FLRE_$$_PTRPOSCHAR$CHAR$PCHAR$INT64$INT64$$INT64+0x284>  // b.none
components/pascal/import/flre/src/FLRE.pas:5814
      result:=TFLREPtrUInt(pointer(@CurrentChar[7]))-TFLREPtrUInt(Text);
      exit;
     end;
{$endif}
{$else}
     CurrentChar:=pointer({$ifdef BIG_ENDIAN}TFLREPtrUInt(TFLREPtrUInt(CurrentChunk)+TFLREPtrUInt(SizeOf(TFLREPtrUInt)-1)){$else}CurrentChunk{$endif});
  234c04:   f9401be0    ldr x0, [sp, #48]
  234c08:   f90017e0    str x0, [sp, #40]
components/pascal/import/flre/src/FLRE.pas:5815
     XoredChunk:=XoredChunk xor XorMask;
  234c0c:   f94023e1    ldr x1, [sp, #64]
  234c10:   f9401fe0    ldr x0, [sp, #56]
  234c14:   ca010000    eor x0, x0, x1
  234c18:   f90023e0    str x0, [sp, #64]
components/pascal/import/flre/src/FLRE.pas:5816
     if TFLREUInt8(SearchChar)=0 then begin
  234c1c:   394003e0    ldrb    w0, [sp]
  234c20:   7100001f    cmp w0, #0x0
  234c24:   54000381    b.ne    234c94 <FLRE_$$_PTRPOSCHAR$CHAR$PCHAR$INT64$INT64$$INT64+0x244>  // b.any
components/pascal/import/flre/src/FLRE.pas:5818
      // Special case
      XoredChunk:=not XoredChunk;
  234c28:   f94023e0    ldr x0, [sp, #64]
  234c2c:   aa2003e0    mvn x0, x0
  234c30:   f90023e0    str x0, [sp, #64]
components/pascal/import/flre/src/FLRE.pas:5819
      while (XoredChunk<>0) and ((XoredChunk and $ff)<>$ff) do begin
  234c34:   14000007    b   234c50 <FLRE_$$_PTRPOSCHAR$CHAR$PCHAR$INT64$INT64$$INT64+0x200>
components/pascal/import/flre/src/FLRE.pas:5820
       XoredChunk:=XoredChunk shr 8;
  234c38:   f94023e0    ldr x0, [sp, #64]
  234c3c:   d348fc00    lsr x0, x0, #8
  234c40:   f90023e0    str x0, [sp, #64]
components/pascal/import/flre/src/FLRE.pas:5821
       {$ifdef BIG_ENDIAN}dec{$else}inc{$endif}(CurrentChar);
  234c44:   f94017e0    ldr x0, [sp, #40]
  234c48:   91000400    add x0, x0, #0x1
  234c4c:   f90017e0    str x0, [sp, #40]
components/pascal/import/flre/src/FLRE.pas:5819
      while (XoredChunk<>0) and ((XoredChunk and $ff)<>$ff) do begin
  234c50:   f94023e0    ldr x0, [sp, #64]
  234c54:   f100001f    cmp x0, #0x0
  234c58:   540002e0    b.eq    234cb4 <FLRE_$$_PTRPOSCHAR$CHAR$PCHAR$INT64$INT64$$INT64+0x264>  // b.none
  234c5c:   f94023e0    ldr x0, [sp, #64]
  234c60:   92401c00    and x0, x0, #0xff
  234c64:   f103fc1f    cmp x0, #0xff
  234c68:   54000260    b.eq    234cb4 <FLRE_$$_PTRPOSCHAR$CHAR$PCHAR$INT64$INT64$$INT64+0x264>  // b.none
  234c6c:   17fffff3    b   234c38 <FLRE_$$_PTRPOSCHAR$CHAR$PCHAR$INT64$INT64$$INT64+0x1e8>
  234c70:   14000011    b   234cb4 <FLRE_$$_PTRPOSCHAR$CHAR$PCHAR$INT64$INT64$$INT64+0x264>
  234c74:   14000010    b   234cb4 <FLRE_$$_PTRPOSCHAR$CHAR$PCHAR$INT64$INT64$$INT64+0x264>
components/pascal/import/flre/src/FLRE.pas:5824
      end;
     end else begin
      while (XoredChunk<>0) and ((XoredChunk and $ff)<>TFLREUInt8(SearchChar)) do begin
  234c78:   14000007    b   234c94 <FLRE_$$_PTRPOSCHAR$CHAR$PCHAR$INT64$INT64$$INT64+0x244>
components/pascal/import/flre/src/FLRE.pas:5825
       XoredChunk:=XoredChunk shr 8;
  234c7c:   f94023e0    ldr x0, [sp, #64]
  234c80:   d348fc00    lsr x0, x0, #8
  234c84:   f90023e0    str x0, [sp, #64]
components/pascal/import/flre/src/FLRE.pas:5826
       {$ifdef BIG_ENDIAN}dec{$else}inc{$endif}(CurrentChar);
  234c88:   f94017e0    ldr x0, [sp, #40]
  234c8c:   91000400    add x0, x0, #0x1
  234c90:   f90017e0    str x0, [sp, #40]
components/pascal/import/flre/src/FLRE.pas:5824
      while (XoredChunk<>0) and ((XoredChunk and $ff)<>TFLREUInt8(SearchChar)) do begin
  234c94:   f94023e0    ldr x0, [sp, #64]
  234c98:   f100001f    cmp x0, #0x0
  234c9c:   540000c0    b.eq    234cb4 <FLRE_$$_PTRPOSCHAR$CHAR$PCHAR$INT64$INT64$$INT64+0x264>  // b.none
  234ca0:   f94023e0    ldr x0, [sp, #64]
  234ca4:   92401c00    and x0, x0, #0xff
  234ca8:   394003e1    ldrb    w1, [sp]
  234cac:   eb01001f    cmp x0, x1
  234cb0:   54fffe61    b.ne    234c7c <FLRE_$$_PTRPOSCHAR$CHAR$PCHAR$INT64$INT64$$INT64+0x22c>  // b.any
components/pascal/import/flre/src/FLRE.pas:5829
      end;
     end;
     if XoredChunk<>0 then begin
  234cb4:   f94023e0    ldr x0, [sp, #64]
  234cb8:   f100001f    cmp x0, #0x0
  234cbc:   540000c0    b.eq    234cd4 <FLRE_$$_PTRPOSCHAR$CHAR$PCHAR$INT64$INT64$$INT64+0x284>  // b.none
components/pascal/import/flre/src/FLRE.pas:5830
      result:=TFLREPtrUInt(pointer(CurrentChar))-TFLREPtrUInt(Text);
  234cc0:   f94017e1    ldr x1, [sp, #40]
  234cc4:   f94007e0    ldr x0, [sp, #8]
  234cc8:   cb000020    sub x0, x1, x0
  234ccc:   f90013e0    str x0, [sp, #32]
components/pascal/import/flre/src/FLRE.pas:5831
      exit;
  234cd0:   14000020    b   234d50 <FLRE_$$_PTRPOSCHAR$CHAR$PCHAR$INT64$INT64$$INT64+0x300>
components/pascal/import/flre/src/FLRE.pas:5835
     end;
{$endif}
    end;
    inc(CurrentChunk);
  234cd4:   f9401be0    ldr x0, [sp, #48]
  234cd8:   91002000    add x0, x0, #0x8
  234cdc:   f9001be0    str x0, [sp, #48]
components/pascal/import/flre/src/FLRE.pas:5836
    dec(Size,SizeOf(TFLREPtrUInt));
  234ce0:   f94027e0    ldr x0, [sp, #72]
  234ce4:   d1002000    sub x0, x0, #0x8
  234ce8:   f90027e0    str x0, [sp, #72]
components/pascal/import/flre/src/FLRE.pas:5774
   while Size>=SizeOf(TFLREPtrUInt) do begin
  234cec:   f94027e0    ldr x0, [sp, #72]
  234cf0:   f100201f    cmp x0, #0x8
  234cf4:   54fff6c2    b.cs    234bcc <FLRE_$$_PTRPOSCHAR$CHAR$PCHAR$INT64$INT64$$INT64+0x17c>  // b.hs, b.nlast
components/pascal/import/flre/src/FLRE.pas:5840
   end;

   // Set chunkwise to charwise pointer
   CurrentChar:=pointer(CurrentChunk);
  234cf8:   f9401be0    ldr x0, [sp, #48]
  234cfc:   f90017e0    str x0, [sp, #40]
components/pascal/import/flre/src/FLRE.pas:5844
  end;

  // Scan rest of the remained characters, if there are any
  while Size>0 do begin
  234d00:   14000011    b   234d44 <FLRE_$$_PTRPOSCHAR$CHAR$PCHAR$INT64$INT64$$INT64+0x2f4>
components/pascal/import/flre/src/FLRE.pas:5845
   if CurrentChar^=SearchChar then begin
  234d04:   f94017e0    ldr x0, [sp, #40]
  234d08:   39400001    ldrb    w1, [x0]
  234d0c:   394003e0    ldrb    w0, [sp]
  234d10:   6b00003f    cmp w1, w0
  234d14:   540000c1    b.ne    234d2c <FLRE_$$_PTRPOSCHAR$CHAR$PCHAR$INT64$INT64$$INT64+0x2dc>  // b.any
components/pascal/import/flre/src/FLRE.pas:5846
    result:=TFLREPtrUInt(pointer(CurrentChar))-TFLREPtrUInt(Text);
  234d18:   f94017e1    ldr x1, [sp, #40]
  234d1c:   f94007e0    ldr x0, [sp, #8]
  234d20:   cb000020    sub x0, x1, x0
  234d24:   f90013e0    str x0, [sp, #32]
components/pascal/import/flre/src/FLRE.pas:5847
    exit;
  234d28:   1400000a    b   234d50 <FLRE_$$_PTRPOSCHAR$CHAR$PCHAR$INT64$INT64$$INT64+0x300>
components/pascal/import/flre/src/FLRE.pas:5849
   end;
   inc(CurrentChar);
  234d2c:   f94017e0    ldr x0, [sp, #40]
  234d30:   91000400    add x0, x0, #0x1
  234d34:   f90017e0    str x0, [sp, #40]
components/pascal/import/flre/src/FLRE.pas:5850
   dec(Size);
  234d38:   f94027e0    ldr x0, [sp, #72]
  234d3c:   d1000400    sub x0, x0, #0x1
  234d40:   f90027e0    str x0, [sp, #72]
components/pascal/import/flre/src/FLRE.pas:5844
  while Size>0 do begin
  234d44:   f94027e0    ldr x0, [sp, #72]
  234d48:   f100001f    cmp x0, #0x0
  234d4c:   54fffdc8    b.hi    234d04 <FLRE_$$_PTRPOSCHAR$CHAR$PCHAR$INT64$INT64$$INT64+0x2b4>  // b.pmore
components/pascal/import/flre/src/FLRE.pas:5854
  end;

 end;
end;
  234d50:   f94013e0    ldr x0, [sp, #32]
  234d54:   910003bf    mov sp, x29
  234d58:   a8c17bfd    ldp x29, x30, [sp], #16
  234d5c:   d65f03c0    ret