0000000000000710 : { 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 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 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 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 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 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 REFILL_LINEBUF; 826: 41 39 c0 cmp r8d,eax 829: 0f 8f 19 04 00 00 jg c48 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 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 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 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 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 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 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 CopyLoadRawBuf(cstate); 8bd: 4c 89 ef mov rdi,r13 8c0: e8 6b fc ff ff call 530 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 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 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 8fb: 45 85 e4 test r12d,r12d 8fe: 7e 15 jle 915 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 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 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 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 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 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 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 9d3: 89 c3 mov ebx,eax if (nverified == 0) 9d5: 85 c0 test eax,eax 9d7: 75 cb jne 9a4 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 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 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 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 a3a: 80 7c 24 3a 00 cmp BYTE PTR [rsp+0x3a],0x0 a3f: 74 0e je a4f 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 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 if (c == '\r') a66: 40 80 fe 0d cmp sil,0xd a6a: 0f 84 10 01 00 00 je b80 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 if (c == quotec && !last_was_esc) a8b: 45 84 e4 test r12b,r12b a8e: 0f 84 54 01 00 00 je be8 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 if (c == '\r' && (!is_csv || !in_quote)) aa4: 40 80 fe 0d cmp sil,0xd aa8: 0f 84 ea 02 00 00 je d98 if (c == '\n' && (!is_csv || !in_quote)) aae: 40 80 fe 0a cmp sil,0xa ab2: 0f 84 60 02 00 00 je d18 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 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 adb: 41 83 fc 0f cmp r12d,0xf adf: 0f 8e cd fe ff ff jle 9b2 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 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 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 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 if (c == '\n' && (!is_csv || !in_quote)) b2a: 40 80 fe 0a cmp sil,0xa b2e: 0f 84 e4 01 00 00 je d18 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 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 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 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 input_buf_ptr++; b6e: 41 89 f8 mov r8d,edi b71: e9 a0 fc ff ff jmp 816 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 b96: 31 d2 xor edx,edx b98: e9 79 fc ff ff jmp 816 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 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 bc5: 45 84 db test r11b,r11b bc8: 74 08 je bd2 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 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 bf7: 83 f9 0d cmp ecx,0xd bfa: 0f 84 af 03 00 00 je faf if (c == '\n' && (!is_csv || !in_quote)) c00: 40 80 fe 0a cmp sil,0xa c04: 0f 84 ad 03 00 00 je fb7 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 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 c29: 41 39 c4 cmp r12d,eax c2c: 0f 8d b5 fd ff ff jge 9e7 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 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 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 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 } 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 cb1: 00 return (__m128i) ((__v2du)__A | (__v2du)__B); cb2: 66 0f 74 05 00 00 00 pcmpeqb xmm0,XMMWORD PTR [rip+0x0] # cba 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 return (__m128i) ((__v16qi)__A == (__v16qi)__B); cc9: 66 0f 74 0d 00 00 00 pcmpeqb xmm1,XMMWORD PTR [rip+0x0] # cd1 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 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 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 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 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 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 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 if (result) d6c: 84 c9 test cl,cl d6e: 0f 84 f3 00 00 00 je e67 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 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 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 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 if (cstate->eol_type == EOL_CRNL) dd9: 83 fe 03 cmp esi,0x3 ddc: 0f 84 00 00 00 00 je de2 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 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 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 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 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 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 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 e70: 83 f8 03 cmp eax,0x3 e73: 0f 84 60 02 00 00 je 10d9 e79: 83 f8 01 cmp eax,0x1 e7c: 0f 85 fd fe ff ff jne d7f 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 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 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 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 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 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 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 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 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 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 (cstate->eol_type == EOL_CR && c2 != '\r')) f66: 83 fa 02 cmp edx,0x2 f69: 75 09 jne f74 f6b: 40 84 f6 test sil,sil f6e: 0f 85 00 00 00 00 jne f74 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 f83: 45 3b 85 08 02 00 00 cmp r8d,DWORD PTR [r13+0x208] f8a: 0f 8f 00 00 00 00 jg f90 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 faa: e9 49 fe ff ff jmp df8 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 if (in_quote && c == (cstate->eol_type == EOL_NL ? '\n' : '\r')) fce: 83 f9 0a cmp ecx,0xa fd1: 74 dc je faf 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 fea: eb cb jmp fb7 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 1006: e9 ed fd ff ff jmp df8 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 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 1032: c6 44 24 1c 00 mov BYTE PTR [rsp+0x1c],0x0 1037: e9 67 f7 ff ff jmp 7a3 if ((cstate->eol_type == EOL_NL && c2 != '\n') || 103c: 3c 0a cmp al,0xa 103e: 0f 84 30 ff ff ff je f74 1044: e9 00 00 00 00 jmp 1049 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 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 1067: eb d3 jmp 103c 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 } while (inbytes > 0); 1084: 85 c0 test eax,eax 1086: 7f e8 jg 1070 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 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 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 else if (c2 != '\r') 10c8: 80 f9 0d cmp cl,0xd 10cb: 0f 85 00 00 00 00 jne 10d1 c2 = copy_input_buf[input_buf_ptr++]; 10d1: 44 89 cf mov edi,r9d 10d4: e9 54 fe ff ff jmp f2d 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 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 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 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 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 1146: e9 00 00 00 00 jmp 114b 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 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 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 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 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 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 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 11f0: 48 8d 3d 00 00 00 00 lea rdi,[rip+0x0] # 11f7 11f7: 31 c0 xor eax,eax 11f9: e8 00 00 00 00 call 11fe 11fe: 48 8d 15 00 00 00 00 lea rdx,[rip+0x0] # 1205 1205: be 47 02 00 00 mov esi,0x247 120a: 48 8d 3d 00 00 00 00 lea rdi,[rip+0x0] # 1211 1211: e8 00 00 00 00 call 1216 1216: 5a pop rdx 1217: 59 pop rcx 1218: e9 00 00 00 00 jmp 121d 121d: 0f 1f 00 nop DWORD PTR [rax]