copyfromparse-constant.asm
application/octet-stream
Filename: copyfromparse-constant.asm
Type: application/octet-stream
Part: 0
0000000000000960 <CopyReadLine>:
{
960: 41 57 push r15
resetStringInfo(&cstate->line_buf);
962: 48 8d 87 e0 01 00 00 lea rax,[rdi+0x1e0]
{
969: 41 56 push r14
96b: 41 55 push r13
96d: 41 89 f5 mov r13d,esi
970: 41 54 push r12
972: 55 push rbp
973: 53 push rbx
974: 48 89 fb mov rbx,rdi
resetStringInfo(&cstate->line_buf);
977: 48 89 c7 mov rdi,rax
{
97a: 48 83 ec 58 sub rsp,0x58
97e: 89 74 24 18 mov DWORD PTR [rsp+0x18],esi
resetStringInfo(&cstate->line_buf);
982: 48 89 44 24 10 mov QWORD PTR [rsp+0x10],rax
987: e8 00 00 00 00 call 98c <CopyReadLine+0x2c>
if (unlikely(!cstate->simd_initialized))
98c: 44 0f b6 93 42 01 00 movzx r10d,BYTE PTR [rbx+0x142]
993: 00
cstate->line_buf_valid = false;
994: c6 83 f8 01 00 00 00 mov BYTE PTR [rbx+0x1f8],0x0
if (unlikely(!cstate->simd_initialized))
99b: 45 84 d2 test r10b,r10b
99e: 0f 84 fc 00 00 00 je aa0 <CopyReadLine+0x140>
if (cstate->simd_continue) {
9a4: 0f b6 83 41 01 00 00 movzx eax,BYTE PTR [rbx+0x141]
9ab: 84 c0 test al,al
9ad: 0f 85 03 01 00 00 jne ab6 <CopyReadLine+0x156>
if (is_csv)
9b3: 80 7c 24 18 00 cmp BYTE PTR [rsp+0x18],0x0
9b8: 0f 84 82 02 00 00 je c40 <CopyReadLine+0x2e0>
quotec = cstate->opts.quote[0];
9be: 48 8b 93 98 00 00 00 mov rdx,QWORD PTR [rbx+0x98]
9c5: 0f b6 32 movzx esi,BYTE PTR [rdx]
escapec = cstate->opts.escape[0];
9c8: 48 8b 93 a0 00 00 00 mov rdx,QWORD PTR [rbx+0xa0]
9cf: 0f b6 0a movzx ecx,BYTE PTR [rdx]
quotec = cstate->opts.quote[0];
9d2: 40 88 74 24 1f mov BYTE PTR [rsp+0x1f],sil
escapec = '\0';
9d7: 40 38 ce cmp sil,cl
9da: 0f 44 c8 cmove ecx,eax
9dd: 88 4c 24 0c mov BYTE PTR [rsp+0xc],cl
input_buf_ptr = cstate->input_buf_index;
9e1: 8b 83 08 02 00 00 mov eax,DWORD PTR [rbx+0x208]
bool in_quote = false,
9e7: c6 44 24 08 00 mov BYTE PTR [rsp+0x8],0x0
last_was_esc = false;
9ec: 45 31 f6 xor r14d,r14d
bool hit_eof = false;
9ef: 31 ff xor edi,edi
9f1: 44 88 54 24 20 mov BYTE PTR [rsp+0x20],r10b
9f6: 44 89 e9 mov ecx,r13d
copy_buf_len = cstate->input_buf_len;
9f9: 8b b3 0c 02 00 00 mov esi,DWORD PTR [rbx+0x20c]
bool need_data = false;
9ff: 31 ed xor ebp,ebp
copy_input_buf = cstate->input_buf;
a01: 4c 8b bb 00 02 00 00 mov r15,QWORD PTR [rbx+0x200]
input_buf_ptr = cstate->input_buf_index;
a08: 45 89 f5 mov r13d,r14d
a0b: 41 89 c4 mov r12d,eax
copy_buf_len = cstate->input_buf_len;
a0e: 41 89 ce mov r14d,ecx
if (input_buf_ptr >= copy_buf_len || need_data)
a11: 41 39 f4 cmp r12d,esi
a14: 0f 8d 36 02 00 00 jge c50 <CopyReadLine+0x2f0>
a1a: 40 84 ed test bpl,bpl
a1d: 0f 85 2d 02 00 00 jne c50 <CopyReadLine+0x2f0>
c = copy_input_buf[input_buf_ptr++];
a23: 49 63 d4 movsxd rdx,r12d
a26: 41 8d 4c 24 01 lea ecx,[r12+0x1]
a2b: 41 0f b6 14 17 movzx edx,BYTE PTR [r15+rdx*1]
if (is_csv)
a30: 45 84 f6 test r14b,r14b
a33: 0f 84 5f 02 00 00 je c98 <CopyReadLine+0x338>
if (c == '\r')
a39: 80 fa 0d cmp dl,0xd
a3c: 0f 84 06 03 00 00 je d48 <CopyReadLine+0x3e8>
if (simd_continue && !last_was_esc && copy_buf_len - input_buf_ptr >= sizeof(Vector8))
a42: 45 89 eb mov r11d,r13d
a45: 41 83 f3 01 xor r11d,0x1
if (in_quote && c == escapec)
a49: 38 54 24 0c cmp BYTE PTR [rsp+0xc],dl
a4d: 41 0f 94 c0 sete r8b
if (c == quotec && !last_was_esc)
a51: 3a 54 24 1f cmp dl,BYTE PTR [rsp+0x1f]
a55: 40 0f 94 c5 sete bpl
if (in_quote && c == escapec)
a59: 44 22 44 24 08 and r8b,BYTE PTR [rsp+0x8]
a5e: 0f 84 24 03 00 00 je d88 <CopyReadLine+0x428>
if (c == quotec && !last_was_esc)
a64: 45 84 ed test r13b,r13b
a67: 0f 84 43 03 00 00 je db0 <CopyReadLine+0x450>
a6d: 45 31 c0 xor r8d,r8d
a70: 40 84 ed test bpl,bpl
a73: 0f 84 37 03 00 00 je db0 <CopyReadLine+0x450>
if (c == '\r' && (!is_csv || !in_quote))
a79: 80 fa 0d cmp dl,0xd
a7c: 0f 84 76 04 00 00 je ef8 <CopyReadLine+0x598>
if (c == '\n' && (!is_csv || !in_quote))
a82: 80 fa 0a cmp dl,0xa
a85: 0f 84 d5 09 00 00 je 1460 <CopyReadLine+0xb00>
a8b: c6 44 24 08 00 mov BYTE PTR [rsp+0x8],0x0
c = copy_input_buf[input_buf_ptr++];
a90: 45 89 c5 mov r13d,r8d
a93: 31 ed xor ebp,ebp
a95: 41 89 cc mov r12d,ecx
a98: e9 74 ff ff ff jmp a11 <CopyReadLine+0xb1>
a9d: 0f 1f 00 nop DWORD PTR [rax]
cstate->simd_last_sleep_cycle = 0;
aa0: c7 83 44 01 00 00 00 mov DWORD PTR [rbx+0x144],0x0
aa7: 00 00 00
cstate->simd_continue = true;
aaa: b9 01 01 00 00 mov ecx,0x101
aaf: 66 89 8b 41 01 00 00 mov WORD PTR [rbx+0x141],cx
if (is_csv)
ab6: 80 7c 24 18 00 cmp BYTE PTR [rsp+0x18],0x0
abb: 0f 85 1f 01 00 00 jne be0 <CopyReadLine+0x280>
char escapec = '\0';
ac1: c6 44 24 0c 00 mov BYTE PTR [rsp+0xc],0x0
Vector8 escape = vector8_broadcast(0);
ac6: 66 0f ef e4 pxor xmm4,xmm4
char quotec = '\0';
aca: c6 44 24 1f 00 mov BYTE PTR [rsp+0x1f],0x0
Vector8 escape = vector8_broadcast(0);
acf: 0f 29 64 24 40 movaps XMMWORD PTR [rsp+0x40],xmm4
Vector8 quote = vector8_broadcast(0);
ad4: 0f 29 64 24 30 movaps XMMWORD PTR [rsp+0x30],xmm4
input_buf_ptr = cstate->input_buf_index;
ad9: 8b 83 08 02 00 00 mov eax,DWORD PTR [rbx+0x208]
bool in_quote = false,
adf: c6 44 24 08 00 mov BYTE PTR [rsp+0x8],0x0
last_was_esc = false;
ae4: 45 31 e4 xor r12d,r12d
bool hit_eof = false;
ae7: 31 f6 xor esi,esi
uint64 simd_total_advance = 0;
ae9: 48 c7 44 24 28 00 00 mov QWORD PTR [rsp+0x28],0x0
af0: 00 00
af2: 44 89 ef mov edi,r13d
bool need_data = false;
af5: 31 ed xor ebp,ebp
af7: 45 89 e5 mov r13d,r12d
uint64 simd_total_cycle = 0;
afa: 48 c7 44 24 20 00 00 mov QWORD PTR [rsp+0x20],0x0
b01: 00 00
copy_input_buf = cstate->input_buf;
b03: 4c 8b b3 00 02 00 00 mov r14,QWORD PTR [rbx+0x200]
input_buf_ptr = cstate->input_buf_index;
b0a: 41 89 c7 mov r15d,eax
copy_buf_len = cstate->input_buf_len;
b0d: 41 89 fc mov r12d,edi
b10: 8b 8b 0c 02 00 00 mov ecx,DWORD PTR [rbx+0x20c]
if (input_buf_ptr >= copy_buf_len || need_data)
b16: 41 39 cf cmp r15d,ecx
b19: 0f 9d c2 setge dl
b1c: 40 08 d5 or bpl,dl
b1f: 74 35 je b56 <CopyReadLine+0x1f6>
REFILL_LINEBUF;
b21: 41 39 c7 cmp r15d,eax
b24: 0f 8f 06 03 00 00 jg e30 <CopyReadLine+0x4d0>
CopyLoadInputBuf(cstate);
b2a: 48 89 df mov rdi,rbx
b2d: e8 de fb ff ff call 710 <CopyLoadInputBuf>
copy_buf_len = cstate->input_buf_len;
b32: 8b 8b 0c 02 00 00 mov ecx,DWORD PTR [rbx+0x20c]
input_buf_ptr = cstate->input_buf_index;
b38: 44 8b bb 08 02 00 00 mov r15d,DWORD PTR [rbx+0x208]
hit_eof = cstate->input_reached_eof;
b3f: 0f b6 b3 10 02 00 00 movzx esi,BYTE PTR [rbx+0x210]
if (INPUT_BUF_BYTES(cstate) <= 0)
b46: 89 ca mov edx,ecx
input_buf_ptr = cstate->input_buf_index;
b48: 44 89 f8 mov eax,r15d
if (INPUT_BUF_BYTES(cstate) <= 0)
b4b: 44 29 fa sub edx,r15d
b4e: 85 d2 test edx,edx
b50: 0f 8e da 08 00 00 jle 1430 <CopyReadLine+0xad0>
if (simd_continue && !last_was_esc && copy_buf_len - input_buf_ptr >= sizeof(Vector8))
b56: 45 89 ea mov r10d,r13d
b59: 41 80 f2 01 xor r10b,0x1
b5d: 74 0e je b6d <CopyReadLine+0x20d>
b5f: 89 ca mov edx,ecx
b61: 44 29 fa sub edx,r15d
b64: 83 fa 0f cmp edx,0xf
b67: 0f 87 eb 02 00 00 ja e58 <CopyReadLine+0x4f8>
c = copy_input_buf[input_buf_ptr++];
b6d: 49 63 d7 movsxd rdx,r15d
b70: 45 8d 47 01 lea r8d,[r15+0x1]
b74: 41 0f b6 14 16 movzx edx,BYTE PTR [r14+rdx*1]
if (is_csv)
b79: 45 84 e4 test r12b,r12b
b7c: 0f 84 6e 01 00 00 je cf0 <CopyReadLine+0x390>
if (c == '\r')
b82: 80 fa 0d cmp dl,0xd
b85: 0f 84 dd 01 00 00 je d68 <CopyReadLine+0x408>
if (in_quote && c == escapec)
b8b: 38 54 24 0c cmp BYTE PTR [rsp+0xc],dl
b8f: 40 0f 94 c7 sete dil
if (c == quotec && !last_was_esc)
b93: 3a 54 24 1f cmp dl,BYTE PTR [rsp+0x1f]
b97: 41 0f 94 c3 sete r11b
if (in_quote && c == escapec)
b9b: 40 22 7c 24 08 and dil,BYTE PTR [rsp+0x8]
ba0: 0f 84 3a 02 00 00 je de0 <CopyReadLine+0x480>
if (c == quotec && !last_was_esc)
ba6: 45 84 db test r11b,r11b
ba9: 0f 84 59 02 00 00 je e08 <CopyReadLine+0x4a8>
in_quote = !in_quote;
baf: c6 44 24 08 00 mov BYTE PTR [rsp+0x8],0x0
if (c == quotec && !last_was_esc)
bb4: 31 ff xor edi,edi
bb6: 45 84 ed test r13b,r13b
bb9: 0f 84 49 02 00 00 je e08 <CopyReadLine+0x4a8>
if (c == '\r' && (!is_csv || !in_quote))
bbf: 80 fa 0d cmp dl,0xd
bc2: 0f 84 f8 03 00 00 je fc0 <CopyReadLine+0x660>
if (c == '\n' && (!is_csv || !in_quote))
bc8: 80 fa 0a cmp dl,0xa
bcb: 0f 84 af 08 00 00 je 1480 <CopyReadLine+0xb20>
c = copy_input_buf[input_buf_ptr++];
bd1: 41 89 fd mov r13d,edi
bd4: 45 89 c7 mov r15d,r8d
bd7: 31 ed xor ebp,ebp
bd9: e9 38 ff ff ff jmp b16 <CopyReadLine+0x1b6>
bde: 66 90 xchg ax,ax
quotec = cstate->opts.quote[0];
be0: 48 8b 83 98 00 00 00 mov rax,QWORD PTR [rbx+0x98]
be7: 0f b6 08 movzx ecx,BYTE PTR [rax]
escapec = cstate->opts.escape[0];
bea: 48 8b 83 a0 00 00 00 mov rax,QWORD PTR [rbx+0xa0]
_mm_set_epi8 (char __q15, char __q14, char __q13, char __q12,
char __q11, char __q10, char __q09, char __q08,
char __q07, char __q06, char __q05, char __q04,
char __q03, char __q02, char __q01, char __q00)
{
return __extension__ (__m128i)(__v16qi){
bf1: 66 0f 6e c1 movd xmm0,ecx
bf5: 0f b6 30 movzx esi,BYTE PTR [rax]
quotec = cstate->opts.quote[0];
bf8: 88 4c 24 1f mov BYTE PTR [rsp+0x1f],cl
bfc: 66 0f 60 c0 punpcklbw xmm0,xmm0
c00: 66 0f 61 c0 punpcklwd xmm0,xmm0
escapec = cstate->opts.escape[0];
c04: 40 88 74 24 0c mov BYTE PTR [rsp+0xc],sil
c09: 66 0f 70 d8 00 pshufd xmm3,xmm0,0x0
c0e: 0f 29 5c 24 30 movaps XMMWORD PTR [rsp+0x30],xmm3
if (quotec == escapec)
c13: 40 38 f1 cmp cl,sil
c16: 0f 84 b4 06 00 00 je 12d0 <CopyReadLine+0x970>
c1c: 66 0f 6e 44 24 0c movd xmm0,DWORD PTR [rsp+0xc]
c22: 66 0f 60 c0 punpcklbw xmm0,xmm0
c26: 66 0f 61 c0 punpcklwd xmm0,xmm0
c2a: 66 0f 70 f0 00 pshufd xmm6,xmm0,0x0
c2f: 0f 29 74 24 40 movaps XMMWORD PTR [rsp+0x40],xmm6
c34: e9 a0 fe ff ff jmp ad9 <CopyReadLine+0x179>
c39: 0f 1f 80 00 00 00 00 nop DWORD PTR [rax+0x0]
char escapec = '\0';
c40: c6 44 24 0c 00 mov BYTE PTR [rsp+0xc],0x0
char quotec = '\0';
c45: c6 44 24 1f 00 mov BYTE PTR [rsp+0x1f],0x0
c4a: e9 92 fd ff ff jmp 9e1 <CopyReadLine+0x81>
c4f: 90 nop
REFILL_LINEBUF;
c50: 41 39 c4 cmp r12d,eax
c53: 0f 8f 77 02 00 00 jg ed0 <CopyReadLine+0x570>
CopyLoadInputBuf(cstate);
c59: 48 89 df mov rdi,rbx
c5c: e8 af fa ff ff call 710 <CopyLoadInputBuf>
copy_buf_len = cstate->input_buf_len;
c61: 8b b3 0c 02 00 00 mov esi,DWORD PTR [rbx+0x20c]
input_buf_ptr = cstate->input_buf_index;
c67: 44 8b a3 08 02 00 00 mov r12d,DWORD PTR [rbx+0x208]
hit_eof = cstate->input_reached_eof;
c6e: 0f b6 bb 10 02 00 00 movzx edi,BYTE PTR [rbx+0x210]
if (INPUT_BUF_BYTES(cstate) <= 0)
c75: 89 f2 mov edx,esi
input_buf_ptr = cstate->input_buf_index;
c77: 44 89 e0 mov eax,r12d
if (INPUT_BUF_BYTES(cstate) <= 0)
c7a: 44 29 e2 sub edx,r12d
c7d: 85 d2 test edx,edx
c7f: 0f 8f 9e fd ff ff jg a23 <CopyReadLine+0xc3>
input_buf_ptr = cstate->input_buf_index;
c85: 44 0f b6 54 24 20 movzx r10d,BYTE PTR [rsp+0x20]
c8b: 44 89 e1 mov ecx,r12d
c8e: e9 98 04 00 00 jmp 112b <CopyReadLine+0x7cb>
c93: 0f 1f 44 00 00 nop DWORD PTR [rax+rax*1+0x0]
if (c == '\r' && (!is_csv || !in_quote))
c98: 80 fa 0d cmp dl,0xd
c9b: 0f 84 5f 02 00 00 je f00 <CopyReadLine+0x5a0>
if (c == '\n' && (!is_csv || !in_quote))
ca1: 80 fa 0a cmp dl,0xa
ca4: 0f 84 b6 07 00 00 je 1460 <CopyReadLine+0xb00>
IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(0);
caa: 39 ce cmp esi,ecx
cac: 41 0f 9e c0 setle r8b
if (c == '\\' && !is_csv)
cb0: 80 fa 5c cmp dl,0x5c
cb3: 0f 85 da fd ff ff jne a93 <CopyReadLine+0x133>
IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(0);
cb9: 89 fa mov edx,edi
cbb: 83 f2 01 xor edx,0x1
cbe: 89 d5 mov ebp,edx
cc0: 44 20 c5 and bpl,r8b
cc3: 0f 85 95 00 00 00 jne d5e <CopyReadLine+0x3fe>
IF_NEED_REFILL_AND_EOF_BREAK(0);
cc9: 41 20 f8 and r8b,dil
ccc: 44 89 c5 mov ebp,r8d
ccf: 0f 85 7d 07 00 00 jne 1452 <CopyReadLine+0xaf2>
c2 = copy_input_buf[input_buf_ptr];
cd5: 48 63 c9 movsxd rcx,ecx
input_buf_ptr++; /* consume the '.' */
cd8: 45 8d 5c 24 02 lea r11d,[r12+0x2]
if (c2 == '.')
cdd: 41 80 3c 0f 2e cmp BYTE PTR [r15+rcx*1],0x2e
ce2: 0f 84 c8 03 00 00 je 10b0 <CopyReadLine+0x750>
input_buf_ptr++;
ce8: 45 89 dc mov r12d,r11d
ceb: e9 21 fd ff ff jmp a11 <CopyReadLine+0xb1>
if (c == '\r' && (!is_csv || !in_quote))
cf0: 80 fa 0d cmp dl,0xd
cf3: 0f 84 ca 02 00 00 je fc3 <CopyReadLine+0x663>
if (c == '\n' && (!is_csv || !in_quote))
cf9: 80 fa 0a cmp dl,0xa
cfc: 0f 84 7e 07 00 00 je 1480 <CopyReadLine+0xb20>
IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(0);
d02: 44 39 c1 cmp ecx,r8d
d05: 40 0f 9e c7 setle dil
if (c == '\\' && !is_csv)
d09: 80 fa 5c cmp dl,0x5c
d0c: 0f 85 8e 07 00 00 jne 14a0 <CopyReadLine+0xb40>
IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(0);
d12: 89 f2 mov edx,esi
d14: 83 f2 01 xor edx,0x1
d17: 89 d5 mov ebp,edx
d19: 40 20 fd and bpl,dil
d1c: 75 5f jne d7d <CopyReadLine+0x41d>
IF_NEED_REFILL_AND_EOF_BREAK(0);
d1e: 40 20 f7 and dil,sil
d21: 89 fd mov ebp,edi
d23: 0f 85 18 07 00 00 jne 1441 <CopyReadLine+0xae1>
c2 = copy_input_buf[input_buf_ptr];
d29: 4d 63 c0 movsxd r8,r8d
input_buf_ptr++; /* consume the '.' */
d2c: 41 8d 7f 02 lea edi,[r15+0x2]
if (c2 == '.')
d30: 43 80 3c 06 2e cmp BYTE PTR [r14+r8*1],0x2e
d35: 0f 84 25 04 00 00 je 1160 <CopyReadLine+0x800>
input_buf_ptr++;
d3b: 41 89 ff mov r15d,edi
d3e: e9 d3 fd ff ff jmp b16 <CopyReadLine+0x1b6>
d43: 0f 1f 44 00 00 nop DWORD PTR [rax+rax*1+0x0]
IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(0);
d48: 39 ce cmp esi,ecx
d4a: 41 89 f8 mov r8d,edi
d4d: 40 0f 9e c5 setle bpl
d51: 41 83 f0 01 xor r8d,0x1
d55: 44 20 c5 and bpl,r8b
d58: 0f 84 e4 fc ff ff je a42 <CopyReadLine+0xe2>
d5e: 31 ff xor edi,edi
d60: e9 ac fc ff ff jmp a11 <CopyReadLine+0xb1>
d65: 0f 1f 00 nop DWORD PTR [rax]
d68: 44 39 c1 cmp ecx,r8d
d6b: 89 f7 mov edi,esi
d6d: 40 0f 9e c5 setle bpl
d71: 83 f7 01 xor edi,0x1
d74: 40 20 fd and bpl,dil
d77: 0f 84 0e fe ff ff je b8b <CopyReadLine+0x22b>
d7d: 31 f6 xor esi,esi
d7f: e9 92 fd ff ff jmp b16 <CopyReadLine+0x1b6>
d84: 0f 1f 40 00 nop DWORD PTR [rax+0x0]
if (c == quotec && !last_was_esc)
d88: 45 84 db test r11b,r11b
d8b: 74 0d je d9a <CopyReadLine+0x43a>
d8d: 40 84 ed test bpl,bpl
d90: 74 08 je d9a <CopyReadLine+0x43a>
in_quote = !in_quote;
d92: 80 74 24 08 01 xor BYTE PTR [rsp+0x8],0x1
d97: 45 31 ed xor r13d,r13d
if (c != escapec)
d9a: 38 54 24 0c cmp BYTE PTR [rsp+0xc],dl
d9e: 45 0f 44 c5 cmove r8d,r13d
if (in_quote && c == (cstate->eol_type == EOL_NL ? '\n' : '\r'))
da2: 80 7c 24 08 00 cmp BYTE PTR [rsp+0x8],0x0
da7: 0f 84 cc fc ff ff je a79 <CopyReadLine+0x119>
dad: 45 89 c3 mov r11d,r8d
db0: 83 7b 20 01 cmp DWORD PTR [rbx+0x20],0x1
db4: 44 0f be c2 movsx r8d,dl
db8: 0f 84 22 04 00 00 je 11e0 <CopyReadLine+0x880>
dbe: 41 83 f8 0d cmp r8d,0xd
dc2: 0f 84 1e 04 00 00 je 11e6 <CopyReadLine+0x886>
if (c == '\n' && (!is_csv || !in_quote))
dc8: 80 fa 0a cmp dl,0xa
dcb: 0f 84 1d 04 00 00 je 11ee <CopyReadLine+0x88e>
dd1: e9 87 04 00 00 jmp 125d <CopyReadLine+0x8fd>
dd6: 66 2e 0f 1f 84 00 00 cs nop WORD PTR [rax+rax*1+0x0]
ddd: 00 00 00
if (c == quotec && !last_was_esc)
de0: 45 84 db test r11b,r11b
de3: 74 0d je df2 <CopyReadLine+0x492>
de5: 45 84 d2 test r10b,r10b
de8: 74 08 je df2 <CopyReadLine+0x492>
in_quote = !in_quote;
dea: 80 74 24 08 01 xor BYTE PTR [rsp+0x8],0x1
def: 45 31 ed xor r13d,r13d
if (c != escapec)
df2: 38 54 24 0c cmp BYTE PTR [rsp+0xc],dl
df6: 41 0f 44 fd cmove edi,r13d
if (in_quote && c == (cstate->eol_type == EOL_NL ? '\n' : '\r'))
dfa: 80 7c 24 08 00 cmp BYTE PTR [rsp+0x8],0x0
dff: 0f 84 ba fd ff ff je bbf <CopyReadLine+0x25f>
e05: 41 89 fa mov r10d,edi
e08: 83 7b 20 01 cmp DWORD PTR [rbx+0x20],0x1
e0c: 0f be fa movsx edi,dl
e0f: 0f 84 eb 03 00 00 je 1200 <CopyReadLine+0x8a0>
e15: 83 ff 0d cmp edi,0xd
e18: 0f 84 e7 03 00 00 je 1205 <CopyReadLine+0x8a5>
if (c == '\n' && (!is_csv || !in_quote))
e1e: 80 fa 0a cmp dl,0xa
e21: 0f 84 e6 03 00 00 je 120d <CopyReadLine+0x8ad>
e27: e9 49 04 00 00 jmp 1275 <CopyReadLine+0x915>
e2c: 0f 1f 40 00 nop DWORD PTR [rax+0x0]
REFILL_LINEBUF;
e30: 48 8b 7c 24 10 mov rdi,QWORD PTR [rsp+0x10]
e35: 44 89 fa mov edx,r15d
e38: 48 63 f0 movsxd rsi,eax
e3b: 48 03 b3 00 02 00 00 add rsi,QWORD PTR [rbx+0x200]
e42: 29 c2 sub edx,eax
e44: e8 00 00 00 00 call e49 <CopyReadLine+0x4e9>
e49: 44 89 bb 08 02 00 00 mov DWORD PTR [rbx+0x208],r15d
e50: e9 d5 fc ff ff jmp b2a <CopyReadLine+0x1ca>
e55: 0f 1f 00 nop DWORD PTR [rax]
simd_total_cycle++;
e58: 48 83 44 24 20 01 add QWORD PTR [rsp+0x20],0x1
vector8_load(&chunk, (const uint8 *) ©_input_buf[input_buf_ptr]);
e5e: 49 63 d7 movsxd rdx,r15d
if (!in_quote)
e61: 80 7c 24 08 00 cmp BYTE PTR [rsp+0x8],0x0
}
extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadu_si128 (__m128i_u const *__P)
{
return *__P;
e66: f3 41 0f 6f 0c 16 movdqu xmm1,XMMWORD PTR [r14+rdx*1]
e6c: 66 0f ef c0 pxor xmm0,xmm0
e70: 75 1c jne e8e <CopyReadLine+0x52e>
}
extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_epi8 (__m128i __A, __m128i __B)
{
return (__m128i) ((__v16qi)__A == (__v16qi)__B);
e72: 66 0f 6f d1 movdqa xmm2,xmm1
return (__m128i) ((__v2du)__A | (__v2du)__B);
e76: 66 0f 6f c1 movdqa xmm0,xmm1
return (__m128i) ((__v16qi)__A == (__v16qi)__B);
e7a: 66 0f 74 15 00 00 00 pcmpeqb xmm2,XMMWORD PTR [rip+0x0] # e82 <CopyReadLine+0x522>
e81: 00
return (__m128i) ((__v2du)__A | (__v2du)__B);
e82: 66 0f 74 05 00 00 00 pcmpeqb xmm0,XMMWORD PTR [rip+0x0] # e8a <CopyReadLine+0x52a>
e89: 00
e8a: 66 0f eb c2 por xmm0,xmm2
if (is_csv)
e8e: 45 84 e4 test r12b,r12b
e91: 0f 84 01 02 00 00 je 1098 <CopyReadLine+0x738>
return (__m128i) ((__v16qi)__A == (__v16qi)__B);
e97: 66 0f 6f 54 24 30 movdqa xmm2,XMMWORD PTR [rsp+0x30]
if (escapec != '\0')
e9d: 80 7c 24 0c 00 cmp BYTE PTR [rsp+0xc],0x0
ea2: 66 0f 74 d1 pcmpeqb xmm2,xmm1
return (__m128i) ((__v2du)__A | (__v2du)__B);
ea6: 66 0f eb c2 por xmm0,xmm2
eaa: 0f 85 d8 03 00 00 jne 1288 <CopyReadLine+0x928>
}
extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movemask_epi8 (__m128i __A)
{
return __builtin_ia32_pmovmskb128 ((__v16qi)__A);
eb0: 66 0f d7 d0 pmovmskb edx,xmm0
if (mask != 0)
eb4: 85 d2 test edx,edx
eb6: 0f 84 c4 01 00 00 je 1080 <CopyReadLine+0x720>
pg_rightmost_one_pos32(uint32 word)
{
#ifdef HAVE__BUILTIN_CTZ
Assert(word != 0);
return __builtin_ctz(word);
ebc: f3 0f bc d2 tzcnt edx,edx
simd_total_advance += advance;
ec0: 48 01 54 24 28 add QWORD PTR [rsp+0x28],rdx
input_buf_ptr += advance;
ec5: 41 01 d7 add r15d,edx
simd_total_advance += advance;
ec8: e9 a0 fc ff ff jmp b6d <CopyReadLine+0x20d>
ecd: 0f 1f 00 nop DWORD PTR [rax]
REFILL_LINEBUF;
ed0: 48 8b 7c 24 10 mov rdi,QWORD PTR [rsp+0x10]
ed5: 44 89 e2 mov edx,r12d
ed8: 48 63 f0 movsxd rsi,eax
edb: 48 03 b3 00 02 00 00 add rsi,QWORD PTR [rbx+0x200]
ee2: 29 c2 sub edx,eax
ee4: e8 00 00 00 00 call ee9 <CopyReadLine+0x589>
ee9: 44 89 a3 08 02 00 00 mov DWORD PTR [rbx+0x208],r12d
ef0: e9 64 fd ff ff jmp c59 <CopyReadLine+0x2f9>
ef5: 0f 1f 00 nop DWORD PTR [rax]
if (c == '\r' && (!is_csv || !in_quote))
ef8: c6 44 24 08 00 mov BYTE PTR [rsp+0x8],0x0
efd: 45 89 c5 mov r13d,r8d
if (cstate->eol_type == EOL_UNKNOWN ||
f00: 8b 53 20 mov edx,DWORD PTR [rbx+0x20]
f03: 85 d2 test edx,edx
f05: 40 0f 94 c5 sete bpl
f09: 83 fa 03 cmp edx,0x3
f0c: 41 0f 94 c0 sete r8b
f10: 44 08 c5 or bpl,r8b
f13: 0f 84 30 05 00 00 je 1449 <CopyReadLine+0xae9>
IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(0);
f19: 39 ce cmp esi,ecx
f1b: 40 0f 9e c5 setle bpl
f1f: 83 f7 01 xor edi,0x1
f22: 40 20 fd and bpl,dil
f25: 0f 85 33 fe ff ff jne d5e <CopyReadLine+0x3fe>
c = copy_input_buf[input_buf_ptr];
f2b: 48 63 f1 movsxd rsi,ecx
if (c == '\n')
f2e: 41 80 3c 37 0a cmp BYTE PTR [r15+rsi*1],0xa
f33: 0f 84 67 03 00 00 je 12a0 <CopyReadLine+0x940>
if (cstate->eol_type == EOL_CRNL)
f39: 83 fa 03 cmp edx,0x3
f3c: 0f 84 00 00 00 00 je f42 <CopyReadLine+0x5e2>
cstate->eol_type = EOL_CR;
f42: c7 43 20 02 00 00 00 mov DWORD PTR [rbx+0x20],0x2
prev_raw_ptr > cstate->input_buf_index)
f49: 41 89 c4 mov r12d,eax
if (cstate->simd_current_sleep_cycle == 0)
f4c: 66 83 ab 46 01 00 00 sub WORD PTR [rbx+0x146],0x1
f53: 01
f54: 75 07 jne f5d <CopyReadLine+0x5fd>
cstate->simd_continue = true;
f56: c6 83 41 01 00 00 01 mov BYTE PTR [rbx+0x141],0x1
REFILL_LINEBUF;
f5d: 39 c8 cmp eax,ecx
f5f: 0f 8c 3e 04 00 00 jl 13a3 <CopyReadLine+0xa43>
if (result)
f65: 40 84 ed test bpl,bpl
f68: 0f 85 da 01 00 00 jne 1148 <CopyReadLine+0x7e8>
switch (cstate->eol_type)
f6e: 8b 43 20 mov eax,DWORD PTR [rbx+0x20]
f71: 83 f8 02 cmp eax,0x2
f74: 74 0e je f84 <CopyReadLine+0x624>
f76: 83 f8 03 cmp eax,0x3
f79: 0f 84 51 04 00 00 je 13d0 <CopyReadLine+0xa70>
f7f: 83 f8 01 cmp eax,0x1
f82: 75 1c jne fa0 <CopyReadLine+0x640>
cstate->line_buf.len--;
f84: 8b 83 e8 01 00 00 mov eax,DWORD PTR [rbx+0x1e8]
cstate->line_buf.data[cstate->line_buf.len] = '\0';
f8a: 48 8b 93 e0 01 00 00 mov rdx,QWORD PTR [rbx+0x1e0]
cstate->line_buf.len--;
f91: 83 e8 01 sub eax,0x1
f94: 89 83 e8 01 00 00 mov DWORD PTR [rbx+0x1e8],eax
cstate->line_buf.data[cstate->line_buf.len] = '\0';
f9a: 48 98 cdqe
f9c: c6 04 02 00 mov BYTE PTR [rdx+rax*1],0x0
cstate->line_buf_valid = true;
fa0: c6 83 f8 01 00 00 01 mov BYTE PTR [rbx+0x1f8],0x1
}
fa7: 48 83 c4 58 add rsp,0x58
fab: 89 e8 mov eax,ebp
fad: 5b pop rbx
fae: 5d pop rbp
faf: 41 5c pop r12
fb1: 41 5d pop r13
fb3: 41 5e pop r14
fb5: 41 5f pop r15
fb7: c3 ret
fb8: 0f 1f 84 00 00 00 00 nop DWORD PTR [rax+rax*1+0x0]
fbf: 00
if (c == '\r' && (!is_csv || !in_quote))
fc0: 41 89 fd mov r13d,edi
if (cstate->eol_type == EOL_UNKNOWN ||
fc3: 8b 53 20 mov edx,DWORD PTR [rbx+0x20]
fc6: 85 d2 test edx,edx
fc8: 40 0f 94 c5 sete bpl
fcc: 83 fa 03 cmp edx,0x3
fcf: 40 0f 94 c7 sete dil
fd3: 40 08 fd or bpl,dil
fd6: 0f 84 5c 04 00 00 je 1438 <CopyReadLine+0xad8>
IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(0);
fdc: 44 39 c1 cmp ecx,r8d
fdf: 40 0f 9e c5 setle bpl
fe3: 83 f6 01 xor esi,0x1
fe6: 40 20 f5 and bpl,sil
fe9: 0f 85 8e fd ff ff jne d7d <CopyReadLine+0x41d>
c = copy_input_buf[input_buf_ptr];
fef: 49 63 c8 movsxd rcx,r8d
if (c == '\n')
ff2: 41 80 3c 0e 0a cmp BYTE PTR [r14+rcx*1],0xa
ff7: 0f 84 bb 02 00 00 je 12b8 <CopyReadLine+0x958>
if (cstate->eol_type == EOL_CRNL)
ffd: 83 fa 03 cmp edx,0x3
1000: 0f 84 00 00 00 00 je 1006 <CopyReadLine+0x6a6>
cstate->eol_type = EOL_CR;
1006: c7 43 20 02 00 00 00 mov DWORD PTR [rbx+0x20],0x2
prev_raw_ptr > cstate->input_buf_index)
100d: 41 89 c7 mov r15d,eax
if (simd_total_cycle && simd_total_advance / simd_total_cycle >= SIMD_ADVANCE_AT_LEAST)
1010: 48 8b 74 24 20 mov rsi,QWORD PTR [rsp+0x20]
cstate->simd_last_sleep_cycle >>= 1;
1015: 0f b7 8b 44 01 00 00 movzx ecx,WORD PTR [rbx+0x144]
if (simd_total_cycle && simd_total_advance / simd_total_cycle >= SIMD_ADVANCE_AT_LEAST)
101c: 48 85 f6 test rsi,rsi
101f: 0f 84 4b 03 00 00 je 1370 <CopyReadLine+0xa10>
1025: 48 8b 44 24 28 mov rax,QWORD PTR [rsp+0x28]
102a: 31 d2 xor edx,edx
102c: 48 f7 f6 div rsi
102f: 48 83 f8 04 cmp rax,0x4
1033: 0f 86 37 03 00 00 jbe 1370 <CopyReadLine+0xa10>
cstate->simd_last_sleep_cycle >>= 1;
1039: 89 c8 mov eax,ecx
103b: 66 d1 e8 shr ax,1
103e: 66 89 83 44 01 00 00 mov WORD PTR [rbx+0x144],ax
REFILL_LINEBUF;
1045: 45 39 f8 cmp r8d,r15d
1048: 0f 8e 17 ff ff ff jle f65 <CopyReadLine+0x605>
104e: 44 89 c2 mov edx,r8d
1051: 48 8b 7c 24 10 mov rdi,QWORD PTR [rsp+0x10]
1056: 49 63 f7 movsxd rsi,r15d
1059: 44 89 44 24 08 mov DWORD PTR [rsp+0x8],r8d
105e: 44 29 fa sub edx,r15d
1061: 48 03 b3 00 02 00 00 add rsi,QWORD PTR [rbx+0x200]
1068: e8 00 00 00 00 call 106d <CopyReadLine+0x70d>
106d: 44 8b 44 24 08 mov r8d,DWORD PTR [rsp+0x8]
1072: 44 89 83 08 02 00 00 mov DWORD PTR [rbx+0x208],r8d
1079: e9 e7 fe ff ff jmp f65 <CopyReadLine+0x605>
107e: 66 90 xchg ax,ax
simd_total_advance += sizeof(Vector8);
1080: 48 83 44 24 28 10 add QWORD PTR [rsp+0x28],0x10
input_buf_ptr += sizeof(Vector8);
1086: 41 83 c7 10 add r15d,0x10
simd_total_advance += sizeof(Vector8);
108a: 45 31 ed xor r13d,r13d
108d: 31 ed xor ebp,ebp
108f: e9 82 fa ff ff jmp b16 <CopyReadLine+0x1b6>
1094: 0f 1f 40 00 nop DWORD PTR [rax+0x0]
return (__m128i) ((__v16qi)__A == (__v16qi)__B);
1098: 66 0f 74 0d 00 00 00 pcmpeqb xmm1,XMMWORD PTR [rip+0x0] # 10a0 <CopyReadLine+0x740>
109f: 00
return (__m128i) ((__v2du)__A | (__v2du)__B);
10a0: 66 0f eb c1 por xmm0,xmm1
10a4: e9 07 fe ff ff jmp eb0 <CopyReadLine+0x550>
10a9: 0f 1f 80 00 00 00 00 nop DWORD PTR [rax+0x0]
if (cstate->eol_type == EOL_CRNL)
10b0: 8b 7b 20 mov edi,DWORD PTR [rbx+0x20]
10b3: 83 ff 03 cmp edi,0x3
10b6: 0f 84 34 02 00 00 je 12f0 <CopyReadLine+0x990>
IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(0);
10bc: 44 39 de cmp esi,r11d
10bf: 40 0f 9e c5 setle bpl
10c3: 40 20 d5 and bpl,dl
10c6: 0f 85 92 fc ff ff jne d5e <CopyReadLine+0x3fe>
c2 = copy_input_buf[input_buf_ptr++];
10cc: 41 8d 4b 01 lea ecx,[r11+0x1]
10d0: 4d 63 db movsxd r11,r11d
10d3: 44 0f b6 54 24 20 movzx r10d,BYTE PTR [rsp+0x20]
10d9: 43 0f b6 04 1f movzx eax,BYTE PTR [r15+r11*1]
if (c2 != '\r' && c2 != '\n')
10de: 3c 0d cmp al,0xd
10e0: 40 0f 95 c6 setne sil
10e4: 3c 0a cmp al,0xa
10e6: 74 09 je 10f1 <CopyReadLine+0x791>
10e8: 40 84 f6 test sil,sil
10eb: 0f 85 00 00 00 00 jne 10f1 <CopyReadLine+0x791>
if ((cstate->eol_type == EOL_NL && c2 != '\n') ||
10f1: 89 fa mov edx,edi
10f3: 83 e2 fd and edx,0xfffffffd
10f6: 83 fa 01 cmp edx,0x1
10f9: 0f 85 f9 02 00 00 jne 13f8 <CopyReadLine+0xa98>
10ff: 3c 0a cmp al,0xa
1101: 0f 85 a8 03 00 00 jne 14af <CopyReadLine+0xb4f>
if (cstate->line_buf.len > 0 ||
1107: 8b 83 e8 01 00 00 mov eax,DWORD PTR [rbx+0x1e8]
110d: 85 c0 test eax,eax
110f: 0f 8f 00 00 00 00 jg 1115 <CopyReadLine+0x7b5>
1115: 44 3b a3 08 02 00 00 cmp r12d,DWORD PTR [rbx+0x208]
111c: 0f 8f 00 00 00 00 jg 1122 <CopyReadLine+0x7c2>
cstate->input_buf_index = input_buf_ptr;
1122: 89 8b 08 02 00 00 mov DWORD PTR [rbx+0x208],ecx
break;
1128: 41 89 cc mov r12d,ecx
if (cstate->simd_current_sleep_cycle == 0)
112b: 66 83 ab 46 01 00 00 sub WORD PTR [rbx+0x146],0x1
1132: 01
1133: 75 13 jne 1148 <CopyReadLine+0x7e8>
cstate->simd_continue = true;
1135: c6 83 41 01 00 00 01 mov BYTE PTR [rbx+0x141],0x1
REFILL_LINEBUF;
113c: 44 39 e1 cmp ecx,r12d
113f: 0f 8f 5b 02 00 00 jg 13a0 <CopyReadLine+0xa40>
1145: 0f 1f 00 nop DWORD PTR [rax]
if (cstate->copy_src == COPY_FRONTEND)
1148: 83 7b 08 01 cmp DWORD PTR [rbx+0x8],0x1
114c: 0f 84 ce 00 00 00 je 1220 <CopyReadLine+0x8c0>
REFILL_LINEBUF;
1152: bd 01 00 00 00 mov ebp,0x1
1157: e9 44 fe ff ff jmp fa0 <CopyReadLine+0x640>
115c: 0f 1f 40 00 nop DWORD PTR [rax+0x0]
if (cstate->eol_type == EOL_CRNL)
1160: 8b 73 20 mov esi,DWORD PTR [rbx+0x20]
1163: 83 fe 03 cmp esi,0x3
1166: 0f 84 c4 01 00 00 je 1330 <CopyReadLine+0x9d0>
IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(0);
116c: 39 f9 cmp ecx,edi
116e: 40 0f 9e c5 setle bpl
1172: 40 20 d5 and bpl,dl
1175: 0f 85 02 fc ff ff jne d7d <CopyReadLine+0x41d>
c2 = copy_input_buf[input_buf_ptr++];
117b: 44 8d 47 01 lea r8d,[rdi+0x1]
117f: 48 63 ff movsxd rdi,edi
1182: 41 0f b6 04 3e movzx eax,BYTE PTR [r14+rdi*1]
if (c2 != '\r' && c2 != '\n')
1187: 3c 0d cmp al,0xd
1189: 0f 95 c1 setne cl
118c: 3c 0a cmp al,0xa
118e: 74 08 je 1198 <CopyReadLine+0x838>
1190: 84 c9 test cl,cl
1192: 0f 85 00 00 00 00 jne 1198 <CopyReadLine+0x838>
if ((cstate->eol_type == EOL_NL && c2 != '\n') ||
1198: 89 f2 mov edx,esi
119a: 83 e2 fd and edx,0xfffffffd
119d: 83 fa 01 cmp edx,0x1
11a0: 0f 85 6a 02 00 00 jne 1410 <CopyReadLine+0xab0>
11a6: 3c 0a cmp al,0xa
11a8: 0f 85 fc 02 00 00 jne 14aa <CopyReadLine+0xb4a>
if (cstate->line_buf.len > 0 ||
11ae: 8b 93 e8 01 00 00 mov edx,DWORD PTR [rbx+0x1e8]
11b4: 85 d2 test edx,edx
11b6: 0f 8f 00 00 00 00 jg 11bc <CopyReadLine+0x85c>
11bc: 44 3b bb 08 02 00 00 cmp r15d,DWORD PTR [rbx+0x208]
11c3: 0f 8f 00 00 00 00 jg 11c9 <CopyReadLine+0x869>
cstate->input_buf_index = input_buf_ptr;
11c9: 44 89 83 08 02 00 00 mov DWORD PTR [rbx+0x208],r8d
break;
11d0: 45 89 c7 mov r15d,r8d
result = true; /* report EOF */
11d3: bd 01 00 00 00 mov ebp,0x1
break;
11d8: e9 33 fe ff ff jmp 1010 <CopyReadLine+0x6b0>
11dd: 0f 1f 00 nop DWORD PTR [rax]
if (in_quote && c == (cstate->eol_type == EOL_NL ? '\n' : '\r'))
11e0: 41 83 f8 0a cmp r8d,0xa
11e4: 75 72 jne 1258 <CopyReadLine+0x8f8>
cstate->cur_lineno++;
11e6: 48 83 83 28 01 00 00 add QWORD PTR [rbx+0x128],0x1
11ed: 01
if (c == '\r' && (!is_csv || !in_quote))
11ee: 44 88 74 24 08 mov BYTE PTR [rsp+0x8],r14b
11f3: 45 89 dd mov r13d,r11d
11f6: 31 ed xor ebp,ebp
c = copy_input_buf[input_buf_ptr++];
11f8: 41 89 cc mov r12d,ecx
11fb: e9 11 f8 ff ff jmp a11 <CopyReadLine+0xb1>
if (in_quote && c == (cstate->eol_type == EOL_NL ? '\n' : '\r'))
1200: 83 ff 0a cmp edi,0xa
1203: 75 6b jne 1270 <CopyReadLine+0x910>
cstate->cur_lineno++;
1205: 48 83 83 28 01 00 00 add QWORD PTR [rbx+0x128],0x1
120c: 01
if (c == '\r' && (!is_csv || !in_quote))
120d: 44 88 64 24 08 mov BYTE PTR [rsp+0x8],r12b
1212: 45 89 d5 mov r13d,r10d
c = copy_input_buf[input_buf_ptr++];
1215: 45 89 c7 mov r15d,r8d
1218: 31 ed xor ebp,ebp
121a: e9 f7 f8 ff ff jmp b16 <CopyReadLine+0x1b6>
121f: 90 nop
inbytes = CopyGetData(cstate, cstate->input_buf,
1220: 48 8b b3 00 02 00 00 mov rsi,QWORD PTR [rbx+0x200]
1227: ba 00 00 01 00 mov edx,0x10000
122c: 48 89 df mov rdi,rbx
122f: e8 3c f1 ff ff call 370 <CopyGetData.constprop.0>
} while (inbytes > 0);
1234: 85 c0 test eax,eax
1236: 7f e8 jg 1220 <CopyReadLine+0x8c0>
cstate->input_buf_index = 0;
1238: 48 c7 83 08 02 00 00 mov QWORD PTR [rbx+0x208],0x0
123f: 00 00 00 00
cstate->raw_buf_index = 0;
1243: 48 c7 83 20 02 00 00 mov QWORD PTR [rbx+0x220],0x0
124a: 00 00 00 00
124e: e9 ff fe ff ff jmp 1152 <CopyReadLine+0x7f2>
1253: 0f 1f 44 00 00 nop DWORD PTR [rax+rax*1+0x0]
if (c == '\r' && (!is_csv || !in_quote))
1258: 80 fa 0d cmp dl,0xd
125b: 74 91 je 11ee <CopyReadLine+0x88e>
if (c == '\n' && (!is_csv || !in_quote))
125d: 44 88 74 24 08 mov BYTE PTR [rsp+0x8],r14b
1262: 45 89 d8 mov r8d,r11d
1265: e9 26 f8 ff ff jmp a90 <CopyReadLine+0x130>
126a: 66 0f 1f 44 00 00 nop WORD PTR [rax+rax*1+0x0]
if (c == '\r' && (!is_csv || !in_quote))
1270: 80 fa 0d cmp dl,0xd
1273: 74 98 je 120d <CopyReadLine+0x8ad>
if (c == '\n' && (!is_csv || !in_quote))
1275: 44 88 64 24 08 mov BYTE PTR [rsp+0x8],r12b
127a: 44 89 d7 mov edi,r10d
127d: e9 4f f9 ff ff jmp bd1 <CopyReadLine+0x271>
1282: 66 0f 1f 44 00 00 nop WORD PTR [rax+rax*1+0x0]
return (__m128i) ((__v16qi)__A == (__v16qi)__B);
1288: 66 0f 74 4c 24 40 pcmpeqb xmm1,XMMWORD PTR [rsp+0x40]
return (__m128i) ((__v2du)__A | (__v2du)__B);
128e: 66 0f eb c1 por xmm0,xmm1
1292: e9 19 fc ff ff jmp eb0 <CopyReadLine+0x550>
1297: 66 0f 1f 84 00 00 00 nop WORD PTR [rax+rax*1+0x0]
129e: 00 00
input_buf_ptr++; /* eat newline */
12a0: 41 8d 4c 24 02 lea ecx,[r12+0x2]
cstate->eol_type = EOL_CRNL; /* in case not set yet */
12a5: c7 43 20 03 00 00 00 mov DWORD PTR [rbx+0x20],0x3
prev_raw_ptr > cstate->input_buf_index)
12ac: 41 89 c4 mov r12d,eax
12af: e9 98 fc ff ff jmp f4c <CopyReadLine+0x5ec>
12b4: 0f 1f 40 00 nop DWORD PTR [rax+0x0]
input_buf_ptr++; /* eat newline */
12b8: 45 8d 47 02 lea r8d,[r15+0x2]
cstate->eol_type = EOL_CRNL; /* in case not set yet */
12bc: c7 43 20 03 00 00 00 mov DWORD PTR [rbx+0x20],0x3
prev_raw_ptr > cstate->input_buf_index)
12c3: 41 89 c7 mov r15d,eax
12c6: e9 45 fd ff ff jmp 1010 <CopyReadLine+0x6b0>
12cb: 0f 1f 44 00 00 nop DWORD PTR [rax+rax*1+0x0]
Vector8 escape = vector8_broadcast(0);
12d0: 66 0f ef ff pxor xmm7,xmm7
12d4: 0f 29 7c 24 40 movaps XMMWORD PTR [rsp+0x40],xmm7
if (quotec != escapec)
12d9: 84 c9 test cl,cl
12db: 0f 84 f8 f7 ff ff je ad9 <CopyReadLine+0x179>
12e1: c6 44 24 0c 00 mov BYTE PTR [rsp+0xc],0x0
12e6: e9 31 f9 ff ff jmp c1c <CopyReadLine+0x2bc>
12eb: 0f 1f 44 00 00 nop DWORD PTR [rax+rax*1+0x0]
IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(0);
12f0: 44 39 de cmp esi,r11d
12f3: 40 0f 9e c5 setle bpl
12f7: 40 20 d5 and bpl,dl
12fa: 0f 85 5e fa ff ff jne d5e <CopyReadLine+0x3fe>
c2 = copy_input_buf[input_buf_ptr++];
1300: 4d 63 db movsxd r11,r11d
1303: 45 8d 44 24 03 lea r8d,[r12+0x3]
1308: 43 0f b6 0c 1f movzx ecx,BYTE PTR [r15+r11*1]
if (c2 == '\n')
130d: 80 f9 0a cmp cl,0xa
1310: 0f 84 00 00 00 00 je 1316 <CopyReadLine+0x9b6>
else if (c2 != '\r')
1316: 80 f9 0d cmp cl,0xd
1319: 0f 85 00 00 00 00 jne 131f <CopyReadLine+0x9bf>
c2 = copy_input_buf[input_buf_ptr++];
131f: 45 89 c3 mov r11d,r8d
1322: e9 95 fd ff ff jmp 10bc <CopyReadLine+0x75c>
1327: 66 0f 1f 84 00 00 00 nop WORD PTR [rax+rax*1+0x0]
132e: 00 00
IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(0);
1330: 39 f9 cmp ecx,edi
1332: 40 0f 9e c5 setle bpl
1336: 40 20 d5 and bpl,dl
1339: 0f 85 3e fa ff ff jne d7d <CopyReadLine+0x41d>
c2 = copy_input_buf[input_buf_ptr++];
133f: 48 63 ff movsxd rdi,edi
1342: 45 8d 47 03 lea r8d,[r15+0x3]
1346: 41 0f b6 3c 3e movzx edi,BYTE PTR [r14+rdi*1]
if (c2 == '\n')
134b: 40 80 ff 0a cmp dil,0xa
134f: 0f 84 00 00 00 00 je 1355 <CopyReadLine+0x9f5>
else if (c2 != '\r')
1355: 40 80 ff 0d cmp dil,0xd
1359: 0f 85 00 00 00 00 jne 135f <CopyReadLine+0x9ff>
c2 = copy_input_buf[input_buf_ptr++];
135f: 44 89 c7 mov edi,r8d
1362: e9 05 fe ff ff jmp 116c <CopyReadLine+0x80c>
1367: 66 0f 1f 84 00 00 00 nop WORD PTR [rax+rax*1+0x0]
136e: 00 00
cstate->simd_continue = false;
1370: c6 83 41 01 00 00 00 mov BYTE PTR [rbx+0x141],0x0
simd_last_sleep_cycle = 1;
1377: b8 01 00 00 00 mov eax,0x1
if (simd_last_sleep_cycle == 0)
137c: 66 85 c9 test cx,cx
137f: 74 10 je 1391 <CopyReadLine+0xa31>
simd_last_sleep_cycle <<= 1;
1381: 8d 04 09 lea eax,[rcx+rcx*1]
1384: 66 81 f9 00 02 cmp cx,0x200
1389: ba 00 04 00 00 mov edx,0x400
138e: 0f 43 c2 cmovae eax,edx
cstate->simd_current_sleep_cycle = simd_last_sleep_cycle;
1391: 66 89 83 46 01 00 00 mov WORD PTR [rbx+0x146],ax
cstate->simd_last_sleep_cycle = simd_last_sleep_cycle;
1398: e9 a1 fc ff ff jmp 103e <CopyReadLine+0x6de>
139d: 0f 1f 00 nop DWORD PTR [rax]
REFILL_LINEBUF;
13a0: 44 89 d5 mov ebp,r10d
13a3: 89 ca mov edx,ecx
13a5: 48 8b 7c 24 10 mov rdi,QWORD PTR [rsp+0x10]
13aa: 49 63 f4 movsxd rsi,r12d
13ad: 89 4c 24 08 mov DWORD PTR [rsp+0x8],ecx
13b1: 44 29 e2 sub edx,r12d
13b4: 48 03 b3 00 02 00 00 add rsi,QWORD PTR [rbx+0x200]
13bb: e8 00 00 00 00 call 13c0 <CopyReadLine+0xa60>
13c0: 8b 4c 24 08 mov ecx,DWORD PTR [rsp+0x8]
13c4: 89 8b 08 02 00 00 mov DWORD PTR [rbx+0x208],ecx
13ca: e9 96 fb ff ff jmp f65 <CopyReadLine+0x605>
13cf: 90 nop
cstate->line_buf.len -= 2;
13d0: 8b 83 e8 01 00 00 mov eax,DWORD PTR [rbx+0x1e8]
cstate->line_buf.data[cstate->line_buf.len] = '\0';
13d6: 48 8b 93 e0 01 00 00 mov rdx,QWORD PTR [rbx+0x1e0]
cstate->line_buf.len -= 2;
13dd: 83 e8 02 sub eax,0x2
13e0: 89 83 e8 01 00 00 mov DWORD PTR [rbx+0x1e8],eax
cstate->line_buf.data[cstate->line_buf.len] = '\0';
13e6: 48 98 cdqe
13e8: c6 04 02 00 mov BYTE PTR [rdx+rax*1],0x0
break;
13ec: e9 af fb ff ff jmp fa0 <CopyReadLine+0x640>
13f1: 0f 1f 80 00 00 00 00 nop DWORD PTR [rax+0x0]
(cstate->eol_type == EOL_CR && c2 != '\r'))
13f8: 83 ff 02 cmp edi,0x2
13fb: 0f 85 06 fd ff ff jne 1107 <CopyReadLine+0x7a7>
1401: 40 84 f6 test sil,sil
1404: 0f 84 fd fc ff ff je 1107 <CopyReadLine+0x7a7>
140a: e9 00 00 00 00 jmp 140f <CopyReadLine+0xaaf>
140f: 90 nop
1410: 83 fe 02 cmp esi,0x2
1413: 0f 85 95 fd ff ff jne 11ae <CopyReadLine+0x84e>
1419: 84 c9 test cl,cl
141b: 0f 84 8d fd ff ff je 11ae <CopyReadLine+0x84e>
1421: e9 00 00 00 00 jmp 1426 <CopyReadLine+0xac6>
1426: 66 2e 0f 1f 84 00 00 cs nop WORD PTR [rax+rax*1+0x0]
142d: 00 00 00
input_buf_ptr = cstate->input_buf_index;
1430: 45 89 f8 mov r8d,r15d
1433: e9 d8 fb ff ff jmp 1010 <CopyReadLine+0x6b0>
else if (cstate->eol_type == EOL_NL)
1438: 83 fa 01 cmp edx,0x1
143b: 0f 84 00 00 00 00 je 1441 <CopyReadLine+0xae1>
prev_raw_ptr > cstate->input_buf_index)
1441: 41 89 c7 mov r15d,eax
1444: e9 c7 fb ff ff jmp 1010 <CopyReadLine+0x6b0>
else if (cstate->eol_type == EOL_NL)
1449: 83 fa 01 cmp edx,0x1
144c: 0f 84 00 00 00 00 je 1452 <CopyReadLine+0xaf2>
prev_raw_ptr > cstate->input_buf_index)
1452: 41 89 c4 mov r12d,eax
1455: e9 f2 fa ff ff jmp f4c <CopyReadLine+0x5ec>
145a: 66 0f 1f 44 00 00 nop WORD PTR [rax+rax*1+0x0]
if (cstate->eol_type == EOL_CR || cstate->eol_type == EOL_CRNL)
1460: 8b 73 20 mov esi,DWORD PTR [rbx+0x20]
1463: 8d 56 fe lea edx,[rsi-0x2]
1466: 83 fa 01 cmp edx,0x1
1469: 0f 86 00 00 00 00 jbe 146f <CopyReadLine+0xb0f>
cstate->eol_type = EOL_NL; /* in case not set yet */
146f: c7 43 20 01 00 00 00 mov DWORD PTR [rbx+0x20],0x1
prev_raw_ptr > cstate->input_buf_index)
1476: 41 89 c4 mov r12d,eax
bool result = false;
1479: 31 ed xor ebp,ebp
break;
147b: e9 cc fa ff ff jmp f4c <CopyReadLine+0x5ec>
if (cstate->eol_type == EOL_CR || cstate->eol_type == EOL_CRNL)
1480: 8b 4b 20 mov ecx,DWORD PTR [rbx+0x20]
1483: 8d 51 fe lea edx,[rcx-0x2]
1486: 83 fa 01 cmp edx,0x1
1489: 0f 86 00 00 00 00 jbe 148f <CopyReadLine+0xb2f>
cstate->eol_type = EOL_NL; /* in case not set yet */
148f: c7 43 20 01 00 00 00 mov DWORD PTR [rbx+0x20],0x1
prev_raw_ptr > cstate->input_buf_index)
1496: 41 89 c7 mov r15d,eax
bool result = false;
1499: 31 ed xor ebp,ebp
break;
149b: e9 70 fb ff ff jmp 1010 <CopyReadLine+0x6b0>
14a0: 31 ed xor ebp,ebp
c = copy_input_buf[input_buf_ptr++];
14a2: 45 89 c7 mov r15d,r8d
14a5: e9 6c f6 ff ff jmp b16 <CopyReadLine+0x1b6>
14aa: e9 00 00 00 00 jmp 14af <CopyReadLine+0xb4f>
14af: e9 00 00 00 00 jmp 14b4 <CopyReadLine+0xb54>
14b4: 66 66 2e 0f 1f 84 00 data16 cs nop WORD PTR [rax+rax*1+0x0]
14bb: 00 00 00 00
14bf: 90 nop