; assembly | /* r2dec pseudo code output */ | /* bslalg_arrayprimitives.t/none @ 0x4cc8c0 */ | #include | ; (fcn) sym.void_testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_ () | uint64_t void_testCopyConstructWithIterators_FnPtrConvertibleType_bool_bool_bool_ (uint32_t arg3, uint32_t arg2) { | uint32_t var_8h; | int64_t var_10h; | int64_t var_18h; | int64_t var_20h; | uint32_t var_2ch; | int64_t var_30h; | int64_t var_38h; | int64_t var_40h; | uint32_t var_44h; | int64_t var_48h; | int64_t var_50h; | rdx = arg3; | rsi = arg2; | /* void testCopyConstructWithIterators(bool, bool, bool) */ 0x004cc8c0 push rbp | 0x004cc8c1 push r15 | 0x004cc8c3 push r14 | 0x004cc8c5 push r13 | 0x004cc8c7 push r12 | 0x004cc8c9 push rbx | 0x004cc8ca sub rsp, 0x58 | 0x004cc8ce mov dword [rsp + 0x2c], edx | *((rsp + 0x2c)) = edx; 0x004cc8d2 mov dword [rsp + 0x44], esi | *((rsp + 0x44)) = esi; 0x004cc8d6 cmp byte [rip + 0x24c0b9], 0 | | if (*(obj.verbose) != 0) { 0x004cc8dd je 0x4cc8e9 | 0x004cc8df mov edi, 0x4f6973 | 0x004cc8e4 call 0x401710 | puts ("\t\tfrom same type."); | } 0x004cc8e9 xor ebx, ebx | ebx = 0; 0x004cc8eb jmp 0x4cc917 | goto label_8; | label_1: 0x004cc8f0 mov edi, 0x74fa60 | edi = testCopyConstructWithIterators(bool, bool, bool)::u; 0x004cc8f5 mov rsi, rbp | rsi = rbp; 0x004cc8f8 call 0x4e3ed0 | voidverify(FnPtrConvertibleType*,char const*) (); 0x004cc8fd mov edi, 0x74fa60 | edi = testCopyConstructWithIterators(bool, bool, bool)::u; 0x004cc902 mov rsi, rbp | rsi = rbp; 0x004cc905 call 0x4e4130 | voidcleanup(FnPtrConvertibleType*,char const*) (); 0x004cc90a inc rbx | rbx++; 0x004cc90d cmp rbx, 0x1e | | if (rbx == 0x1e) { 0x004cc911 je 0x4cd000 | goto label_9; | } | label_8: 0x004cc917 mov qword [rsp + 8], rbx | *((rsp + 8)) = rbx; 0x004cc91c lea rbp, [rbx*8] | rbp = rbx*8; 0x004cc924 mov r12, qword [rbp + rbp*4 + 0x4f3c98] | r12 = *((rbp + rbp*4 + 0x4f3c98)); 0x004cc92c mov rdi, r12 | 0x004cc92f call 0x401790 | eax = strlen (*((rbp + rbp*4 + 0x4f3c98))); 0x004cc934 cmp eax, 0x11 | | if (eax >= 0x11) { 0x004cc937 jl 0x4cc962 | 0x004cc939 mov edi, 0x4f4e04 | 0x004cc93e mov edx, 0x4f4393 | edx = "MAX_SIZE >= (int)std::strlen(SPEC)"; 0x004cc943 mov esi, 0xfe6 | esi = 0xfe6; 0x004cc948 xor eax, eax | eax = 0; 0x004cc94a call 0x401680 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s (failed)\n"); 0x004cc94f mov eax, dword [rip + 0x24c043] | eax = (anonymous namespace)::testStatus; 0x004cc955 cmp eax, 0x64 | | if (eax > 0x64) { 0x004cc958 ja 0x4cc962 | goto label_10; | } 0x004cc95a inc eax | eax++; 0x004cc95c mov dword [rip + 0x24c036], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_10: 0x004cc962 mov r13d, dword [rbp + rbp*4 + 0x4f3c90] | r13d = *((rbp + rbp*4 + obj.DATA_3)); 0x004cc96a movsxd r15, dword [rbp + rbp*4 + 0x4f3ca0] | r15 = *((rbp + rbp*4 + 0x4f3ca0)); 0x004cc972 mov ebx, dword [rbp + rbp*4 + 0x4f3ca4] | ebx = *((rbp + rbp*4 + 0x4f3ca4)); 0x004cc979 movsxd r14, dword [rbp + rbp*4 + 0x4f3ca8] | r14 = *((rbp + rbp*4 + 0x4f3ca8)); 0x004cc981 mov rbp, qword [rbp + rbp*4 + 0x4f3cb0] | rbp = *((rbp + rbp*4 + 0x4f3cb0)); 0x004cc989 cmp byte [rip + 0x24c000], 0 | | if (*(obj.veryVerbose) != 0) { 0x004cc990 je 0x4cc9b1 | 0x004cc992 mov qword [rsp], rbp | *(rsp) = rbp; 0x004cc996 mov edi, 0x4f5c41 | 0x004cc99b mov esi, r13d | esi = r13d; 0x004cc99e mov rdx, r12 | rdx = r12; 0x004cc9a1 mov ecx, r15d | ecx = r15d; 0x004cc9a4 mov r8d, ebx | r8d = ebx; 0x004cc9a7 mov r9d, r14d | r9d = r14d; 0x004cc9aa xor eax, eax | eax = 0; 0x004cc9ac call 0x401680 | printf ("LINE = %d, SPEC = %s, SRC = %d, NE = %d, DST = %d, EXP = %s\n"); | } 0x004cc9b1 mov dword [rsp + 0x18], r13d | *((rsp + 0x18)) = r13d; 0x004cc9b6 mov qword [rsp + 0x20], rbx | *((rsp + 0x20)) = rbx; 0x004cc9bb mov edi, 0x74fa60 | edi = testCopyConstructWithIterators(bool, bool, bool)::u; 0x004cc9c0 mov rsi, r12 | rsi = r12; 0x004cc9c3 call 0x4e3dd0 | FnPtrConvertibleType&gg(FnPtrConvertibleType*,char const*) (); 0x004cc9c8 mov edi, 0x74fa60 | edi = testCopyConstructWithIterators(bool, bool, bool)::u; 0x004cc9cd mov rsi, r12 | rsi = r12; 0x004cc9d0 call 0x4e3ed0 | voidverify(FnPtrConvertibleType*,char const*) (); 0x004cc9d5 mov r13d, dword [rip + 0x24bfc8] | r13d = numCopyCtorCalls; 0x004cc9dc mov r12d, dword [rip + 0x24bfc9] | r12d = numCharCtorCalls; 0x004cc9e3 cmp byte [rsp + 0x2c], 0 | | if (*((rsp + 0x2c)) != 0) { 0x004cc9e8 je 0x4ccab0 | 0x004cc9ee cmp byte [rip + 0x24bf9b], 0 | 0x004cc9f5 mov rbx, qword [rsp + 8] | rbx = *((rsp + 8)); | if (*(obj.veryVerbose) != 0) { 0x004cc9fa je 0x4cca0f | 0x004cc9fc cmp dword [rip + 0x24bbb5], 0 | | if (*(obj.testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::firstTime) == 0) { 0x004cca03 je 0x4cca0f | goto label_11; | } 0x004cca05 mov edi, 0x4f43ea | 0x004cca0a call 0x401710 | puts ("\t\tBSLMA EXCEPTION TEST -- (ENABLED) --"); | } | label_11: 0x004cca0f mov dword [rip + 0x24bb9f], 0 | *(obj.testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::firstTime) = 0; 0x004cca19 cmp byte [rip + 0x24bf75], 0 | | if (*(obj.veryVeryVerbose) != 0) { 0x004cca20 je 0x4cca2c | 0x004cca22 mov edi, 0x4f4411 | 0x004cca27 call 0x401710 | puts ("\t\tBegin bslma exception test."); | } 0x004cca2c mov rax, qword [rip + 0x24bded] | rax = Z; 0x004cca33 mov qword [rsp + 0x30], 0x4f69e0 | *((rsp + 0x30)) = vtable.BloombergLP::bslma::TestAllocator_Proxy_BloombergLP::bslma::TestAllocator_.0; 0x004cca3c mov qword [rsp + 0x38], rax | *((rsp + 0x38)) = rax; 0x004cca41 mov qword [rax + 0x20], 0 | *((rax + 0x20)) = 0; 0x004cca49 test rax, rax | | if (rax == 0) { 0x004cca4c je 0x4ccca5 | goto label_12; | } | label_0: 0x004cca52 cmp rbx, 6 | | if (rbx < 6) { 0x004cca56 jb 0x4cce9c | goto label_13; | } 0x004cca5c mov r11, rbp | r11 = rbp; 0x004cca5f lea rax, [r15*8 + 0x74fa60] | rax = r15*8 + obj_testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u; 0x004cca67 lea rdi, [r15*8] | rdi = r15*8; 0x004cca6f lea rcx, [r14*8 + 0x74fa60] | rcx = r14*8 + obj_testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u; 0x004cca77 mov ebp, dword [rip + 0x24bf27] | ebp = numCopyCtorCalls; 0x004cca7d mov rbx, qword [rsp + 0x20] | rbx = *((rsp + 0x20)); 0x004cca82 lea edx, [rbx + r15] | edx = rbx + r15; 0x004cca86 movsxd r10, edx | r10 = (int64_t) edx; 0x004cca89 shl r10, 3 | r10 <<= 3; 0x004cca8d mov rsi, r10 | rsi = r10; 0x004cca90 sub rsi, rdi | rsi -= rdi; 0x004cca93 add rsi, 0xfffffffffffffff8 | rsi += 0xfffffffffffffff8; 0x004cca97 cmp rsi, 0x18 | | if (rsi >= 0x18) { 0x004cca9b jae 0x4ccd25 | goto label_14; | } 0x004ccaa1 mov rbx, qword [rsp + 8] | rbx = *((rsp + 8)); 0x004ccaa6 jmp 0x4cce70 | goto label_15; | } 0x004ccab0 cmp qword [rip + 0x24bd68], 0 | 0x004ccab8 mov rbx, qword [rsp + 8] | rbx = *((rsp + 8)); | if (*(obj.Z) == 0) { 0x004ccabd jne 0x4ccad0 | 0x004ccabf mov rax, qword [rip + 0x2847f2] | rax = BloombergLP::bslma::Default::s_defaultAllocator; 0x004ccac6 test rax, rax | | if (rax != 0) { 0x004ccac9 jne 0x4ccad0 | goto label_16; | } 0x004ccacb call 0x4eede0 | BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() (); | } | label_16: 0x004ccad0 cmp rbx, 6 | 0x004ccad4 mov esi, dword [rsp + 0x18] | esi = *((rsp + 0x18)); | if (rbx < 6) { 0x004ccad8 jb 0x4ccc93 | goto label_17; | } 0x004ccade mov qword [rsp + 0x10], rbp | *((rsp + 0x10)) = rbp; 0x004ccae3 mov rax, qword [rsp + 0x20] | rax = *((rsp + 0x20)); 0x004ccae8 lea ecx, [rax + r15] | ecx = rax + r15; 0x004ccaec lea rax, [r15*8 + 0x74fa60] | rax = r15*8 + obj_testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u; 0x004ccaf4 movsxd rbx, ecx | rbx = (int64_t) ecx; 0x004ccaf7 lea rcx, [r14*8 + 0x74fa60] | rcx = r14*8 + obj_testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u; 0x004ccaff mov edi, dword [rip + 0x24be9f] | edi = numCopyCtorCalls; 0x004ccb05 lea r11, [rbx*8] | r11 = rbx*8; 0x004ccb0d lea rbp, [r15*8] | rbp = r15*8; 0x004ccb15 mov rdx, r11 | rdx = r11; 0x004ccb18 sub rdx, rbp | rdx -= rbp; 0x004ccb1b lea r10, [rdx - 8] | r10 = rdx - 8; 0x004ccb1f cmp r10, 0x18 | | if (r10 < 0x18) { 0x004ccb23 jb 0x4ccc60 | goto label_18; | } 0x004ccb29 lea r9, [r14*8 + 0x74fa60] | r9 = r14*8 + obj_testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u; 0x004ccb31 lea rbx, [rbx*8 + 0x74fa60] | rbx = rbx*8 + obj_testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u; 0x004ccb39 cmp r9, rbx | | if (r9 < rbx) { 0x004ccb3c jae 0x4ccb57 | 0x004ccb3e lea rdx, [rdx + r14*8 + 0x74fa60] | rdx = rdx + r14*8 + obj_testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u; 0x004ccb46 lea rbx, [r15*8 + 0x74fa60] | rbx = r15*8 + obj_testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u; 0x004ccb4e cmp rbx, rdx | | if (rbx < rdx) { 0x004ccb51 jb 0x4ccc60 | goto label_18; | } | } 0x004ccb57 shr r10, 3 | r10 >>= 3; 0x004ccb5b inc r10 | r10++; 0x004ccb5e mov r15, r10 | r15 = r10; 0x004ccb61 movabs rdx, 0x3ffffffffffffffc | rdx = 0x3ffffffffffffffc; 0x004ccb6b and r15, rdx | r15 &= rdx; 0x004ccb6e movd xmm0, edi | xmm0 = edi; 0x004ccb72 lea rdx, [r15 - 4] | rdx = r15 - 4; 0x004ccb76 mov r9, rdx | r9 = rdx; 0x004ccb79 shr r9, 2 | r9 >>= 2; 0x004ccb7d inc r9 | r9++; 0x004ccb80 test rdx, rdx | | if (rdx == 0) { 0x004ccb83 je 0x4ccfd6 | goto label_19; | } 0x004ccb89 mov rbx, r9 | rbx = r9; 0x004ccb8c and rbx, 0xfffffffffffffffe | rbx &= 0xfffffffffffffffe; 0x004ccb90 neg rbx | rbx = -rbx; 0x004ccb93 pxor xmm1, xmm1 | xmm1 = 0; 0x004ccb97 xor edi, edi | edi = 0; 0x004ccb99 movdqa xmm4, xmmword [rip + 0x238ff] | __asm ("movdqa xmm4, xmmword [0x004f04a0]"); 0x004ccba1 nop word cs:[rax + rax] | 0x004ccbab nop dword [rax + rax] | | do { 0x004ccbb0 movups xmm2, xmmword [rbp + rdi*8 + 0x74fa60] | __asm ("movups xmm2, xmmword [rbp + rdi*8 + obj.testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u]"); 0x004ccbb8 movups xmm3, xmmword [rbp + rdi*8 + 0x74fa70] | __asm ("movups xmm3, xmmword [rbp + rdi*8 + 0x74fa70]"); 0x004ccbc0 lea rdx, [r14*8] | rdx = r14*8; 0x004ccbc8 movups xmmword [rdx + rdi*8 + 0x74fa60], xmm2 | __asm ("movups xmmword [rdx + rdi*8 + obj.testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u], xmm2"); 0x004ccbd0 movups xmmword [rdx + rdi*8 + 0x74fa70], xmm3 | __asm ("movups xmmword [rdx + rdi*8 + 0x74fa70], xmm3"); 0x004ccbd8 movdqu xmm2, xmmword [rbp + rdi*8 + 0x74fa80] | __asm ("movdqu xmm2, xmmword [rbp + rdi*8 + 0x74fa80]"); 0x004ccbe1 movups xmm3, xmmword [rbp + rdi*8 + 0x74fa90] | __asm ("movups xmm3, xmmword [rbp + rdi*8 + 0x74fa90]"); 0x004ccbe9 movdqu xmmword [rdx + rdi*8 + 0x74fa80], xmm2 | __asm ("movdqu xmmword [rdx + rdi*8 + 0x74fa80], xmm2"); 0x004ccbf2 movups xmmword [rdx + rdi*8 + 0x74fa90], xmm3 | __asm ("movups xmmword [rdx + rdi*8 + 0x74fa90], xmm3"); 0x004ccbfa paddd xmm0, xmm4 | __asm ("paddd xmm0, xmm4"); 0x004ccbfe paddd xmm1, xmm4 | __asm ("paddd xmm1, xmm4"); 0x004ccc02 add rdi, 8 | rdi += 8; 0x004ccc06 add rbx, 2 | rbx += 2; 0x004ccc0a jne 0x4ccbb0 | | } while (rbx != 0); 0x004ccc0c test r9b, 1 | | if ((r9b & 1) != 0) { 0x004ccc10 je 0x4ccc32 | | label_2: 0x004ccc12 movdqu xmm2, xmmword [rax + rdi*8] | __asm ("movdqu xmm2, xmmword [rax + rdi*8]"); 0x004ccc17 movups xmm3, xmmword [rax + rdi*8 + 0x10] | __asm ("movups xmm3, xmmword [rax + rdi*8 + 0x10]"); 0x004ccc1c movdqu xmmword [rcx + rdi*8], xmm2 | __asm ("movdqu xmmword [rcx + rdi*8], xmm2"); 0x004ccc21 movups xmmword [rcx + rdi*8 + 0x10], xmm3 | __asm ("movups xmmword [rcx + rdi*8 + 0x10], xmm3"); 0x004ccc26 pcmpeqd xmm2, xmm2 | __asm ("pcmpeqd xmm2, xmm2"); 0x004ccc2a psubd xmm1, xmm2 | __asm ("psubd xmm1, xmm2"); 0x004ccc2e psubd xmm0, xmm2 | __asm ("psubd xmm0, xmm2"); | } | label_3: 0x004ccc32 paddd xmm0, xmm1 | __asm ("paddd xmm0, xmm1"); 0x004ccc36 pshufd xmm1, xmm0, 0x55 | __asm ("pshufd xmm1, xmm0, 0x55"); 0x004ccc3b paddd xmm1, xmm0 | __asm ("paddd xmm1, xmm0"); 0x004ccc3f movd edi, xmm1 | edi = xmm1; 0x004ccc43 cmp r10, r15 | 0x004ccc46 mov esi, dword [rsp + 0x18] | esi = *((rsp + 0x18)); | if (r10 == r15) { 0x004ccc4a je 0x4ccc83 | goto label_20; | } 0x004ccc4c lea rax, [rax + r15*8] | rax = rax + r15*8; 0x004ccc50 lea rcx, [rcx + r15*8] | rcx = rcx + r15*8; 0x004ccc54 nop word cs:[rax + rax] | 0x004ccc5e nop | | label_18: 0x004ccc60 sub r11, rax | r11 -= rax; 0x004ccc63 lea rdx, [r11 + 0x74fa60] | rdx = r11 + obj_testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u; 0x004ccc6a xor ebx, ebx | ebx = 0; 0x004ccc6c nop dword [rax] | | do { 0x004ccc70 mov rbp, qword [rax + rbx] | rbp = *((rax + rbx)); 0x004ccc74 mov qword [rcx + rbx], rbp | *((rcx + rbx)) = rbp; 0x004ccc78 inc edi | edi++; 0x004ccc7a add rbx, 8 | rbx += 8; 0x004ccc7e cmp rdx, rbx | 0x004ccc81 jne 0x4ccc70 | | } while (rdx != rbx); | label_20: 0x004ccc83 mov dword [rip + 0x24bd1b], edi | *(obj.numCopyCtorCalls) = edi; 0x004ccc89 mov rbp, qword [rsp + 0x10] | rbp = *((rsp + 0x10)); 0x004ccc8e mov rbx, qword [rsp + 8] | rbx = *((rsp + 8)); | label_17: 0x004ccc93 cmp byte [rip + 0x24bcf6], 0 | | if (*(obj.veryVerbose) != 0) { 0x004ccc9a jne 0x4ccee3 | goto label_21; | } 0x004ccca0 jmp 0x4ccf01 | goto label_22; | label_12: 0x004ccca5 mov eax, 1 | eax = 1; 0x004cccaa mov qword [rsp + 0x10], rax | *((rsp + 0x10)) = rax; 0x004cccaf mov rax, qword [rip + 0x284602] | rax = BloombergLP::bslma::Default::s_defaultAllocator; 0x004cccb6 test rax, rax | | if (rax != 0) { 0x004cccb9 jne 0x4cca52 | goto label_0; | } 0x004cccbf call 0x4eede0 | BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() (); 0x004cccc4 jmp 0x4cca52 | goto label_0; | label_14: 0x004ccd25 mov dword [rsp + 0x10], r12d | *((rsp + 0x10)) = r12d; 0x004ccd2a lea r8, [r14*8 + 0x74fa60] | r8 = r14*8 + obj_testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u; 0x004ccd32 add ebx, r15d | ebx += r15d; 0x004ccd35 movsxd rbx, ebx | rbx = (int64_t) ebx; 0x004ccd38 lea rdx, [rbx*8 + 0x74fa60] | rdx = rbx*8 + obj_testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u; 0x004ccd40 cmp r8, rdx | | if (r8 < rdx) { 0x004ccd43 jae 0x4ccd70 | 0x004ccd45 shl rbx, 3 | rbx <<= 3; 0x004ccd49 sub rbx, rdi | rbx -= rdi; 0x004ccd4c lea rdx, [rbx + r14*8 + 0x74fa60] | rdx = rbx + r14*8 + obj_testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u; 0x004ccd54 lea rbx, [r15*8 + 0x74fa60] | rbx = r15*8 + obj_testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u; 0x004ccd5c cmp rbx, rdx | | if (rbx >= rdx) { 0x004ccd5f jae 0x4ccd70 | goto label_23; | } 0x004ccd61 mov r12d, dword [rsp + 0x10] | r12d = *((rsp + 0x10)); 0x004ccd66 mov rbx, qword [rsp + 8] | rbx = *((rsp + 8)); 0x004ccd6b jmp 0x4cce70 | goto label_15; | } | label_23: 0x004ccd70 shr rsi, 3 | rsi >>= 3; 0x004ccd74 inc rsi | rsi++; 0x004ccd77 mov r8, rsi | r8 = rsi; 0x004ccd7a movabs rdx, 0x3ffffffffffffffc | rdx = 0x3ffffffffffffffc; 0x004ccd84 and r8, rdx | r8 &= rdx; 0x004ccd87 movd xmm0, ebp | xmm0 = ebp; 0x004ccd8b lea rdx, [r8 - 4] | rdx = r8 - 4; 0x004ccd8f mov r9, rdx | r9 = rdx; 0x004ccd92 shr r9, 2 | r9 >>= 2; 0x004ccd96 inc r9 | r9++; 0x004ccd99 test rdx, rdx | | if (rdx == 0) { 0x004ccd9c je 0x4ccfeb | goto label_24; | } 0x004ccda2 mov rbx, r9 | rbx = r9; 0x004ccda5 and rbx, 0xfffffffffffffffe | rbx &= 0xfffffffffffffffe; 0x004ccda9 neg rbx | rbx = -rbx; 0x004ccdac pxor xmm1, xmm1 | xmm1 = 0; 0x004ccdb0 xor ebp, ebp | ebp = 0; 0x004ccdb2 movdqa xmm4, xmmword [rip + 0x236e6] | __asm ("movdqa xmm4, xmmword [0x004f04a0]"); 0x004ccdba nop word [rax + rax] | | do { 0x004ccdc0 movups xmm2, xmmword [rdi + rbp*8 + 0x74fa60] | __asm ("movups xmm2, xmmword [rdi + rbp*8 + obj.testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u]"); 0x004ccdc8 movups xmm3, xmmword [rdi + rbp*8 + 0x74fa70] | __asm ("movups xmm3, xmmword [rdi + rbp*8 + 0x74fa70]"); 0x004ccdd0 lea rdx, [r14*8] | rdx = r14*8; 0x004ccdd8 movups xmmword [rdx + rbp*8 + 0x74fa60], xmm2 | __asm ("movups xmmword [rdx + rbp*8 + obj.testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u], xmm2"); 0x004ccde0 movups xmmword [rdx + rbp*8 + 0x74fa70], xmm3 | __asm ("movups xmmword [rdx + rbp*8 + 0x74fa70], xmm3"); 0x004ccde8 movdqu xmm2, xmmword [rdi + rbp*8 + 0x74fa80] | __asm ("movdqu xmm2, xmmword [rdi + rbp*8 + 0x74fa80]"); 0x004ccdf1 movups xmm3, xmmword [rdi + rbp*8 + 0x74fa90] | __asm ("movups xmm3, xmmword [rdi + rbp*8 + 0x74fa90]"); 0x004ccdf9 movdqu xmmword [rdx + rbp*8 + 0x74fa80], xmm2 | __asm ("movdqu xmmword [rdx + rbp*8 + 0x74fa80], xmm2"); 0x004cce02 movups xmmword [rdx + rbp*8 + 0x74fa90], xmm3 | __asm ("movups xmmword [rdx + rbp*8 + 0x74fa90], xmm3"); 0x004cce0a paddd xmm0, xmm4 | __asm ("paddd xmm0, xmm4"); 0x004cce0e paddd xmm1, xmm4 | __asm ("paddd xmm1, xmm4"); 0x004cce12 add rbp, 8 | rbp += 8; 0x004cce16 add rbx, 2 | rbx += 2; 0x004cce1a jne 0x4ccdc0 | | } while (rbx != 0); 0x004cce1c test r9b, 1 | | if ((r9b & 1) != 0) { 0x004cce20 je 0x4cce42 | | label_4: 0x004cce22 movdqu xmm2, xmmword [rax + rbp*8] | __asm ("movdqu xmm2, xmmword [rax + rbp*8]"); 0x004cce27 movups xmm3, xmmword [rax + rbp*8 + 0x10] | __asm ("movups xmm3, xmmword [rax + rbp*8 + 0x10]"); 0x004cce2c movdqu xmmword [rcx + rbp*8], xmm2 | __asm ("movdqu xmmword [rcx + rbp*8], xmm2"); 0x004cce31 movups xmmword [rcx + rbp*8 + 0x10], xmm3 | __asm ("movups xmmword [rcx + rbp*8 + 0x10], xmm3"); 0x004cce36 pcmpeqd xmm2, xmm2 | __asm ("pcmpeqd xmm2, xmm2"); 0x004cce3a psubd xmm1, xmm2 | __asm ("psubd xmm1, xmm2"); 0x004cce3e psubd xmm0, xmm2 | __asm ("psubd xmm0, xmm2"); | } | label_5: 0x004cce42 paddd xmm0, xmm1 | __asm ("paddd xmm0, xmm1"); 0x004cce46 pshufd xmm1, xmm0, 0x55 | __asm ("pshufd xmm1, xmm0, 0x55"); 0x004cce4b paddd xmm1, xmm0 | __asm ("paddd xmm1, xmm0"); 0x004cce4f movd ebp, xmm1 | 0x004cce53 cmp rsi, r8 | 0x004cce56 mov r12d, dword [rsp + 0x10] | r12d = *((rsp + 0x10)); 0x004cce5b mov rbx, qword [rsp + 8] | rbx = *((rsp + 8)); | if (rsi == r8) { 0x004cce60 je 0x4cce93 | goto label_25; | } 0x004cce62 lea rax, [rax + r8*8] | rax = rax + r8*8; 0x004cce66 lea rcx, [rcx + r8*8] | rcx = rcx + r8*8; 0x004cce6a nop word [rax + rax] | | label_15: 0x004cce70 sub r10, rax | r10 -= rax; 0x004cce73 lea rdx, [r10 + 0x74fa60] | rdx = r10 + obj_testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u; 0x004cce7a xor esi, esi | esi = 0; 0x004cce7c nop dword [rax] | | do { 0x004cce80 mov rdi, qword [rax + rsi] | rdi = *((rax + rsi)); 0x004cce84 mov qword [rcx + rsi], rdi | *((rcx + rsi)) = rdi; 0x004cce88 inc ebp | ebp++; 0x004cce8a add rsi, 8 | rsi += 8; 0x004cce8e cmp rdx, rsi | 0x004cce91 jne 0x4cce80 | | } while (rdx != rsi); | label_25: 0x004cce93 mov dword [rip + 0x24bb0b], ebp | *(obj.numCopyCtorCalls) = ebp; 0x004cce99 mov rbp, r11 | | label_13: 0x004cce9c mov rax, qword [rsp + 0x30] | rax = *((rsp + 0x30)); 0x004ccea1 lea rdi, [rsp + 0x30] | rdi = rsp + 0x30; 0x004ccea6 mov rsi, 0xffffffffffffffff | rsi = 0xffffffffffffffff; 0x004ccead call qword [rax + 0x10] | uint64_t (*rax + 0x10)() (); 0x004cceb0 cmp byte [rip + 0x24bade], 0 | | if (*(obj.veryVeryVerbose) != 0) { 0x004cceb7 je 0x4ccec3 | 0x004cceb9 mov edi, 0x4f4571 | 0x004ccebe call 0x401710 | puts ("\t\tEnd bslma exception test."); | } 0x004ccec3 cmp byte [rip + 0x24bac6], 0 | | if (*(obj.veryVerbose) != 0) { 0x004cceca je 0x4ccf01 | 0x004ccecc mov edi, 0xa | 0x004cced1 call 0x401720 | eax = putchar (0xa); 0x004cced6 mov esi, dword [rsp + 0x18] | esi = *((rsp + 0x18)); 0x004cceda cmp byte [rip + 0x24baaf], 0 | | if (*(obj.veryVerbose) == 0) { 0x004ccee1 je 0x4ccf01 | goto label_22; | } | label_21: 0x004ccee3 mov edx, dword [rip + 0x24babb] | edx = numCopyCtorCalls; 0x004ccee9 sub edx, r13d | edx -= r13d; 0x004cceec mov ecx, dword [rip + 0x24baba] | ecx = numCharCtorCalls; 0x004ccef2 sub ecx, r12d | ecx -= r12d; 0x004ccef5 mov edi, 0x4f5db4 | 0x004ccefa xor eax, eax | eax = 0; 0x004ccefc call 0x401680 | eax = printf ("LINE = %d, #copy ctors = %d, #char ctors = %d.\n"); | } | label_22: 0x004ccf01 cmp byte [rsp + 0x44], 0 | | if (*((rsp + 0x44)) == 0) { 0x004ccf06 je 0x4ccf60 | goto label_26; | } 0x004ccf08 cmp r13d, dword [rip + 0x24ba95] | | if (r13d != *(obj.numCopyCtorCalls)) { 0x004ccf0f je 0x4ccf3a | 0x004ccf11 mov edi, 0x4f4e04 | 0x004ccf16 mov edx, 0x4f5176 | edx = "NUM_COPIES == numCopyCtorCalls"; 0x004ccf1b mov esi, 0x1005 | esi = 0x1005; 0x004ccf20 xor eax, eax | eax = 0; 0x004ccf22 call 0x401680 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s (failed)\n"); 0x004ccf27 mov eax, dword [rip + 0x24ba6b] | eax = (anonymous namespace)::testStatus; 0x004ccf2d cmp eax, 0x64 | | if (eax > 0x64) { 0x004ccf30 ja 0x4ccf3a | goto label_27; | } 0x004ccf32 inc eax | eax++; 0x004ccf34 mov dword [rip + 0x24ba5e], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_27: 0x004ccf3a cmp r12d, dword [rip + 0x24ba6b] | | if (r12d == *(obj.numCharCtorCalls)) { 0x004ccf41 je 0x4cc8f0 | goto label_1; | } 0x004ccf47 mov edi, 0x4f4e04 | edi = "Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s (failed)\n"; 0x004ccf4c mov edx, 0x4f5de4 | edx = "NUM_CTORS == numCharCtorCalls"; 0x004ccf51 mov esi, 0x1006 | esi = 0x1006; 0x004ccf56 jmp 0x4ccfb3 | goto label_28; | label_26: 0x004ccf60 add r13d, dword [rsp + 0x20] | r13d += *((rsp + 0x20)); 0x004ccf65 cmp r13d, dword [rip + 0x24ba38] | | if (r13d > *(obj.numCopyCtorCalls)) { 0x004ccf6c jle 0x4ccf97 | 0x004ccf6e mov edi, 0x4f4e04 | 0x004ccf73 mov edx, 0x4f5e02 | edx = "NUM_COPIES + NE <= numCopyCtorCalls"; 0x004ccf78 mov esi, 0x1009 | esi = 0x1009; 0x004ccf7d xor eax, eax | eax = 0; 0x004ccf7f call 0x401680 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s (failed)\n"); 0x004ccf84 mov eax, dword [rip + 0x24ba0e] | eax = (anonymous namespace)::testStatus; 0x004ccf8a cmp eax, 0x64 | | if (eax > 0x64) { 0x004ccf8d ja 0x4ccf97 | goto label_29; | } 0x004ccf8f inc eax | eax++; 0x004ccf91 mov dword [rip + 0x24ba01], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_29: 0x004ccf97 cmp r12d, dword [rip + 0x24ba0e] | | if (r12d == *(obj.numCharCtorCalls)) { 0x004ccf9e je 0x4cc8f0 | goto label_1; | } 0x004ccfa4 mov edi, 0x4f4e04 | 0x004ccfa9 mov edx, 0x4f5de4 | edx = "NUM_CTORS == numCharCtorCalls"; 0x004ccfae mov esi, 0x100a | esi = 0x100a; | label_28: 0x004ccfb3 xor eax, eax | eax = 0; 0x004ccfb5 call 0x401680 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s (failed)\n"); 0x004ccfba mov eax, dword [rip + 0x24b9d8] | eax = (anonymous namespace)::testStatus; 0x004ccfc0 cmp eax, 0x64 | | if (eax > 0x64) { 0x004ccfc3 ja 0x4cc8f0 | goto label_1; | } 0x004ccfc9 inc eax | eax++; 0x004ccfcb mov dword [rip + 0x24b9c7], eax | *(obj._anonymous_namespace_::testStatus) = eax; 0x004ccfd1 jmp 0x4cc8f0 | goto label_1; | label_19: 0x004ccfd6 pxor xmm1, xmm1 | xmm1 = 0; 0x004ccfda xor edi, edi | edi = 0; 0x004ccfdc test r9b, 1 | | if ((r9b & 1) != 0) { 0x004ccfe0 jne 0x4ccc12 | goto label_2; | } 0x004ccfe6 jmp 0x4ccc32 | goto label_3; | label_24: 0x004ccfeb pxor xmm1, xmm1 | xmm1 = 0; 0x004ccfef xor ebp, ebp | ebp = 0; 0x004ccff1 test r9b, 1 | | if ((r9b & 1) != 0) { 0x004ccff5 jne 0x4cce22 | goto label_4; | } 0x004ccffb jmp 0x4cce42 | goto label_5; | label_9: 0x004cd000 cmp byte [rip + 0x24b98f], 0 | | if (*(obj.verbose) != 0) { 0x004cd007 je 0x4cd013 | 0x004cd009 mov edi, 0x4f695c | 0x004cd00e call 0x401710 | puts ("\t\tfrom different type."); | } 0x004cd013 xor r13d, r13d | r13d = 0; 0x004cd016 jmp 0x4cd047 | goto label_30; | label_6: 0x004cd020 mov edi, 0x74fa60 | edi = testCopyConstructWithIterators(bool, bool, bool)::u; 0x004cd025 mov rsi, rbp | rsi = rbp; 0x004cd028 call 0x4e3ed0 | voidverify(FnPtrConvertibleType*,char const*) (); 0x004cd02d mov edi, 0x74fa60 | edi = testCopyConstructWithIterators(bool, bool, bool)::u; 0x004cd032 mov rsi, rbp | rsi = rbp; 0x004cd035 call 0x4e4130 | voidcleanup(FnPtrConvertibleType*,char const*) (); 0x004cd03a inc r13 | r13++; 0x004cd03d cmp r13, 0x1e | | if (r13 == 0x1e) { 0x004cd041 je 0x4cd56a | goto label_31; | } | label_30: 0x004cd047 lea rbp, [r13*8] | rbp = r13*8; 0x004cd04f mov r12, qword [rbp + rbp*4 + 0x4f3c98] | r12 = *((rbp + rbp*4 + 0x4f3c98)); 0x004cd057 mov rdi, r12 | 0x004cd05a call 0x401790 | eax = strlen (*((rbp + rbp*4 + 0x4f3c98))); 0x004cd05f cmp eax, 0x11 | | if (eax >= 0x11) { 0x004cd062 jl 0x4cd08d | 0x004cd064 mov edi, 0x4f4e04 | 0x004cd069 mov edx, 0x4f4393 | edx = "MAX_SIZE >= (int)std::strlen(SPEC)"; 0x004cd06e mov esi, 0x1019 | esi = 0x1019; 0x004cd073 xor eax, eax | eax = 0; 0x004cd075 call 0x401680 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s (failed)\n"); 0x004cd07a mov eax, dword [rip + 0x24b918] | eax = (anonymous namespace)::testStatus; 0x004cd080 cmp eax, 0x64 | | if (eax > 0x64) { 0x004cd083 ja 0x4cd08d | goto label_32; | } 0x004cd085 inc eax | eax++; 0x004cd087 mov dword [rip + 0x24b90b], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_32: 0x004cd08d mov rdi, r12 | 0x004cd090 call 0x401790 | rax = strlen (r12); 0x004cd095 cmp rax, 0x14 | | if (rax >= 0x14) { 0x004cd099 jb 0x4cd0c4 | 0x004cd09b mov edi, 0x4f4e04 | 0x004cd0a0 mov edx, 0x4f5e26 | edx = "SPEC_CE_LEN > std::strlen(SPEC)"; 0x004cd0a5 mov esi, 0x101c | esi = 0x101c; 0x004cd0aa xor eax, eax | eax = 0; 0x004cd0ac call 0x401680 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s (failed)\n"); 0x004cd0b1 mov eax, dword [rip + 0x24b8e1] | eax = (anonymous namespace)::testStatus; 0x004cd0b7 cmp eax, 0x64 | | if (eax > 0x64) { 0x004cd0ba ja 0x4cd0c4 | goto label_33; | } 0x004cd0bc inc eax | eax++; 0x004cd0be mov dword [rip + 0x24b8d4], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_33: 0x004cd0c4 mov qword [rsp + 8], r13 | *((rsp + 8)) = r13; 0x004cd0c9 pxor xmm0, xmm0 | xmm0 = 0; 0x004cd0cd movdqa xmmword [rsp + 0x30], xmm0 | __asm ("movdqa xmmword [rsp + 0x30], xmm0"); 0x004cd0d3 mov dword [rsp + 0x40], 0 | *((rsp + 0x40)) = 0; 0x004cd0db mov al, byte [r12] | al = *(r12); 0x004cd0df test al, al | | if (al == 0) { 0x004cd0e1 je 0x4cd101 | goto label_34; | } 0x004cd0e3 xor ecx, ecx | ecx = 0; 0x004cd0e5 nop word cs:[rax + rax] | 0x004cd0ef nop | | do { 0x004cd0f0 mov byte [rsp + rcx + 0x30], al | *((rsp + rcx + 0x30)) = al; 0x004cd0f4 movzx eax, byte [r12 + rcx + 1] | eax = *((r12 + rcx + 1)); 0x004cd0fa inc rcx | rcx++; 0x004cd0fd test al, al | 0x004cd0ff jne 0x4cd0f0 | | } while (al != 0); | label_34: 0x004cd101 mov r14d, dword [rbp + rbp*4 + 0x4f3c90] | r14d = *((rbp + rbp*4 + obj.DATA_3)); 0x004cd109 movsxd rbx, dword [rbp + rbp*4 + 0x4f3ca0] | rbx = *((rbp + rbp*4 + 0x4f3ca0)); 0x004cd111 movsxd r15, dword [rbp + rbp*4 + 0x4f3ca4] | r15 = *((rbp + rbp*4 + 0x4f3ca4)); 0x004cd119 movsxd r13, dword [rbp + rbp*4 + 0x4f3ca8] | r13 = *((rbp + rbp*4 + 0x4f3ca8)); 0x004cd121 mov rbp, qword [rbp + rbp*4 + 0x4f3cb0] | rbp = *((rbp + rbp*4 + 0x4f3cb0)); 0x004cd129 cmp byte [rip + 0x24b860], 0 | | if (*(obj.veryVerbose) != 0) { 0x004cd130 je 0x4cd150 | 0x004cd132 mov qword [rsp], rbp | *(rsp) = rbp; 0x004cd136 mov edi, 0x4f5c41 | 0x004cd13b mov esi, r14d | esi = r14d; 0x004cd13e mov rdx, r12 | rdx = r12; 0x004cd141 mov ecx, ebx | ecx = ebx; 0x004cd143 mov r8d, r15d | r8d = r15d; 0x004cd146 mov r9d, r13d | r9d = r13d; 0x004cd149 xor eax, eax | eax = 0; 0x004cd14b call 0x401680 | printf ("LINE = %d, SPEC = %s, SRC = %d, NE = %d, DST = %d, EXP = %s\n"); | } 0x004cd150 mov edi, 0x74fa60 | edi = testCopyConstructWithIterators(bool, bool, bool)::u; 0x004cd155 mov rsi, r12 | rsi = r12; 0x004cd158 call 0x4e3dd0 | FnPtrConvertibleType&gg(FnPtrConvertibleType*,char const*) (); 0x004cd15d mov edi, 0x74fa60 | edi = testCopyConstructWithIterators(bool, bool, bool)::u; 0x004cd162 mov rsi, r12 | rsi = r12; 0x004cd165 call 0x4e3ed0 | voidverify(FnPtrConvertibleType*,char const*) (); 0x004cd16a mov r12d, dword [rip + 0x24b833] | r12d = numCopyCtorCalls; 0x004cd171 mov eax, dword [rip + 0x24b835] | eax = numCharCtorCalls; 0x004cd177 mov dword [rsp + 0x20], eax | *((rsp + 0x20)) = eax; 0x004cd17b cmp byte [rsp + 0x2c], 0 | | if (*((rsp + 0x2c)) == 0) { 0x004cd180 je 0x4cd340 | goto label_35; | } 0x004cd186 cmp byte [rip + 0x24b803], 0 | | if (*(obj.veryVerbose) != 0) { 0x004cd18d je 0x4cd1a2 | 0x004cd18f cmp dword [rip + 0x24b426], 0 | | if (*(0x007185bc) == 0) { 0x004cd196 je 0x4cd1a2 | goto label_36; | } 0x004cd198 mov edi, 0x4f43ea | 0x004cd19d call 0x401710 | puts ("\t\tBSLMA EXCEPTION TEST -- (ENABLED) --"); | } | label_36: 0x004cd1a2 mov dword [rip + 0x24b410], 0 | *(0x007185bc) = 0; 0x004cd1ac cmp byte [rip + 0x24b7e2], 0 | | if (*(obj.veryVeryVerbose) != 0) { 0x004cd1b3 je 0x4cd1bf | 0x004cd1b5 mov edi, 0x4f4411 | 0x004cd1ba call 0x401710 | puts ("\t\tBegin bslma exception test."); | } 0x004cd1bf mov rax, qword [rip + 0x24b65a] | rax = Z; 0x004cd1c6 mov qword [rsp + 0x48], 0x4f69e0 | *((rsp + 0x48)) = vtable.BloombergLP::bslma::TestAllocator_Proxy_BloombergLP::bslma::TestAllocator_.0; 0x004cd1cf mov qword [rsp + 0x50], rax | *((rsp + 0x50)) = rax; 0x004cd1d4 mov qword [rax + 0x20], 0 | *((rax + 0x20)) = 0; 0x004cd1dc test rax, rax | | if (rax == 0) { 0x004cd1df je 0x4cd4ea | goto label_37; | } | label_7: 0x004cd1e5 cmp qword [rsp + 8], 6 | | if (*((rsp + 8)) < 6) { 0x004cd1eb jb 0x4cd2f8 | goto label_38; | } 0x004cd1f1 add r15d, ebx | r15d += ebx; 0x004cd1f4 movsxd rax, r15d | rax = (int64_t) r15d; 0x004cd1f7 lea rcx, [rsp + rbx + 0x30] | rcx = rsp + rbx + 0x30; 0x004cd1fc lea rsi, [r13*8 + 0x74fa60] | rsi = r13*8 + obj_testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u; 0x004cd204 mov edx, eax | edx = eax; 0x004cd206 sub edx, ebx | edx -= ebx; 0x004cd208 not rbx | rbx = ~rbx; 0x004cd20b add rbx, rax | rbx += rax; 0x004cd20e and rdx, 7 | rdx &= 7; | if (rdx == 0) { 0x004cd212 je 0x4cd23b | goto label_39; | } 0x004cd214 nop word cs:[rax + rax] | 0x004cd21e nop | | do { 0x004cd220 movsx rdi, byte [rcx] | rdi = *(rcx); 0x004cd224 mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004cd22c mov qword [rsi], rdi | *(rsi) = rdi; 0x004cd22f inc rcx | rcx++; 0x004cd232 add rsi, 8 | rsi += 8; 0x004cd236 dec rdx | rdx--; 0x004cd239 jne 0x4cd220 | | } while (rdx != 0); | label_39: 0x004cd23b cmp rbx, 7 | | if (rbx < 7) { 0x004cd23f jb 0x4cd2f8 | goto label_38; | } 0x004cd245 lea rax, [rsp + rax + 0x30] | rax = rsp + rax + 0x30; 0x004cd24a xor edi, edi | edi = 0; 0x004cd24c nop dword [rax] | | do { 0x004cd250 movsx rdx, byte [rcx + rdi] | rdx = *((rcx + rdi)); 0x004cd255 mov rdx, qword [rdx*8 + 0x7171d0] | rdx = *((rdx*8 + obj.funcPtrArray)); 0x004cd25d mov qword [rsi + rdi*8], rdx | *((rsi + rdi*8)) = rdx; 0x004cd261 movsx rdx, byte [rcx + rdi + 1] | rdx = *((rcx + rdi + 1)); 0x004cd267 mov rdx, qword [rdx*8 + 0x7171d0] | rdx = *((rdx*8 + obj.funcPtrArray)); 0x004cd26f mov qword [rsi + rdi*8 + 8], rdx | *((rsi + rdi*8 + 8)) = rdx; 0x004cd274 movsx rdx, byte [rcx + rdi + 2] | rdx = *((rcx + rdi + 2)); 0x004cd27a mov rdx, qword [rdx*8 + 0x7171d0] | rdx = *((rdx*8 + obj.funcPtrArray)); 0x004cd282 mov qword [rsi + rdi*8 + 0x10], rdx | *((rsi + rdi*8 + 0x10)) = rdx; 0x004cd287 movsx rdx, byte [rcx + rdi + 3] | rdx = *((rcx + rdi + 3)); 0x004cd28d mov rdx, qword [rdx*8 + 0x7171d0] | rdx = *((rdx*8 + obj.funcPtrArray)); 0x004cd295 mov qword [rsi + rdi*8 + 0x18], rdx | *((rsi + rdi*8 + 0x18)) = rdx; 0x004cd29a movsx rdx, byte [rcx + rdi + 4] | rdx = *((rcx + rdi + 4)); 0x004cd2a0 mov rdx, qword [rdx*8 + 0x7171d0] | rdx = *((rdx*8 + obj.funcPtrArray)); 0x004cd2a8 mov qword [rsi + rdi*8 + 0x20], rdx | *((rsi + rdi*8 + 0x20)) = rdx; 0x004cd2ad movsx rdx, byte [rcx + rdi + 5] | rdx = *((rcx + rdi + 5)); 0x004cd2b3 mov rdx, qword [rdx*8 + 0x7171d0] | rdx = *((rdx*8 + obj.funcPtrArray)); 0x004cd2bb mov qword [rsi + rdi*8 + 0x28], rdx | *((rsi + rdi*8 + 0x28)) = rdx; 0x004cd2c0 movsx rdx, byte [rcx + rdi + 6] | rdx = *((rcx + rdi + 6)); 0x004cd2c6 mov rdx, qword [rdx*8 + 0x7171d0] | rdx = *((rdx*8 + obj.funcPtrArray)); 0x004cd2ce mov qword [rsi + rdi*8 + 0x30], rdx | *((rsi + rdi*8 + 0x30)) = rdx; 0x004cd2d3 movsx rdx, byte [rcx + rdi + 7] | rdx = *((rcx + rdi + 7)); 0x004cd2d9 mov rdx, qword [rdx*8 + 0x7171d0] | rdx = *((rdx*8 + obj.funcPtrArray)); 0x004cd2e1 mov qword [rsi + rdi*8 + 0x38], rdx | *((rsi + rdi*8 + 0x38)) = rdx; 0x004cd2e6 lea rdx, [rcx + rdi + 8] | rdx = rcx + rdi + 8; 0x004cd2eb add rdi, 8 | rdi += 8; 0x004cd2ef cmp rdx, rax | 0x004cd2f2 jne 0x4cd250 | | } while (rdx != rax); | label_38: 0x004cd2f8 mov rax, qword [rsp + 0x48] | rax = *((rsp + 0x48)); 0x004cd2fd lea rdi, [rsp + 0x48] | rdi = rsp + 0x48; 0x004cd302 mov rsi, 0xffffffffffffffff | rsi = 0xffffffffffffffff; 0x004cd309 call qword [rax + 0x10] | uint64_t (*rax + 0x10)() (); 0x004cd30c cmp byte [rip + 0x24b682], 0 | 0x004cd313 mov r13, qword [rsp + 8] | r13 = *((rsp + 8)); | if (*(obj.veryVeryVerbose) != 0) { 0x004cd318 je 0x4cd324 | 0x004cd31a mov edi, 0x4f4571 | 0x004cd31f call 0x401710 | puts ("\t\tEnd bslma exception test."); | } 0x004cd324 cmp byte [rip + 0x24b665], 0 | | if (*(obj.veryVerbose) == 0) { 0x004cd32b je 0x4cd4ab | goto label_40; | } 0x004cd331 mov edi, 0xa | 0x004cd336 call 0x401720 | putchar (0xa); 0x004cd33b jmp 0x4cd480 | goto label_41; | label_35: 0x004cd340 cmp qword [rip + 0x24b4d8], 0 | 0x004cd348 mov rcx, r13 | rcx = r13; | if (*(obj.Z) == 0) { 0x004cd34b jne 0x4cd370 | 0x004cd34d mov rax, qword [rip + 0x283f64] | rax = BloombergLP::bslma::Default::s_defaultAllocator; 0x004cd354 test rax, rax | | if (rax != 0) { 0x004cd357 jne 0x4cd370 | goto label_42; | } 0x004cd359 call 0x4eede0 | BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() (); 0x004cd35e mov rcx, r13 | rcx = r13; 0x004cd361 nop word cs:[rax + rax] | 0x004cd36b nop dword [rax + rax] | | } | label_42: 0x004cd370 mov r13, qword [rsp + 8] | r13 = *((rsp + 8)); 0x004cd375 cmp r13, 6 | | if (r13 < 6) { 0x004cd379 jb 0x4cd480 | goto label_41; | } 0x004cd37f add r15, rbx | r15 += rbx; 0x004cd382 lea rax, [rcx*8 + 0x74fa60] | rax = rcx*8 + obj_testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u; 0x004cd38a lea rcx, [rsp + rbx + 0x30] | rcx = rsp + rbx + 0x30; 0x004cd38f mov edx, r15d | edx = r15d; 0x004cd392 sub edx, ebx | edx -= ebx; 0x004cd394 not rbx | rbx = ~rbx; 0x004cd397 add rbx, r15 | rbx += r15; 0x004cd39a and rdx, 7 | rdx &= 7; | if (rdx == 0) { 0x004cd39e je 0x4cd3bb | goto label_43; | } | do { 0x004cd3a0 movsx rdi, byte [rcx] | rdi = *(rcx); 0x004cd3a4 mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004cd3ac mov qword [rax], rdi | *(rax) = rdi; 0x004cd3af inc rcx | rcx++; 0x004cd3b2 add rax, 8 | rax += 8; 0x004cd3b6 dec rdx | rdx--; 0x004cd3b9 jne 0x4cd3a0 | | } while (rdx != 0); | label_43: 0x004cd3bb cmp rbx, 7 | | if (rbx < 7) { 0x004cd3bf jb 0x4cd480 | goto label_41; | } 0x004cd3c5 lea rdx, [rsp + r15 + 0x30] | rdx = rsp + r15 + 0x30; 0x004cd3ca xor ebx, ebx | ebx = 0; 0x004cd3cc nop dword [rax] | | do { 0x004cd3d0 movsx rdi, byte [rcx + rbx] | rdi = *((rcx + rbx)); 0x004cd3d5 mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004cd3dd mov qword [rax + rbx*8], rdi | *((rax + rbx*8)) = rdi; 0x004cd3e1 movsx rdi, byte [rcx + rbx + 1] | rdi = *((rcx + rbx + 1)); 0x004cd3e7 mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004cd3ef mov qword [rax + rbx*8 + 8], rdi | *((rax + rbx*8 + 8)) = rdi; 0x004cd3f4 movsx rdi, byte [rcx + rbx + 2] | rdi = *((rcx + rbx + 2)); 0x004cd3fa mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004cd402 mov qword [rax + rbx*8 + 0x10], rdi | *((rax + rbx*8 + 0x10)) = rdi; 0x004cd407 movsx rdi, byte [rcx + rbx + 3] | rdi = *((rcx + rbx + 3)); 0x004cd40d mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004cd415 mov qword [rax + rbx*8 + 0x18], rdi | *((rax + rbx*8 + 0x18)) = rdi; 0x004cd41a movsx rdi, byte [rcx + rbx + 4] | rdi = *((rcx + rbx + 4)); 0x004cd420 mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004cd428 mov qword [rax + rbx*8 + 0x20], rdi | *((rax + rbx*8 + 0x20)) = rdi; 0x004cd42d movsx rdi, byte [rcx + rbx + 5] | rdi = *((rcx + rbx + 5)); 0x004cd433 mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004cd43b mov qword [rax + rbx*8 + 0x28], rdi | *((rax + rbx*8 + 0x28)) = rdi; 0x004cd440 movsx rdi, byte [rcx + rbx + 6] | rdi = *((rcx + rbx + 6)); 0x004cd446 mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004cd44e mov qword [rax + rbx*8 + 0x30], rdi | *((rax + rbx*8 + 0x30)) = rdi; 0x004cd453 movsx rdi, byte [rcx + rbx + 7] | rdi = *((rcx + rbx + 7)); 0x004cd459 mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004cd461 mov qword [rax + rbx*8 + 0x38], rdi | *((rax + rbx*8 + 0x38)) = rdi; 0x004cd466 lea rdi, [rcx + rbx + 8] | rdi = rcx + rbx + 8; 0x004cd46b add rbx, 8 | rbx += 8; 0x004cd46f cmp rdi, rdx | 0x004cd472 jne 0x4cd3d0 | | } while (rdi != rdx); 0x004cd478 nop dword [rax + rax] | | label_41: 0x004cd480 cmp byte [rip + 0x24b509], 0 | | if (*(obj.veryVerbose) != 0) { 0x004cd487 je 0x4cd4ab | 0x004cd489 mov edx, dword [rip + 0x24b515] | edx = numCopyCtorCalls; 0x004cd48f sub edx, r12d | edx -= r12d; 0x004cd492 mov ecx, dword [rip + 0x24b514] | ecx = numCharCtorCalls; 0x004cd498 sub ecx, dword [rsp + 0x20] | ecx -= *((rsp + 0x20)); 0x004cd49c mov edi, 0x4f5db4 | 0x004cd4a1 mov esi, r14d | esi = r14d; 0x004cd4a4 xor eax, eax | eax = 0; 0x004cd4a6 call 0x401680 | eax = printf ("LINE = %d, #copy ctors = %d, #char ctors = %d.\n"); | } | label_40: 0x004cd4ab cmp r12d, dword [rip + 0x24b4f2] | | if (r12d == *(obj.numCopyCtorCalls)) { 0x004cd4b2 je 0x4cd020 | goto label_6; | } 0x004cd4b8 mov edi, 0x4f4e04 | 0x004cd4bd mov edx, 0x4f5176 | edx = "NUM_COPIES == numCopyCtorCalls"; 0x004cd4c2 mov esi, 0x103f | esi = 0x103f; 0x004cd4c7 xor eax, eax | eax = 0; 0x004cd4c9 call 0x401680 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s (failed)\n"); 0x004cd4ce mov eax, dword [rip + 0x24b4c4] | eax = (anonymous namespace)::testStatus; 0x004cd4d4 cmp eax, 0x64 | | if (eax > 0x64) { 0x004cd4d7 ja 0x4cd020 | goto label_6; | } 0x004cd4dd inc eax | eax++; 0x004cd4df mov dword [rip + 0x24b4b3], eax | *(obj._anonymous_namespace_::testStatus) = eax; 0x004cd4e5 jmp 0x4cd020 | goto label_6; | label_37: 0x004cd4ea mov eax, 1 | eax = 1; 0x004cd4ef mov qword [rsp + 0x18], rax | *((rsp + 0x18)) = rax; 0x004cd4f4 mov rax, qword [rip + 0x283dbd] | rax = BloombergLP::bslma::Default::s_defaultAllocator; 0x004cd4fb test rax, rax | | if (rax != 0) { 0x004cd4fe jne 0x4cd1e5 | goto label_7; | } 0x004cd504 call 0x4eede0 | BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() (); 0x004cd509 jmp 0x4cd1e5 | goto label_7; | label_31: 0x004cd56a add rsp, 0x58 | 0x004cd56e pop rbx | 0x004cd56f pop r12 | 0x004cd571 pop r13 | 0x004cd573 pop r14 | 0x004cd575 pop r15 | 0x004cd577 pop rbp | 0x004cd578 ret | return rax; | }