; assembly | /* r2dec pseudo code output */ | /* bslalg_arrayprimitives.t/assume @ 0x4cd470 */ | #include | ; (fcn) sym.void_testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_ () | uint64_t void_testCopyConstructWithIterators_AmbiguousConvertibleType_bool_bool_bool_ (uint32_t arg3, uint32_t arg2) { | int64_t var_14h; | int64_t var_18h; | int64_t var_20h; | uint32_t var_28h; | int64_t var_30h; | uint32_t var_3ch; | int64_t var_40h; | int64_t var_48h; | int64_t var_50h; | uint32_t var_54h; | int64_t var_58h; | int64_t var_60h; | rdx = arg3; | rsi = arg2; | /* void testCopyConstructWithIterators(bool, bool, bool) */ 0x004cd470 push rbp | 0x004cd471 push r15 | 0x004cd473 push r14 | 0x004cd475 push r13 | 0x004cd477 push r12 | 0x004cd479 push rbx | 0x004cd47a sub rsp, 0x68 | 0x004cd47e mov dword [rsp + 0x3c], edx | *((rsp + 0x3c)) = edx; 0x004cd482 mov dword [rsp + 0x54], esi | *((rsp + 0x54)) = esi; 0x004cd486 cmp byte [rip + 0x24b509], 0 | | if (*(obj.verbose) != 0) { 0x004cd48d je 0x4cd499 | 0x004cd48f mov edi, 0x4f67e9 | 0x004cd494 call 0x401710 | puts ("\t\tfrom same type."); | } 0x004cd499 xor r13d, r13d | r13d = 0; 0x004cd49c jmp 0x4cd4c7 | goto label_10; | label_1: 0x004cd4a0 mov edi, 0x74fae0 | edi = testCopyConstructWithIterators(bool, bool, bool)::u; 0x004cd4a5 mov rsi, rbp | rsi = rbp; 0x004cd4a8 call 0x4e42c0 | voidverify(AmbiguousConvertibleType*,char const*) (); 0x004cd4ad mov edi, 0x74fae0 | edi = testCopyConstructWithIterators(bool, bool, bool)::u; 0x004cd4b2 mov rsi, rbp | rsi = rbp; 0x004cd4b5 call 0x4e4520 | voidcleanup(AmbiguousConvertibleType*,char const*) (); 0x004cd4ba inc r13 | r13++; 0x004cd4bd cmp r13, 0x1e | | if (r13 == 0x1e) { 0x004cd4c1 je 0x4cdba6 | goto label_11; | } | label_10: 0x004cd4c7 mov qword [rsp + 0x28], r13 | *((rsp + 0x28)) = r13; 0x004cd4cc lea rbp, [r13*8] | rbp = r13*8; 0x004cd4d4 mov r12, qword [rbp + rbp*4 + 0x4f3b08] | r12 = *((rbp + rbp*4 + 0x4f3b08)); 0x004cd4dc mov rdi, r12 | 0x004cd4df call 0x401790 | eax = strlen (*((rbp + rbp*4 + 0x4f3b08))); 0x004cd4e4 cmp eax, 0x11 | | if (eax >= 0x11) { 0x004cd4e7 jl 0x4cd512 | 0x004cd4e9 mov edi, 0x4f4c78 | 0x004cd4ee mov edx, 0x4f4203 | edx = "MAX_SIZE >= (int)std::strlen(SPEC)"; 0x004cd4f3 mov esi, 0xfe6 | esi = 0xfe6; 0x004cd4f8 xor eax, eax | eax = 0; 0x004cd4fa call 0x401680 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s (failed)\n"); 0x004cd4ff mov eax, dword [rip + 0x24b493] | eax = (anonymous namespace)::testStatus; 0x004cd505 cmp eax, 0x64 | | if (eax > 0x64) { 0x004cd508 ja 0x4cd512 | goto label_12; | } 0x004cd50a inc eax | eax++; 0x004cd50c mov dword [rip + 0x24b486], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_12: 0x004cd512 mov r13d, dword [rbp + rbp*4 + 0x4f3b00] | r13d = *((rbp + rbp*4 + obj.DATA_3)); 0x004cd51a movsxd r15, dword [rbp + rbp*4 + 0x4f3b10] | r15 = *((rbp + rbp*4 + 0x4f3b10)); 0x004cd522 mov ebx, dword [rbp + rbp*4 + 0x4f3b14] | ebx = *((rbp + rbp*4 + 0x4f3b14)); 0x004cd529 movsxd r14, dword [rbp + rbp*4 + 0x4f3b18] | r14 = *((rbp + rbp*4 + 0x4f3b18)); 0x004cd531 mov rbp, qword [rbp + rbp*4 + 0x4f3b20] | rbp = *((rbp + rbp*4 + 0x4f3b20)); 0x004cd539 cmp byte [rip + 0x24b450], 0 | | if (*(obj.veryVerbose) != 0) { 0x004cd540 je 0x4cd561 | 0x004cd542 mov qword [rsp], rbp | *(rsp) = rbp; 0x004cd546 mov edi, 0x4f5ab7 | 0x004cd54b mov esi, r13d | esi = r13d; 0x004cd54e mov rdx, r12 | rdx = r12; 0x004cd551 mov ecx, r15d | ecx = r15d; 0x004cd554 mov r8d, ebx | r8d = ebx; 0x004cd557 mov r9d, r14d | r9d = r14d; 0x004cd55a xor eax, eax | eax = 0; 0x004cd55c call 0x401680 | printf ("LINE = %d, SPEC = %s, SRC = %d, NE = %d, DST = %d, EXP = %s\n"); | } 0x004cd561 mov dword [rsp + 0x18], r13d | *((rsp + 0x18)) = r13d; 0x004cd566 mov qword [rsp + 0x30], rbx | *((rsp + 0x30)) = rbx; 0x004cd56b mov edi, 0x74fae0 | edi = testCopyConstructWithIterators(bool, bool, bool)::u; 0x004cd570 mov rsi, r12 | rsi = r12; 0x004cd573 call 0x4e41c0 | AmbiguousConvertibleType&gg(AmbiguousConvertibleType*,char const*) (); 0x004cd578 mov edi, 0x74fae0 | edi = testCopyConstructWithIterators(bool, bool, bool)::u; 0x004cd57d mov rsi, r12 | rsi = r12; 0x004cd580 call 0x4e42c0 | voidverify(AmbiguousConvertibleType*,char const*) (); 0x004cd585 mov ebx, dword [rip + 0x24b419] | ebx = numCopyCtorCalls; 0x004cd58b mov r12d, dword [rip + 0x24b41a] | r12d = numCharCtorCalls; 0x004cd592 cmp byte [rsp + 0x3c], 0 | | if (*((rsp + 0x3c)) != 0) { 0x004cd597 je 0x4cd660 | 0x004cd59d cmp byte [rip + 0x24b3ec], 0 | 0x004cd5a4 mov r13, qword [rsp + 0x28] | r13 = *((rsp + 0x28)); | if (*(obj.veryVerbose) != 0) { 0x004cd5a9 je 0x4cd5be | 0x004cd5ab cmp dword [rip + 0x24b00e], 0 | | if (*(0x007185c0) == 0) { 0x004cd5b2 je 0x4cd5be | goto label_13; | } 0x004cd5b4 mov edi, 0x4f425a | 0x004cd5b9 call 0x401710 | puts ("\t\tBSLMA EXCEPTION TEST -- (ENABLED) --"); | } | label_13: 0x004cd5be mov dword [rip + 0x24aff8], 0 | *(0x007185c0) = 0; 0x004cd5c8 cmp byte [rip + 0x24b3c6], 0 | | if (*(obj.veryVeryVerbose) != 0) { 0x004cd5cf je 0x4cd5db | 0x004cd5d1 mov edi, 0x4f4281 | 0x004cd5d6 call 0x401710 | puts ("\t\tBegin bslma exception test."); | } 0x004cd5db mov rax, qword [rip + 0x24b23e] | rax = Z; 0x004cd5e2 mov qword [rsp + 0x40], 0x4f6858 | *((rsp + 0x40)) = vtable.BloombergLP::bslma::TestAllocator_Proxy_BloombergLP::bslma::TestAllocator_.0; 0x004cd5eb mov qword [rsp + 0x48], rax | *((rsp + 0x48)) = rax; 0x004cd5f0 mov qword [rax + 0x20], 0 | *((rax + 0x20)) = 0; 0x004cd5f8 test rax, rax | | if (rax == 0) { 0x004cd5fb je 0x4cd7f6 | goto label_14; | } | label_0: 0x004cd601 cmp r13, 6 | | if (r13 < 6) { 0x004cd605 jb 0x4cd9ee | goto label_15; | } 0x004cd60b mov r11d, ebx | r11d = ebx; 0x004cd60e mov qword [rsp + 0x20], rbp | *((rsp + 0x20)) = rbp; 0x004cd613 lea rax, [r15*8 + 0x74fae0] | rax = r15*8 + obj_testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u; 0x004cd61b lea rdi, [r15*8] | rdi = r15*8; 0x004cd623 lea rcx, [r14*8 + 0x74fae0] | rcx = r14*8 + obj_testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u; 0x004cd62b mov ebp, dword [rip + 0x24b373] | ebp = numCopyCtorCalls; 0x004cd631 mov rbx, qword [rsp + 0x30] | rbx = *((rsp + 0x30)); 0x004cd636 lea edx, [rbx + r15] | edx = rbx + r15; 0x004cd63a movsxd r10, edx | r10 = (int64_t) edx; 0x004cd63d shl r10, 3 | r10 <<= 3; 0x004cd641 mov rsi, r10 | rsi = r10; 0x004cd644 sub rsi, rdi | rsi -= rdi; 0x004cd647 add rsi, 0xfffffffffffffff8 | rsi += 0xfffffffffffffff8; 0x004cd64b cmp rsi, 0x18 | | if (rsi >= 0x18) { 0x004cd64f jae 0x4cd876 | goto label_16; | } 0x004cd655 mov ebx, r11d | ebx = r11d; 0x004cd658 jmp 0x4cd9c0 | goto label_17; | } 0x004cd660 cmp qword [rip + 0x24b1b8], 0 | 0x004cd668 mov r13, qword [rsp + 0x28] | r13 = *((rsp + 0x28)); | if (*(obj.Z) == 0) { 0x004cd66d jne 0x4cd680 | 0x004cd66f mov rax, qword [rip + 0x283c42] | rax = BloombergLP::bslma::Default::s_defaultAllocator; 0x004cd676 test rax, rax | | if (rax != 0) { 0x004cd679 jne 0x4cd680 | goto label_18; | } 0x004cd67b call 0x4eec50 | BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() (); | } | label_18: 0x004cd680 cmp r13, 6 | 0x004cd684 mov esi, dword [rsp + 0x18] | esi = *((rsp + 0x18)); | if (r13 < 6) { 0x004cd688 jb 0x4cda2c | goto label_19; | } 0x004cd68e mov dword [rsp + 0x14], ebx | *((rsp + 0x14)) = ebx; 0x004cd692 mov qword [rsp + 0x20], rbp | *((rsp + 0x20)) = rbp; 0x004cd697 mov rax, qword [rsp + 0x30] | rax = *((rsp + 0x30)); 0x004cd69c add eax, r15d | eax += r15d; 0x004cd69f lea rdi, [r15*8 + 0x74fae0] | rdi = r15*8 + obj_testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u; 0x004cd6a7 cdqe | rax = (int64_t) eax; 0x004cd6a9 lea rcx, [r14*8 + 0x74fae0] | rcx = r14*8 + obj_testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u; 0x004cd6b1 mov ebp, dword [rip + 0x24b2ed] | ebp = numCopyCtorCalls; 0x004cd6b7 lea r13, [rax*8] | r13 = rax*8; 0x004cd6bf lea rbx, [r15*8] | rbx = r15*8; 0x004cd6c7 mov rdx, r13 | rdx = r13; 0x004cd6ca sub rdx, rbx | rdx -= rbx; 0x004cd6cd lea r10, [rdx - 8] | r10 = rdx - 8; 0x004cd6d1 cmp r10, 0x18 | | if (r10 < 0x18) { 0x004cd6d5 jb 0x4cdb30 | goto label_20; | } 0x004cd6db lea rbx, [r14*8 + 0x74fae0] | rbx = r14*8 + obj_testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u; 0x004cd6e3 lea rax, [rax*8 + 0x74fae0] | rax = rax*8 + obj_testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u; 0x004cd6eb cmp rbx, rax | | if (rbx < rax) { 0x004cd6ee jae 0x4cd709 | 0x004cd6f0 lea rax, [rdx + r14*8 + 0x74fae0] | rax = rdx + r14*8 + obj_testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u; 0x004cd6f8 lea rdx, [r15*8 + 0x74fae0] | rdx = r15*8 + obj_testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u; 0x004cd700 cmp rdx, rax | | if (rdx < rax) { 0x004cd703 jb 0x4cdb30 | goto label_20; | } | } 0x004cd709 shr r10, 3 | r10 >>= 3; 0x004cd70d inc r10 | r10++; 0x004cd710 mov r8, r10 | r8 = r10; 0x004cd713 movabs rax, 0x3ffffffffffffffc | rax = 0x3ffffffffffffffc; 0x004cd71d and r8, rax | r8 &= rax; 0x004cd720 movd xmm0, ebp | xmm0 = ebp; 0x004cd724 lea rax, [r8 - 4] | rax = r8 - 4; 0x004cd728 mov r9, rax | r9 = rax; 0x004cd72b shr r9, 2 | r9 >>= 2; 0x004cd72f inc r9 | r9++; 0x004cd732 test rax, rax | | if (rax == 0) { 0x004cd735 je 0x4cdb79 | goto label_21; | } 0x004cd73b mov rsi, r9 | rsi = r9; 0x004cd73e and rsi, 0xfffffffffffffffe | rsi &= 0xfffffffffffffffe; 0x004cd742 neg rsi | rsi = -rsi; 0x004cd745 pxor xmm1, xmm1 | xmm1 = 0; 0x004cd749 mov rax, rdi | rax = rdi; 0x004cd74c xor ebp, ebp | ebp = 0; 0x004cd74e movdqa xmm4, xmmword [rip + 0x22bba] | __asm ("movdqa xmm4, xmmword [0x004f0310]"); 0x004cd756 nop word cs:[rax + rax] | | do { 0x004cd760 movups xmm2, xmmword [rax] | __asm ("movups xmm2, xmmword [rax]"); 0x004cd763 movups xmm3, xmmword [rax + 0x10] | __asm ("movups xmm3, xmmword [rax + 0x10]"); 0x004cd767 lea rbx, [r14*8] | rbx = r14*8; 0x004cd76f movups xmmword [rbx + rbp*8 + 0x74fae0], xmm2 | __asm ("movups xmmword [rbx + rbp*8 + obj.testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u], xmm2"); 0x004cd777 movups xmmword [rbx + rbp*8 + 0x74faf0], xmm3 | __asm ("movups xmmword [rbx + rbp*8 + 0x74faf0], xmm3"); 0x004cd77f movdqu xmm2, xmmword [rax + 0x20] | __asm ("movdqu xmm2, xmmword [rax + 0x20]"); 0x004cd784 movups xmm3, xmmword [rax + 0x30] | __asm ("movups xmm3, xmmword [rax + 0x30]"); 0x004cd788 movdqu xmmword [rbx + rbp*8 + 0x74fb00], xmm2 | __asm ("movdqu xmmword [rbx + rbp*8 + 0x74fb00], xmm2"); 0x004cd791 movups xmmword [rbx + rbp*8 + 0x74fb10], xmm3 | __asm ("movups xmmword [rbx + rbp*8 + 0x74fb10], xmm3"); 0x004cd799 paddd xmm0, xmm4 | __asm ("paddd xmm0, xmm4"); 0x004cd79d paddd xmm1, xmm4 | __asm ("paddd xmm1, xmm4"); 0x004cd7a1 add rbp, 8 | rbp += 8; 0x004cd7a5 add rax, 0x40 | rax += 0x40; 0x004cd7a9 add rsi, 2 | rsi += 2; 0x004cd7ad jne 0x4cd760 | | } while (rsi != 0); 0x004cd7af test r9b, 1 | | if ((r9b & 1) != 0) { 0x004cd7b3 je 0x4cd7d3 | | label_4: 0x004cd7b5 movdqu xmm2, xmmword [rax] | __asm ("movdqu xmm2, xmmword [rax]"); 0x004cd7b9 movups xmm3, xmmword [rax + 0x10] | __asm ("movups xmm3, xmmword [rax + 0x10]"); 0x004cd7bd movdqu xmmword [rcx + rbp*8], xmm2 | __asm ("movdqu xmmword [rcx + rbp*8], xmm2"); 0x004cd7c2 movups xmmword [rcx + rbp*8 + 0x10], xmm3 | __asm ("movups xmmword [rcx + rbp*8 + 0x10], xmm3"); 0x004cd7c7 pcmpeqd xmm2, xmm2 | __asm ("pcmpeqd xmm2, xmm2"); 0x004cd7cb psubd xmm1, xmm2 | __asm ("psubd xmm1, xmm2"); 0x004cd7cf psubd xmm0, xmm2 | __asm ("psubd xmm0, xmm2"); | } | label_5: 0x004cd7d3 paddd xmm0, xmm1 | __asm ("paddd xmm0, xmm1"); 0x004cd7d7 pshufd xmm1, xmm0, 0x55 | __asm ("pshufd xmm1, xmm0, 0x55"); 0x004cd7dc paddd xmm1, xmm0 | __asm ("paddd xmm1, xmm0"); 0x004cd7e0 movd ebp, xmm1 | 0x004cd7e4 cmp r10, r8 | | if (r10 != r8) { 0x004cd7e7 jne 0x4cdb24 | goto label_22; | } 0x004cd7ed mov esi, dword [rsp + 0x18] | esi = *((rsp + 0x18)); 0x004cd7f1 jmp 0x4cdb53 | goto label_23; | label_14: 0x004cd7f6 mov eax, 1 | eax = 1; 0x004cd7fb mov qword [rsp + 0x20], rax | *((rsp + 0x20)) = rax; 0x004cd800 mov rax, qword [rip + 0x283ab1] | rax = BloombergLP::bslma::Default::s_defaultAllocator; 0x004cd807 test rax, rax | | if (rax != 0) { 0x004cd80a jne 0x4cd601 | goto label_0; | } 0x004cd810 call 0x4eec50 | rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() (); 0x004cd815 jmp 0x4cd601 | goto label_0; | label_16: 0x004cd876 mov dword [rsp + 0x14], r12d | *((rsp + 0x14)) = r12d; 0x004cd87b lea r8, [r14*8 + 0x74fae0] | r8 = r14*8 + obj_testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u; 0x004cd883 add ebx, r15d | ebx += r15d; 0x004cd886 movsxd rbx, ebx | rbx = (int64_t) ebx; 0x004cd889 lea rdx, [rbx*8 + 0x74fae0] | rdx = rbx*8 + obj_testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u; 0x004cd891 cmp r8, rdx | | if (r8 < rdx) { 0x004cd894 jae 0x4cd8bf | 0x004cd896 shl rbx, 3 | rbx <<= 3; 0x004cd89a sub rbx, rdi | rbx -= rdi; 0x004cd89d lea rdx, [rbx + r14*8 + 0x74fae0] | rdx = rbx + r14*8 + obj_testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u; 0x004cd8a5 lea rbx, [r15*8 + 0x74fae0] | rbx = r15*8 + obj_testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u; 0x004cd8ad cmp rbx, rdx | | if (rbx >= rdx) { 0x004cd8b0 jae 0x4cd8bf | goto label_24; | } 0x004cd8b2 mov r12d, dword [rsp + 0x14] | r12d = *((rsp + 0x14)); 0x004cd8b7 mov ebx, r11d | ebx = r11d; 0x004cd8ba jmp 0x4cd9c0 | goto label_17; | } | label_24: 0x004cd8bf shr rsi, 3 | rsi >>= 3; 0x004cd8c3 inc rsi | rsi++; 0x004cd8c6 mov r8, rsi | r8 = rsi; 0x004cd8c9 movabs rdx, 0x3ffffffffffffffc | rdx = 0x3ffffffffffffffc; 0x004cd8d3 and r8, rdx | r8 &= rdx; 0x004cd8d6 movd xmm0, ebp | xmm0 = ebp; 0x004cd8da lea rdx, [r8 - 4] | rdx = r8 - 4; 0x004cd8de mov r9, rdx | r9 = rdx; 0x004cd8e1 shr r9, 2 | r9 >>= 2; 0x004cd8e5 inc r9 | r9++; 0x004cd8e8 test rdx, rdx | | if (rdx == 0) { 0x004cd8eb je 0x4cdb91 | goto label_25; | } 0x004cd8f1 mov rbx, r9 | rbx = r9; 0x004cd8f4 and rbx, 0xfffffffffffffffe | rbx &= 0xfffffffffffffffe; 0x004cd8f8 neg rbx | rbx = -rbx; 0x004cd8fb pxor xmm1, xmm1 | xmm1 = 0; 0x004cd8ff xor ebp, ebp | ebp = 0; 0x004cd901 movdqa xmm4, xmmword [rip + 0x22a07] | __asm ("movdqa xmm4, xmmword [0x004f0310]"); 0x004cd909 nop dword [rax] | | do { 0x004cd910 movups xmm2, xmmword [rdi + rbp*8 + 0x74fae0] | __asm ("movups xmm2, xmmword [rdi + rbp*8 + obj.testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u]"); 0x004cd918 movups xmm3, xmmword [rdi + rbp*8 + 0x74faf0] | __asm ("movups xmm3, xmmword [rdi + rbp*8 + 0x74faf0]"); 0x004cd920 lea rdx, [r14*8] | rdx = r14*8; 0x004cd928 movups xmmword [rdx + rbp*8 + 0x74fae0], xmm2 | __asm ("movups xmmword [rdx + rbp*8 + obj.testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u], xmm2"); 0x004cd930 movups xmmword [rdx + rbp*8 + 0x74faf0], xmm3 | __asm ("movups xmmword [rdx + rbp*8 + 0x74faf0], xmm3"); 0x004cd938 movdqu xmm2, xmmword [rdi + rbp*8 + 0x74fb00] | __asm ("movdqu xmm2, xmmword [rdi + rbp*8 + 0x74fb00]"); 0x004cd941 movups xmm3, xmmword [rdi + rbp*8 + 0x74fb10] | __asm ("movups xmm3, xmmword [rdi + rbp*8 + 0x74fb10]"); 0x004cd949 movdqu xmmword [rdx + rbp*8 + 0x74fb00], xmm2 | __asm ("movdqu xmmword [rdx + rbp*8 + 0x74fb00], xmm2"); 0x004cd952 movups xmmword [rdx + rbp*8 + 0x74fb10], xmm3 | __asm ("movups xmmword [rdx + rbp*8 + 0x74fb10], xmm3"); 0x004cd95a paddd xmm0, xmm4 | __asm ("paddd xmm0, xmm4"); 0x004cd95e paddd xmm1, xmm4 | __asm ("paddd xmm1, xmm4"); 0x004cd962 add rbp, 8 | rbp += 8; 0x004cd966 add rbx, 2 | rbx += 2; 0x004cd96a jne 0x4cd910 | | } while (rbx != 0); 0x004cd96c test r9b, 1 | | if ((r9b & 1) != 0) { 0x004cd970 je 0x4cd992 | | label_6: 0x004cd972 movdqu xmm2, xmmword [rax + rbp*8] | __asm ("movdqu xmm2, xmmword [rax + rbp*8]"); 0x004cd977 movups xmm3, xmmword [rax + rbp*8 + 0x10] | __asm ("movups xmm3, xmmword [rax + rbp*8 + 0x10]"); 0x004cd97c movdqu xmmword [rcx + rbp*8], xmm2 | __asm ("movdqu xmmword [rcx + rbp*8], xmm2"); 0x004cd981 movups xmmword [rcx + rbp*8 + 0x10], xmm3 | __asm ("movups xmmword [rcx + rbp*8 + 0x10], xmm3"); 0x004cd986 pcmpeqd xmm2, xmm2 | __asm ("pcmpeqd xmm2, xmm2"); 0x004cd98a psubd xmm1, xmm2 | __asm ("psubd xmm1, xmm2"); 0x004cd98e psubd xmm0, xmm2 | __asm ("psubd xmm0, xmm2"); | } | label_7: 0x004cd992 paddd xmm0, xmm1 | __asm ("paddd xmm0, xmm1"); 0x004cd996 pshufd xmm1, xmm0, 0x55 | __asm ("pshufd xmm1, xmm0, 0x55"); 0x004cd99b paddd xmm1, xmm0 | __asm ("paddd xmm1, xmm0"); 0x004cd99f movd ebp, xmm1 | 0x004cd9a3 cmp rsi, r8 | 0x004cd9a6 mov r12d, dword [rsp + 0x14] | r12d = *((rsp + 0x14)); 0x004cd9ab mov ebx, r11d | ebx = r11d; | if (rsi == r8) { 0x004cd9ae je 0x4cd9e3 | goto label_26; | } 0x004cd9b0 lea rax, [rax + r8*8] | rax = rax + r8*8; 0x004cd9b4 lea rcx, [rcx + r8*8] | rcx = rcx + r8*8; 0x004cd9b8 nop dword [rax + rax] | | label_17: 0x004cd9c0 sub r10, rax | r10 -= rax; 0x004cd9c3 lea rdx, [r10 + 0x74fae0] | rdx = r10 + obj_testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u; 0x004cd9ca xor esi, esi | esi = 0; 0x004cd9cc nop dword [rax] | | do { 0x004cd9d0 mov rdi, qword [rax + rsi] | rdi = *((rax + rsi)); 0x004cd9d4 mov qword [rcx + rsi], rdi | *((rcx + rsi)) = rdi; 0x004cd9d8 inc ebp | ebp++; 0x004cd9da add rsi, 8 | rsi += 8; 0x004cd9de cmp rdx, rsi | 0x004cd9e1 jne 0x4cd9d0 | | } while (rdx != rsi); | label_26: 0x004cd9e3 mov dword [rip + 0x24afbb], ebp | *(obj.numCopyCtorCalls) = ebp; 0x004cd9e9 mov rbp, qword [rsp + 0x20] | rbp = *((rsp + 0x20)); | label_15: 0x004cd9ee mov rax, qword [rsp + 0x40] | rax = *((rsp + 0x40)); 0x004cd9f3 lea rdi, [rsp + 0x40] | rdi = rsp + 0x40; 0x004cd9f8 mov rsi, 0xffffffffffffffff | rsi = 0xffffffffffffffff; 0x004cd9ff call qword [rax + 0x10] | uint64_t (*rax + 0x10)() (); 0x004cda02 cmp byte [rip + 0x24af8c], 0 | | if (*(obj.veryVeryVerbose) != 0) { 0x004cda09 je 0x4cda15 | 0x004cda0b mov edi, 0x4f43e1 | 0x004cda10 call 0x401710 | puts ("\t\tEnd bslma exception test."); | } 0x004cda15 cmp byte [rip + 0x24af74], 0 | | if (*(obj.veryVerbose) != 0) { 0x004cda1c je 0x4cda52 | 0x004cda1e mov edi, 0xa | 0x004cda23 call 0x401720 | eax = putchar (0xa); 0x004cda28 mov esi, dword [rsp + 0x18] | esi = *((rsp + 0x18)); | label_19: 0x004cda2c cmp byte [rip + 0x24af5d], 0 | | if (*(obj.veryVerbose) == 0) { 0x004cda33 je 0x4cda52 | goto label_3; | } | label_2: 0x004cda35 mov edx, dword [rip + 0x24af69] | edx = numCopyCtorCalls; 0x004cda3b sub edx, ebx | edx -= ebx; 0x004cda3d mov ecx, dword [rip + 0x24af69] | ecx = numCharCtorCalls; 0x004cda43 sub ecx, r12d | ecx -= r12d; 0x004cda46 mov edi, 0x4f5c2a | 0x004cda4b xor eax, eax | eax = 0; 0x004cda4d call 0x401680 | eax = printf ("LINE = %d, #copy ctors = %d, #char ctors = %d.\n"); | } | label_3: 0x004cda52 cmp byte [rsp + 0x54], 0 | | if (*((rsp + 0x54)) == 0) { 0x004cda57 je 0x4cdab0 | goto label_27; | } 0x004cda59 cmp ebx, dword [rip + 0x24af45] | | if (ebx != *(obj.numCopyCtorCalls)) { 0x004cda5f je 0x4cda8a | 0x004cda61 mov edi, 0x4f4c78 | 0x004cda66 mov edx, 0x4f4fec | edx = "NUM_COPIES == numCopyCtorCalls"; 0x004cda6b mov esi, 0x1005 | esi = 0x1005; 0x004cda70 xor eax, eax | eax = 0; 0x004cda72 call 0x401680 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s (failed)\n"); 0x004cda77 mov eax, dword [rip + 0x24af1b] | eax = (anonymous namespace)::testStatus; 0x004cda7d cmp eax, 0x64 | | if (eax > 0x64) { 0x004cda80 ja 0x4cda8a | goto label_28; | } 0x004cda82 inc eax | eax++; 0x004cda84 mov dword [rip + 0x24af0e], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_28: 0x004cda8a cmp r12d, dword [rip + 0x24af1b] | | if (r12d == *(obj.numCharCtorCalls)) { 0x004cda91 je 0x4cd4a0 | goto label_1; | } 0x004cda97 mov edi, 0x4f4c78 | edi = "Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s (failed)\n"; 0x004cda9c mov edx, 0x4f5c5a | edx = "NUM_CTORS == numCharCtorCalls"; 0x004cdaa1 mov esi, 0x1006 | esi = 0x1006; 0x004cdaa6 jmp 0x4cdb01 | goto label_29; | label_27: 0x004cdab0 add ebx, dword [rsp + 0x30] | ebx += *((rsp + 0x30)); 0x004cdab4 cmp ebx, dword [rip + 0x24aeea] | | if (ebx > *(obj.numCopyCtorCalls)) { 0x004cdaba jle 0x4cdae5 | 0x004cdabc mov edi, 0x4f4c78 | 0x004cdac1 mov edx, 0x4f5c78 | edx = "NUM_COPIES + NE <= numCopyCtorCalls"; 0x004cdac6 mov esi, 0x1009 | esi = 0x1009; 0x004cdacb xor eax, eax | eax = 0; 0x004cdacd call 0x401680 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s (failed)\n"); 0x004cdad2 mov eax, dword [rip + 0x24aec0] | eax = (anonymous namespace)::testStatus; 0x004cdad8 cmp eax, 0x64 | | if (eax > 0x64) { 0x004cdadb ja 0x4cdae5 | goto label_30; | } 0x004cdadd inc eax | eax++; 0x004cdadf mov dword [rip + 0x24aeb3], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_30: 0x004cdae5 cmp r12d, dword [rip + 0x24aec0] | | if (r12d == *(obj.numCharCtorCalls)) { 0x004cdaec je 0x4cd4a0 | goto label_1; | } 0x004cdaf2 mov edi, 0x4f4c78 | 0x004cdaf7 mov edx, 0x4f5c5a | edx = "NUM_CTORS == numCharCtorCalls"; 0x004cdafc mov esi, 0x100a | esi = 0x100a; | label_29: 0x004cdb01 xor eax, eax | eax = 0; 0x004cdb03 call 0x401680 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s (failed)\n"); 0x004cdb08 mov eax, dword [rip + 0x24ae8a] | eax = (anonymous namespace)::testStatus; 0x004cdb0e cmp eax, 0x64 | | if (eax > 0x64) { 0x004cdb11 ja 0x4cd4a0 | goto label_1; | } 0x004cdb17 inc eax | eax++; 0x004cdb19 mov dword [rip + 0x24ae79], eax | *(obj._anonymous_namespace_::testStatus) = eax; 0x004cdb1f jmp 0x4cd4a0 | goto label_1; | label_22: 0x004cdb24 lea rdi, [rdi + r8*8] | rdi = rdi + r8*8; 0x004cdb28 lea rcx, [rcx + r8*8] | rcx = rcx + r8*8; 0x004cdb2c mov esi, dword [rsp + 0x18] | esi = *((rsp + 0x18)); | label_20: 0x004cdb30 sub r13, rdi | r13 -= rdi; 0x004cdb33 lea rax, [r13 + 0x74fae0] | rax = r13 + obj_testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u; 0x004cdb3a xor edx, edx | edx = 0; 0x004cdb3c nop dword [rax] | | do { 0x004cdb40 mov rbx, qword [rdi + rdx] | rbx = *((rdi + rdx)); 0x004cdb44 mov qword [rcx + rdx], rbx | *((rcx + rdx)) = rbx; 0x004cdb48 inc ebp | ebp++; 0x004cdb4a add rdx, 8 | rdx += 8; 0x004cdb4e cmp rax, rdx | 0x004cdb51 jne 0x4cdb40 | | } while (rax != rdx); | label_23: 0x004cdb53 mov dword [rip + 0x24ae4b], ebp | *(obj.numCopyCtorCalls) = ebp; 0x004cdb59 mov rbp, qword [rsp + 0x20] | rbp = *((rsp + 0x20)); 0x004cdb5e mov r13, qword [rsp + 0x28] | r13 = *((rsp + 0x28)); 0x004cdb63 mov ebx, dword [rsp + 0x14] | ebx = *((rsp + 0x14)); 0x004cdb67 cmp byte [rip + 0x24ae22], 0 | | if (*(obj.veryVerbose) != 0) { 0x004cdb6e jne 0x4cda35 | goto label_2; | } 0x004cdb74 jmp 0x4cda52 | goto label_3; | label_21: 0x004cdb79 pxor xmm1, xmm1 | xmm1 = 0; 0x004cdb7d mov rax, rdi | rax = rdi; 0x004cdb80 xor ebp, ebp | ebp = 0; 0x004cdb82 test r9b, 1 | | if ((r9b & 1) != 0) { 0x004cdb86 jne 0x4cd7b5 | goto label_4; | } 0x004cdb8c jmp 0x4cd7d3 | goto label_5; | label_25: 0x004cdb91 pxor xmm1, xmm1 | xmm1 = 0; 0x004cdb95 xor ebp, ebp | ebp = 0; 0x004cdb97 test r9b, 1 | | if ((r9b & 1) != 0) { 0x004cdb9b jne 0x4cd972 | goto label_6; | } 0x004cdba1 jmp 0x4cd992 | goto label_7; | label_11: 0x004cdba6 cmp byte [rip + 0x24ade9], 0 | | if (*(obj.verbose) != 0) { 0x004cdbad je 0x4cdbb9 | 0x004cdbaf mov edi, 0x4f67d2 | 0x004cdbb4 call 0x401710 | puts ("\t\tfrom different type."); | } 0x004cdbb9 xor r13d, r13d | r13d = 0; 0x004cdbbc jmp 0x4cdbe7 | goto label_31; | label_8: 0x004cdbc0 mov edi, 0x74fae0 | edi = testCopyConstructWithIterators(bool, bool, bool)::u; 0x004cdbc5 mov rsi, rbp | rsi = rbp; 0x004cdbc8 call 0x4e42c0 | voidverify(AmbiguousConvertibleType*,char const*) (); 0x004cdbcd mov edi, 0x74fae0 | edi = testCopyConstructWithIterators(bool, bool, bool)::u; 0x004cdbd2 mov rsi, rbp | rsi = rbp; 0x004cdbd5 call 0x4e4520 | voidcleanup(AmbiguousConvertibleType*,char const*) (); 0x004cdbda inc r13 | r13++; 0x004cdbdd cmp r13, 0x1e | | if (r13 == 0x1e) { 0x004cdbe1 je 0x4ce10a | goto label_32; | } | label_31: 0x004cdbe7 lea rbp, [r13*8] | rbp = r13*8; 0x004cdbef mov r12, qword [rbp + rbp*4 + 0x4f3b08] | r12 = *((rbp + rbp*4 + 0x4f3b08)); 0x004cdbf7 mov rdi, r12 | 0x004cdbfa call 0x401790 | eax = strlen (*((rbp + rbp*4 + 0x4f3b08))); 0x004cdbff cmp eax, 0x11 | | if (eax >= 0x11) { 0x004cdc02 jl 0x4cdc2d | 0x004cdc04 mov edi, 0x4f4c78 | 0x004cdc09 mov edx, 0x4f4203 | edx = "MAX_SIZE >= (int)std::strlen(SPEC)"; 0x004cdc0e mov esi, 0x1019 | esi = 0x1019; 0x004cdc13 xor eax, eax | eax = 0; 0x004cdc15 call 0x401680 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s (failed)\n"); 0x004cdc1a mov eax, dword [rip + 0x24ad78] | eax = (anonymous namespace)::testStatus; 0x004cdc20 cmp eax, 0x64 | | if (eax > 0x64) { 0x004cdc23 ja 0x4cdc2d | goto label_33; | } 0x004cdc25 inc eax | eax++; 0x004cdc27 mov dword [rip + 0x24ad6b], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_33: 0x004cdc2d mov rdi, r12 | 0x004cdc30 call 0x401790 | rax = strlen (r12); 0x004cdc35 cmp rax, 0x14 | | if (rax >= 0x14) { 0x004cdc39 jb 0x4cdc64 | 0x004cdc3b mov edi, 0x4f4c78 | 0x004cdc40 mov edx, 0x4f5c9c | edx = "SPEC_CE_LEN > std::strlen(SPEC)"; 0x004cdc45 mov esi, 0x101c | esi = 0x101c; 0x004cdc4a xor eax, eax | eax = 0; 0x004cdc4c call 0x401680 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s (failed)\n"); 0x004cdc51 mov eax, dword [rip + 0x24ad41] | eax = (anonymous namespace)::testStatus; 0x004cdc57 cmp eax, 0x64 | | if (eax > 0x64) { 0x004cdc5a ja 0x4cdc64 | goto label_34; | } 0x004cdc5c inc eax | eax++; 0x004cdc5e mov dword [rip + 0x24ad34], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_34: 0x004cdc64 mov qword [rsp + 0x28], r13 | *((rsp + 0x28)) = r13; 0x004cdc69 pxor xmm0, xmm0 | xmm0 = 0; 0x004cdc6d movdqa xmmword [rsp + 0x40], xmm0 | __asm ("movdqa xmmword [rsp + 0x40], xmm0"); 0x004cdc73 mov dword [rsp + 0x50], 0 | *((rsp + 0x50)) = 0; 0x004cdc7b mov al, byte [r12] | al = *(r12); 0x004cdc7f test al, al | | if (al == 0) { 0x004cdc81 je 0x4cdca1 | goto label_35; | } 0x004cdc83 xor ecx, ecx | ecx = 0; 0x004cdc85 nop word cs:[rax + rax] | 0x004cdc8f nop | | do { 0x004cdc90 mov byte [rsp + rcx + 0x40], al | *((rsp + rcx + 0x40)) = al; 0x004cdc94 movzx eax, byte [r12 + rcx + 1] | eax = *((r12 + rcx + 1)); 0x004cdc9a inc rcx | rcx++; 0x004cdc9d test al, al | 0x004cdc9f jne 0x4cdc90 | | } while (al != 0); | label_35: 0x004cdca1 mov r14d, dword [rbp + rbp*4 + 0x4f3b00] | r14d = *((rbp + rbp*4 + obj.DATA_3)); 0x004cdca9 movsxd rbx, dword [rbp + rbp*4 + 0x4f3b10] | rbx = *((rbp + rbp*4 + 0x4f3b10)); 0x004cdcb1 movsxd r15, dword [rbp + rbp*4 + 0x4f3b14] | r15 = *((rbp + rbp*4 + 0x4f3b14)); 0x004cdcb9 movsxd r13, dword [rbp + rbp*4 + 0x4f3b18] | r13 = *((rbp + rbp*4 + 0x4f3b18)); 0x004cdcc1 mov rbp, qword [rbp + rbp*4 + 0x4f3b20] | rbp = *((rbp + rbp*4 + 0x4f3b20)); 0x004cdcc9 cmp byte [rip + 0x24acc0], 0 | | if (*(obj.veryVerbose) != 0) { 0x004cdcd0 je 0x4cdcf0 | 0x004cdcd2 mov qword [rsp], rbp | *(rsp) = rbp; 0x004cdcd6 mov edi, 0x4f5ab7 | 0x004cdcdb mov esi, r14d | esi = r14d; 0x004cdcde mov rdx, r12 | rdx = r12; 0x004cdce1 mov ecx, ebx | ecx = ebx; 0x004cdce3 mov r8d, r15d | r8d = r15d; 0x004cdce6 mov r9d, r13d | r9d = r13d; 0x004cdce9 xor eax, eax | eax = 0; 0x004cdceb call 0x401680 | printf ("LINE = %d, SPEC = %s, SRC = %d, NE = %d, DST = %d, EXP = %s\n"); | } 0x004cdcf0 mov edi, 0x74fae0 | edi = testCopyConstructWithIterators(bool, bool, bool)::u; 0x004cdcf5 mov rsi, r12 | rsi = r12; 0x004cdcf8 call 0x4e41c0 | AmbiguousConvertibleType&gg(AmbiguousConvertibleType*,char const*) (); 0x004cdcfd mov edi, 0x74fae0 | edi = testCopyConstructWithIterators(bool, bool, bool)::u; 0x004cdd02 mov rsi, r12 | rsi = r12; 0x004cdd05 call 0x4e42c0 | voidverify(AmbiguousConvertibleType*,char const*) (); 0x004cdd0a mov r12d, dword [rip + 0x24ac93] | r12d = numCopyCtorCalls; 0x004cdd11 mov eax, dword [rip + 0x24ac95] | eax = numCharCtorCalls; 0x004cdd17 mov dword [rsp + 0x30], eax | *((rsp + 0x30)) = eax; 0x004cdd1b cmp byte [rsp + 0x3c], 0 | | if (*((rsp + 0x3c)) == 0) { 0x004cdd20 je 0x4cdee0 | goto label_36; | } 0x004cdd26 cmp byte [rip + 0x24ac63], 0 | | if (*(obj.veryVerbose) != 0) { 0x004cdd2d je 0x4cdd42 | 0x004cdd2f cmp dword [rip + 0x24a88e], 0 | | if (*(obj.testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::firstTime) == 0) { 0x004cdd36 je 0x4cdd42 | goto label_37; | } 0x004cdd38 mov edi, 0x4f425a | 0x004cdd3d call 0x401710 | puts ("\t\tBSLMA EXCEPTION TEST -- (ENABLED) --"); | } | label_37: 0x004cdd42 mov dword [rip + 0x24a878], 0 | *(obj.testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::firstTime) = 0; 0x004cdd4c cmp byte [rip + 0x24ac42], 0 | | if (*(obj.veryVeryVerbose) != 0) { 0x004cdd53 je 0x4cdd5f | 0x004cdd55 mov edi, 0x4f4281 | 0x004cdd5a call 0x401710 | puts ("\t\tBegin bslma exception test."); | } 0x004cdd5f mov rax, qword [rip + 0x24aaba] | rax = Z; 0x004cdd66 mov qword [rsp + 0x58], 0x4f6858 | *((rsp + 0x58)) = vtable.BloombergLP::bslma::TestAllocator_Proxy_BloombergLP::bslma::TestAllocator_.0; 0x004cdd6f mov qword [rsp + 0x60], rax | *((rsp + 0x60)) = rax; 0x004cdd74 mov qword [rax + 0x20], 0 | *((rax + 0x20)) = 0; 0x004cdd7c test rax, rax | | if (rax == 0) { 0x004cdd7f je 0x4ce08a | goto label_38; | } | label_9: 0x004cdd85 cmp qword [rsp + 0x28], 6 | | if (*((rsp + 0x28)) < 6) { 0x004cdd8b jb 0x4cde98 | goto label_39; | } 0x004cdd91 add r15d, ebx | r15d += ebx; 0x004cdd94 movsxd rax, r15d | rax = (int64_t) r15d; 0x004cdd97 lea rcx, [rsp + rbx + 0x40] | rcx = rsp + rbx + 0x40; 0x004cdd9c lea rsi, [r13*8 + 0x74fae0] | rsi = r13*8 + obj_testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u; 0x004cdda4 mov edx, eax | edx = eax; 0x004cdda6 sub edx, ebx | edx -= ebx; 0x004cdda8 not rbx | rbx = ~rbx; 0x004cddab add rbx, rax | rbx += rax; 0x004cddae and rdx, 7 | rdx &= 7; | if (rdx == 0) { 0x004cddb2 je 0x4cdddb | goto label_40; | } 0x004cddb4 nop word cs:[rax + rax] | 0x004cddbe nop | | do { 0x004cddc0 movsx rdi, byte [rcx] | rdi = *(rcx); 0x004cddc4 mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004cddcc mov qword [rsi], rdi | *(rsi) = rdi; 0x004cddcf inc rcx | rcx++; 0x004cddd2 add rsi, 8 | rsi += 8; 0x004cddd6 dec rdx | rdx--; 0x004cddd9 jne 0x4cddc0 | | } while (rdx != 0); | label_40: 0x004cdddb cmp rbx, 7 | | if (rbx < 7) { 0x004cdddf jb 0x4cde98 | goto label_39; | } 0x004cdde5 lea rax, [rsp + rax + 0x40] | rax = rsp + rax + 0x40; 0x004cddea xor edi, edi | edi = 0; 0x004cddec nop dword [rax] | | do { 0x004cddf0 movsx rdx, byte [rcx + rdi] | rdx = *((rcx + rdi)); 0x004cddf5 mov rdx, qword [rdx*8 + 0x7171d0] | rdx = *((rdx*8 + obj.funcPtrArray)); 0x004cddfd mov qword [rsi + rdi*8], rdx | *((rsi + rdi*8)) = rdx; 0x004cde01 movsx rdx, byte [rcx + rdi + 1] | rdx = *((rcx + rdi + 1)); 0x004cde07 mov rdx, qword [rdx*8 + 0x7171d0] | rdx = *((rdx*8 + obj.funcPtrArray)); 0x004cde0f mov qword [rsi + rdi*8 + 8], rdx | *((rsi + rdi*8 + 8)) = rdx; 0x004cde14 movsx rdx, byte [rcx + rdi + 2] | rdx = *((rcx + rdi + 2)); 0x004cde1a mov rdx, qword [rdx*8 + 0x7171d0] | rdx = *((rdx*8 + obj.funcPtrArray)); 0x004cde22 mov qword [rsi + rdi*8 + 0x10], rdx | *((rsi + rdi*8 + 0x10)) = rdx; 0x004cde27 movsx rdx, byte [rcx + rdi + 3] | rdx = *((rcx + rdi + 3)); 0x004cde2d mov rdx, qword [rdx*8 + 0x7171d0] | rdx = *((rdx*8 + obj.funcPtrArray)); 0x004cde35 mov qword [rsi + rdi*8 + 0x18], rdx | *((rsi + rdi*8 + 0x18)) = rdx; 0x004cde3a movsx rdx, byte [rcx + rdi + 4] | rdx = *((rcx + rdi + 4)); 0x004cde40 mov rdx, qword [rdx*8 + 0x7171d0] | rdx = *((rdx*8 + obj.funcPtrArray)); 0x004cde48 mov qword [rsi + rdi*8 + 0x20], rdx | *((rsi + rdi*8 + 0x20)) = rdx; 0x004cde4d movsx rdx, byte [rcx + rdi + 5] | rdx = *((rcx + rdi + 5)); 0x004cde53 mov rdx, qword [rdx*8 + 0x7171d0] | rdx = *((rdx*8 + obj.funcPtrArray)); 0x004cde5b mov qword [rsi + rdi*8 + 0x28], rdx | *((rsi + rdi*8 + 0x28)) = rdx; 0x004cde60 movsx rdx, byte [rcx + rdi + 6] | rdx = *((rcx + rdi + 6)); 0x004cde66 mov rdx, qword [rdx*8 + 0x7171d0] | rdx = *((rdx*8 + obj.funcPtrArray)); 0x004cde6e mov qword [rsi + rdi*8 + 0x30], rdx | *((rsi + rdi*8 + 0x30)) = rdx; 0x004cde73 movsx rdx, byte [rcx + rdi + 7] | rdx = *((rcx + rdi + 7)); 0x004cde79 mov rdx, qword [rdx*8 + 0x7171d0] | rdx = *((rdx*8 + obj.funcPtrArray)); 0x004cde81 mov qword [rsi + rdi*8 + 0x38], rdx | *((rsi + rdi*8 + 0x38)) = rdx; 0x004cde86 lea rdx, [rcx + rdi + 8] | rdx = rcx + rdi + 8; 0x004cde8b add rdi, 8 | rdi += 8; 0x004cde8f cmp rdx, rax | 0x004cde92 jne 0x4cddf0 | | } while (rdx != rax); | label_39: 0x004cde98 mov rax, qword [rsp + 0x58] | rax = *((rsp + 0x58)); 0x004cde9d lea rdi, [rsp + 0x58] | rdi = rsp + 0x58; 0x004cdea2 mov rsi, 0xffffffffffffffff | rsi = 0xffffffffffffffff; 0x004cdea9 call qword [rax + 0x10] | uint64_t (*rax + 0x10)() (); 0x004cdeac cmp byte [rip + 0x24aae2], 0 | 0x004cdeb3 mov r13, qword [rsp + 0x28] | r13 = *((rsp + 0x28)); | if (*(obj.veryVeryVerbose) != 0) { 0x004cdeb8 je 0x4cdec4 | 0x004cdeba mov edi, 0x4f43e1 | 0x004cdebf call 0x401710 | puts ("\t\tEnd bslma exception test."); | } 0x004cdec4 cmp byte [rip + 0x24aac5], 0 | | if (*(obj.veryVerbose) == 0) { 0x004cdecb je 0x4ce04b | goto label_41; | } 0x004cded1 mov edi, 0xa | 0x004cded6 call 0x401720 | putchar (0xa); 0x004cdedb jmp 0x4ce020 | goto label_42; | label_36: 0x004cdee0 cmp qword [rip + 0x24a938], 0 | 0x004cdee8 mov rcx, r13 | rcx = r13; | if (*(obj.Z) == 0) { 0x004cdeeb jne 0x4cdf10 | 0x004cdeed mov rax, qword [rip + 0x2833c4] | rax = BloombergLP::bslma::Default::s_defaultAllocator; 0x004cdef4 test rax, rax | | if (rax != 0) { 0x004cdef7 jne 0x4cdf10 | goto label_43; | } 0x004cdef9 call 0x4eec50 | BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() (); 0x004cdefe mov rcx, r13 | rcx = r13; 0x004cdf01 nop word cs:[rax + rax] | 0x004cdf0b nop dword [rax + rax] | | } | label_43: 0x004cdf10 mov r13, qword [rsp + 0x28] | r13 = *((rsp + 0x28)); 0x004cdf15 cmp r13, 6 | | if (r13 < 6) { 0x004cdf19 jb 0x4ce020 | goto label_42; | } 0x004cdf1f add r15, rbx | r15 += rbx; 0x004cdf22 lea rax, [rcx*8 + 0x74fae0] | rax = rcx*8 + obj_testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u; 0x004cdf2a lea rcx, [rsp + rbx + 0x40] | rcx = rsp + rbx + 0x40; 0x004cdf2f mov edx, r15d | edx = r15d; 0x004cdf32 sub edx, ebx | edx -= ebx; 0x004cdf34 not rbx | rbx = ~rbx; 0x004cdf37 add rbx, r15 | rbx += r15; 0x004cdf3a and rdx, 7 | rdx &= 7; | if (rdx == 0) { 0x004cdf3e je 0x4cdf5b | goto label_44; | } | do { 0x004cdf40 movsx rdi, byte [rcx] | rdi = *(rcx); 0x004cdf44 mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004cdf4c mov qword [rax], rdi | *(rax) = rdi; 0x004cdf4f inc rcx | rcx++; 0x004cdf52 add rax, 8 | rax += 8; 0x004cdf56 dec rdx | rdx--; 0x004cdf59 jne 0x4cdf40 | | } while (rdx != 0); | label_44: 0x004cdf5b cmp rbx, 7 | | if (rbx < 7) { 0x004cdf5f jb 0x4ce020 | goto label_42; | } 0x004cdf65 lea rdx, [rsp + r15 + 0x40] | rdx = rsp + r15 + 0x40; 0x004cdf6a xor ebx, ebx | ebx = 0; 0x004cdf6c nop dword [rax] | | do { 0x004cdf70 movsx rdi, byte [rcx + rbx] | rdi = *((rcx + rbx)); 0x004cdf75 mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004cdf7d mov qword [rax + rbx*8], rdi | *((rax + rbx*8)) = rdi; 0x004cdf81 movsx rdi, byte [rcx + rbx + 1] | rdi = *((rcx + rbx + 1)); 0x004cdf87 mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004cdf8f mov qword [rax + rbx*8 + 8], rdi | *((rax + rbx*8 + 8)) = rdi; 0x004cdf94 movsx rdi, byte [rcx + rbx + 2] | rdi = *((rcx + rbx + 2)); 0x004cdf9a mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004cdfa2 mov qword [rax + rbx*8 + 0x10], rdi | *((rax + rbx*8 + 0x10)) = rdi; 0x004cdfa7 movsx rdi, byte [rcx + rbx + 3] | rdi = *((rcx + rbx + 3)); 0x004cdfad mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004cdfb5 mov qword [rax + rbx*8 + 0x18], rdi | *((rax + rbx*8 + 0x18)) = rdi; 0x004cdfba movsx rdi, byte [rcx + rbx + 4] | rdi = *((rcx + rbx + 4)); 0x004cdfc0 mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004cdfc8 mov qword [rax + rbx*8 + 0x20], rdi | *((rax + rbx*8 + 0x20)) = rdi; 0x004cdfcd movsx rdi, byte [rcx + rbx + 5] | rdi = *((rcx + rbx + 5)); 0x004cdfd3 mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004cdfdb mov qword [rax + rbx*8 + 0x28], rdi | *((rax + rbx*8 + 0x28)) = rdi; 0x004cdfe0 movsx rdi, byte [rcx + rbx + 6] | rdi = *((rcx + rbx + 6)); 0x004cdfe6 mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004cdfee mov qword [rax + rbx*8 + 0x30], rdi | *((rax + rbx*8 + 0x30)) = rdi; 0x004cdff3 movsx rdi, byte [rcx + rbx + 7] | rdi = *((rcx + rbx + 7)); 0x004cdff9 mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004ce001 mov qword [rax + rbx*8 + 0x38], rdi | *((rax + rbx*8 + 0x38)) = rdi; 0x004ce006 lea rdi, [rcx + rbx + 8] | rdi = rcx + rbx + 8; 0x004ce00b add rbx, 8 | rbx += 8; 0x004ce00f cmp rdi, rdx | 0x004ce012 jne 0x4cdf70 | | } while (rdi != rdx); 0x004ce018 nop dword [rax + rax] | | label_42: 0x004ce020 cmp byte [rip + 0x24a969], 0 | | if (*(obj.veryVerbose) != 0) { 0x004ce027 je 0x4ce04b | 0x004ce029 mov edx, dword [rip + 0x24a975] | edx = numCopyCtorCalls; 0x004ce02f sub edx, r12d | edx -= r12d; 0x004ce032 mov ecx, dword [rip + 0x24a974] | ecx = numCharCtorCalls; 0x004ce038 sub ecx, dword [rsp + 0x30] | ecx -= *((rsp + 0x30)); 0x004ce03c mov edi, 0x4f5c2a | 0x004ce041 mov esi, r14d | esi = r14d; 0x004ce044 xor eax, eax | eax = 0; 0x004ce046 call 0x401680 | eax = printf ("LINE = %d, #copy ctors = %d, #char ctors = %d.\n"); | } | label_41: 0x004ce04b cmp r12d, dword [rip + 0x24a952] | | if (r12d == *(obj.numCopyCtorCalls)) { 0x004ce052 je 0x4cdbc0 | goto label_8; | } 0x004ce058 mov edi, 0x4f4c78 | 0x004ce05d mov edx, 0x4f4fec | edx = "NUM_COPIES == numCopyCtorCalls"; 0x004ce062 mov esi, 0x103f | esi = 0x103f; 0x004ce067 xor eax, eax | eax = 0; 0x004ce069 call 0x401680 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s (failed)\n"); 0x004ce06e mov eax, dword [rip + 0x24a924] | eax = (anonymous namespace)::testStatus; 0x004ce074 cmp eax, 0x64 | | if (eax > 0x64) { 0x004ce077 ja 0x4cdbc0 | goto label_8; | } 0x004ce07d inc eax | eax++; 0x004ce07f mov dword [rip + 0x24a913], eax | *(obj._anonymous_namespace_::testStatus) = eax; 0x004ce085 jmp 0x4cdbc0 | goto label_8; | label_38: 0x004ce08a mov eax, 1 | eax = 1; 0x004ce08f mov qword [rsp + 0x18], rax | *((rsp + 0x18)) = rax; 0x004ce094 mov rax, qword [rip + 0x28321d] | rax = BloombergLP::bslma::Default::s_defaultAllocator; 0x004ce09b test rax, rax | | if (rax != 0) { 0x004ce09e jne 0x4cdd85 | goto label_9; | } 0x004ce0a4 call 0x4eec50 | BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() (); 0x004ce0a9 jmp 0x4cdd85 | goto label_9; | label_32: 0x004ce10a add rsp, 0x68 | 0x004ce10e pop rbx | 0x004ce10f pop r12 | 0x004ce111 pop r13 | 0x004ce113 pop r14 | 0x004ce115 pop r15 | 0x004ce117 pop rbp | 0x004ce118 ret | return rax; | }