263 lines
4.4 KiB
ArmAsm
263 lines
4.4 KiB
ArmAsm
.globl _start
|
|
.type _start, @function
|
|
.globl entry
|
|
.type entry, @function
|
|
|
|
_start:
|
|
pop %rax
|
|
mov %rax,argc(%rip)
|
|
mov %rax,%rdi
|
|
pop %rax
|
|
mov %rax,argv(%rip)
|
|
cmp $1,%rdi
|
|
jg _start_endif
|
|
mov $1,%rdi
|
|
call usage
|
|
jmp _exit
|
|
_start_endif:
|
|
|
|
mov $0,%rdi
|
|
jmp _exit
|
|
|
|
usage:
|
|
lea help0(%rip),%rdi
|
|
mov $help0l,%rsi
|
|
call write
|
|
|
|
mov argv(%rip),%rdi
|
|
push %rdi
|
|
call strlen
|
|
pop %rdi
|
|
mov %rax,%rsi
|
|
call write
|
|
|
|
lea help1(%rip),%rdi
|
|
mov $help1l,%rsi
|
|
call write
|
|
|
|
ret
|
|
|
|
// rdi - buf
|
|
// -> rax - len
|
|
strlen:
|
|
mov %rdi,%rsi
|
|
xor %rax,%rax
|
|
repne scasb
|
|
sub %rsi,%rdi
|
|
mov %rdi,%rax
|
|
dec %rax
|
|
ret
|
|
|
|
// rdi - buf
|
|
// rsi - len
|
|
write:
|
|
push %rdi
|
|
push %rsi
|
|
pop %rdx
|
|
pop %rsi
|
|
mov $1,%rax
|
|
mov $1,%rdi
|
|
syscall
|
|
ret
|
|
|
|
help0:
|
|
.ascii "Usage: "
|
|
.set help0l, .-help0
|
|
help1:
|
|
.ascii " regex0 [regex1 ...]\n"
|
|
.ascii "writes NUL-separated list of matching strings, one per regex to stdout\n"
|
|
.ascii "uses stack memory, consider disabling the limit if it segfaults\n"
|
|
.set help1l, .-help1
|
|
|
|
// rdi - exit code
|
|
_exit:
|
|
mov $0x3c,%rax
|
|
syscall
|
|
ret
|
|
|
|
.include "target/charjmpt.s"
|
|
|
|
.macro eaptrdiff32 ptr=%rax, out=%rax, off=0, tmp=%r11
|
|
eaptrdiff32.\@:
|
|
.if \ptr != \out
|
|
push \ptr
|
|
.endif
|
|
.if \off
|
|
add $\off,\ptr
|
|
.endif
|
|
push \tmp
|
|
mov \ptr,\tmp
|
|
movslq (\tmp),\tmp
|
|
add \tmp,\ptr
|
|
pop \tmp
|
|
.if \ptr != \out
|
|
mov \ptr,\out
|
|
pop \ptr
|
|
.endif
|
|
.endm
|
|
|
|
.macro mkptrdiff32 to=%r11, to_low=%r11d, ptr=%rax, off=0
|
|
mkptrdiff32.\@:
|
|
push \to
|
|
.if \off
|
|
push \ptr
|
|
add $\off,\ptr
|
|
.endif
|
|
sub \ptr,\to
|
|
movl \to_low,(\ptr)
|
|
.if \off
|
|
pop \ptr
|
|
.endif
|
|
pop \to
|
|
.endm
|
|
|
|
// rdi - &state
|
|
// rsi - char
|
|
// rcx, r8, r9, r10, r11 - scratch
|
|
// r12 - real stack (rsp - fake stack)
|
|
// -> rax - status
|
|
//parse_...:
|
|
|
|
append_tnode_recurse:
|
|
|
|
|
|
// rdi - &group_alt
|
|
// rsi - type
|
|
// -> rax - text_node ptr
|
|
push_tnode:
|
|
movslq (%rdi),%rcx
|
|
sub $(5*4),%r12
|
|
and $-8,%r12
|
|
movl %esi,0(%r12)
|
|
movl $0,4(%r12)
|
|
mov %r12,%rax
|
|
mkptrdiff32 %rax,%eax,%rdi
|
|
test %rcx,%rcx
|
|
jz ptn_ptout
|
|
add %rdi,%rcx
|
|
mkptrdiff32 %rax,%eax,%rcx,4
|
|
ptn_ptout:
|
|
movslq 4(%rdi),%rcx
|
|
test %rcx,%rcx
|
|
jnz ptn_jout
|
|
mkptrdiff32 %rax,%eax,%rdi,4
|
|
ptn_jout:
|
|
ret
|
|
|
|
parse_escape:
|
|
incq (2*8)(%rdi)
|
|
mov (2*8)(%rdi),%rsi
|
|
movzbq (%rsi),%rsi
|
|
test %sil,%sil
|
|
jz parse_exit
|
|
jmp parse_self
|
|
|
|
parse_self:
|
|
push %rdi
|
|
push %rsi
|
|
sub $2,%rsp
|
|
movw $0,(%rsp)
|
|
movb %sil,(%rsp)
|
|
mov %rsp,%rdi
|
|
mov $1,%rsi
|
|
call write
|
|
add $2,%rsp
|
|
pop %rsi
|
|
pop %rdi
|
|
push %rsi
|
|
movq (%rdi),%rax # rax - group
|
|
eaptrdiff32 %rax # rax - group_alt
|
|
mov %rax,%rdi
|
|
movslq (%rax),%r9
|
|
test %r9,%r9
|
|
jz ps_alloc
|
|
eaptrdiff32 %rax # rax - text_node
|
|
movl (%rax),%r9d
|
|
cmp $3,%r9d
|
|
je ps_noalloc
|
|
ps_alloc:
|
|
mov $3,%rsi
|
|
call push_tnode
|
|
dec %r12
|
|
mkptrdiff32 %r12,%r12d,%rax,(8+0) # text_chars.text
|
|
inc %r12
|
|
movl $0,(8+4)(%rax) # text_chars.len
|
|
ps_noalloc:
|
|
eaptrdiff32 %rax,%r9,(8+0)
|
|
pop %rsi
|
|
movl (8+4)(%rax),%r8d
|
|
sub %r8,%r9
|
|
movb %sil,(%r9)
|
|
incl (8+4)(%rax)
|
|
xor %rax,%rax
|
|
ret
|
|
|
|
parse_grbegin:
|
|
parse_grend:
|
|
parse_murder:
|
|
parse_nextalt:
|
|
parse_erase:
|
|
parse_exit:
|
|
mov $1,%rax
|
|
ret
|
|
|
|
// rdi - regex
|
|
// rsi - callback
|
|
// rdx - cb data
|
|
entry:
|
|
push %rbp
|
|
mov %rsp,%rbp
|
|
// svregs state group group_alt
|
|
// (r12-r14)
|
|
sub $(3*8 + 5*8 + 3*4 + 3*4),%rsp
|
|
mov %r12,-8(%rbp)
|
|
mov %r13,-16(%rbp)
|
|
mov %r14,-24(%rbp)
|
|
mov %rsp,%r12
|
|
mov %rdi,(-3*8-5*8 + 2*8)(%rbp) # state.regchar
|
|
mov %rsi,(-3*8-5*8 + 3*8)(%rbp) # state.callback
|
|
mov %rdx,(-3*8-5*8 + 4*8)(%rbp) # state.cbdata
|
|
lea (-3*8-5*8-3*4)(%rbp),%r9
|
|
mov %r9,(-3*8-5*8 + 0*8)(%rbp) # state.mother_gr
|
|
mov %r9,(-3*8-5*8 + 1*8)(%rbp) # state.current_gr
|
|
lea (-3*8-5*8-3*4)(%rbp),%r9
|
|
lea (-3*8-5*8-3*4-3*4)(%rbp),%r8
|
|
mkptrdiff32 %r8,%r8d,%r9 # group.alts_tail
|
|
mkptrdiff32 %r8,%r8d,%r9,4 # group.alts_head
|
|
movl $0,(-3*8-5*8-3*4 + 2*4)(%rbp) # group.up
|
|
movl $0,(-3*8-5*8-3*4-3*4 + 0*4)(%rbp) # group_alt.text_tail
|
|
movl $0,(-3*8-5*8-3*4-3*4 + 1*4)(%rbp) # group_alt.text_head
|
|
movl $0,(-3*8-5*8-3*4-3*4 + 2*4)(%rbp) # group_alt.next
|
|
xchg %r12,%rsp
|
|
sub $512,%r12
|
|
entry_parse_begin:
|
|
mov (-3*8-5*8 + 2*8)(%rbp),%rsi
|
|
movzbq (%rsi),%rsi # char to sil
|
|
lea charjmpt(%rip),%r11
|
|
movzx %sil,%r10
|
|
shl $1,%r10
|
|
add %r10,%r11
|
|
movswq (%r11),%r11
|
|
charjmpt_prej:
|
|
lea charjmpt_prej(%rip),%r10
|
|
add %r10,%r11
|
|
lea (-3*8-5*8)(%rbp),%rdi # &state
|
|
call *%r11
|
|
test %rax,%rax
|
|
jnz entry_parse_end
|
|
incq (-3*8-5*8+2*8)(%rbp)
|
|
jmp entry_parse_begin
|
|
entry_parse_end:
|
|
mov -8(%rbp),%r12
|
|
mov -16(%rbp),%r13
|
|
mov -24(%rbp),%r14
|
|
mov %rbp,%rsp
|
|
pop %rbp
|
|
ret
|
|
|
|
.bss
|
|
argc:
|
|
.zero 8
|
|
argv:
|
|
.zero 8
|