copyfromparse-variable.asm
application/octet-stream
Filename: copyfromparse-variable.asm
Type: application/octet-stream
Part: 1
0000000000000710 <CopyReadLine>:
{
710: 41 57 push r15
resetStringInfo(&cstate->line_buf);
712: 48 8d 87 e0 01 00 00 lea rax,[rdi+0x1e0]
{
719: 41 56 push r14
71b: 41 55 push r13
71d: 49 89 fd mov r13,rdi
resetStringInfo(&cstate->line_buf);
720: 48 89 c7 mov rdi,rax
{
723: 41 54 push r12
725: 55 push rbp
726: 53 push rbx
727: 48 83 ec 68 sub rsp,0x68
72b: 89 74 24 3c mov DWORD PTR [rsp+0x3c],esi
72f: 40 88 74 24 38 mov BYTE PTR [rsp+0x38],sil
resetStringInfo(&cstate->line_buf);
734: 48 89 44 24 28 mov QWORD PTR [rsp+0x28],rax
739: e8 00 00 00 00 call 73e <CopyReadLine+0x2e>
if (unlikely(!cstate->simd_initialized))
73e: 41 80 bd 42 01 00 00 cmp BYTE PTR [r13+0x142],0x0
745: 00
cstate->line_buf_valid = false;
746: 41 c6 85 f8 01 00 00 mov BYTE PTR [r13+0x1f8],0x0
74d: 00
if (unlikely(!cstate->simd_initialized))
74e: 0f 84 a8 09 00 00 je 10fc <CopyReadLine+0x9ec>
result = CopyReadLineText(cstate, is_csv, cstate->simd_continue);
754: 41 0f b6 85 41 01 00 movzx eax,BYTE PTR [r13+0x141]
75b: 00
75c: 88 44 24 3a mov BYTE PTR [rsp+0x3a],al
if (is_csv)
760: 80 7c 24 3c 00 cmp BYTE PTR [rsp+0x3c],0x0
765: 74 59 je 7c0 <CopyReadLine+0xb0>
quotec = cstate->opts.quote[0];
767: 49 8b 85 98 00 00 00 mov rax,QWORD PTR [r13+0x98]
76e: 0f b6 38 movzx edi,BYTE PTR [rax]
escapec = cstate->opts.escape[0];
771: 49 8b 85 a0 00 00 00 mov rax,QWORD PTR [r13+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){
778: 66 0f 6e c7 movd xmm0,edi
77c: 0f b6 08 movzx ecx,BYTE PTR [rax]
quotec = cstate->opts.quote[0];
77f: 40 88 7c 24 3b mov BYTE PTR [rsp+0x3b],dil
784: 66 0f 60 c0 punpcklbw xmm0,xmm0
788: 66 0f 61 c0 punpcklwd xmm0,xmm0
escapec = cstate->opts.escape[0];
78c: 88 4c 24 1c mov BYTE PTR [rsp+0x1c],cl
790: 66 0f 70 d8 00 pshufd xmm3,xmm0,0x0
795: 0f 29 5c 24 40 movaps XMMWORD PTR [rsp+0x40],xmm3
if (quotec == escapec)
79a: 40 38 cf cmp dil,cl
79d: 0f 84 7d 08 00 00 je 1020 <CopyReadLine+0x910>
7a3: 66 0f 6e 44 24 1c movd xmm0,DWORD PTR [rsp+0x1c]
7a9: 66 0f 60 c0 punpcklbw xmm0,xmm0
7ad: 66 0f 61 c0 punpcklwd xmm0,xmm0
7b1: 66 0f 70 f0 00 pshufd xmm6,xmm0,0x0
7b6: 0f 29 74 24 50 movaps XMMWORD PTR [rsp+0x50],xmm6
7bb: eb 1b jmp 7d8 <CopyReadLine+0xc8>
7bd: 0f 1f 00 nop DWORD PTR [rax]
char escapec = '\0';
7c0: c6 44 24 1c 00 mov BYTE PTR [rsp+0x1c],0x0
Vector8 escape = vector8_broadcast(0);
7c5: 66 0f ef e4 pxor xmm4,xmm4
char quotec = '\0';
7c9: c6 44 24 3b 00 mov BYTE PTR [rsp+0x3b],0x0
Vector8 escape = vector8_broadcast(0);
7ce: 0f 29 64 24 50 movaps XMMWORD PTR [rsp+0x50],xmm4
Vector8 quote = vector8_broadcast(0);
7d3: 0f 29 64 24 40 movaps XMMWORD PTR [rsp+0x40],xmm4
input_buf_ptr = cstate->input_buf_index;
7d8: 41 8b 85 08 02 00 00 mov eax,DWORD PTR [r13+0x208]
bool in_quote = false,
7df: 45 31 ff xor r15d,r15d
last_was_esc = false;
7e2: 31 ed xor ebp,ebp
bool hit_eof = false;
7e4: 31 d2 xor edx,edx
uint64 simd_total_advance = 0;
7e6: 48 c7 44 24 30 00 00 mov QWORD PTR [rsp+0x30],0x0
7ed: 00 00
copy_input_buf = cstate->input_buf;
7ef: 4d 8b b5 00 02 00 00 mov r14,QWORD PTR [r13+0x200]
bool need_data = false;
7f6: 31 c9 xor ecx,ecx
7f8: 41 89 ec mov r12d,ebp
copy_buf_len = cstate->input_buf_len;
7fb: 41 8b 9d 0c 02 00 00 mov ebx,DWORD PTR [r13+0x20c]
802: 44 88 7c 24 39 mov BYTE PTR [rsp+0x39],r15b
input_buf_ptr = cstate->input_buf_index;
807: 41 89 c0 mov r8d,eax
copy_buf_len = cstate->input_buf_len;
80a: 4d 89 ef mov r15,r13
uint64 simd_total_cycle = 0;
80d: 48 c7 44 24 20 00 00 mov QWORD PTR [rsp+0x20],0x0
814: 00 00
if (input_buf_ptr >= copy_buf_len || need_data)
816: 41 39 d8 cmp r8d,ebx
819: 40 0f 9d c6 setge sil
81d: 40 08 f1 or cl,sil
820: 0f 84 0b 02 00 00 je a31 <CopyReadLine+0x321>
REFILL_LINEBUF;
826: 41 39 c0 cmp r8d,eax
829: 0f 8f 19 04 00 00 jg c48 <CopyReadLine+0x538>
int nbytes = INPUT_BUF_BYTES(cstate);
82f: 41 8b 9f 0c 02 00 00 mov ebx,DWORD PTR [r15+0x20c]
if (cstate->raw_buf == cstate->input_buf)
836: 49 8b bf 00 02 00 00 mov rdi,QWORD PTR [r15+0x200]
int nbytes = INPUT_BUF_BYTES(cstate);
83d: 89 dd mov ebp,ebx
83f: 29 c5 sub ebp,eax
if (cstate->raw_buf == cstate->input_buf)
841: 49 39 bf 18 02 00 00 cmp QWORD PTR [r15+0x218],rdi
848: 0f 84 aa 04 00 00 je cf8 <CopyReadLine+0x5e8>
84e: 44 88 64 24 0c mov BYTE PTR [rsp+0xc],r12b
853: 4d 89 fd mov r13,r15
856: 4c 89 74 24 10 mov QWORD PTR [rsp+0x10],r14
85b: 88 4c 24 1b mov BYTE PTR [rsp+0x1b],cl
85f: eb 6b jmp 8cc <CopyReadLine+0x1bc>
861: 0f 1f 80 00 00 00 00 nop DWORD PTR [rax+0x0]
if (unverifiedlen == 0)
868: 29 da sub edx,ebx
86a: 41 89 d4 mov r12d,edx
86d: 0f 85 4d 01 00 00 jne 9c0 <CopyReadLine+0x2b0>
if (cstate->raw_reached_eof)
873: 41 80 bd 28 02 00 00 cmp BYTE PTR [r13+0x228],0x0
87a: 00
87b: 0f 84 31 01 00 00 je 9b2 <CopyReadLine+0x2a2>
cstate->input_reached_eof = true;
881: 41 c6 85 10 02 00 00 mov BYTE PTR [r13+0x210],0x1
888: 01
889: 41 8b 85 08 02 00 00 mov eax,DWORD PTR [r13+0x208]
if (INPUT_BUF_BYTES(cstate) > nbytes)
890: 89 de mov esi,ebx
892: 41 89 c0 mov r8d,eax
895: 29 c6 sub esi,eax
897: 39 f5 cmp ebp,esi
899: 0f 8c dd 08 00 00 jl 117c <CopyReadLine+0xa6c>
if (cstate->input_reached_error)
89f: 41 80 bd 11 02 00 00 cmp BYTE PTR [r13+0x211],0x0
8a6: 00
8a7: 0f 85 a6 08 00 00 jne 1153 <CopyReadLine+0xa43>
if (cstate->input_reached_eof)
8ad: 41 0f b6 95 10 02 00 movzx edx,BYTE PTR [r13+0x210]
8b4: 00
8b5: 84 d2 test dl,dl
8b7: 0f 85 e3 02 00 00 jne ba0 <CopyReadLine+0x490>
CopyLoadRawBuf(cstate);
8bd: 4c 89 ef mov rdi,r13
8c0: e8 6b fc ff ff call 530 <CopyLoadRawBuf>
int preverifiedlen = cstate->input_buf_len;
8c5: 41 8b 9d 0c 02 00 00 mov ebx,DWORD PTR [r13+0x20c]
if (!cstate->need_transcoding)
8cc: 41 80 7d 28 00 cmp BYTE PTR [r13+0x28],0x0
int unverifiedlen = cstate->raw_buf_len - cstate->input_buf_len;
8d1: 41 8b 95 24 02 00 00 mov edx,DWORD PTR [r13+0x224]
if (!cstate->need_transcoding)
8d8: 74 8e je 868 <CopyReadLine+0x158>
nbytes = INPUT_BUF_BYTES(cstate);
8da: 41 8b 85 08 02 00 00 mov eax,DWORD PTR [r13+0x208]
8e1: 41 89 dc mov r12d,ebx
8e4: 41 29 c4 sub r12d,eax
if (RAW_BUF_BYTES(cstate) == 0)
8e7: 41 39 95 20 02 00 00 cmp DWORD PTR [r13+0x220],edx
8ee: 0f 84 0c 02 00 00 je b00 <CopyReadLine+0x3f0>
memmove(cstate->input_buf, cstate->input_buf + cstate->input_buf_index,
8f4: 49 63 dc movsxd rbx,r12d
if (nbytes > 0 && cstate->input_buf_index > 0)
8f7: 85 c0 test eax,eax
8f9: 7e 1a jle 915 <CopyReadLine+0x205>
8fb: 45 85 e4 test r12d,r12d
8fe: 7e 15 jle 915 <CopyReadLine+0x205>
memmove(cstate->input_buf, cstate->input_buf + cstate->input_buf_index,
900: 49 8b bd 00 02 00 00 mov rdi,QWORD PTR [r13+0x200]
907: 48 63 f0 movsxd rsi,eax
return __builtin___memmove_chk (__dest, __src, __len,
90a: 48 89 da mov rdx,rbx
90d: 48 01 fe add rsi,rdi
910: e8 00 00 00 00 call 915 <CopyReadLine+0x205>
cstate->input_buf[nbytes] = '\0';
915: 49 8b 85 00 02 00 00 mov rax,QWORD PTR [r13+0x200]
cstate->input_buf_len = nbytes;
91c: 45 89 a5 0c 02 00 00 mov DWORD PTR [r13+0x20c],r12d
cstate->input_buf_index = 0;
923: 41 c7 85 08 02 00 00 mov DWORD PTR [r13+0x208],0x0
92a: 00 00 00 00
cstate->input_buf[nbytes] = '\0';
92e: c6 04 18 00 mov BYTE PTR [rax+rbx*1],0x0
src = (unsigned char *) cstate->raw_buf + cstate->raw_buf_index;
932: 49 63 8d 20 02 00 00 movsxd rcx,DWORD PTR [r13+0x220]
dst = (unsigned char *) cstate->input_buf + cstate->input_buf_len;
939: 49 63 9d 0c 02 00 00 movsxd rbx,DWORD PTR [r13+0x20c]
srclen = cstate->raw_buf_len - cstate->raw_buf_index;
940: 45 8b a5 24 02 00 00 mov r12d,DWORD PTR [r13+0x224]
src = (unsigned char *) cstate->raw_buf + cstate->raw_buf_index;
947: 48 89 c8 mov rax,rcx
94a: 49 03 8d 18 02 00 00 add rcx,QWORD PTR [r13+0x218]
951: 49 89 ce mov r14,rcx
srclen = cstate->raw_buf_len - cstate->raw_buf_index;
954: 41 29 c4 sub r12d,eax
dst = (unsigned char *) cstate->input_buf + cstate->input_buf_len;
957: 49 89 df mov r15,rbx
95a: 49 03 9d 00 02 00 00 add rbx,QWORD PTR [r13+0x200]
convertedlen = pg_do_encoding_conversion_buf(cstate->conversion_proc,
961: e8 00 00 00 00 call 966 <CopyReadLine+0x256>
966: 41 8b 75 24 mov esi,DWORD PTR [r13+0x24]
96a: 41 8b 7d 2c mov edi,DWORD PTR [r13+0x2c]
96e: 6a 01 push 0x1
970: 89 c2 mov edx,eax
dstlen = INPUT_BUF_SIZE - cstate->input_buf_len + 1;
972: b8 01 00 01 00 mov eax,0x10001
convertedlen = pg_do_encoding_conversion_buf(cstate->conversion_proc,
977: 49 89 d9 mov r9,rbx
97a: 45 89 e0 mov r8d,r12d
dstlen = INPUT_BUF_SIZE - cstate->input_buf_len + 1;
97d: 44 29 f8 sub eax,r15d
convertedlen = pg_do_encoding_conversion_buf(cstate->conversion_proc,
980: 4c 89 f1 mov rcx,r14
983: 50 push rax
984: e8 00 00 00 00 call 989 <CopyReadLine+0x279>
if (convertedlen == 0)
989: 5e pop rsi
98a: 5f pop rdi
98b: 85 c0 test eax,eax
98d: 0f 84 35 01 00 00 je ac8 <CopyReadLine+0x3b8>
cstate->raw_buf_index += convertedlen;
993: 41 01 85 20 02 00 00 add DWORD PTR [r13+0x220],eax
cstate->input_buf_len += strlen((char *) dst);
99a: 48 89 df mov rdi,rbx
99d: e8 00 00 00 00 call 9a2 <CopyReadLine+0x292>
9a2: 89 c3 mov ebx,eax
9a4: 41 03 9d 0c 02 00 00 add ebx,DWORD PTR [r13+0x20c]
9ab: 41 89 9d 0c 02 00 00 mov DWORD PTR [r13+0x20c],ebx
9b2: 41 8b 85 08 02 00 00 mov eax,DWORD PTR [r13+0x208]
9b9: e9 d2 fe ff ff jmp 890 <CopyReadLine+0x180>
9be: 66 90 xchg ax,ax
nverified = pg_encoding_verifymbstr(cstate->file_encoding,
9c0: 41 8b 7d 24 mov edi,DWORD PTR [r13+0x24]
9c4: 48 63 f3 movsxd rsi,ebx
cstate->raw_buf + preverifiedlen,
9c7: 49 03 b5 18 02 00 00 add rsi,QWORD PTR [r13+0x218]
nverified = pg_encoding_verifymbstr(cstate->file_encoding,
9ce: e8 00 00 00 00 call 9d3 <CopyReadLine+0x2c3>
9d3: 89 c3 mov ebx,eax
if (nverified == 0)
9d5: 85 c0 test eax,eax
9d7: 75 cb jne 9a4 <CopyReadLine+0x294>
if (cstate->raw_reached_eof || unverifiedlen >= pg_encoding_max_length(cstate->file_encoding))
9d9: 41 80 bd 28 02 00 00 cmp BYTE PTR [r13+0x228],0x0
9e0: 00
9e1: 0f 84 39 02 00 00 je c20 <CopyReadLine+0x510>
9e7: 44 0f b6 64 24 0c movzx r12d,BYTE PTR [rsp+0xc]
9ed: 4c 8b 74 24 10 mov r14,QWORD PTR [rsp+0x10]
9f2: 4d 89 ef mov r15,r13
9f5: 0f b6 4c 24 1b movzx ecx,BYTE PTR [rsp+0x1b]
9fa: 41 8b 85 0c 02 00 00 mov eax,DWORD PTR [r13+0x20c]
if (INPUT_BUF_BYTES(cstate) > nbytes)
a01: 89 c3 mov ebx,eax
a03: 41 8b 87 08 02 00 00 mov eax,DWORD PTR [r15+0x208]
cstate->input_reached_error = true;
a0a: 41 c6 87 11 02 00 00 mov BYTE PTR [r15+0x211],0x1
a11: 01
if (INPUT_BUF_BYTES(cstate) > nbytes)
a12: 89 de mov esi,ebx
a14: 29 c6 sub esi,eax
a16: 41 89 c0 mov r8d,eax
a19: 39 ee cmp esi,ebp
a1b: 0f 8e 2f 07 00 00 jle 1150 <CopyReadLine+0xa40>
hit_eof = cstate->input_reached_eof;
a21: 41 0f b6 97 10 02 00 movzx edx,BYTE PTR [r15+0x210]
a28: 00
if (INPUT_BUF_BYTES(cstate) <= 0)
a29: 85 f6 test esi,esi
a2b: 0f 8e ee 06 00 00 jle 111f <CopyReadLine+0xa0f>
if (simd_continue && !last_was_esc && copy_buf_len - input_buf_ptr >= sizeof(Vector8))
a31: 44 89 e7 mov edi,r12d
a34: 40 80 f7 01 xor dil,0x1
a38: 74 15 je a4f <CopyReadLine+0x33f>
a3a: 80 7c 24 3a 00 cmp BYTE PTR [rsp+0x3a],0x0
a3f: 74 0e je a4f <CopyReadLine+0x33f>
a41: 89 d9 mov ecx,ebx
a43: 44 29 c1 sub ecx,r8d
a46: 83 f9 0f cmp ecx,0xf
a49: 0f 87 39 02 00 00 ja c88 <CopyReadLine+0x578>
c = copy_input_buf[input_buf_ptr++];
a4f: 49 63 c8 movsxd rcx,r8d
if (is_csv)
a52: 80 7c 24 38 00 cmp BYTE PTR [rsp+0x38],0x0
c = copy_input_buf[input_buf_ptr++];
a57: 45 8d 48 01 lea r9d,[r8+0x1]
a5b: 41 0f b6 34 0e movzx esi,BYTE PTR [r14+rcx*1]
if (is_csv)
a60: 0f 84 ba 00 00 00 je b20 <CopyReadLine+0x410>
if (c == '\r')
a66: 40 80 fe 0d cmp sil,0xd
a6a: 0f 84 10 01 00 00 je b80 <CopyReadLine+0x470>
if (in_quote && c == escapec)
a70: 40 38 74 24 1c cmp BYTE PTR [rsp+0x1c],sil
a75: 0f 94 c1 sete cl
if (c == quotec && !last_was_esc)
a78: 40 3a 74 24 3b cmp sil,BYTE PTR [rsp+0x3b]
a7d: 41 0f 94 c3 sete r11b
if (in_quote && c == escapec)
a81: 22 4c 24 39 and cl,BYTE PTR [rsp+0x39]
a85: 0f 84 35 01 00 00 je bc0 <CopyReadLine+0x4b0>
if (c == quotec && !last_was_esc)
a8b: 45 84 e4 test r12b,r12b
a8e: 0f 84 54 01 00 00 je be8 <CopyReadLine+0x4d8>
in_quote = !in_quote;
a94: c6 44 24 39 00 mov BYTE PTR [rsp+0x39],0x0
if (c == quotec && !last_was_esc)
a99: 31 c9 xor ecx,ecx
a9b: 45 84 db test r11b,r11b
a9e: 0f 84 44 01 00 00 je be8 <CopyReadLine+0x4d8>
if (c == '\r' && (!is_csv || !in_quote))
aa4: 40 80 fe 0d cmp sil,0xd
aa8: 0f 84 ea 02 00 00 je d98 <CopyReadLine+0x688>
if (c == '\n' && (!is_csv || !in_quote))
aae: 40 80 fe 0a cmp sil,0xa
ab2: 0f 84 60 02 00 00 je d18 <CopyReadLine+0x608>
c = copy_input_buf[input_buf_ptr++];
ab8: 41 89 cc mov r12d,ecx
abb: 45 89 c8 mov r8d,r9d
abe: 31 c9 xor ecx,ecx
ac0: e9 51 fd ff ff jmp 816 <CopyReadLine+0x106>
ac5: 0f 1f 00 nop DWORD PTR [rax]
if (INPUT_BUF_BYTES(cstate) > nbytes)
ac8: 41 8b 9d 0c 02 00 00 mov ebx,DWORD PTR [r13+0x20c]
if (cstate->raw_reached_eof || srclen >= MAX_CONVERSION_INPUT_LENGTH)
acf: 41 80 bd 28 02 00 00 cmp BYTE PTR [r13+0x228],0x0
ad6: 00
if (INPUT_BUF_BYTES(cstate) > nbytes)
ad7: 89 d8 mov eax,ebx
if (cstate->raw_reached_eof || srclen >= MAX_CONVERSION_INPUT_LENGTH)
ad9: 75 0a jne ae5 <CopyReadLine+0x3d5>
adb: 41 83 fc 0f cmp r12d,0xf
adf: 0f 8e cd fe ff ff jle 9b2 <CopyReadLine+0x2a2>
ae5: 44 0f b6 64 24 0c movzx r12d,BYTE PTR [rsp+0xc]
aeb: 4c 8b 74 24 10 mov r14,QWORD PTR [rsp+0x10]
af0: 4d 89 ef mov r15,r13
af3: 0f b6 4c 24 1b movzx ecx,BYTE PTR [rsp+0x1b]
af8: e9 04 ff ff ff jmp a01 <CopyReadLine+0x2f1>
afd: 0f 1f 00 nop DWORD PTR [rax]
if (cstate->raw_reached_eof)
b00: 41 80 bd 28 02 00 00 cmp BYTE PTR [r13+0x228],0x0
b07: 00
b08: 0f 84 82 fd ff ff je 890 <CopyReadLine+0x180>
cstate->input_reached_eof = true;
b0e: 41 c6 85 10 02 00 00 mov BYTE PTR [r13+0x210],0x1
b15: 01
b16: e9 75 fd ff ff jmp 890 <CopyReadLine+0x180>
b1b: 0f 1f 44 00 00 nop DWORD PTR [rax+rax*1+0x0]
if (c == '\r' && (!is_csv || !in_quote))
b20: 40 80 fe 0d cmp sil,0xd
b24: 0f 84 71 02 00 00 je d9b <CopyReadLine+0x68b>
if (c == '\n' && (!is_csv || !in_quote))
b2a: 40 80 fe 0a cmp sil,0xa
b2e: 0f 84 e4 01 00 00 je d18 <CopyReadLine+0x608>
IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(0);
b34: 44 39 cb cmp ebx,r9d
b37: 40 0f 9e c7 setle dil
if (c == '\\' && !is_csv)
b3b: 40 80 fe 5c cmp sil,0x5c
b3f: 0f 85 57 06 00 00 jne 119c <CopyReadLine+0xa8c>
IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(0);
b45: 89 d6 mov esi,edx
b47: 83 f6 01 xor esi,0x1
b4a: 89 f1 mov ecx,esi
b4c: 40 20 f9 and cl,dil
b4f: 75 45 jne b96 <CopyReadLine+0x486>
IF_NEED_REFILL_AND_EOF_BREAK(0);
b51: 40 20 d7 and dil,dl
b54: 89 f9 mov ecx,edi
b56: 0f 85 d1 05 00 00 jne 112d <CopyReadLine+0xa1d>
c2 = copy_input_buf[input_buf_ptr];
b5c: 4d 63 c9 movsxd r9,r9d
input_buf_ptr++; /* consume the '.' */
b5f: 41 8d 78 02 lea edi,[r8+0x2]
if (c2 == '.')
b63: 43 80 3c 0e 2e cmp BYTE PTR [r14+r9*1],0x2e
b68: 0f 84 b2 03 00 00 je f20 <CopyReadLine+0x810>
input_buf_ptr++;
b6e: 41 89 f8 mov r8d,edi
b71: e9 a0 fc ff ff jmp 816 <CopyReadLine+0x106>
b76: 66 2e 0f 1f 84 00 00 cs nop WORD PTR [rax+rax*1+0x0]
b7d: 00 00 00
IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(0);
b80: 44 39 cb cmp ebx,r9d
b83: 41 89 d3 mov r11d,edx
b86: 0f 9e c1 setle cl
b89: 41 83 f3 01 xor r11d,0x1
b8d: 44 20 d9 and cl,r11b
b90: 0f 84 da fe ff ff je a70 <CopyReadLine+0x360>
b96: 31 d2 xor edx,edx
b98: e9 79 fc ff ff jmp 816 <CopyReadLine+0x106>
b9d: 0f 1f 00 nop DWORD PTR [rax]
ba0: 44 0f b6 64 24 0c movzx r12d,BYTE PTR [rsp+0xc]
ba6: 4c 8b 74 24 10 mov r14,QWORD PTR [rsp+0x10]
bab: 4d 89 ef mov r15,r13
bae: 0f b6 4c 24 1b movzx ecx,BYTE PTR [rsp+0x1b]
bb3: e9 71 fe ff ff jmp a29 <CopyReadLine+0x319>
bb8: 0f 1f 84 00 00 00 00 nop DWORD PTR [rax+rax*1+0x0]
bbf: 00
if (c == quotec && !last_was_esc)
bc0: 40 84 ff test dil,dil
bc3: 74 0d je bd2 <CopyReadLine+0x4c2>
bc5: 45 84 db test r11b,r11b
bc8: 74 08 je bd2 <CopyReadLine+0x4c2>
in_quote = !in_quote;
bca: 80 74 24 39 01 xor BYTE PTR [rsp+0x39],0x1
bcf: 45 31 e4 xor r12d,r12d
if (c != escapec)
bd2: 40 38 74 24 1c cmp BYTE PTR [rsp+0x1c],sil
bd7: 41 0f 44 cc cmove ecx,r12d
if (in_quote && c == (cstate->eol_type == EOL_NL ? '\n' : '\r'))
bdb: 80 7c 24 39 00 cmp BYTE PTR [rsp+0x39],0x0
be0: 0f 84 be fe ff ff je aa4 <CopyReadLine+0x394>
be6: 89 cf mov edi,ecx
be8: 41 83 7f 20 01 cmp DWORD PTR [r15+0x20],0x1
bed: 40 0f be ce movsx ecx,sil
bf1: 0f 84 d7 03 00 00 je fce <CopyReadLine+0x8be>
bf7: 83 f9 0d cmp ecx,0xd
bfa: 0f 84 af 03 00 00 je faf <CopyReadLine+0x89f>
if (c == '\n' && (!is_csv || !in_quote))
c00: 40 80 fe 0a cmp sil,0xa
c04: 0f 84 ad 03 00 00 je fb7 <CopyReadLine+0x8a7>
c0a: 89 f9 mov ecx,edi
c0c: 0f b6 7c 24 38 movzx edi,BYTE PTR [rsp+0x38]
c11: 40 88 7c 24 39 mov BYTE PTR [rsp+0x39],dil
c16: e9 9d fe ff ff jmp ab8 <CopyReadLine+0x3a8>
c1b: 0f 1f 44 00 00 nop DWORD PTR [rax+rax*1+0x0]
if (cstate->raw_reached_eof || unverifiedlen >= pg_encoding_max_length(cstate->file_encoding))
c20: 41 8b 7d 24 mov edi,DWORD PTR [r13+0x24]
c24: e8 00 00 00 00 call c29 <CopyReadLine+0x519>
c29: 41 39 c4 cmp r12d,eax
c2c: 0f 8d b5 fd ff ff jge 9e7 <CopyReadLine+0x2d7>
if (INPUT_BUF_BYTES(cstate) > nbytes)
c32: 41 8b 9d 0c 02 00 00 mov ebx,DWORD PTR [r13+0x20c]
c39: 41 8b 85 08 02 00 00 mov eax,DWORD PTR [r13+0x208]
c40: e9 4b fc ff ff jmp 890 <CopyReadLine+0x180>
c45: 0f 1f 00 nop DWORD PTR [rax]
REFILL_LINEBUF;
c48: 44 89 c2 mov edx,r8d
c4b: 48 8b 7c 24 28 mov rdi,QWORD PTR [rsp+0x28]
c50: 48 63 f0 movsxd rsi,eax
c53: 88 4c 24 10 mov BYTE PTR [rsp+0x10],cl
c57: 29 c2 sub edx,eax
c59: 49 03 b7 00 02 00 00 add rsi,QWORD PTR [r15+0x200]
c60: 44 89 44 24 0c mov DWORD PTR [rsp+0xc],r8d
c65: e8 00 00 00 00 call c6a <CopyReadLine+0x55a>
c6a: 44 8b 44 24 0c mov r8d,DWORD PTR [rsp+0xc]
c6f: 0f b6 4c 24 10 movzx ecx,BYTE PTR [rsp+0x10]
c74: 45 89 87 08 02 00 00 mov DWORD PTR [r15+0x208],r8d
c7b: 44 89 c0 mov eax,r8d
c7e: e9 ac fb ff ff jmp 82f <CopyReadLine+0x11f>
c83: 0f 1f 44 00 00 nop DWORD PTR [rax+rax*1+0x0]
simd_total_cycle++;
c88: 48 83 44 24 20 01 add QWORD PTR [rsp+0x20],0x1
vector8_load(&chunk, (const uint8 *) ©_input_buf[input_buf_ptr]);
c8e: 49 63 c8 movsxd rcx,r8d
if (!in_quote)
c91: 80 7c 24 39 00 cmp BYTE PTR [rsp+0x39],0x0
}
extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_loadu_si128 (__m128i_u const *__P)
{
return *__P;
c96: f3 41 0f 6f 0c 0e movdqu xmm1,XMMWORD PTR [r14+rcx*1]
c9c: 66 0f ef c0 pxor xmm0,xmm0
ca0: 75 1c jne cbe <CopyReadLine+0x5ae>
}
extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_cmpeq_epi8 (__m128i __A, __m128i __B)
{
return (__m128i) ((__v16qi)__A == (__v16qi)__B);
ca2: 66 0f 6f d1 movdqa xmm2,xmm1
return (__m128i) ((__v2du)__A | (__v2du)__B);
ca6: 66 0f 6f c1 movdqa xmm0,xmm1
return (__m128i) ((__v16qi)__A == (__v16qi)__B);
caa: 66 0f 74 15 00 00 00 pcmpeqb xmm2,XMMWORD PTR [rip+0x0] # cb2 <CopyReadLine+0x5a2>
cb1: 00
return (__m128i) ((__v2du)__A | (__v2du)__B);
cb2: 66 0f 74 05 00 00 00 pcmpeqb xmm0,XMMWORD PTR [rip+0x0] # cba <CopyReadLine+0x5aa>
cb9: 00
cba: 66 0f eb c2 por xmm0,xmm2
if (is_csv)
cbe: 80 7c 24 38 00 cmp BYTE PTR [rsp+0x38],0x0
cc3: 0f 85 df 01 00 00 jne ea8 <CopyReadLine+0x798>
return (__m128i) ((__v16qi)__A == (__v16qi)__B);
cc9: 66 0f 74 0d 00 00 00 pcmpeqb xmm1,XMMWORD PTR [rip+0x0] # cd1 <CopyReadLine+0x5c1>
cd0: 00
return (__m128i) ((__v2du)__A | (__v2du)__B);
cd1: 66 0f eb c1 por xmm0,xmm1
}
extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
_mm_movemask_epi8 (__m128i __A)
{
return __builtin_ia32_pmovmskb128 ((__v16qi)__A);
cd5: 66 0f d7 c8 pmovmskb ecx,xmm0
if (mask != 0)
cd9: 85 c9 test ecx,ecx
cdb: 0f 84 f6 01 00 00 je ed7 <CopyReadLine+0x7c7>
pg_rightmost_one_pos32(uint32 word)
{
#ifdef HAVE__BUILTIN_CTZ
Assert(word != 0);
return __builtin_ctz(word);
ce1: f3 0f bc c9 tzcnt ecx,ecx
simd_total_advance += advance;
ce5: 48 01 4c 24 30 add QWORD PTR [rsp+0x30],rcx
input_buf_ptr += advance;
cea: 41 01 c8 add r8d,ecx
simd_total_advance += advance;
ced: e9 5d fd ff ff jmp a4f <CopyReadLine+0x33f>
cf2: 66 0f 1f 44 00 00 nop WORD PTR [rax+rax*1+0x0]
cstate->raw_buf_index = cstate->input_buf_index;
cf8: 41 89 87 20 02 00 00 mov DWORD PTR [r15+0x220],eax
cff: 4d 89 fd mov r13,r15
d02: 44 88 64 24 0c mov BYTE PTR [rsp+0xc],r12b
d07: 4c 89 74 24 10 mov QWORD PTR [rsp+0x10],r14
d0c: 88 4c 24 1b mov BYTE PTR [rsp+0x1b],cl
d10: e9 b7 fb ff ff jmp 8cc <CopyReadLine+0x1bc>
d15: 0f 1f 00 nop DWORD PTR [rax]
if (cstate->eol_type == EOL_CR || cstate->eol_type == EOL_CRNL)
d18: 41 8b 7f 20 mov edi,DWORD PTR [r15+0x20]
d1c: 45 89 cc mov r12d,r9d
d1f: 4d 89 fd mov r13,r15
d22: 8d 57 fe lea edx,[rdi-0x2]
d25: 83 fa 01 cmp edx,0x1
d28: 0f 86 00 00 00 00 jbe d2e <CopyReadLine+0x61e>
cstate->eol_type = EOL_NL; /* in case not set yet */
d2e: 41 c7 47 20 01 00 00 mov DWORD PTR [r15+0x20],0x1
d35: 00
prev_raw_ptr > cstate->input_buf_index)
d36: 48 63 f0 movsxd rsi,eax
bool result = false;
d39: 31 c9 xor ecx,ecx
if (simd_continue)
d3b: 80 7c 24 3a 00 cmp BYTE PTR [rsp+0x3a],0x0
d40: 0f 85 b2 00 00 00 jne df8 <CopyReadLine+0x6e8>
d46: 66 2e 0f 1f 84 00 00 cs nop WORD PTR [rax+rax*1+0x0]
d4d: 00 00 00
if (cstate->simd_current_sleep_cycle == 0)
d50: 66 41 83 ad 46 01 00 sub WORD PTR [r13+0x146],0x1
d57: 00 01
d59: 75 08 jne d63 <CopyReadLine+0x653>
cstate->simd_continue = true;
d5b: 41 c6 85 41 01 00 00 mov BYTE PTR [r13+0x141],0x1
d62: 01
REFILL_LINEBUF;
d63: 41 39 f4 cmp r12d,esi
d66: 0f 8f cd 00 00 00 jg e39 <CopyReadLine+0x729>
if (result)
d6c: 84 c9 test cl,cl
d6e: 0f 84 f3 00 00 00 je e67 <CopyReadLine+0x757>
if (cstate->copy_src == COPY_FRONTEND)
d74: 41 83 7d 08 01 cmp DWORD PTR [r13+0x8],0x1
d79: 0f 84 ea 02 00 00 je 1069 <CopyReadLine+0x959>
cstate->line_buf_valid = true;
d7f: 41 c6 85 f8 01 00 00 mov BYTE PTR [r13+0x1f8],0x1
d86: 01
}
d87: 48 83 c4 68 add rsp,0x68
d8b: 89 c8 mov eax,ecx
d8d: 5b pop rbx
d8e: 5d pop rbp
d8f: 41 5c pop r12
d91: 41 5d pop r13
d93: 41 5e pop r14
d95: 41 5f pop r15
d97: c3 ret
if (c == '\r' && (!is_csv || !in_quote))
d98: 41 89 cc mov r12d,ecx
if (cstate->eol_type == EOL_UNKNOWN ||
d9b: 41 8b 77 20 mov esi,DWORD PTR [r15+0x20]
d9f: 85 f6 test esi,esi
da1: 0f 94 c1 sete cl
da4: 83 fe 03 cmp esi,0x3
da7: 40 0f 94 c7 sete dil
dab: 40 08 f9 or cl,dil
dae: 0f 84 87 03 00 00 je 113b <CopyReadLine+0xa2b>
IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(0);
db4: 44 39 cb cmp ebx,r9d
db7: 0f 9e c1 setle cl
dba: 83 f2 01 xor edx,0x1
dbd: 20 d1 and cl,dl
dbf: 0f 85 d1 fd ff ff jne b96 <CopyReadLine+0x486>
c = copy_input_buf[input_buf_ptr];
dc5: 49 63 d1 movsxd rdx,r9d
dc8: 4d 89 fd mov r13,r15
if (c == '\n')
dcb: 41 80 3c 16 0a cmp BYTE PTR [r14+rdx*1],0xa
c = copy_input_buf[input_buf_ptr];
dd0: 49 89 d4 mov r12,rdx
if (c == '\n')
dd3: 0f 84 13 02 00 00 je fec <CopyReadLine+0x8dc>
if (cstate->eol_type == EOL_CRNL)
dd9: 83 fe 03 cmp esi,0x3
ddc: 0f 84 00 00 00 00 je de2 <CopyReadLine+0x6d2>
if (simd_continue)
de2: 80 7c 24 3a 00 cmp BYTE PTR [rsp+0x3a],0x0
cstate->eol_type = EOL_CR;
de7: 41 c7 47 20 02 00 00 mov DWORD PTR [r15+0x20],0x2
dee: 00
prev_raw_ptr > cstate->input_buf_index)
def: 48 63 f0 movsxd rsi,eax
if (simd_continue)
df2: 0f 84 58 ff ff ff je d50 <CopyReadLine+0x640>
if (simd_total_cycle && simd_total_advance / simd_total_cycle >= SIMD_ADVANCE_AT_LEAST)
df8: 48 8b 54 24 20 mov rdx,QWORD PTR [rsp+0x20]
cstate->simd_last_sleep_cycle >>= 1;
dfd: 41 0f b7 bd 44 01 00 movzx edi,WORD PTR [r13+0x144]
e04: 00
if (simd_total_cycle && simd_total_advance / simd_total_cycle >= SIMD_ADVANCE_AT_LEAST)
e05: 48 85 d2 test rdx,rdx
e08: 0f 84 dd 00 00 00 je eeb <CopyReadLine+0x7db>
e0e: 48 8b 44 24 30 mov rax,QWORD PTR [rsp+0x30]
e13: 48 89 d3 mov rbx,rdx
e16: 31 d2 xor edx,edx
e18: 48 f7 f3 div rbx
e1b: 48 83 f8 04 cmp rax,0x4
e1f: 0f 86 c6 00 00 00 jbe eeb <CopyReadLine+0x7db>
cstate->simd_last_sleep_cycle >>= 1;
e25: 66 d1 ef shr di,1
e28: 66 41 89 bd 44 01 00 mov WORD PTR [r13+0x144],di
e2f: 00
REFILL_LINEBUF;
e30: 41 39 f4 cmp r12d,esi
e33: 0f 8e 33 ff ff ff jle d6c <CopyReadLine+0x65c>
e39: 48 8b 7c 24 28 mov rdi,QWORD PTR [rsp+0x28]
e3e: 44 89 e2 mov edx,r12d
e41: 88 4c 24 0c mov BYTE PTR [rsp+0xc],cl
e45: 29 f2 sub edx,esi
e47: 49 03 b5 00 02 00 00 add rsi,QWORD PTR [r13+0x200]
e4e: e8 00 00 00 00 call e53 <CopyReadLine+0x743>
e53: 0f b6 4c 24 0c movzx ecx,BYTE PTR [rsp+0xc]
e58: 45 89 a5 08 02 00 00 mov DWORD PTR [r13+0x208],r12d
if (result)
e5f: 84 c9 test cl,cl
e61: 0f 85 0d ff ff ff jne d74 <CopyReadLine+0x664>
switch (cstate->eol_type)
e67: 41 8b 45 20 mov eax,DWORD PTR [r13+0x20]
e6b: 83 f8 02 cmp eax,0x2
e6e: 74 12 je e82 <CopyReadLine+0x772>
e70: 83 f8 03 cmp eax,0x3
e73: 0f 84 60 02 00 00 je 10d9 <CopyReadLine+0x9c9>
e79: 83 f8 01 cmp eax,0x1
e7c: 0f 85 fd fe ff ff jne d7f <CopyReadLine+0x66f>
cstate->line_buf.len--;
e82: 41 8b 85 e8 01 00 00 mov eax,DWORD PTR [r13+0x1e8]
cstate->line_buf.data[cstate->line_buf.len] = '\0';
e89: 49 8b 95 e0 01 00 00 mov rdx,QWORD PTR [r13+0x1e0]
cstate->line_buf.len--;
e90: 83 e8 01 sub eax,0x1
e93: 41 89 85 e8 01 00 00 mov DWORD PTR [r13+0x1e8],eax
cstate->line_buf.data[cstate->line_buf.len] = '\0';
e9a: 48 98 cdqe
e9c: c6 04 02 00 mov BYTE PTR [rdx+rax*1],0x0
break;
ea0: e9 da fe ff ff jmp d7f <CopyReadLine+0x66f>
ea5: 0f 1f 00 nop DWORD PTR [rax]
return (__m128i) ((__v16qi)__A == (__v16qi)__B);
ea8: 66 0f 6f 54 24 40 movdqa xmm2,XMMWORD PTR [rsp+0x40]
if (escapec != '\0')
eae: 80 7c 24 1c 00 cmp BYTE PTR [rsp+0x1c],0x0
eb3: 66 0f 74 d1 pcmpeqb xmm2,xmm1
return (__m128i) ((__v2du)__A | (__v2du)__B);
eb7: 66 0f eb c2 por xmm0,xmm2
ebb: 0f 84 14 fe ff ff je cd5 <CopyReadLine+0x5c5>
return (__m128i) ((__v16qi)__A == (__v16qi)__B);
ec1: 66 0f 74 4c 24 50 pcmpeqb xmm1,XMMWORD PTR [rsp+0x50]
return (__m128i) ((__v2du)__A | (__v2du)__B);
ec7: 66 0f eb c1 por xmm0,xmm1
return __builtin_ia32_pmovmskb128 ((__v16qi)__A);
ecb: 66 0f d7 c8 pmovmskb ecx,xmm0
if (mask != 0)
ecf: 85 c9 test ecx,ecx
ed1: 0f 85 0a fe ff ff jne ce1 <CopyReadLine+0x5d1>
simd_total_advance += sizeof(Vector8);
ed7: 48 83 44 24 30 10 add QWORD PTR [rsp+0x30],0x10
input_buf_ptr += sizeof(Vector8);
edd: 41 83 c0 10 add r8d,0x10
simd_total_advance += sizeof(Vector8);
ee1: 45 31 e4 xor r12d,r12d
ee4: 31 c9 xor ecx,ecx
ee6: e9 2b f9 ff ff jmp 816 <CopyReadLine+0x106>
cstate->simd_continue = false;
eeb: 41 c6 85 41 01 00 00 mov BYTE PTR [r13+0x141],0x0
ef2: 00
simd_last_sleep_cycle = 1;
ef3: b8 01 00 00 00 mov eax,0x1
if (simd_last_sleep_cycle == 0)
ef8: 66 85 ff test di,di
efb: 0f 85 0a 01 00 00 jne 100b <CopyReadLine+0x8fb>
cstate->simd_last_sleep_cycle = simd_last_sleep_cycle;
f01: 66 0f 6e f8 movd xmm7,eax
f05: f2 0f 70 c7 00 pshuflw xmm0,xmm7,0x0
f0a: 66 41 0f 7e 85 44 01 movd DWORD PTR [r13+0x144],xmm0
f11: 00 00
f13: e9 4b fe ff ff jmp d63 <CopyReadLine+0x653>
f18: 0f 1f 84 00 00 00 00 nop DWORD PTR [rax+rax*1+0x0]
f1f: 00
if (cstate->eol_type == EOL_CRNL)
f20: 41 8b 57 20 mov edx,DWORD PTR [r15+0x20]
f24: 83 fa 03 cmp edx,0x3
f27: 0f 84 78 01 00 00 je 10a5 <CopyReadLine+0x995>
IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(0);
f2d: 39 fb cmp ebx,edi
f2f: 0f 9e c1 setle cl
f32: 40 20 f1 and cl,sil
f35: 0f 85 5b fc ff ff jne b96 <CopyReadLine+0x486>
c2 = copy_input_buf[input_buf_ptr++];
f3b: 44 8d 67 01 lea r12d,[rdi+0x1]
f3f: 48 63 ff movsxd rdi,edi
f42: 4d 89 fd mov r13,r15
f45: 41 0f b6 04 3e movzx eax,BYTE PTR [r14+rdi*1]
if (c2 != '\r' && c2 != '\n')
f4a: 3c 0d cmp al,0xd
f4c: 40 0f 95 c6 setne sil
f50: 3c 0a cmp al,0xa
f52: 0f 85 f8 00 00 00 jne 1050 <CopyReadLine+0x940>
if ((cstate->eol_type == EOL_NL && c2 != '\n') ||
f58: 89 d1 mov ecx,edx
f5a: 83 e1 fd and ecx,0xfffffffd
f5d: 83 f9 01 cmp ecx,0x1
f60: 0f 84 d6 00 00 00 je 103c <CopyReadLine+0x92c>
(cstate->eol_type == EOL_CR && c2 != '\r'))
f66: 83 fa 02 cmp edx,0x2
f69: 75 09 jne f74 <CopyReadLine+0x864>
f6b: 40 84 f6 test sil,sil
f6e: 0f 85 00 00 00 00 jne f74 <CopyReadLine+0x864>
if (cstate->line_buf.len > 0 ||
f74: 41 8b 85 e8 01 00 00 mov eax,DWORD PTR [r13+0x1e8]
f7b: 85 c0 test eax,eax
f7d: 0f 8f 00 00 00 00 jg f83 <CopyReadLine+0x873>
f83: 45 3b 85 08 02 00 00 cmp r8d,DWORD PTR [r13+0x208]
f8a: 0f 8f 00 00 00 00 jg f90 <CopyReadLine+0x880>
if (simd_continue)
f90: 80 7c 24 3a 00 cmp BYTE PTR [rsp+0x3a],0x0
cstate->input_buf_index = input_buf_ptr;
f95: 45 89 a5 08 02 00 00 mov DWORD PTR [r13+0x208],r12d
break;
f9c: 49 63 f4 movsxd rsi,r12d
result = true; /* report EOF */
f9f: b9 01 00 00 00 mov ecx,0x1
if (simd_continue)
fa4: 0f 84 a6 fd ff ff je d50 <CopyReadLine+0x640>
faa: e9 49 fe ff ff jmp df8 <CopyReadLine+0x6e8>
cstate->cur_lineno++;
faf: 49 83 87 28 01 00 00 add QWORD PTR [r15+0x128],0x1
fb6: 01
if (c == '\r' && (!is_csv || !in_quote))
fb7: 41 89 fc mov r12d,edi
fba: 0f b6 7c 24 38 movzx edi,BYTE PTR [rsp+0x38]
c = copy_input_buf[input_buf_ptr++];
fbf: 45 89 c8 mov r8d,r9d
fc2: 31 c9 xor ecx,ecx
fc4: 40 88 7c 24 39 mov BYTE PTR [rsp+0x39],dil
fc9: e9 48 f8 ff ff jmp 816 <CopyReadLine+0x106>
if (in_quote && c == (cstate->eol_type == EOL_NL ? '\n' : '\r'))
fce: 83 f9 0a cmp ecx,0xa
fd1: 74 dc je faf <CopyReadLine+0x89f>
if (c == '\r' && (!is_csv || !in_quote))
fd3: 44 0f b6 54 24 38 movzx r10d,BYTE PTR [rsp+0x38]
fd9: 89 f9 mov ecx,edi
fdb: 44 88 54 24 39 mov BYTE PTR [rsp+0x39],r10b
fe0: 40 80 fe 0d cmp sil,0xd
fe4: 0f 85 ce fa ff ff jne ab8 <CopyReadLine+0x3a8>
fea: eb cb jmp fb7 <CopyReadLine+0x8a7>
if (simd_continue)
fec: 80 7c 24 3a 00 cmp BYTE PTR [rsp+0x3a],0x0
cstate->eol_type = EOL_CRNL; /* in case not set yet */
ff1: 41 c7 47 20 03 00 00 mov DWORD PTR [r15+0x20],0x3
ff8: 00
input_buf_ptr++; /* eat newline */
ff9: 45 8d 60 02 lea r12d,[r8+0x2]
prev_raw_ptr > cstate->input_buf_index)
ffd: 48 63 f0 movsxd rsi,eax
if (simd_continue)
1000: 0f 84 4a fd ff ff je d50 <CopyReadLine+0x640>
1006: e9 ed fd ff ff jmp df8 <CopyReadLine+0x6e8>
simd_last_sleep_cycle <<= 1;
100b: 8d 04 3f lea eax,[rdi+rdi*1]
100e: 66 81 ff 00 02 cmp di,0x200
1013: ba 00 04 00 00 mov edx,0x400
1018: 0f 43 c2 cmovae eax,edx
101b: e9 e1 fe ff ff jmp f01 <CopyReadLine+0x7f1>
Vector8 escape = vector8_broadcast(0);
1020: 66 0f ef f6 pxor xmm6,xmm6
1024: 0f 29 74 24 50 movaps XMMWORD PTR [rsp+0x50],xmm6
if (quotec != escapec)
1029: 40 84 ff test dil,dil
102c: 0f 84 a6 f7 ff ff je 7d8 <CopyReadLine+0xc8>
1032: c6 44 24 1c 00 mov BYTE PTR [rsp+0x1c],0x0
1037: e9 67 f7 ff ff jmp 7a3 <CopyReadLine+0x93>
if ((cstate->eol_type == EOL_NL && c2 != '\n') ||
103c: 3c 0a cmp al,0xa
103e: 0f 84 30 ff ff ff je f74 <CopyReadLine+0x864>
1044: e9 00 00 00 00 jmp 1049 <CopyReadLine+0x939>
1049: 0f 1f 80 00 00 00 00 nop DWORD PTR [rax+0x0]
if (c2 != '\r' && c2 != '\n')
1050: 40 84 f6 test sil,sil
1053: 0f 85 00 00 00 00 jne 1059 <CopyReadLine+0x949>
if ((cstate->eol_type == EOL_NL && c2 != '\n') ||
1059: 89 d1 mov ecx,edx
105b: 83 e1 fd and ecx,0xfffffffd
105e: 83 f9 01 cmp ecx,0x1
1061: 0f 85 ff fe ff ff jne f66 <CopyReadLine+0x856>
1067: eb d3 jmp 103c <CopyReadLine+0x92c>
1069: 89 cb mov ebx,ecx
106b: 0f 1f 44 00 00 nop DWORD PTR [rax+rax*1+0x0]
inbytes = CopyGetData(cstate, cstate->input_buf,
1070: 49 8b b5 00 02 00 00 mov rsi,QWORD PTR [r13+0x200]
1077: ba 00 00 01 00 mov edx,0x10000
107c: 4c 89 ef mov rdi,r13
107f: e8 ec f2 ff ff call 370 <CopyGetData.constprop.0>
} while (inbytes > 0);
1084: 85 c0 test eax,eax
1086: 7f e8 jg 1070 <CopyReadLine+0x960>
cstate->input_buf_index = 0;
1088: 49 c7 85 08 02 00 00 mov QWORD PTR [r13+0x208],0x0
108f: 00 00 00 00
1093: 89 d9 mov ecx,ebx
cstate->raw_buf_index = 0;
1095: 49 c7 85 20 02 00 00 mov QWORD PTR [r13+0x220],0x0
109c: 00 00 00 00
10a0: e9 da fc ff ff jmp d7f <CopyReadLine+0x66f>
IF_NEED_REFILL_AND_NOT_EOF_CONTINUE(0);
10a5: 39 fb cmp ebx,edi
10a7: 0f 9e c1 setle cl
10aa: 40 20 f1 and cl,sil
10ad: 0f 85 e3 fa ff ff jne b96 <CopyReadLine+0x486>
c2 = copy_input_buf[input_buf_ptr++];
10b3: 48 63 ff movsxd rdi,edi
10b6: 45 8d 48 03 lea r9d,[r8+0x3]
10ba: 41 0f b6 0c 3e movzx ecx,BYTE PTR [r14+rdi*1]
if (c2 == '\n')
10bf: 80 f9 0a cmp cl,0xa
10c2: 0f 84 00 00 00 00 je 10c8 <CopyReadLine+0x9b8>
else if (c2 != '\r')
10c8: 80 f9 0d cmp cl,0xd
10cb: 0f 85 00 00 00 00 jne 10d1 <CopyReadLine+0x9c1>
c2 = copy_input_buf[input_buf_ptr++];
10d1: 44 89 cf mov edi,r9d
10d4: e9 54 fe ff ff jmp f2d <CopyReadLine+0x81d>
cstate->line_buf.len -= 2;
10d9: 41 8b 85 e8 01 00 00 mov eax,DWORD PTR [r13+0x1e8]
cstate->line_buf.data[cstate->line_buf.len] = '\0';
10e0: 49 8b 95 e0 01 00 00 mov rdx,QWORD PTR [r13+0x1e0]
cstate->line_buf.len -= 2;
10e7: 83 e8 02 sub eax,0x2
10ea: 41 89 85 e8 01 00 00 mov DWORD PTR [r13+0x1e8],eax
cstate->line_buf.data[cstate->line_buf.len] = '\0';
10f1: 48 98 cdqe
10f3: c6 04 02 00 mov BYTE PTR [rdx+rax*1],0x0
break;
10f7: e9 83 fc ff ff jmp d7f <CopyReadLine+0x66f>
cstate->simd_continue = true;
10fc: 41 b8 01 01 00 00 mov r8d,0x101
cstate->simd_last_sleep_cycle = 0;
1102: c6 44 24 3a 01 mov BYTE PTR [rsp+0x3a],0x1
cstate->simd_continue = true;
1107: 66 45 89 85 41 01 00 mov WORD PTR [r13+0x141],r8w
110e: 00
cstate->simd_last_sleep_cycle = 0;
110f: 41 c7 85 44 01 00 00 mov DWORD PTR [r13+0x144],0x0
1116: 00 00 00 00
111a: e9 41 f6 ff ff jmp 760 <CopyReadLine+0x50>
REFILL_LINEBUF;
111f: 48 63 f0 movsxd rsi,eax
1122: 4d 89 fd mov r13,r15
input_buf_ptr = cstate->input_buf_index;
1125: 41 89 f4 mov r12d,esi
1128: e9 0e fc ff ff jmp d3b <CopyReadLine+0x62b>
prev_raw_ptr > cstate->input_buf_index)
112d: 45 89 cc mov r12d,r9d
1130: 4d 89 fd mov r13,r15
1133: 48 63 f0 movsxd rsi,eax
1136: e9 00 fc ff ff jmp d3b <CopyReadLine+0x62b>
else if (cstate->eol_type == EOL_NL)
113b: 45 89 cc mov r12d,r9d
113e: 4d 89 fd mov r13,r15
1141: 83 fe 01 cmp esi,0x1
1144: 75 ed jne 1133 <CopyReadLine+0xa23>
1146: e9 00 00 00 00 jmp 114b <CopyReadLine+0xa3b>
114b: 0f 1f 44 00 00 nop DWORD PTR [rax+rax*1+0x0]
1150: 4d 89 fd mov r13,r15
if (!cstate->need_transcoding)
1153: 41 80 7d 28 00 cmp BYTE PTR [r13+0x28],0x0
cstate->raw_buf + cstate->input_buf_len,
1158: 49 8b 8d 18 02 00 00 mov rcx,QWORD PTR [r13+0x218]
115f: 48 63 eb movsxd rbp,ebx
cstate->raw_buf_len - cstate->input_buf_len);
1162: 41 8b 85 24 02 00 00 mov eax,DWORD PTR [r13+0x224]
if (!cstate->need_transcoding)
1169: 75 3b jne 11a6 <CopyReadLine+0xa96>
report_invalid_encoding(cstate->file_encoding,
116b: 29 d8 sub eax,ebx
116d: 41 8b 7d 24 mov edi,DWORD PTR [r13+0x24]
cstate->raw_buf + cstate->input_buf_len,
1171: 48 8d 34 29 lea rsi,[rcx+rbp*1]
report_invalid_encoding(cstate->file_encoding,
1175: 89 c2 mov edx,eax
1177: e8 00 00 00 00 call 117c <CopyReadLine+0xa6c>
if (cstate->input_reached_eof)
117c: 44 0f b6 64 24 0c movzx r12d,BYTE PTR [rsp+0xc]
1182: 4c 8b 74 24 10 mov r14,QWORD PTR [rsp+0x10]
1187: 4d 89 ef mov r15,r13
118a: 0f b6 4c 24 1b movzx ecx,BYTE PTR [rsp+0x1b]
118f: 41 0f b6 95 10 02 00 movzx edx,BYTE PTR [r13+0x210]
1196: 00
1197: e9 8d f8 ff ff jmp a29 <CopyReadLine+0x319>
119c: 31 c9 xor ecx,ecx
c = copy_input_buf[input_buf_ptr++];
119e: 45 89 c8 mov r8d,r9d
11a1: e9 70 f6 ff ff jmp 816 <CopyReadLine+0x106>
src = (unsigned char *) cstate->raw_buf + cstate->raw_buf_index;
11a6: 49 63 b5 20 02 00 00 movsxd rsi,DWORD PTR [r13+0x220]
dst = (unsigned char *) cstate->input_buf + cstate->input_buf_len;
11ad: 49 03 ad 00 02 00 00 add rbp,QWORD PTR [r13+0x200]
srclen = cstate->raw_buf_len - cstate->raw_buf_index;
11b4: 29 f0 sub eax,esi
src = (unsigned char *) cstate->raw_buf + cstate->raw_buf_index;
11b6: 4c 8d 34 31 lea r14,[rcx+rsi*1]
srclen = cstate->raw_buf_len - cstate->raw_buf_index;
11ba: 41 89 c4 mov r12d,eax
(void) pg_do_encoding_conversion_buf(cstate->conversion_proc,
11bd: e8 00 00 00 00 call 11c2 <CopyReadLine+0xab2>
11c2: 41 8b 75 24 mov esi,DWORD PTR [r13+0x24]
11c6: 41 8b 7d 2c mov edi,DWORD PTR [r13+0x2c]
11ca: 6a 00 push 0x0
11cc: 89 c2 mov edx,eax
dstlen = INPUT_BUF_SIZE - cstate->input_buf_len + 1;
11ce: b8 01 00 01 00 mov eax,0x10001
(void) pg_do_encoding_conversion_buf(cstate->conversion_proc,
11d3: 4c 89 f1 mov rcx,r14
11d6: 49 89 e9 mov r9,rbp
dstlen = INPUT_BUF_SIZE - cstate->input_buf_len + 1;
11d9: 29 d8 sub eax,ebx
(void) pg_do_encoding_conversion_buf(cstate->conversion_proc,
11db: 45 89 e0 mov r8d,r12d
11de: 50 push rax
11df: e8 00 00 00 00 call 11e4 <CopyReadLine+0xad4>
elog(ERROR, "encoding conversion failed without error");
11e4: 31 f6 xor esi,esi
11e6: bf 15 00 00 00 mov edi,0x15
11eb: e8 00 00 00 00 call 11f0 <CopyReadLine+0xae0>
11f0: 48 8d 3d 00 00 00 00 lea rdi,[rip+0x0] # 11f7 <CopyReadLine+0xae7>
11f7: 31 c0 xor eax,eax
11f9: e8 00 00 00 00 call 11fe <CopyReadLine+0xaee>
11fe: 48 8d 15 00 00 00 00 lea rdx,[rip+0x0] # 1205 <CopyReadLine+0xaf5>
1205: be 47 02 00 00 mov esi,0x247
120a: 48 8d 3d 00 00 00 00 lea rdi,[rip+0x0] # 1211 <CopyReadLine+0xb01>
1211: e8 00 00 00 00 call 1216 <CopyReadLine+0xb06>
1216: 5a pop rdx
1217: 59 pop rcx
1218: e9 00 00 00 00 jmp 121d <CopyReadLine+0xb0d>
121d: 0f 1f 00 nop DWORD PTR [rax]