mirror of
https://github.com/gorhill/uBlock.git
synced 2024-09-02 09:09:38 +02:00
use WebAssembly-1.0 compliant function names
These functions were renamed in 2018, before the WebAssembly 1.0 spec
was finalized. wabt 1.0.25 dropped support for pre-1.0 names and the
sources fail to compile with errors like:
```
$ wat2wasm lz4-block-codec.wat
lz4-block-codec.wat:71:5: error: unexpected token get_local, expected ).
get_local $ilen
^^^^^^^^^
lz4-block-codec.wat:78:5: error: unexpected token get_local.
get_local $ilen
^^^^^^^^^
```
This commit is contained in:
Dominik 'Rathann' Mierzejewski
parent
7b2319b7cd
commit
798338e7fa
@ -64,92 +64,92 @@
|
||||
(local $x i32)
|
||||
(local $y i32)
|
||||
;; trie index is a uint32 offset, need to convert to uint8 offset
|
||||
get_local $icell
|
||||
local.get $icell
|
||||
i32.const 2
|
||||
i32.shl
|
||||
set_local $icell
|
||||
local.set $icell
|
||||
;; const buf32 = this.buf32;
|
||||
;; const buf8 = this.buf8;
|
||||
;; const char0 = buf32[CHAR0_SLOT];
|
||||
i32.const 2060
|
||||
i32.load align=4
|
||||
set_local $char0
|
||||
local.set $char0
|
||||
;; const aR = buf32[HAYSTACK_SIZE_SLOT];
|
||||
i32.const 2048
|
||||
i32.load align=4
|
||||
set_local $aR
|
||||
local.set $aR
|
||||
;; let al = ai;
|
||||
get_local $ai
|
||||
set_local $al
|
||||
local.get $ai
|
||||
local.set $al
|
||||
block $matchFound
|
||||
block $matchNotFound
|
||||
;; for (;;) {
|
||||
loop $mainLoop
|
||||
;; x = buf8[al];
|
||||
get_local $al
|
||||
local.get $al
|
||||
i32.load8_u
|
||||
set_local $x
|
||||
local.set $x
|
||||
;; al += 1;
|
||||
get_local $al
|
||||
local.get $al
|
||||
i32.const 1
|
||||
i32.add
|
||||
set_local $al
|
||||
local.set $al
|
||||
;; // find matching segment
|
||||
;; for (;;) {
|
||||
block $nextSegment loop $findSegment
|
||||
;; y = buf32[icell+SEGMENT_INFO];
|
||||
get_local $icell
|
||||
local.get $icell
|
||||
i32.load offset=8 align=4
|
||||
tee_local $y
|
||||
local.tee $y
|
||||
;; bl = char0 + (y & 0x00FFFFFF);
|
||||
i32.const 0x00FFFFFF
|
||||
i32.and
|
||||
get_local $char0
|
||||
local.get $char0
|
||||
i32.add
|
||||
tee_local $bl
|
||||
local.tee $bl
|
||||
;; if ( buf8[bl] === x ) {
|
||||
i32.load8_u
|
||||
get_local $x
|
||||
local.get $x
|
||||
i32.eq
|
||||
if
|
||||
;; y = (y >>> 24) - 1;
|
||||
get_local $y
|
||||
local.get $y
|
||||
i32.const 24
|
||||
i32.shr_u
|
||||
i32.const 1
|
||||
i32.sub
|
||||
tee_local $y
|
||||
local.tee $y
|
||||
;; if ( n !== 0 ) {
|
||||
if
|
||||
;; x = al + y;
|
||||
get_local $y
|
||||
get_local $al
|
||||
local.get $y
|
||||
local.get $al
|
||||
i32.add
|
||||
tee_local $x
|
||||
local.tee $x
|
||||
;; if ( x > aR ) { return 0; }
|
||||
get_local $aR
|
||||
local.get $aR
|
||||
i32.gt_u
|
||||
br_if $matchNotFound
|
||||
;; for (;;) {
|
||||
loop
|
||||
;; bl += 1;
|
||||
get_local $bl
|
||||
local.get $bl
|
||||
i32.const 1
|
||||
i32.add
|
||||
tee_local $bl
|
||||
local.tee $bl
|
||||
;; if ( buf8[bl] !== buf8[al] ) { return 0; }
|
||||
i32.load8_u
|
||||
get_local $al
|
||||
local.get $al
|
||||
i32.load8_u
|
||||
i32.ne
|
||||
br_if $matchNotFound
|
||||
;; al += 1;
|
||||
get_local $al
|
||||
local.get $al
|
||||
i32.const 1
|
||||
i32.add
|
||||
tee_local $al
|
||||
local.tee $al
|
||||
;; if ( al === x ) { break; }
|
||||
get_local $x
|
||||
local.get $x
|
||||
i32.ne
|
||||
br_if 0
|
||||
end
|
||||
@ -158,11 +158,11 @@
|
||||
br $nextSegment
|
||||
end
|
||||
;; icell = buf32[icell+CELL_OR];
|
||||
get_local $icell
|
||||
local.get $icell
|
||||
i32.load offset=4 align=4
|
||||
i32.const 2
|
||||
i32.shl
|
||||
tee_local $icell
|
||||
local.tee $icell
|
||||
;; if ( icell === 0 ) { return 0; }
|
||||
i32.eqz
|
||||
br_if $matchNotFound
|
||||
@ -171,14 +171,14 @@
|
||||
end end
|
||||
;; // next segment
|
||||
;; icell = buf32[icell+CELL_AND];
|
||||
get_local $icell
|
||||
local.get $icell
|
||||
i32.load align=4
|
||||
i32.const 2
|
||||
i32.shl
|
||||
tee_local $icell
|
||||
local.tee $icell
|
||||
;; const x = buf32[icell+BCELL_EXTRA];
|
||||
i32.load offset=8 align=4
|
||||
tee_local $x
|
||||
local.tee $x
|
||||
;; if ( x <= BCELL_EXTRA_MAX ) {
|
||||
i32.const 0x00FFFFFF
|
||||
i32.le_u
|
||||
@ -186,43 +186,43 @@
|
||||
;; if ( x !== 0 && this.matchesExtra(ai, al, x) !== 0 ) {
|
||||
;; return 1;
|
||||
;; }
|
||||
get_local $x
|
||||
local.get $x
|
||||
if
|
||||
get_local $ai
|
||||
get_local $al
|
||||
get_local $x
|
||||
local.get $ai
|
||||
local.get $al
|
||||
local.get $x
|
||||
call $matchesExtra
|
||||
br_if $matchFound
|
||||
end
|
||||
;; x = buf32[icell+BCELL_ALT_AND];
|
||||
get_local $icell
|
||||
local.get $icell
|
||||
i32.load offset=4 align=4
|
||||
i32.const 2
|
||||
i32.shl
|
||||
tee_local $x
|
||||
local.tee $x
|
||||
;; if ( x !== 0 && this.matchesLeft(x, ai, al) !== 0 ) {
|
||||
if
|
||||
get_local $x
|
||||
get_local $ai
|
||||
get_local $al
|
||||
local.get $x
|
||||
local.get $ai
|
||||
local.get $al
|
||||
call $matchesLeft
|
||||
br_if $matchFound
|
||||
;; }
|
||||
end
|
||||
;; icell = buf32[icell+BCELL_NEXT_AND];
|
||||
get_local $icell
|
||||
local.get $icell
|
||||
i32.load align=4
|
||||
i32.const 2
|
||||
i32.shl
|
||||
tee_local $icell
|
||||
local.tee $icell
|
||||
;; if ( icell === 0 ) { return 0; }
|
||||
i32.eqz
|
||||
br_if $matchNotFound
|
||||
;; }
|
||||
end
|
||||
;; if ( al === aR ) { return 0; }
|
||||
get_local $al
|
||||
get_local $aR
|
||||
local.get $al
|
||||
local.get $aR
|
||||
i32.ne
|
||||
br_if $mainLoop
|
||||
;; }
|
||||
@ -255,60 +255,60 @@
|
||||
;; const char0 = buf32[CHAR0_SLOT];
|
||||
i32.const 2060
|
||||
i32.load align=4
|
||||
set_local $char0
|
||||
local.set $char0
|
||||
block $matchFound
|
||||
block $matchNotFound
|
||||
;; for (;;) {
|
||||
loop $mainLoop
|
||||
;; if ( ar === 0 ) { return 0; }
|
||||
get_local $ar
|
||||
local.get $ar
|
||||
i32.eqz
|
||||
br_if $matchNotFound
|
||||
;; ar -= 1;
|
||||
get_local $ar
|
||||
local.get $ar
|
||||
i32.const 1
|
||||
i32.sub
|
||||
tee_local $ar
|
||||
local.tee $ar
|
||||
;; x = buf8[ar];
|
||||
i32.load8_u
|
||||
set_local $x
|
||||
local.set $x
|
||||
;; // find matching segment
|
||||
;; for (;;) {
|
||||
block $nextSegment loop $findSegment
|
||||
;; y = buf32[icell+SEGMENT_INFO];
|
||||
get_local $icell
|
||||
local.get $icell
|
||||
i32.load offset=8 align=4
|
||||
tee_local $y
|
||||
local.tee $y
|
||||
;; br = char0 + (y & 0x00FFFFFF);
|
||||
i32.const 0x00FFFFFF
|
||||
i32.and
|
||||
get_local $char0
|
||||
local.get $char0
|
||||
i32.add
|
||||
tee_local $br
|
||||
local.tee $br
|
||||
;; y = (y >>> 24) - 1;
|
||||
get_local $y
|
||||
local.get $y
|
||||
i32.const 24
|
||||
i32.shr_u
|
||||
i32.const 1
|
||||
i32.sub
|
||||
tee_local $y
|
||||
local.tee $y
|
||||
;; br += y;
|
||||
i32.add
|
||||
tee_local $br
|
||||
local.tee $br
|
||||
;; if ( buf8[br] === x ) {
|
||||
i32.load8_u
|
||||
get_local $x
|
||||
local.get $x
|
||||
i32.eq
|
||||
if
|
||||
;; // all characters in segment must match
|
||||
;; if ( y !== 0 ) {
|
||||
get_local $y
|
||||
local.get $y
|
||||
if
|
||||
;; x = ar - y;
|
||||
get_local $ar
|
||||
get_local $y
|
||||
local.get $ar
|
||||
local.get $y
|
||||
i32.sub
|
||||
tee_local $x
|
||||
local.tee $x
|
||||
;; if ( x < 0 ) { return 0; }
|
||||
i32.const 0
|
||||
i32.lt_s
|
||||
@ -317,21 +317,21 @@
|
||||
loop
|
||||
;; ar -= 1; br -= 1;
|
||||
;; if ( buf8[ar] !== buf8[br] ) { return 0; }
|
||||
get_local $ar
|
||||
local.get $ar
|
||||
i32.const 1
|
||||
i32.sub
|
||||
tee_local $ar
|
||||
local.tee $ar
|
||||
i32.load8_u
|
||||
get_local $br
|
||||
local.get $br
|
||||
i32.const 1
|
||||
i32.sub
|
||||
tee_local $br
|
||||
local.tee $br
|
||||
i32.load8_u
|
||||
i32.ne
|
||||
br_if $matchNotFound
|
||||
;; if ( ar === x ) { break; }
|
||||
get_local $ar
|
||||
get_local $x
|
||||
local.get $ar
|
||||
local.get $x
|
||||
i32.ne
|
||||
br_if 0
|
||||
end
|
||||
@ -340,11 +340,11 @@
|
||||
br $nextSegment
|
||||
end
|
||||
;; icell = buf32[icell+CELL_OR];
|
||||
get_local $icell
|
||||
local.get $icell
|
||||
i32.load offset=4 align=4
|
||||
i32.const 2
|
||||
i32.shl
|
||||
tee_local $icell
|
||||
local.tee $icell
|
||||
;; if ( icell === 0 ) { return 0; }
|
||||
i32.eqz
|
||||
br_if $matchNotFound
|
||||
@ -353,14 +353,14 @@
|
||||
end end
|
||||
;; // next segment
|
||||
;; icell = buf32[icell+CELL_AND];
|
||||
get_local $icell
|
||||
local.get $icell
|
||||
i32.load align=4
|
||||
i32.const 2
|
||||
i32.shl
|
||||
tee_local $icell
|
||||
local.tee $icell
|
||||
;; const x = buf32[icell+BCELL_EXTRA];
|
||||
i32.load offset=8 align=4
|
||||
tee_local $x
|
||||
local.tee $x
|
||||
;; if ( x <= BCELL_EXTRA_MAX ) {
|
||||
i32.const 0x00FFFFFF
|
||||
i32.le_u
|
||||
@ -368,20 +368,20 @@
|
||||
;; if ( x !== 0 && this.matchesExtra(ar, r, x) !== 0 ) {
|
||||
;; return 1;
|
||||
;; }
|
||||
get_local $x
|
||||
local.get $x
|
||||
if
|
||||
get_local $ar
|
||||
get_local $r
|
||||
get_local $x
|
||||
local.get $ar
|
||||
local.get $r
|
||||
local.get $x
|
||||
call $matchesExtra
|
||||
br_if $matchFound
|
||||
end
|
||||
;; icell = buf32[icell+BCELL_NEXT_AND];
|
||||
get_local $icell
|
||||
local.get $icell
|
||||
i32.load align=4
|
||||
i32.const 2
|
||||
i32.shl
|
||||
tee_local $icell
|
||||
local.tee $icell
|
||||
;; if ( icell === 0 ) { return 0; }
|
||||
i32.eqz
|
||||
br_if $matchNotFound
|
||||
@ -414,35 +414,35 @@
|
||||
;; if ( ix !== 1 ) {
|
||||
;; const iu = this.extraHandler(l, r, ix);
|
||||
;; if ( iu === 0 ) { return 0; }
|
||||
get_local $ix
|
||||
local.get $ix
|
||||
i32.const 1
|
||||
i32.ne
|
||||
if
|
||||
get_local $l
|
||||
get_local $r
|
||||
get_local $ix
|
||||
local.get $l
|
||||
local.get $r
|
||||
local.get $ix
|
||||
call $extraHandler
|
||||
tee_local $iu
|
||||
local.tee $iu
|
||||
i32.eqz
|
||||
br_if $fail
|
||||
;; } else {
|
||||
;; iu = -1;
|
||||
else
|
||||
i32.const -1
|
||||
set_local $iu
|
||||
local.set $iu
|
||||
;; }
|
||||
end
|
||||
;; this.buf32[RESULT_IU_SLOT] = iu;
|
||||
i32.const 2076
|
||||
get_local $iu
|
||||
local.get $iu
|
||||
i32.store align=4
|
||||
;; this.buf32[RESULT_L_SLOT] = l;
|
||||
i32.const 2068
|
||||
get_local $l
|
||||
local.get $l
|
||||
i32.store align=4
|
||||
;; this.buf32[RESULT_R_SLOT] = r;
|
||||
i32.const 2072
|
||||
get_local $r
|
||||
local.get $r
|
||||
i32.store align=4
|
||||
end ;; $succeed
|
||||
i32.const 1
|
||||
@ -470,49 +470,49 @@
|
||||
;; if ( haystackLeft < 0 || (haystackLeft + needleLen) > haystackRight ) {
|
||||
;; return 0;
|
||||
;; }
|
||||
get_local $haystackLeft
|
||||
local.get $haystackLeft
|
||||
i32.const 0
|
||||
i32.lt_s
|
||||
br_if $fail
|
||||
get_local $haystackLeft
|
||||
get_local $needleLen
|
||||
local.get $haystackLeft
|
||||
local.get $needleLen
|
||||
i32.add
|
||||
get_local $haystackRight
|
||||
local.get $haystackRight
|
||||
i32.gt_u
|
||||
br_if $fail
|
||||
;; const charCodes = this.buf8;
|
||||
;; needleLeft += this.buf32[CHAR0_SLOT];
|
||||
get_local $needleLeft
|
||||
local.get $needleLeft
|
||||
i32.const 2060 ;; CHAR0_SLOT memory address
|
||||
i32.load align=4 ;; CHAR0 memory address
|
||||
i32.add ;; needle memory address
|
||||
tee_local $needleLeft
|
||||
local.tee $needleLeft
|
||||
;; const needleRight = needleLeft + needleLen;
|
||||
get_local $needleLen
|
||||
local.get $needleLen
|
||||
i32.add
|
||||
set_local $needleRight
|
||||
local.set $needleRight
|
||||
;; while ( charCodes[haystackLeft] === charCodes[needleLeft] ) {
|
||||
loop $compare
|
||||
get_local $haystackLeft
|
||||
local.get $haystackLeft
|
||||
i32.load8_u
|
||||
get_local $needleLeft
|
||||
local.get $needleLeft
|
||||
i32.load8_u
|
||||
i32.ne
|
||||
br_if $fail
|
||||
;; needleLeft += 1;
|
||||
get_local $needleLeft
|
||||
local.get $needleLeft
|
||||
i32.const 1
|
||||
i32.add
|
||||
tee_local $needleLeft
|
||||
local.tee $needleLeft
|
||||
;; if ( needleLeft === needleRight ) { return 1; }
|
||||
get_local $needleRight
|
||||
local.get $needleRight
|
||||
i32.eq
|
||||
br_if $succeed
|
||||
;; haystackLeft += 1;
|
||||
i32.const 1
|
||||
get_local $haystackLeft
|
||||
local.get $haystackLeft
|
||||
i32.add
|
||||
set_local $haystackLeft
|
||||
local.set $haystackLeft
|
||||
br $compare
|
||||
end
|
||||
;; }
|
||||
@ -545,76 +545,76 @@
|
||||
block $fail
|
||||
block $succeed
|
||||
;; if ( needleLen === 0 ) { return haystackLeft; }
|
||||
get_local $needleLen
|
||||
local.get $needleLen
|
||||
i32.eqz
|
||||
br_if $succeed
|
||||
;; haystackEnd -= needleLen;
|
||||
get_local $haystackEnd
|
||||
get_local $needleLen
|
||||
local.get $haystackEnd
|
||||
local.get $needleLen
|
||||
i32.sub
|
||||
tee_local $haystackEnd
|
||||
local.tee $haystackEnd
|
||||
;; if ( haystackEnd < haystackLeft ) { return -1; }
|
||||
get_local $haystackLeft
|
||||
local.get $haystackLeft
|
||||
i32.lt_s
|
||||
br_if $fail
|
||||
;; needleLeft += this.buf32[CHAR0_SLOT];
|
||||
get_local $needleLeft
|
||||
local.get $needleLeft
|
||||
i32.const 2060 ;; CHAR0_SLOT memory address
|
||||
i32.load align=4 ;; CHAR0 memory address
|
||||
i32.add ;; needle memory address
|
||||
tee_local $needleLeft
|
||||
local.tee $needleLeft
|
||||
;; const needleRight = needleLeft + needleLen;
|
||||
get_local $needleLen
|
||||
local.get $needleLen
|
||||
i32.add
|
||||
set_local $needleRight
|
||||
local.set $needleRight
|
||||
;; const charCodes = this.buf8;
|
||||
;; for (;;) {
|
||||
loop $mainLoop
|
||||
;; let i = haystackLeft;
|
||||
;; let j = needleLeft;
|
||||
get_local $haystackLeft
|
||||
set_local $i
|
||||
get_local $needleLeft
|
||||
set_local $j
|
||||
local.get $haystackLeft
|
||||
local.set $i
|
||||
local.get $needleLeft
|
||||
local.set $j
|
||||
;; while ( charCodes[i] === charCodes[j] ) {
|
||||
block $breakMatchChars loop $matchChars
|
||||
get_local $i
|
||||
local.get $i
|
||||
i32.load8_u
|
||||
get_local $j
|
||||
local.get $j
|
||||
i32.load8_u
|
||||
i32.ne
|
||||
br_if $breakMatchChars
|
||||
;; j += 1;
|
||||
get_local $j
|
||||
local.get $j
|
||||
i32.const 1
|
||||
i32.add
|
||||
tee_local $j
|
||||
local.tee $j
|
||||
;; if ( j === needleRight ) { return haystackLeft; }
|
||||
get_local $needleRight
|
||||
local.get $needleRight
|
||||
i32.eq
|
||||
br_if $succeed
|
||||
;; i += 1;
|
||||
get_local $i
|
||||
local.get $i
|
||||
i32.const 1
|
||||
i32.add
|
||||
set_local $i
|
||||
local.set $i
|
||||
br $matchChars
|
||||
;; }
|
||||
end end
|
||||
;; haystackLeft += 1;
|
||||
get_local $haystackLeft
|
||||
local.get $haystackLeft
|
||||
i32.const 1
|
||||
i32.add
|
||||
tee_local $haystackLeft
|
||||
local.tee $haystackLeft
|
||||
;; if ( haystackLeft > haystackEnd ) { break; }
|
||||
get_local $haystackEnd
|
||||
local.get $haystackEnd
|
||||
i32.gt_u
|
||||
br_if $fail
|
||||
br $mainLoop
|
||||
;; }
|
||||
end
|
||||
end ;; $succeed
|
||||
get_local $haystackLeft
|
||||
local.get $haystackLeft
|
||||
return
|
||||
end ;; $fail
|
||||
;; return -1;
|
||||
@ -640,82 +640,82 @@
|
||||
(local $j i32)
|
||||
(local $c0 i32)
|
||||
;; if ( needleLen === 0 ) { return haystackBeg; }
|
||||
get_local $needleLen
|
||||
local.get $needleLen
|
||||
i32.eqz
|
||||
if
|
||||
get_local $haystackBeg
|
||||
local.get $haystackBeg
|
||||
return
|
||||
end
|
||||
block $fail
|
||||
block $succeed
|
||||
;; let haystackLeft = haystackEnd - needleLen;
|
||||
get_local $haystackEnd
|
||||
get_local $needleLen
|
||||
local.get $haystackEnd
|
||||
local.get $needleLen
|
||||
i32.sub
|
||||
tee_local $haystackLeft
|
||||
local.tee $haystackLeft
|
||||
;; if ( haystackLeft < haystackBeg ) { return -1; }
|
||||
get_local $haystackBeg
|
||||
local.get $haystackBeg
|
||||
i32.lt_s
|
||||
br_if $fail
|
||||
;; needleLeft += this.buf32[CHAR0_SLOT];
|
||||
get_local $needleLeft
|
||||
local.get $needleLeft
|
||||
i32.const 2060 ;; CHAR0_SLOT memory address
|
||||
i32.load align=4 ;; CHAR0 memory address
|
||||
i32.add ;; needle memory address
|
||||
tee_local $needleLeft
|
||||
local.tee $needleLeft
|
||||
;; const needleRight = needleLeft + needleLen;
|
||||
get_local $needleLen
|
||||
local.get $needleLen
|
||||
i32.add
|
||||
set_local $needleRight
|
||||
local.set $needleRight
|
||||
;; const charCodes = this.buf8;
|
||||
;; for (;;) {
|
||||
loop $mainLoop
|
||||
;; let i = haystackLeft;
|
||||
;; let j = needleLeft;
|
||||
get_local $haystackLeft
|
||||
set_local $i
|
||||
get_local $needleLeft
|
||||
set_local $j
|
||||
local.get $haystackLeft
|
||||
local.set $i
|
||||
local.get $needleLeft
|
||||
local.set $j
|
||||
;; while ( charCodes[i] === charCodes[j] ) {
|
||||
block $breakMatchChars loop $matchChars
|
||||
get_local $i
|
||||
local.get $i
|
||||
i32.load8_u
|
||||
get_local $j
|
||||
local.get $j
|
||||
i32.load8_u
|
||||
i32.ne
|
||||
br_if $breakMatchChars
|
||||
;; j += 1;
|
||||
get_local $j
|
||||
local.get $j
|
||||
i32.const 1
|
||||
i32.add
|
||||
tee_local $j
|
||||
local.tee $j
|
||||
;; if ( j === needleRight ) { return haystackLeft; }
|
||||
get_local $needleRight
|
||||
local.get $needleRight
|
||||
i32.eq
|
||||
br_if $succeed
|
||||
;; i += 1;
|
||||
get_local $i
|
||||
local.get $i
|
||||
i32.const 1
|
||||
i32.add
|
||||
set_local $i
|
||||
local.set $i
|
||||
br $matchChars
|
||||
;; }
|
||||
end end
|
||||
;; if ( haystackLeft === haystackBeg ) { break; }
|
||||
;; haystackLeft -= 1;
|
||||
get_local $haystackLeft
|
||||
get_local $haystackBeg
|
||||
local.get $haystackLeft
|
||||
local.get $haystackBeg
|
||||
i32.eq
|
||||
br_if $fail
|
||||
get_local $haystackLeft
|
||||
local.get $haystackLeft
|
||||
i32.const 1
|
||||
i32.sub
|
||||
set_local $haystackLeft
|
||||
local.set $haystackLeft
|
||||
br $mainLoop
|
||||
;; }
|
||||
end
|
||||
end ;; $succeed
|
||||
get_local $haystackLeft
|
||||
local.get $haystackLeft
|
||||
return
|
||||
end ;; $fail
|
||||
;; return -1;
|
||||
|
||||
@ -64,19 +64,19 @@
|
||||
;;
|
||||
i32.const 264 ;; start of char section is stored at addr 264
|
||||
i32.load
|
||||
set_local $char0
|
||||
local.set $char0
|
||||
;; let ineedle = this.buf[255];
|
||||
i32.const 255 ;; addr of needle is stored at addr 255
|
||||
i32.load8_u
|
||||
set_local $ineedle
|
||||
local.set $ineedle
|
||||
;; let icell = this.buf32[iroot+0];
|
||||
get_local $iroot
|
||||
local.get $iroot
|
||||
i32.const 2
|
||||
i32.shl
|
||||
i32.load
|
||||
i32.const 2
|
||||
i32.shl
|
||||
tee_local $icell
|
||||
local.tee $icell
|
||||
;; if ( icell === 0 ) { return -1; }
|
||||
i32.eqz
|
||||
if
|
||||
@ -86,43 +86,43 @@
|
||||
;; for (;;) {
|
||||
block $noSegment loop $nextSegment
|
||||
;; if ( ineedle === 0 ) { return -1; }
|
||||
get_local $ineedle
|
||||
local.get $ineedle
|
||||
i32.eqz
|
||||
if
|
||||
i32.const -1
|
||||
return
|
||||
end
|
||||
;; ineedle -= 1;
|
||||
get_local $ineedle
|
||||
local.get $ineedle
|
||||
i32.const -1
|
||||
i32.add
|
||||
tee_local $ineedle
|
||||
local.tee $ineedle
|
||||
;; let c = this.buf[ineedle];
|
||||
i32.load8_u
|
||||
set_local $c
|
||||
local.set $c
|
||||
;; for (;;) {
|
||||
block $foundSegment loop $findSegment
|
||||
;; v = this.buf32[icell+2];
|
||||
get_local $icell
|
||||
local.get $icell
|
||||
i32.load offset=8
|
||||
tee_local $v
|
||||
local.tee $v
|
||||
;; i0 = char0 + (v >>> 8);
|
||||
i32.const 8
|
||||
i32.shr_u
|
||||
get_local $char0
|
||||
local.get $char0
|
||||
i32.add
|
||||
tee_local $i0
|
||||
local.tee $i0
|
||||
;; if ( this.buf[i0] === c ) { break; }
|
||||
i32.load8_u
|
||||
get_local $c
|
||||
local.get $c
|
||||
i32.eq
|
||||
br_if $foundSegment
|
||||
;; icell = this.buf32[icell+0];
|
||||
get_local $icell
|
||||
local.get $icell
|
||||
i32.load
|
||||
i32.const 2
|
||||
i32.shl
|
||||
tee_local $icell
|
||||
local.tee $icell
|
||||
i32.eqz
|
||||
if
|
||||
i32.const -1
|
||||
@ -131,44 +131,44 @@
|
||||
br 0
|
||||
end end
|
||||
;; let n = v & 0x7F;
|
||||
get_local $v
|
||||
local.get $v
|
||||
i32.const 0x7F
|
||||
i32.and
|
||||
tee_local $n
|
||||
local.tee $n
|
||||
;; if ( n > 1 ) {
|
||||
i32.const 1
|
||||
i32.gt_u
|
||||
if
|
||||
;; n -= 1;
|
||||
get_local $n
|
||||
local.get $n
|
||||
i32.const -1
|
||||
i32.add
|
||||
tee_local $n
|
||||
local.tee $n
|
||||
;; if ( n > ineedle ) { return -1; }
|
||||
get_local $ineedle
|
||||
local.get $ineedle
|
||||
i32.gt_u
|
||||
if
|
||||
i32.const -1
|
||||
return
|
||||
end
|
||||
get_local $i0
|
||||
local.get $i0
|
||||
i32.const 1
|
||||
i32.add
|
||||
tee_local $i0
|
||||
local.tee $i0
|
||||
;; const i1 = i0 + n;
|
||||
get_local $n
|
||||
local.get $n
|
||||
i32.add
|
||||
set_local $i1
|
||||
local.set $i1
|
||||
;; do {
|
||||
loop
|
||||
;; ineedle -= 1;
|
||||
get_local $ineedle
|
||||
local.get $ineedle
|
||||
i32.const -1
|
||||
i32.add
|
||||
tee_local $ineedle
|
||||
local.tee $ineedle
|
||||
;; if ( this.buf[i0] !== this.buf[ineedle] ) { return -1; }
|
||||
i32.load8_u
|
||||
get_local $i0
|
||||
local.get $i0
|
||||
i32.load8_u
|
||||
i32.ne
|
||||
if
|
||||
@ -176,47 +176,47 @@
|
||||
return
|
||||
end
|
||||
;; i0 += 1;
|
||||
get_local $i0
|
||||
local.get $i0
|
||||
i32.const 1
|
||||
i32.add
|
||||
tee_local $i0
|
||||
local.tee $i0
|
||||
;; } while ( i0 < i1 );
|
||||
get_local $i1
|
||||
local.get $i1
|
||||
i32.lt_u
|
||||
br_if 0
|
||||
end
|
||||
end
|
||||
;; if ( (v & 0x80) !== 0 ) {
|
||||
get_local $v
|
||||
local.get $v
|
||||
i32.const 0x80
|
||||
i32.and
|
||||
if
|
||||
;; if ( ineedle === 0 || buf8[ineedle-1] === 0x2E /* '.' */ ) {
|
||||
;; return ineedle;
|
||||
;; }
|
||||
get_local $ineedle
|
||||
local.get $ineedle
|
||||
i32.eqz
|
||||
if
|
||||
i32.const 0
|
||||
return
|
||||
end
|
||||
get_local $ineedle
|
||||
local.get $ineedle
|
||||
i32.const -1
|
||||
i32.add
|
||||
i32.load8_u
|
||||
i32.const 0x2E
|
||||
i32.eq
|
||||
if
|
||||
get_local $ineedle
|
||||
local.get $ineedle
|
||||
return
|
||||
end
|
||||
end
|
||||
;; icell = this.buf32[icell+1];
|
||||
get_local $icell
|
||||
local.get $icell
|
||||
i32.load offset=4
|
||||
i32.const 2
|
||||
i32.shl
|
||||
tee_local $icell
|
||||
local.tee $icell
|
||||
;; if ( icell === 0 ) { break; }
|
||||
br_if 0
|
||||
end end
|
||||
@ -245,7 +245,7 @@
|
||||
;; let lhnchar = this.buf[255];
|
||||
i32.const 255
|
||||
i32.load8_u
|
||||
tee_local $lhnchar
|
||||
local.tee $lhnchar
|
||||
;; if ( lhnchar === 0 ) { return 0; }
|
||||
i32.eqz
|
||||
if
|
||||
@ -281,21 +281,21 @@
|
||||
end
|
||||
end
|
||||
;; let icell = this.buf32[iroot+0];
|
||||
get_local $iroot
|
||||
local.get $iroot
|
||||
i32.const 2
|
||||
i32.shl
|
||||
tee_local $iroot
|
||||
local.tee $iroot
|
||||
i32.load
|
||||
i32.const 2
|
||||
i32.shl
|
||||
tee_local $icell
|
||||
local.tee $icell
|
||||
;; if ( this.buf32[icell+2] === 0 ) {
|
||||
i32.eqz
|
||||
if
|
||||
;; this.buf32[iroot+0] = this.addLeafCell(lhnchar);
|
||||
;; return 1;
|
||||
get_local $iroot
|
||||
get_local $lhnchar
|
||||
local.get $iroot
|
||||
local.get $lhnchar
|
||||
call $addLeafCell
|
||||
i32.store
|
||||
i32.const 1
|
||||
@ -304,37 +304,37 @@
|
||||
;; const char0 = this.buf32[HNBIGTRIE_CHAR0_SLOT];
|
||||
i32.const 264
|
||||
i32.load
|
||||
set_local $char0
|
||||
local.set $char0
|
||||
;; for (;;) {
|
||||
loop $nextSegment
|
||||
;; const v = this.buf32[icell+2];
|
||||
get_local $icell
|
||||
local.get $icell
|
||||
i32.load offset=8
|
||||
tee_local $v
|
||||
local.tee $v
|
||||
;; let isegchar0 = char0 + (v >>> 8);
|
||||
i32.const 8
|
||||
i32.shr_u
|
||||
get_local $char0
|
||||
local.get $char0
|
||||
i32.add
|
||||
tee_local $isegchar0
|
||||
local.tee $isegchar0
|
||||
;; if ( this.buf[isegchar0] !== this.buf[lhnchar-1] ) {
|
||||
i32.load8_u
|
||||
get_local $lhnchar
|
||||
local.get $lhnchar
|
||||
i32.const -1
|
||||
i32.add
|
||||
i32.load8_u
|
||||
i32.ne
|
||||
if
|
||||
;; inext = this.buf32[icell+0];
|
||||
get_local $icell
|
||||
local.get $icell
|
||||
i32.load
|
||||
tee_local $inext
|
||||
local.tee $inext
|
||||
;; if ( inext === 0 ) {
|
||||
i32.eqz
|
||||
if
|
||||
;; this.buf32[icell+0] = this.addLeafCell(lhnchar);
|
||||
get_local $icell
|
||||
get_local $lhnchar
|
||||
local.get $icell
|
||||
local.get $lhnchar
|
||||
call $addLeafCell
|
||||
i32.store
|
||||
;; return 1;
|
||||
@ -342,25 +342,25 @@
|
||||
return
|
||||
end
|
||||
;; icell = inext;
|
||||
get_local $inext
|
||||
local.get $inext
|
||||
i32.const 2
|
||||
i32.shl
|
||||
set_local $icell
|
||||
local.set $icell
|
||||
br $nextSegment
|
||||
end
|
||||
;; let isegchar = 1;
|
||||
i32.const 1
|
||||
set_local $isegchar
|
||||
local.set $isegchar
|
||||
;; lhnchar -= 1;
|
||||
get_local $lhnchar
|
||||
local.get $lhnchar
|
||||
i32.const -1
|
||||
i32.add
|
||||
set_local $lhnchar
|
||||
local.set $lhnchar
|
||||
;; const lsegchar = v & 0x7F;
|
||||
get_local $v
|
||||
local.get $v
|
||||
i32.const 0x7F
|
||||
i32.and
|
||||
tee_local $lsegchar
|
||||
local.tee $lsegchar
|
||||
;; if ( lsegchar !== 1 ) {
|
||||
i32.const 1
|
||||
i32.ne
|
||||
@ -368,69 +368,69 @@
|
||||
;; for (;;) {
|
||||
block $mismatch loop
|
||||
;; if ( isegchar === lsegchar ) { break; }
|
||||
get_local $isegchar
|
||||
get_local $lsegchar
|
||||
local.get $isegchar
|
||||
local.get $lsegchar
|
||||
i32.eq
|
||||
br_if $mismatch
|
||||
get_local $lhnchar
|
||||
local.get $lhnchar
|
||||
i32.eqz
|
||||
br_if $mismatch
|
||||
;; if ( this.buf[isegchar0+isegchar] !== this.buf[lhnchar-1] ) { break; }
|
||||
get_local $isegchar0
|
||||
get_local $isegchar
|
||||
local.get $isegchar0
|
||||
local.get $isegchar
|
||||
i32.add
|
||||
i32.load8_u
|
||||
get_local $lhnchar
|
||||
local.get $lhnchar
|
||||
i32.const -1
|
||||
i32.add
|
||||
i32.load8_u
|
||||
i32.ne
|
||||
br_if $mismatch
|
||||
;; isegchar += 1;
|
||||
get_local $isegchar
|
||||
local.get $isegchar
|
||||
i32.const 1
|
||||
i32.add
|
||||
set_local $isegchar
|
||||
local.set $isegchar
|
||||
;; lhnchar -= 1;
|
||||
get_local $lhnchar
|
||||
local.get $lhnchar
|
||||
i32.const -1
|
||||
i32.add
|
||||
set_local $lhnchar
|
||||
local.set $lhnchar
|
||||
br 0
|
||||
end end
|
||||
end
|
||||
;; const boundaryBit = v & 0x80;
|
||||
get_local $v
|
||||
local.get $v
|
||||
i32.const 0x80
|
||||
i32.and
|
||||
set_local $boundaryBit
|
||||
local.set $boundaryBit
|
||||
;; if ( isegchar === lsegchar ) {
|
||||
get_local $isegchar
|
||||
get_local $lsegchar
|
||||
local.get $isegchar
|
||||
local.get $lsegchar
|
||||
i32.eq
|
||||
if
|
||||
;; if ( lhnchar === 0 ) {
|
||||
get_local $lhnchar
|
||||
local.get $lhnchar
|
||||
i32.eqz
|
||||
if
|
||||
;; if ( boundaryBit !== 0 ) { return 0; }
|
||||
get_local $boundaryBit
|
||||
local.get $boundaryBit
|
||||
if
|
||||
i32.const 0
|
||||
return
|
||||
end
|
||||
;; this.buf32[icell+2] = v | 0x80;
|
||||
get_local $icell
|
||||
get_local $v
|
||||
local.get $icell
|
||||
local.get $v
|
||||
i32.const 0x80
|
||||
i32.or
|
||||
i32.store offset=8
|
||||
else
|
||||
;; if ( boundaryBit !== 0 ) {
|
||||
get_local $boundaryBit
|
||||
local.get $boundaryBit
|
||||
if
|
||||
;; if ( this.buf[lhnchar-1] === 0x2E /* '.' */ ) { return -1; }
|
||||
get_local $lhnchar
|
||||
local.get $lhnchar
|
||||
i32.const -1
|
||||
i32.add
|
||||
i32.load8_u
|
||||
@ -442,36 +442,36 @@
|
||||
end
|
||||
end
|
||||
;; inext = this.buf32[icell+1];
|
||||
get_local $icell
|
||||
local.get $icell
|
||||
i32.load offset=4
|
||||
tee_local $inext
|
||||
local.tee $inext
|
||||
;; if ( inext !== 0 ) {
|
||||
if
|
||||
;; icell = inext;
|
||||
get_local $inext
|
||||
local.get $inext
|
||||
i32.const 2
|
||||
i32.shl
|
||||
set_local $icell
|
||||
local.set $icell
|
||||
;; continue;
|
||||
br $nextSegment
|
||||
end
|
||||
;; this.buf32[icell+1] = this.addLeafCell(lhnchar);
|
||||
get_local $icell
|
||||
get_local $lhnchar
|
||||
local.get $icell
|
||||
local.get $lhnchar
|
||||
call $addLeafCell
|
||||
i32.store offset=4
|
||||
end
|
||||
else
|
||||
;; isegchar0 -= char0;
|
||||
get_local $icell
|
||||
get_local $isegchar0
|
||||
get_local $char0
|
||||
local.get $icell
|
||||
local.get $isegchar0
|
||||
local.get $char0
|
||||
i32.sub
|
||||
tee_local $isegchar0
|
||||
local.tee $isegchar0
|
||||
;; this.buf32[icell+2] = isegchar0 << 8 | isegchar;
|
||||
i32.const 8
|
||||
i32.shl
|
||||
get_local $isegchar
|
||||
local.get $isegchar
|
||||
i32.or
|
||||
i32.store offset=8
|
||||
;; inext = this.addCell(
|
||||
@ -479,39 +479,39 @@
|
||||
;; this.buf32[icell+1],
|
||||
;; isegchar0 + isegchar << 8 | boundaryBit | lsegchar - isegchar
|
||||
;; );
|
||||
get_local $icell
|
||||
local.get $icell
|
||||
i32.const 0
|
||||
get_local $icell
|
||||
local.get $icell
|
||||
i32.load offset=4
|
||||
get_local $isegchar0
|
||||
get_local $isegchar
|
||||
local.get $isegchar0
|
||||
local.get $isegchar
|
||||
i32.add
|
||||
i32.const 8
|
||||
i32.shl
|
||||
get_local $boundaryBit
|
||||
local.get $boundaryBit
|
||||
i32.or
|
||||
get_local $lsegchar
|
||||
get_local $isegchar
|
||||
local.get $lsegchar
|
||||
local.get $isegchar
|
||||
i32.sub
|
||||
i32.or
|
||||
call $addCell
|
||||
tee_local $inext
|
||||
local.tee $inext
|
||||
;; this.buf32[icell+1] = inext;
|
||||
i32.store offset=4
|
||||
;; if ( lhnchar !== 0 ) {
|
||||
get_local $lhnchar
|
||||
local.get $lhnchar
|
||||
if
|
||||
;; this.buf32[inext+0] = this.addLeafCell(lhnchar);
|
||||
get_local $inext
|
||||
local.get $inext
|
||||
i32.const 2
|
||||
i32.shl
|
||||
get_local $lhnchar
|
||||
local.get $lhnchar
|
||||
call $addLeafCell
|
||||
i32.store
|
||||
else
|
||||
;; this.buf32[icell+2] |= 0x80;
|
||||
get_local $icell
|
||||
get_local $icell
|
||||
local.get $icell
|
||||
local.get $icell
|
||||
i32.load offset=8
|
||||
i32.const 0x80
|
||||
i32.or
|
||||
@ -547,24 +547,24 @@
|
||||
i32.const 260
|
||||
i32.const 260
|
||||
i32.load
|
||||
tee_local $icell
|
||||
local.tee $icell
|
||||
i32.const 12
|
||||
i32.add
|
||||
i32.store
|
||||
;; this.buf32[icell+0] = idown;
|
||||
get_local $icell
|
||||
get_local $idown
|
||||
local.get $icell
|
||||
local.get $idown
|
||||
i32.store
|
||||
;; this.buf32[icell+1] = iright;
|
||||
get_local $icell
|
||||
get_local $iright
|
||||
local.get $icell
|
||||
local.get $iright
|
||||
i32.store offset=4
|
||||
;; this.buf32[icell+2] = v;
|
||||
get_local $icell
|
||||
get_local $v
|
||||
local.get $icell
|
||||
local.get $v
|
||||
i32.store offset=8
|
||||
;; return icell;
|
||||
get_local $icell
|
||||
local.get $icell
|
||||
i32.const 2
|
||||
i32.shr_u
|
||||
)
|
||||
@ -582,58 +582,58 @@
|
||||
;; const r = this.buf32[TRIE1_SLOT] >>> 2;
|
||||
i32.const 260
|
||||
i32.load
|
||||
tee_local $r
|
||||
local.tee $r
|
||||
;; let i = r;
|
||||
set_local $i
|
||||
local.set $i
|
||||
;; while ( lsegchar > 127 ) {
|
||||
block $lastSegment loop
|
||||
get_local $lsegchar
|
||||
local.get $lsegchar
|
||||
i32.const 127
|
||||
i32.le_u
|
||||
br_if $lastSegment
|
||||
;; this.buf32[i+0] = 0;
|
||||
get_local $i
|
||||
local.get $i
|
||||
i32.const 0
|
||||
i32.store
|
||||
;; this.buf32[i+1] = i + 3;
|
||||
get_local $i
|
||||
get_local $i
|
||||
local.get $i
|
||||
local.get $i
|
||||
i32.const 12
|
||||
i32.add
|
||||
i32.const 2
|
||||
i32.shr_u
|
||||
i32.store offset=4
|
||||
;; this.buf32[i+2] = this.addSegment(lsegchar, lsegchar - 127);
|
||||
get_local $i
|
||||
get_local $lsegchar
|
||||
get_local $lsegchar
|
||||
local.get $i
|
||||
local.get $lsegchar
|
||||
local.get $lsegchar
|
||||
i32.const 127
|
||||
i32.sub
|
||||
call $addSegment
|
||||
i32.store offset=8
|
||||
;; lsegchar -= 127;
|
||||
get_local $lsegchar
|
||||
local.get $lsegchar
|
||||
i32.const 127
|
||||
i32.sub
|
||||
set_local $lsegchar
|
||||
local.set $lsegchar
|
||||
;; i += 3;
|
||||
get_local $i
|
||||
local.get $i
|
||||
i32.const 12
|
||||
i32.add
|
||||
set_local $i
|
||||
local.set $i
|
||||
br 0
|
||||
end end
|
||||
;; this.buf32[i+0] = 0;
|
||||
get_local $i
|
||||
local.get $i
|
||||
i32.const 0
|
||||
i32.store
|
||||
;; this.buf32[i+1] = 0;
|
||||
get_local $i
|
||||
local.get $i
|
||||
i32.const 0
|
||||
i32.store offset=4
|
||||
;; this.buf32[i+2] = this.addSegment(lsegchar, 0) | 0x80;
|
||||
get_local $i
|
||||
get_local $lsegchar
|
||||
local.get $i
|
||||
local.get $lsegchar
|
||||
i32.const 0
|
||||
call $addSegment
|
||||
i32.const 0x80
|
||||
@ -641,12 +641,12 @@
|
||||
i32.store offset=8
|
||||
;; this.buf32[TRIE1_SLOT] = i + 3 << 2;
|
||||
i32.const 260
|
||||
get_local $i
|
||||
local.get $i
|
||||
i32.const 12
|
||||
i32.add
|
||||
i32.store
|
||||
;; return r;
|
||||
get_local $r
|
||||
local.get $r
|
||||
i32.const 2
|
||||
i32.shr_u
|
||||
)
|
||||
@ -666,7 +666,7 @@
|
||||
(local $i i32) ;; iterator
|
||||
;;
|
||||
;; if ( lsegchar === 0 ) { return 0; }
|
||||
get_local $lsegchar
|
||||
local.get $lsegchar
|
||||
i32.eqz
|
||||
if
|
||||
i32.const 0
|
||||
@ -675,45 +675,45 @@
|
||||
;; let char1 = this.buf32[HNBIGTRIE_CHAR1_SLOT];
|
||||
i32.const 268
|
||||
i32.load
|
||||
tee_local $char1
|
||||
local.tee $char1
|
||||
;; const isegchar = char1 - this.buf32[HNBIGTRIE_CHAR0_SLOT];
|
||||
i32.const 264
|
||||
i32.load
|
||||
i32.sub
|
||||
set_local $isegchar
|
||||
local.set $isegchar
|
||||
;; let i = lsegchar;
|
||||
get_local $lsegchar
|
||||
set_local $i
|
||||
local.get $lsegchar
|
||||
local.set $i
|
||||
;; do {
|
||||
loop
|
||||
;; this.buf[char1++] = this.buf[--i];
|
||||
get_local $char1
|
||||
get_local $i
|
||||
local.get $char1
|
||||
local.get $i
|
||||
i32.const -1
|
||||
i32.add
|
||||
tee_local $i
|
||||
local.tee $i
|
||||
i32.load8_u
|
||||
i32.store8
|
||||
get_local $char1
|
||||
local.get $char1
|
||||
i32.const 1
|
||||
i32.add
|
||||
set_local $char1
|
||||
local.set $char1
|
||||
;; } while ( i !== lsegend );
|
||||
get_local $i
|
||||
get_local $lsegend
|
||||
local.get $i
|
||||
local.get $lsegend
|
||||
i32.ne
|
||||
br_if 0
|
||||
end
|
||||
;; this.buf32[HNBIGTRIE_CHAR1_SLOT] = char1;
|
||||
i32.const 268
|
||||
get_local $char1
|
||||
local.get $char1
|
||||
i32.store
|
||||
;; return isegchar << 8 | lsegchar - lsegend;
|
||||
get_local $isegchar
|
||||
local.get $isegchar
|
||||
i32.const 8
|
||||
i32.shl
|
||||
get_local $lsegchar
|
||||
get_local $lsegend
|
||||
local.get $lsegchar
|
||||
local.get $lsegend
|
||||
i32.sub
|
||||
i32.or
|
||||
)
|
||||
|
||||
@ -68,15 +68,15 @@
|
||||
(func (export "lz4BlockEncodeBound")
|
||||
(param $ilen i32)
|
||||
(result i32)
|
||||
get_local $ilen
|
||||
local.get $ilen
|
||||
i32.const 0x7E000000
|
||||
i32.gt_u
|
||||
if
|
||||
i32.const 0
|
||||
return
|
||||
end
|
||||
get_local $ilen
|
||||
get_local $ilen
|
||||
local.get $ilen
|
||||
local.get $ilen
|
||||
i32.const 255
|
||||
i32.div_u
|
||||
i32.add
|
||||
@ -123,14 +123,14 @@
|
||||
(local $llen i32) ;; length of found literals
|
||||
(local $moffset i32) ;; offset to found match from current input position
|
||||
(local $mlen i32) ;; length of found match
|
||||
get_local $ilen ;; empty input = empty output
|
||||
local.get $ilen ;; empty input = empty output
|
||||
i32.const 0x7E000000 ;; max input size: 0x7E000000
|
||||
i32.gt_u
|
||||
if
|
||||
i32.const 0
|
||||
return
|
||||
end
|
||||
get_local $ilen ;; "blocks < 13 bytes cannot be compressed"
|
||||
local.get $ilen ;; "blocks < 13 bytes cannot be compressed"
|
||||
i32.const 13
|
||||
i32.lt_u
|
||||
if
|
||||
@ -138,78 +138,78 @@
|
||||
return
|
||||
end
|
||||
call $getLinearMemoryOffset ;; hash table is at start of usable memory
|
||||
set_local $hashPtrBeg
|
||||
get_local $inPtr
|
||||
tee_local $anchorPtr
|
||||
get_local $ilen
|
||||
local.set $hashPtrBeg
|
||||
local.get $inPtr
|
||||
local.tee $anchorPtr
|
||||
local.get $ilen
|
||||
i32.add
|
||||
tee_local $inPtrEnd
|
||||
local.tee $inPtrEnd
|
||||
i32.const -5 ;; "The last 5 bytes are always literals."
|
||||
i32.add
|
||||
tee_local $inPtrEnd2
|
||||
local.tee $inPtrEnd2
|
||||
i32.const -7 ;; "The last match must start at least 12 bytes before end of block"
|
||||
i32.add
|
||||
set_local $inPtrEnd1
|
||||
get_local $outPtr
|
||||
set_local $outPtrBeg
|
||||
local.set $inPtrEnd1
|
||||
local.get $outPtr
|
||||
local.set $outPtrBeg
|
||||
;;
|
||||
;; sequence processing loop
|
||||
;;
|
||||
block $noMoreSequence loop $nextSequence
|
||||
get_local $inPtr
|
||||
get_local $inPtrEnd1
|
||||
local.get $inPtr
|
||||
local.get $inPtrEnd1
|
||||
i32.ge_u ;; 5 or less bytes left?
|
||||
br_if $noMoreSequence
|
||||
get_local $inPtr ;; first sequence of 3 bytes before match-finding loop
|
||||
local.get $inPtr ;; first sequence of 3 bytes before match-finding loop
|
||||
i32.load8_u
|
||||
i32.const 8
|
||||
i32.shl
|
||||
get_local $inPtr
|
||||
local.get $inPtr
|
||||
i32.load8_u offset=1
|
||||
i32.const 16
|
||||
i32.shl
|
||||
i32.or
|
||||
get_local $inPtr
|
||||
local.get $inPtr
|
||||
i32.load8_u offset=2
|
||||
i32.const 24
|
||||
i32.shl
|
||||
i32.or
|
||||
set_local $seq32
|
||||
local.set $seq32
|
||||
;;
|
||||
;; match-finding loop
|
||||
;;
|
||||
loop $findMatch block $noMatchFound
|
||||
get_local $inPtr
|
||||
get_local $inPtrEnd2
|
||||
local.get $inPtr
|
||||
local.get $inPtrEnd2
|
||||
i32.gt_u ;; less than 12 bytes left?
|
||||
br_if $noMoreSequence
|
||||
get_local $seq32 ;; update last byte of current sequence
|
||||
local.get $seq32 ;; update last byte of current sequence
|
||||
i32.const 8
|
||||
i32.shr_u
|
||||
get_local $inPtr
|
||||
local.get $inPtr
|
||||
i32.load8_u offset=3
|
||||
i32.const 24
|
||||
i32.shl
|
||||
i32.or
|
||||
tee_local $seq32
|
||||
local.tee $seq32
|
||||
i32.const 0x9E3779B1 ;; compute 16-bit hash
|
||||
i32.mul
|
||||
i32.const 16
|
||||
i32.shr_u ;; hash value is at top of stack
|
||||
i32.const 2 ;; lookup refPtr at hash entry
|
||||
i32.shl
|
||||
get_local $hashPtrBeg
|
||||
local.get $hashPtrBeg
|
||||
i32.add
|
||||
tee_local $hashPtr
|
||||
local.tee $hashPtr
|
||||
i32.load
|
||||
set_local $refPtr
|
||||
get_local $hashPtr ;; update hash entry with inPtr
|
||||
get_local $inPtr
|
||||
local.set $refPtr
|
||||
local.get $hashPtr ;; update hash entry with inPtr
|
||||
local.get $inPtr
|
||||
i32.store
|
||||
get_local $inPtr
|
||||
get_local $refPtr
|
||||
local.get $inPtr
|
||||
local.get $refPtr
|
||||
i32.sub
|
||||
tee_local $moffset ;; remember match offset, we will need it in case of match
|
||||
local.tee $moffset ;; remember match offset, we will need it in case of match
|
||||
i32.const 0xFFFF
|
||||
i32.gt_s ;; match offset > 65535 = unusable match
|
||||
br_if $noMatchFound
|
||||
@ -217,177 +217,177 @@
|
||||
;; confirm match: different sequences can yield same hash
|
||||
;; compare-branch each byte to potentially save memory read ops
|
||||
;;
|
||||
get_local $seq32 ;; byte 0
|
||||
local.get $seq32 ;; byte 0
|
||||
i32.const 0xFF
|
||||
i32.and
|
||||
get_local $refPtr
|
||||
local.get $refPtr
|
||||
i32.load8_u
|
||||
i32.ne ;; refPtr[0] !== inPtr[0]
|
||||
br_if $noMatchFound
|
||||
get_local $seq32 ;; byte 1
|
||||
local.get $seq32 ;; byte 1
|
||||
i32.const 8
|
||||
i32.shr_u
|
||||
i32.const 0xFF
|
||||
i32.and
|
||||
get_local $refPtr
|
||||
local.get $refPtr
|
||||
i32.load8_u offset=1
|
||||
i32.ne
|
||||
br_if $noMatchFound ;; refPtr[1] !== inPtr[1]
|
||||
get_local $seq32 ;; byte 2
|
||||
local.get $seq32 ;; byte 2
|
||||
i32.const 16
|
||||
i32.shr_u
|
||||
i32.const 0xFF
|
||||
i32.and
|
||||
get_local $refPtr
|
||||
local.get $refPtr
|
||||
i32.load8_u offset=2
|
||||
i32.ne ;; refPtr[2] !== inPtr[2]
|
||||
br_if $noMatchFound
|
||||
get_local $seq32 ;; byte 3
|
||||
local.get $seq32 ;; byte 3
|
||||
i32.const 24
|
||||
i32.shr_u
|
||||
i32.const 0xFF
|
||||
i32.and
|
||||
get_local $refPtr
|
||||
local.get $refPtr
|
||||
i32.load8_u offset=3
|
||||
i32.ne ;; refPtr[3] !== inPtr[3]
|
||||
br_if $noMatchFound
|
||||
;;
|
||||
;; a valid match has been found at this point
|
||||
;;
|
||||
get_local $inPtr ;; compute length of literals
|
||||
get_local $anchorPtr
|
||||
local.get $inPtr ;; compute length of literals
|
||||
local.get $anchorPtr
|
||||
i32.sub
|
||||
set_local $llen
|
||||
get_local $inPtr ;; find match length
|
||||
local.set $llen
|
||||
local.get $inPtr ;; find match length
|
||||
i32.const 4 ;; skip over confirmed 4-byte match
|
||||
i32.add
|
||||
set_local $inPtr
|
||||
get_local $refPtr
|
||||
local.set $inPtr
|
||||
local.get $refPtr
|
||||
i32.const 4
|
||||
i32.add
|
||||
tee_local $mlen ;; remember refPtr to later compute match length
|
||||
set_local $refPtr
|
||||
local.tee $mlen ;; remember refPtr to later compute match length
|
||||
local.set $refPtr
|
||||
block $endOfMatch loop ;; scan input buffer until match ends
|
||||
get_local $inPtr
|
||||
get_local $inPtrEnd2
|
||||
local.get $inPtr
|
||||
local.get $inPtrEnd2
|
||||
i32.ge_u
|
||||
br_if $endOfMatch
|
||||
get_local $inPtr
|
||||
local.get $inPtr
|
||||
i32.load8_u
|
||||
get_local $refPtr
|
||||
local.get $refPtr
|
||||
i32.load8_u
|
||||
i32.ne
|
||||
br_if $endOfMatch
|
||||
get_local $inPtr
|
||||
local.get $inPtr
|
||||
i32.const 1
|
||||
i32.add
|
||||
set_local $inPtr
|
||||
get_local $refPtr
|
||||
local.set $inPtr
|
||||
local.get $refPtr
|
||||
i32.const 1
|
||||
i32.add
|
||||
set_local $refPtr
|
||||
local.set $refPtr
|
||||
br 0
|
||||
end end $endOfMatch
|
||||
;; encode token
|
||||
get_local $outPtr ;; output token
|
||||
get_local $llen
|
||||
get_local $refPtr
|
||||
get_local $mlen
|
||||
local.get $outPtr ;; output token
|
||||
local.get $llen
|
||||
local.get $refPtr
|
||||
local.get $mlen
|
||||
i32.sub
|
||||
tee_local $mlen
|
||||
local.tee $mlen
|
||||
call $writeToken
|
||||
get_local $outPtr
|
||||
local.get $outPtr
|
||||
i32.const 1
|
||||
i32.add
|
||||
set_local $outPtr
|
||||
get_local $llen ;; encode/write length of literals if needed
|
||||
local.set $outPtr
|
||||
local.get $llen ;; encode/write length of literals if needed
|
||||
i32.const 15
|
||||
i32.ge_s
|
||||
if
|
||||
get_local $outPtr
|
||||
get_local $llen
|
||||
local.get $outPtr
|
||||
local.get $llen
|
||||
call $writeLength
|
||||
set_local $outPtr
|
||||
local.set $outPtr
|
||||
end
|
||||
;; copy literals
|
||||
get_local $outPtr
|
||||
get_local $anchorPtr
|
||||
get_local $llen
|
||||
local.get $outPtr
|
||||
local.get $anchorPtr
|
||||
local.get $llen
|
||||
call $copy
|
||||
get_local $outPtr
|
||||
get_local $llen
|
||||
local.get $outPtr
|
||||
local.get $llen
|
||||
i32.add
|
||||
set_local $outPtr
|
||||
local.set $outPtr
|
||||
;; encode match offset
|
||||
get_local $outPtr
|
||||
get_local $moffset
|
||||
local.get $outPtr
|
||||
local.get $moffset
|
||||
i32.store8
|
||||
get_local $outPtr
|
||||
get_local $moffset
|
||||
local.get $outPtr
|
||||
local.get $moffset
|
||||
i32.const 8
|
||||
i32.shr_u
|
||||
i32.store8 offset=1
|
||||
get_local $outPtr
|
||||
local.get $outPtr
|
||||
i32.const 2
|
||||
i32.add
|
||||
set_local $outPtr
|
||||
get_local $mlen ;; encode/write length of match if needed
|
||||
local.set $outPtr
|
||||
local.get $mlen ;; encode/write length of match if needed
|
||||
i32.const 15
|
||||
i32.ge_s
|
||||
if
|
||||
get_local $outPtr
|
||||
get_local $mlen
|
||||
local.get $outPtr
|
||||
local.get $mlen
|
||||
call $writeLength
|
||||
set_local $outPtr
|
||||
local.set $outPtr
|
||||
end
|
||||
get_local $inPtr ;; advance anchor to current position
|
||||
set_local $anchorPtr
|
||||
local.get $inPtr ;; advance anchor to current position
|
||||
local.set $anchorPtr
|
||||
br $nextSequence
|
||||
end $noMatchFound
|
||||
get_local $inPtr ;; no match found: advance to next byte
|
||||
local.get $inPtr ;; no match found: advance to next byte
|
||||
i32.const 1
|
||||
i32.add
|
||||
set_local $inPtr
|
||||
local.set $inPtr
|
||||
br $findMatch end ;; match offset > 65535 = unusable match
|
||||
end end $noMoreSequence
|
||||
;;
|
||||
;; generate last (match-less) sequence if compression succeeded
|
||||
;;
|
||||
get_local $outPtr
|
||||
get_local $outPtrBeg
|
||||
local.get $outPtr
|
||||
local.get $outPtrBeg
|
||||
i32.eq
|
||||
if
|
||||
i32.const 0
|
||||
return
|
||||
end
|
||||
get_local $outPtr
|
||||
get_local $inPtrEnd
|
||||
get_local $anchorPtr
|
||||
local.get $outPtr
|
||||
local.get $inPtrEnd
|
||||
local.get $anchorPtr
|
||||
i32.sub
|
||||
tee_local $llen
|
||||
local.tee $llen
|
||||
i32.const 0
|
||||
call $writeToken
|
||||
get_local $outPtr
|
||||
local.get $outPtr
|
||||
i32.const 1
|
||||
i32.add
|
||||
set_local $outPtr
|
||||
get_local $llen
|
||||
local.set $outPtr
|
||||
local.get $llen
|
||||
i32.const 15
|
||||
i32.ge_u
|
||||
if
|
||||
get_local $outPtr
|
||||
get_local $llen
|
||||
local.get $outPtr
|
||||
local.get $llen
|
||||
call $writeLength
|
||||
set_local $outPtr
|
||||
local.set $outPtr
|
||||
end
|
||||
get_local $outPtr
|
||||
get_local $anchorPtr
|
||||
get_local $llen
|
||||
local.get $outPtr
|
||||
local.get $anchorPtr
|
||||
local.get $llen
|
||||
call $copy
|
||||
get_local $outPtr ;; return number of written bytes
|
||||
get_local $llen
|
||||
local.get $outPtr ;; return number of written bytes
|
||||
local.get $llen
|
||||
i32.add
|
||||
get_local $outPtrBeg
|
||||
local.get $outPtrBeg
|
||||
i32.sub
|
||||
)
|
||||
|
||||
@ -413,128 +413,128 @@
|
||||
(local $token i32) ;; sequence token
|
||||
(local $clen i32) ;; number of bytes to copy
|
||||
(local $_ i32) ;; general purpose variable
|
||||
get_local $ilen ;; if ( ilen == 0 ) { return 0; }
|
||||
local.get $ilen ;; if ( ilen == 0 ) { return 0; }
|
||||
i32.eqz
|
||||
if
|
||||
i32.const 0
|
||||
return
|
||||
end
|
||||
get_local $inPtr0
|
||||
tee_local $inPtr ;; current position in input buffer
|
||||
get_local $ilen
|
||||
local.get $inPtr0
|
||||
local.tee $inPtr ;; current position in input buffer
|
||||
local.get $ilen
|
||||
i32.add
|
||||
set_local $inPtrEnd
|
||||
get_local $outPtr0 ;; start of output buffer
|
||||
set_local $outPtr ;; current position in output buffer
|
||||
local.set $inPtrEnd
|
||||
local.get $outPtr0 ;; start of output buffer
|
||||
local.set $outPtr ;; current position in output buffer
|
||||
block $noMoreSequence loop ;; iterate through all sequences
|
||||
get_local $inPtr
|
||||
get_local $inPtrEnd
|
||||
local.get $inPtr
|
||||
local.get $inPtrEnd
|
||||
i32.ge_u
|
||||
br_if $noMoreSequence ;; break when nothing left to read in input buffer
|
||||
get_local $inPtr ;; read token -- consume one byte
|
||||
local.get $inPtr ;; read token -- consume one byte
|
||||
i32.load8_u
|
||||
get_local $inPtr
|
||||
local.get $inPtr
|
||||
i32.const 1
|
||||
i32.add
|
||||
set_local $inPtr
|
||||
tee_local $token ;; extract length of literals from token
|
||||
local.set $inPtr
|
||||
local.tee $token ;; extract length of literals from token
|
||||
i32.const 4
|
||||
i32.shr_u
|
||||
tee_local $clen ;; consume extra length bytes if present
|
||||
local.tee $clen ;; consume extra length bytes if present
|
||||
i32.eqz
|
||||
if else
|
||||
get_local $clen
|
||||
local.get $clen
|
||||
i32.const 15
|
||||
i32.eq
|
||||
if loop
|
||||
get_local $inPtr
|
||||
local.get $inPtr
|
||||
i32.load8_u
|
||||
get_local $inPtr
|
||||
local.get $inPtr
|
||||
i32.const 1
|
||||
i32.add
|
||||
set_local $inPtr
|
||||
tee_local $_
|
||||
get_local $clen
|
||||
local.set $inPtr
|
||||
local.tee $_
|
||||
local.get $clen
|
||||
i32.add
|
||||
set_local $clen
|
||||
get_local $_
|
||||
local.set $clen
|
||||
local.get $_
|
||||
i32.const 255
|
||||
i32.eq
|
||||
br_if 0
|
||||
end end
|
||||
get_local $outPtr ;; copy literals to ouput buffer
|
||||
get_local $inPtr
|
||||
get_local $clen
|
||||
local.get $outPtr ;; copy literals to ouput buffer
|
||||
local.get $inPtr
|
||||
local.get $clen
|
||||
call $copy
|
||||
get_local $outPtr ;; advance output buffer pointer past copy
|
||||
get_local $clen
|
||||
local.get $outPtr ;; advance output buffer pointer past copy
|
||||
local.get $clen
|
||||
i32.add
|
||||
set_local $outPtr
|
||||
get_local $clen ;; advance input buffer pointer past literals
|
||||
get_local $inPtr
|
||||
local.set $outPtr
|
||||
local.get $clen ;; advance input buffer pointer past literals
|
||||
local.get $inPtr
|
||||
i32.add
|
||||
tee_local $inPtr
|
||||
get_local $inPtrEnd ;; exit if this is the last sequence
|
||||
local.tee $inPtr
|
||||
local.get $inPtrEnd ;; exit if this is the last sequence
|
||||
i32.eq
|
||||
br_if $noMoreSequence
|
||||
end
|
||||
get_local $outPtr ;; read match offset
|
||||
get_local $inPtr
|
||||
local.get $outPtr ;; read match offset
|
||||
local.get $inPtr
|
||||
i32.load8_u
|
||||
get_local $inPtr
|
||||
local.get $inPtr
|
||||
i32.load8_u offset=1
|
||||
i32.const 8
|
||||
i32.shl
|
||||
i32.or
|
||||
i32.sub
|
||||
tee_local $matchPtr
|
||||
get_local $outPtr ;; match position can't be outside input buffer bounds
|
||||
local.tee $matchPtr
|
||||
local.get $outPtr ;; match position can't be outside input buffer bounds
|
||||
i32.eq
|
||||
br_if $noMoreSequence
|
||||
get_local $matchPtr
|
||||
get_local $inPtrEnd
|
||||
local.get $matchPtr
|
||||
local.get $inPtrEnd
|
||||
i32.lt_u
|
||||
br_if $noMoreSequence
|
||||
get_local $inPtr ;; advance input pointer past match offset bytes
|
||||
local.get $inPtr ;; advance input pointer past match offset bytes
|
||||
i32.const 2
|
||||
i32.add
|
||||
set_local $inPtr
|
||||
get_local $token ;; extract length of match from token
|
||||
local.set $inPtr
|
||||
local.get $token ;; extract length of match from token
|
||||
i32.const 15
|
||||
i32.and
|
||||
i32.const 4
|
||||
i32.add
|
||||
tee_local $clen
|
||||
local.tee $clen
|
||||
i32.const 19 ;; consume extra length bytes if present
|
||||
i32.eq
|
||||
if loop
|
||||
get_local $inPtr
|
||||
local.get $inPtr
|
||||
i32.load8_u
|
||||
get_local $inPtr
|
||||
local.get $inPtr
|
||||
i32.const 1
|
||||
i32.add
|
||||
set_local $inPtr
|
||||
tee_local $_
|
||||
get_local $clen
|
||||
local.set $inPtr
|
||||
local.tee $_
|
||||
local.get $clen
|
||||
i32.add
|
||||
set_local $clen
|
||||
get_local $_
|
||||
local.set $clen
|
||||
local.get $_
|
||||
i32.const 255
|
||||
i32.eq
|
||||
br_if 0
|
||||
end end
|
||||
get_local $outPtr ;; copy match to ouput buffer
|
||||
get_local $matchPtr
|
||||
get_local $clen
|
||||
local.get $outPtr ;; copy match to ouput buffer
|
||||
local.get $matchPtr
|
||||
local.get $clen
|
||||
call $copy
|
||||
get_local $clen ;; advance output buffer pointer past copy
|
||||
get_local $outPtr
|
||||
local.get $clen ;; advance output buffer pointer past copy
|
||||
local.get $outPtr
|
||||
i32.add
|
||||
set_local $outPtr
|
||||
local.set $outPtr
|
||||
br 0
|
||||
end end $noMoreSequence
|
||||
get_local $outPtr ;; return number of written bytes
|
||||
get_local $outPtr0
|
||||
local.get $outPtr ;; return number of written bytes
|
||||
local.get $outPtr0
|
||||
i32.sub
|
||||
)
|
||||
|
||||
@ -552,18 +552,18 @@
|
||||
(param $outPtr i32)
|
||||
(param $llen i32)
|
||||
(param $mlen i32)
|
||||
get_local $outPtr
|
||||
get_local $llen
|
||||
local.get $outPtr
|
||||
local.get $llen
|
||||
i32.const 15
|
||||
get_local $llen
|
||||
local.get $llen
|
||||
i32.const 15
|
||||
i32.lt_u
|
||||
select
|
||||
i32.const 4
|
||||
i32.shl
|
||||
get_local $mlen
|
||||
local.get $mlen
|
||||
i32.const 15
|
||||
get_local $mlen
|
||||
local.get $mlen
|
||||
i32.const 15
|
||||
i32.lt_u
|
||||
select
|
||||
@ -582,32 +582,32 @@
|
||||
(param $outPtr i32)
|
||||
(param $len i32)
|
||||
(result i32)
|
||||
get_local $len
|
||||
local.get $len
|
||||
i32.const 15
|
||||
i32.sub
|
||||
set_local $len
|
||||
local.set $len
|
||||
loop
|
||||
get_local $outPtr
|
||||
get_local $len
|
||||
local.get $outPtr
|
||||
local.get $len
|
||||
i32.const 255
|
||||
get_local $len
|
||||
local.get $len
|
||||
i32.const 255
|
||||
i32.lt_u
|
||||
select
|
||||
i32.store8
|
||||
get_local $outPtr
|
||||
local.get $outPtr
|
||||
i32.const 1
|
||||
i32.add
|
||||
set_local $outPtr
|
||||
get_local $len
|
||||
local.set $outPtr
|
||||
local.get $len
|
||||
i32.const 255
|
||||
i32.sub
|
||||
tee_local $len
|
||||
local.tee $len
|
||||
i32.const 0
|
||||
i32.ge_s
|
||||
br_if 0
|
||||
end
|
||||
get_local $outPtr
|
||||
local.get $outPtr
|
||||
)
|
||||
|
||||
;;
|
||||
@ -621,119 +621,119 @@
|
||||
(param $src i32)
|
||||
(param $len i32)
|
||||
block $lessThan8 loop
|
||||
get_local $len
|
||||
local.get $len
|
||||
i32.const 8
|
||||
i32.lt_u
|
||||
br_if $lessThan8
|
||||
get_local $dst
|
||||
get_local $src
|
||||
local.get $dst
|
||||
local.get $src
|
||||
i32.load8_u
|
||||
i32.store8
|
||||
get_local $dst
|
||||
get_local $src
|
||||
local.get $dst
|
||||
local.get $src
|
||||
i32.load8_u offset=1
|
||||
i32.store8 offset=1
|
||||
get_local $dst
|
||||
get_local $src
|
||||
local.get $dst
|
||||
local.get $src
|
||||
i32.load8_u offset=2
|
||||
i32.store8 offset=2
|
||||
get_local $dst
|
||||
get_local $src
|
||||
local.get $dst
|
||||
local.get $src
|
||||
i32.load8_u offset=3
|
||||
i32.store8 offset=3
|
||||
get_local $dst
|
||||
get_local $src
|
||||
local.get $dst
|
||||
local.get $src
|
||||
i32.load8_u offset=4
|
||||
i32.store8 offset=4
|
||||
get_local $dst
|
||||
get_local $src
|
||||
local.get $dst
|
||||
local.get $src
|
||||
i32.load8_u offset=5
|
||||
i32.store8 offset=5
|
||||
get_local $dst
|
||||
get_local $src
|
||||
local.get $dst
|
||||
local.get $src
|
||||
i32.load8_u offset=6
|
||||
i32.store8 offset=6
|
||||
get_local $dst
|
||||
get_local $src
|
||||
local.get $dst
|
||||
local.get $src
|
||||
i32.load8_u offset=7
|
||||
i32.store8 offset=7
|
||||
get_local $dst
|
||||
local.get $dst
|
||||
i32.const 8
|
||||
i32.add
|
||||
set_local $dst
|
||||
get_local $src
|
||||
local.set $dst
|
||||
local.get $src
|
||||
i32.const 8
|
||||
i32.add
|
||||
set_local $src
|
||||
get_local $len
|
||||
local.set $src
|
||||
local.get $len
|
||||
i32.const -8
|
||||
i32.add
|
||||
set_local $len
|
||||
local.set $len
|
||||
br 0
|
||||
end end $lessThan8
|
||||
get_local $len
|
||||
local.get $len
|
||||
i32.const 4
|
||||
i32.ge_u
|
||||
if
|
||||
get_local $dst
|
||||
get_local $src
|
||||
local.get $dst
|
||||
local.get $src
|
||||
i32.load8_u
|
||||
i32.store8
|
||||
get_local $dst
|
||||
get_local $src
|
||||
local.get $dst
|
||||
local.get $src
|
||||
i32.load8_u offset=1
|
||||
i32.store8 offset=1
|
||||
get_local $dst
|
||||
get_local $src
|
||||
local.get $dst
|
||||
local.get $src
|
||||
i32.load8_u offset=2
|
||||
i32.store8 offset=2
|
||||
get_local $dst
|
||||
get_local $src
|
||||
local.get $dst
|
||||
local.get $src
|
||||
i32.load8_u offset=3
|
||||
i32.store8 offset=3
|
||||
get_local $dst
|
||||
local.get $dst
|
||||
i32.const 4
|
||||
i32.add
|
||||
set_local $dst
|
||||
get_local $src
|
||||
local.set $dst
|
||||
local.get $src
|
||||
i32.const 4
|
||||
i32.add
|
||||
set_local $src
|
||||
get_local $len
|
||||
local.set $src
|
||||
local.get $len
|
||||
i32.const -4
|
||||
i32.add
|
||||
set_local $len
|
||||
local.set $len
|
||||
end
|
||||
get_local $len
|
||||
local.get $len
|
||||
i32.const 2
|
||||
i32.ge_u
|
||||
if
|
||||
get_local $dst
|
||||
get_local $src
|
||||
local.get $dst
|
||||
local.get $src
|
||||
i32.load8_u
|
||||
i32.store8
|
||||
get_local $dst
|
||||
get_local $src
|
||||
local.get $dst
|
||||
local.get $src
|
||||
i32.load8_u offset=1
|
||||
i32.store8 offset=1
|
||||
get_local $dst
|
||||
local.get $dst
|
||||
i32.const 2
|
||||
i32.add
|
||||
set_local $dst
|
||||
get_local $src
|
||||
local.set $dst
|
||||
local.get $src
|
||||
i32.const 2
|
||||
i32.add
|
||||
set_local $src
|
||||
get_local $len
|
||||
local.set $src
|
||||
local.get $len
|
||||
i32.const -2
|
||||
i32.add
|
||||
set_local $len
|
||||
local.set $len
|
||||
end
|
||||
get_local $len
|
||||
local.get $len
|
||||
i32.eqz
|
||||
if else
|
||||
get_local $dst
|
||||
get_local $src
|
||||
local.get $dst
|
||||
local.get $src
|
||||
i32.load8_u
|
||||
i32.store8
|
||||
end
|
||||
|
||||
@ -83,133 +83,133 @@
|
||||
;; const iCharData = buf32[CHARDATA_PTR_SLOT];
|
||||
i32.const 404
|
||||
i32.load
|
||||
set_local $iCharData
|
||||
local.set $iCharData
|
||||
;; let iNode = pslBuffer32[RULES_PTR_SLOT];
|
||||
i32.const 400
|
||||
i32.load
|
||||
i32.const 2
|
||||
i32.shl
|
||||
set_local $iNode
|
||||
local.set $iNode
|
||||
;; let iLabel = LABEL_INDICES_SLOT;
|
||||
i32.const 256
|
||||
set_local $iLabel
|
||||
local.set $iLabel
|
||||
;; let cursorPos = -1;
|
||||
i32.const -1
|
||||
set_local $cursorPos
|
||||
local.set $cursorPos
|
||||
;; label-lookup loop
|
||||
;; for (;;) {
|
||||
block $labelLookupDone loop $labelLookup
|
||||
;; // Extract label indices
|
||||
;; const labelBeg = buf8[iLabel+1];
|
||||
;; const labelLen = buf8[iLabel+0] - labelBeg;
|
||||
get_local $iLabel
|
||||
local.get $iLabel
|
||||
i32.load8_u
|
||||
get_local $iLabel
|
||||
local.get $iLabel
|
||||
i32.load8_u offset=1
|
||||
tee_local $labelBeg
|
||||
local.tee $labelBeg
|
||||
i32.sub
|
||||
set_local $labelLen
|
||||
local.set $labelLen
|
||||
;; // Match-lookup loop: binary search
|
||||
;; let r = buf32[iNode+0] >>> 16;
|
||||
;; if ( r === 0 ) { break; }
|
||||
get_local $iNode
|
||||
local.get $iNode
|
||||
i32.load16_u offset=2
|
||||
tee_local $r
|
||||
local.tee $r
|
||||
i32.eqz
|
||||
br_if $labelLookupDone
|
||||
;; const iCandidates = buf32[iNode+2];
|
||||
get_local $iNode
|
||||
local.get $iNode
|
||||
i32.load offset=8
|
||||
i32.const 2
|
||||
i32.shl
|
||||
set_local $iCandidates
|
||||
local.set $iCandidates
|
||||
;; let l = 0;
|
||||
;; let iFound = 0;
|
||||
i32.const 0
|
||||
tee_local $l
|
||||
set_local $iFound
|
||||
local.tee $l
|
||||
local.set $iFound
|
||||
;; while ( l < r ) {
|
||||
block $binarySearchDone loop $binarySearch
|
||||
get_local $l
|
||||
get_local $r
|
||||
local.get $l
|
||||
local.get $r
|
||||
i32.ge_u
|
||||
br_if $binarySearchDone
|
||||
;; const iCandidate = l + r >>> 1;
|
||||
get_local $l
|
||||
get_local $r
|
||||
local.get $l
|
||||
local.get $r
|
||||
i32.add
|
||||
i32.const 1
|
||||
i32.shr_u
|
||||
tee_local $iCandidate
|
||||
local.tee $iCandidate
|
||||
;; const iCandidateNode = iCandidates + iCandidate + (iCandidate << 1);
|
||||
i32.const 2
|
||||
i32.shl
|
||||
tee_local $_1
|
||||
get_local $_1
|
||||
local.tee $_1
|
||||
local.get $_1
|
||||
i32.const 1
|
||||
i32.shl
|
||||
i32.add
|
||||
get_local $iCandidates
|
||||
local.get $iCandidates
|
||||
i32.add
|
||||
tee_local $iCandidateNode
|
||||
local.tee $iCandidateNode
|
||||
;; const candidateLen = buf32[iCandidateNode+0] & 0x000000FF;
|
||||
i32.load8_u
|
||||
set_local $candidateLen
|
||||
local.set $candidateLen
|
||||
;; let d = labelLen - candidateLen;
|
||||
get_local $labelLen
|
||||
get_local $candidateLen
|
||||
local.get $labelLen
|
||||
local.get $candidateLen
|
||||
i32.sub
|
||||
tee_local $d
|
||||
local.tee $d
|
||||
;; if ( d === 0 ) {
|
||||
i32.eqz
|
||||
if
|
||||
;; const iCandidateChar = candidateLen <= 4
|
||||
get_local $candidateLen
|
||||
local.get $candidateLen
|
||||
i32.const 4
|
||||
i32.le_u
|
||||
if
|
||||
;; ? iCandidateNode + 1 << 2
|
||||
get_local $iCandidateNode
|
||||
local.get $iCandidateNode
|
||||
i32.const 4
|
||||
i32.add
|
||||
set_local $iCandidateChar
|
||||
local.set $iCandidateChar
|
||||
else
|
||||
;; : buf32[CHARDATA_PTR_SLOT] + buf32[iCandidateNode+1];
|
||||
get_local $iCharData
|
||||
get_local $iCandidateNode
|
||||
local.get $iCharData
|
||||
local.get $iCandidateNode
|
||||
i32.load offset=4
|
||||
i32.add
|
||||
set_local $iCandidateChar
|
||||
local.set $iCandidateChar
|
||||
end
|
||||
;; for ( let i = 0; i < labelLen; i++ ) {
|
||||
get_local $labelBeg
|
||||
tee_local $_1
|
||||
get_local $labelLen
|
||||
local.get $labelBeg
|
||||
local.tee $_1
|
||||
local.get $labelLen
|
||||
i32.add
|
||||
set_local $_3
|
||||
get_local $iCandidateChar
|
||||
set_local $_2
|
||||
local.set $_3
|
||||
local.get $iCandidateChar
|
||||
local.set $_2
|
||||
block $findDiffDone loop $findDiff
|
||||
;; d = buf8[labelBeg+i] - buf8[iCandidateChar+i];
|
||||
;; if ( d !== 0 ) { break; }
|
||||
get_local $_1
|
||||
local.get $_1
|
||||
i32.load8_u
|
||||
get_local $_2
|
||||
local.get $_2
|
||||
i32.load8_u
|
||||
i32.sub
|
||||
tee_local $d
|
||||
local.tee $d
|
||||
br_if $findDiffDone
|
||||
get_local $_1
|
||||
local.get $_1
|
||||
i32.const 1
|
||||
i32.add
|
||||
tee_local $_1
|
||||
get_local $_3
|
||||
local.tee $_1
|
||||
local.get $_3
|
||||
i32.eq
|
||||
br_if $findDiffDone
|
||||
get_local $_2
|
||||
local.get $_2
|
||||
i32.const 1
|
||||
i32.add
|
||||
set_local $_2
|
||||
local.set $_2
|
||||
br $findDiff
|
||||
;; }
|
||||
end end
|
||||
@ -217,32 +217,32 @@
|
||||
end
|
||||
;; if ( d < 0 ) {
|
||||
;; r = iCandidate;
|
||||
get_local $d
|
||||
local.get $d
|
||||
i32.const 0
|
||||
i32.lt_s
|
||||
if
|
||||
get_local $iCandidate
|
||||
set_local $r
|
||||
local.get $iCandidate
|
||||
local.set $r
|
||||
br $binarySearch
|
||||
end
|
||||
;; } else if ( d > 0 ) {
|
||||
;; l = iCandidate + 1;
|
||||
get_local $d
|
||||
local.get $d
|
||||
i32.const 0
|
||||
i32.gt_s
|
||||
if
|
||||
get_local $iCandidate
|
||||
local.get $iCandidate
|
||||
i32.const 1
|
||||
i32.add
|
||||
set_local $l
|
||||
local.set $l
|
||||
br $binarySearch
|
||||
end
|
||||
;; } else /* if ( d === 0 ) */ {
|
||||
;; iFound = iCandidateNode;
|
||||
;; break;
|
||||
;; }
|
||||
get_local $iCandidateNode
|
||||
set_local $iFound
|
||||
local.get $iCandidateNode
|
||||
local.set $iFound
|
||||
end end
|
||||
;; }
|
||||
;; // 2. If no rules match, the prevailing rule is "*".
|
||||
@ -251,10 +251,10 @@
|
||||
;; buf8[SUFFIX_NOT_FOUND_SLOT] = 1;
|
||||
;; iFound = iCandidates;
|
||||
;; }
|
||||
get_local $iFound
|
||||
local.get $iFound
|
||||
i32.eqz
|
||||
if
|
||||
get_local $iCandidates
|
||||
local.get $iCandidates
|
||||
i32.load offset=4
|
||||
i32.const 0x2A
|
||||
i32.ne
|
||||
@ -262,12 +262,12 @@
|
||||
i32.const 399
|
||||
i32.const 1
|
||||
i32.store8
|
||||
get_local $iCandidates
|
||||
set_local $iFound
|
||||
local.get $iCandidates
|
||||
local.set $iFound
|
||||
end
|
||||
;; iNode = iFound;
|
||||
get_local $iFound
|
||||
tee_local $iNode
|
||||
local.get $iFound
|
||||
local.tee $iNode
|
||||
;; // 5. If the prevailing rule is a exception rule, modify it by
|
||||
;; // removing the leftmost label.
|
||||
;; if ( (buf32[iNode+0] & 0x00000200) !== 0 ) {
|
||||
@ -277,15 +277,15 @@
|
||||
;; break;
|
||||
;; }
|
||||
i32.load8_u offset=1
|
||||
tee_local $_1
|
||||
local.tee $_1
|
||||
i32.const 0x02
|
||||
i32.and
|
||||
if
|
||||
get_local $iLabel
|
||||
local.get $iLabel
|
||||
i32.const 256
|
||||
i32.gt_u
|
||||
if
|
||||
get_local $iLabel
|
||||
local.get $iLabel
|
||||
i32.const -2
|
||||
i32.add
|
||||
return
|
||||
@ -295,25 +295,25 @@
|
||||
;; if ( (buf32[iNode+0] & 0x00000100) !== 0 ) {
|
||||
;; cursorPos = labelBeg;
|
||||
;; }
|
||||
get_local $_1
|
||||
local.get $_1
|
||||
i32.const 0x01
|
||||
i32.and
|
||||
if
|
||||
get_local $iLabel
|
||||
set_local $cursorPos
|
||||
local.get $iLabel
|
||||
local.set $cursorPos
|
||||
end
|
||||
;; if ( labelBeg === 0 ) { break; }
|
||||
get_local $labelBeg
|
||||
local.get $labelBeg
|
||||
i32.eqz
|
||||
br_if $labelLookupDone
|
||||
;; iLabel += 2;
|
||||
get_local $iLabel
|
||||
local.get $iLabel
|
||||
i32.const 2
|
||||
i32.add
|
||||
set_local $iLabel
|
||||
local.set $iLabel
|
||||
br $labelLookup
|
||||
end end
|
||||
get_local $cursorPos
|
||||
local.get $cursorPos
|
||||
)
|
||||
|
||||
;;
|
||||
|
||||
Loading…
Reference in New Issue
Block a user