; assembly | /* r2dec pseudo code output */ | /* bslalg_arrayprimitives.t/none @ 0x4cd5b0 */ | #include | ; (fcn) sym.void_testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_ () | uint64_t void_testCopyConstructWithIterators_AmbiguousConvertibleType_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) */ 0x004cd5b0 push rbp | 0x004cd5b1 push r15 | 0x004cd5b3 push r14 | 0x004cd5b5 push r13 | 0x004cd5b7 push r12 | 0x004cd5b9 push rbx | 0x004cd5ba sub rsp, 0x58 | 0x004cd5be mov dword [rsp + 0x2c], edx | *((rsp + 0x2c)) = edx; 0x004cd5c2 mov dword [rsp + 0x44], esi | *((rsp + 0x44)) = esi; 0x004cd5c6 cmp byte [rip + 0x24b3c9], 0 | | if (*(obj.verbose) != 0) { 0x004cd5cd je 0x4cd5d9 | 0x004cd5cf mov edi, 0x4f6973 | 0x004cd5d4 call 0x401710 | puts ("\t\tfrom same type."); | } 0x004cd5d9 xor ebx, ebx | ebx = 0; 0x004cd5db jmp 0x4cd607 | goto label_8; | label_1: 0x004cd5e0 mov edi, 0x74fae0 | edi = testCopyConstructWithIterators(bool, bool, bool)::u; 0x004cd5e5 mov rsi, rbp | rsi = rbp; 0x004cd5e8 call 0x4e4410 | voidverify(AmbiguousConvertibleType*,char const*) (); 0x004cd5ed mov edi, 0x74fae0 | edi = testCopyConstructWithIterators(bool, bool, bool)::u; 0x004cd5f2 mov rsi, rbp | rsi = rbp; 0x004cd5f5 call 0x4e4670 | voidcleanup(AmbiguousConvertibleType*,char const*) (); 0x004cd5fa inc rbx | rbx++; 0x004cd5fd cmp rbx, 0x1e | | if (rbx == 0x1e) { 0x004cd601 je 0x4cdcf0 | goto label_9; | } | label_8: 0x004cd607 mov qword [rsp + 8], rbx | *((rsp + 8)) = rbx; 0x004cd60c lea rbp, [rbx*8] | rbp = rbx*8; 0x004cd614 mov r12, qword [rbp + rbp*4 + 0x4f3c98] | r12 = *((rbp + rbp*4 + 0x4f3c98)); 0x004cd61c mov rdi, r12 | 0x004cd61f call 0x401790 | eax = strlen (*((rbp + rbp*4 + 0x4f3c98))); 0x004cd624 cmp eax, 0x11 | | if (eax >= 0x11) { 0x004cd627 jl 0x4cd652 | 0x004cd629 mov edi, 0x4f4e04 | 0x004cd62e mov edx, 0x4f4393 | edx = "MAX_SIZE >= (int)std::strlen(SPEC)"; 0x004cd633 mov esi, 0xfe6 | esi = 0xfe6; 0x004cd638 xor eax, eax | eax = 0; 0x004cd63a call 0x401680 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s (failed)\n"); 0x004cd63f mov eax, dword [rip + 0x24b353] | eax = (anonymous namespace)::testStatus; 0x004cd645 cmp eax, 0x64 | | if (eax > 0x64) { 0x004cd648 ja 0x4cd652 | goto label_10; | } 0x004cd64a inc eax | eax++; 0x004cd64c mov dword [rip + 0x24b346], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_10: 0x004cd652 mov r13d, dword [rbp + rbp*4 + 0x4f3c90] | r13d = *((rbp + rbp*4 + obj.DATA_3)); 0x004cd65a movsxd r15, dword [rbp + rbp*4 + 0x4f3ca0] | r15 = *((rbp + rbp*4 + 0x4f3ca0)); 0x004cd662 mov ebx, dword [rbp + rbp*4 + 0x4f3ca4] | ebx = *((rbp + rbp*4 + 0x4f3ca4)); 0x004cd669 movsxd r14, dword [rbp + rbp*4 + 0x4f3ca8] | r14 = *((rbp + rbp*4 + 0x4f3ca8)); 0x004cd671 mov rbp, qword [rbp + rbp*4 + 0x4f3cb0] | rbp = *((rbp + rbp*4 + 0x4f3cb0)); 0x004cd679 cmp byte [rip + 0x24b310], 0 | | if (*(obj.veryVerbose) != 0) { 0x004cd680 je 0x4cd6a1 | 0x004cd682 mov qword [rsp], rbp | *(rsp) = rbp; 0x004cd686 mov edi, 0x4f5c41 | 0x004cd68b mov esi, r13d | esi = r13d; 0x004cd68e mov rdx, r12 | rdx = r12; 0x004cd691 mov ecx, r15d | ecx = r15d; 0x004cd694 mov r8d, ebx | r8d = ebx; 0x004cd697 mov r9d, r14d | r9d = r14d; 0x004cd69a xor eax, eax | eax = 0; 0x004cd69c call 0x401680 | printf ("LINE = %d, SPEC = %s, SRC = %d, NE = %d, DST = %d, EXP = %s\n"); | } 0x004cd6a1 mov dword [rsp + 0x18], r13d | *((rsp + 0x18)) = r13d; 0x004cd6a6 mov qword [rsp + 0x20], rbx | *((rsp + 0x20)) = rbx; 0x004cd6ab mov edi, 0x74fae0 | edi = testCopyConstructWithIterators(bool, bool, bool)::u; 0x004cd6b0 mov rsi, r12 | rsi = r12; 0x004cd6b3 call 0x4e4310 | AmbiguousConvertibleType&gg(AmbiguousConvertibleType*,char const*) (); 0x004cd6b8 mov edi, 0x74fae0 | edi = testCopyConstructWithIterators(bool, bool, bool)::u; 0x004cd6bd mov rsi, r12 | rsi = r12; 0x004cd6c0 call 0x4e4410 | voidverify(AmbiguousConvertibleType*,char const*) (); 0x004cd6c5 mov r13d, dword [rip + 0x24b2d8] | r13d = numCopyCtorCalls; 0x004cd6cc mov r12d, dword [rip + 0x24b2d9] | r12d = numCharCtorCalls; 0x004cd6d3 cmp byte [rsp + 0x2c], 0 | | if (*((rsp + 0x2c)) != 0) { 0x004cd6d8 je 0x4cd7a0 | 0x004cd6de cmp byte [rip + 0x24b2ab], 0 | 0x004cd6e5 mov rbx, qword [rsp + 8] | rbx = *((rsp + 8)); | if (*(obj.veryVerbose) != 0) { 0x004cd6ea je 0x4cd6ff | 0x004cd6ec cmp dword [rip + 0x24aecd], 0 | | if (*(0x007185c0) == 0) { 0x004cd6f3 je 0x4cd6ff | goto label_11; | } 0x004cd6f5 mov edi, 0x4f43ea | 0x004cd6fa call 0x401710 | puts ("\t\tBSLMA EXCEPTION TEST -- (ENABLED) --"); | } | label_11: 0x004cd6ff mov dword [rip + 0x24aeb7], 0 | *(0x007185c0) = 0; 0x004cd709 cmp byte [rip + 0x24b285], 0 | | if (*(obj.veryVeryVerbose) != 0) { 0x004cd710 je 0x4cd71c | 0x004cd712 mov edi, 0x4f4411 | 0x004cd717 call 0x401710 | puts ("\t\tBegin bslma exception test."); | } 0x004cd71c mov rax, qword [rip + 0x24b0fd] | rax = Z; 0x004cd723 mov qword [rsp + 0x30], 0x4f69e0 | *((rsp + 0x30)) = vtable.BloombergLP::bslma::TestAllocator_Proxy_BloombergLP::bslma::TestAllocator_.0; 0x004cd72c mov qword [rsp + 0x38], rax | *((rsp + 0x38)) = rax; 0x004cd731 mov qword [rax + 0x20], 0 | *((rax + 0x20)) = 0; 0x004cd739 test rax, rax | | if (rax == 0) { 0x004cd73c je 0x4cd995 | goto label_12; | } | label_0: 0x004cd742 cmp rbx, 6 | | if (rbx < 6) { 0x004cd746 jb 0x4cdb8c | goto label_13; | } 0x004cd74c mov r11, rbp | r11 = rbp; 0x004cd74f lea rax, [r15*8 + 0x74fae0] | rax = r15*8 + obj_testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u; 0x004cd757 lea rdi, [r15*8] | rdi = r15*8; 0x004cd75f lea rcx, [r14*8 + 0x74fae0] | rcx = r14*8 + obj_testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u; 0x004cd767 mov ebp, dword [rip + 0x24b237] | ebp = numCopyCtorCalls; 0x004cd76d mov rbx, qword [rsp + 0x20] | rbx = *((rsp + 0x20)); 0x004cd772 lea edx, [rbx + r15] | edx = rbx + r15; 0x004cd776 movsxd r10, edx | r10 = (int64_t) edx; 0x004cd779 shl r10, 3 | r10 <<= 3; 0x004cd77d mov rsi, r10 | rsi = r10; 0x004cd780 sub rsi, rdi | rsi -= rdi; 0x004cd783 add rsi, 0xfffffffffffffff8 | rsi += 0xfffffffffffffff8; 0x004cd787 cmp rsi, 0x18 | | if (rsi >= 0x18) { 0x004cd78b jae 0x4cda15 | goto label_14; | } 0x004cd791 mov rbx, qword [rsp + 8] | rbx = *((rsp + 8)); 0x004cd796 jmp 0x4cdb60 | goto label_15; | } 0x004cd7a0 cmp qword [rip + 0x24b078], 0 | 0x004cd7a8 mov rbx, qword [rsp + 8] | rbx = *((rsp + 8)); | if (*(obj.Z) == 0) { 0x004cd7ad jne 0x4cd7c0 | 0x004cd7af mov rax, qword [rip + 0x283b02] | rax = BloombergLP::bslma::Default::s_defaultAllocator; 0x004cd7b6 test rax, rax | | if (rax != 0) { 0x004cd7b9 jne 0x4cd7c0 | goto label_16; | } 0x004cd7bb call 0x4eede0 | BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() (); | } | label_16: 0x004cd7c0 cmp rbx, 6 | 0x004cd7c4 mov esi, dword [rsp + 0x18] | esi = *((rsp + 0x18)); | if (rbx < 6) { 0x004cd7c8 jb 0x4cd983 | goto label_17; | } 0x004cd7ce mov qword [rsp + 0x10], rbp | *((rsp + 0x10)) = rbp; 0x004cd7d3 mov rax, qword [rsp + 0x20] | rax = *((rsp + 0x20)); 0x004cd7d8 lea ecx, [rax + r15] | ecx = rax + r15; 0x004cd7dc lea rax, [r15*8 + 0x74fae0] | rax = r15*8 + obj_testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u; 0x004cd7e4 movsxd rbx, ecx | rbx = (int64_t) ecx; 0x004cd7e7 lea rcx, [r14*8 + 0x74fae0] | rcx = r14*8 + obj_testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u; 0x004cd7ef mov edi, dword [rip + 0x24b1af] | edi = numCopyCtorCalls; 0x004cd7f5 lea r11, [rbx*8] | r11 = rbx*8; 0x004cd7fd lea rbp, [r15*8] | rbp = r15*8; 0x004cd805 mov rdx, r11 | rdx = r11; 0x004cd808 sub rdx, rbp | rdx -= rbp; 0x004cd80b lea r10, [rdx - 8] | r10 = rdx - 8; 0x004cd80f cmp r10, 0x18 | | if (r10 < 0x18) { 0x004cd813 jb 0x4cd950 | goto label_18; | } 0x004cd819 lea r9, [r14*8 + 0x74fae0] | r9 = r14*8 + obj_testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u; 0x004cd821 lea rbx, [rbx*8 + 0x74fae0] | rbx = rbx*8 + obj_testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u; 0x004cd829 cmp r9, rbx | | if (r9 < rbx) { 0x004cd82c jae 0x4cd847 | 0x004cd82e lea rdx, [rdx + r14*8 + 0x74fae0] | rdx = rdx + r14*8 + obj_testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u; 0x004cd836 lea rbx, [r15*8 + 0x74fae0] | rbx = r15*8 + obj_testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u; 0x004cd83e cmp rbx, rdx | | if (rbx < rdx) { 0x004cd841 jb 0x4cd950 | goto label_18; | } | } 0x004cd847 shr r10, 3 | r10 >>= 3; 0x004cd84b inc r10 | r10++; 0x004cd84e mov r15, r10 | r15 = r10; 0x004cd851 movabs rdx, 0x3ffffffffffffffc | rdx = 0x3ffffffffffffffc; 0x004cd85b and r15, rdx | r15 &= rdx; 0x004cd85e movd xmm0, edi | xmm0 = edi; 0x004cd862 lea rdx, [r15 - 4] | rdx = r15 - 4; 0x004cd866 mov r9, rdx | r9 = rdx; 0x004cd869 shr r9, 2 | r9 >>= 2; 0x004cd86d inc r9 | r9++; 0x004cd870 test rdx, rdx | | if (rdx == 0) { 0x004cd873 je 0x4cdcc6 | goto label_19; | } 0x004cd879 mov rbx, r9 | rbx = r9; 0x004cd87c and rbx, 0xfffffffffffffffe | rbx &= 0xfffffffffffffffe; 0x004cd880 neg rbx | rbx = -rbx; 0x004cd883 pxor xmm1, xmm1 | xmm1 = 0; 0x004cd887 xor edi, edi | edi = 0; 0x004cd889 movdqa xmm4, xmmword [rip + 0x22c0f] | __asm ("movdqa xmm4, xmmword [0x004f04a0]"); 0x004cd891 nop word cs:[rax + rax] | 0x004cd89b nop dword [rax + rax] | | do { 0x004cd8a0 movups xmm2, xmmword [rbp + rdi*8 + 0x74fae0] | __asm ("movups xmm2, xmmword [rbp + rdi*8 + obj.testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u]"); 0x004cd8a8 movups xmm3, xmmword [rbp + rdi*8 + 0x74faf0] | __asm ("movups xmm3, xmmword [rbp + rdi*8 + 0x74faf0]"); 0x004cd8b0 lea rdx, [r14*8] | rdx = r14*8; 0x004cd8b8 movups xmmword [rdx + rdi*8 + 0x74fae0], xmm2 | __asm ("movups xmmword [rdx + rdi*8 + obj.testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u], xmm2"); 0x004cd8c0 movups xmmword [rdx + rdi*8 + 0x74faf0], xmm3 | __asm ("movups xmmword [rdx + rdi*8 + 0x74faf0], xmm3"); 0x004cd8c8 movdqu xmm2, xmmword [rbp + rdi*8 + 0x74fb00] | __asm ("movdqu xmm2, xmmword [rbp + rdi*8 + 0x74fb00]"); 0x004cd8d1 movups xmm3, xmmword [rbp + rdi*8 + 0x74fb10] | __asm ("movups xmm3, xmmword [rbp + rdi*8 + 0x74fb10]"); 0x004cd8d9 movdqu xmmword [rdx + rdi*8 + 0x74fb00], xmm2 | __asm ("movdqu xmmword [rdx + rdi*8 + 0x74fb00], xmm2"); 0x004cd8e2 movups xmmword [rdx + rdi*8 + 0x74fb10], xmm3 | __asm ("movups xmmword [rdx + rdi*8 + 0x74fb10], xmm3"); 0x004cd8ea paddd xmm0, xmm4 | __asm ("paddd xmm0, xmm4"); 0x004cd8ee paddd xmm1, xmm4 | __asm ("paddd xmm1, xmm4"); 0x004cd8f2 add rdi, 8 | rdi += 8; 0x004cd8f6 add rbx, 2 | rbx += 2; 0x004cd8fa jne 0x4cd8a0 | | } while (rbx != 0); 0x004cd8fc test r9b, 1 | | if ((r9b & 1) != 0) { 0x004cd900 je 0x4cd922 | | label_2: 0x004cd902 movdqu xmm2, xmmword [rax + rdi*8] | __asm ("movdqu xmm2, xmmword [rax + rdi*8]"); 0x004cd907 movups xmm3, xmmword [rax + rdi*8 + 0x10] | __asm ("movups xmm3, xmmword [rax + rdi*8 + 0x10]"); 0x004cd90c movdqu xmmword [rcx + rdi*8], xmm2 | __asm ("movdqu xmmword [rcx + rdi*8], xmm2"); 0x004cd911 movups xmmword [rcx + rdi*8 + 0x10], xmm3 | __asm ("movups xmmword [rcx + rdi*8 + 0x10], xmm3"); 0x004cd916 pcmpeqd xmm2, xmm2 | __asm ("pcmpeqd xmm2, xmm2"); 0x004cd91a psubd xmm1, xmm2 | __asm ("psubd xmm1, xmm2"); 0x004cd91e psubd xmm0, xmm2 | __asm ("psubd xmm0, xmm2"); | } | label_3: 0x004cd922 paddd xmm0, xmm1 | __asm ("paddd xmm0, xmm1"); 0x004cd926 pshufd xmm1, xmm0, 0x55 | __asm ("pshufd xmm1, xmm0, 0x55"); 0x004cd92b paddd xmm1, xmm0 | __asm ("paddd xmm1, xmm0"); 0x004cd92f movd edi, xmm1 | edi = xmm1; 0x004cd933 cmp r10, r15 | 0x004cd936 mov esi, dword [rsp + 0x18] | esi = *((rsp + 0x18)); | if (r10 == r15) { 0x004cd93a je 0x4cd973 | goto label_20; | } 0x004cd93c lea rax, [rax + r15*8] | rax = rax + r15*8; 0x004cd940 lea rcx, [rcx + r15*8] | rcx = rcx + r15*8; 0x004cd944 nop word cs:[rax + rax] | 0x004cd94e nop | | label_18: 0x004cd950 sub r11, rax | r11 -= rax; 0x004cd953 lea rdx, [r11 + 0x74fae0] | rdx = r11 + obj_testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u; 0x004cd95a xor ebx, ebx | ebx = 0; 0x004cd95c nop dword [rax] | | do { 0x004cd960 mov rbp, qword [rax + rbx] | rbp = *((rax + rbx)); 0x004cd964 mov qword [rcx + rbx], rbp | *((rcx + rbx)) = rbp; 0x004cd968 inc edi | edi++; 0x004cd96a add rbx, 8 | rbx += 8; 0x004cd96e cmp rdx, rbx | 0x004cd971 jne 0x4cd960 | | } while (rdx != rbx); | label_20: 0x004cd973 mov dword [rip + 0x24b02b], edi | *(obj.numCopyCtorCalls) = edi; 0x004cd979 mov rbp, qword [rsp + 0x10] | rbp = *((rsp + 0x10)); 0x004cd97e mov rbx, qword [rsp + 8] | rbx = *((rsp + 8)); | label_17: 0x004cd983 cmp byte [rip + 0x24b006], 0 | | if (*(obj.veryVerbose) != 0) { 0x004cd98a jne 0x4cdbd3 | goto label_21; | } 0x004cd990 jmp 0x4cdbf1 | goto label_22; | label_12: 0x004cd995 mov eax, 1 | eax = 1; 0x004cd99a mov qword [rsp + 0x10], rax | *((rsp + 0x10)) = rax; 0x004cd99f mov rax, qword [rip + 0x283912] | rax = BloombergLP::bslma::Default::s_defaultAllocator; 0x004cd9a6 test rax, rax | | if (rax != 0) { 0x004cd9a9 jne 0x4cd742 | goto label_0; | } 0x004cd9af call 0x4eede0 | BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() (); 0x004cd9b4 jmp 0x4cd742 | goto label_0; | label_14: 0x004cda15 mov dword [rsp + 0x10], r12d | *((rsp + 0x10)) = r12d; 0x004cda1a lea r8, [r14*8 + 0x74fae0] | r8 = r14*8 + obj_testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u; 0x004cda22 add ebx, r15d | ebx += r15d; 0x004cda25 movsxd rbx, ebx | rbx = (int64_t) ebx; 0x004cda28 lea rdx, [rbx*8 + 0x74fae0] | rdx = rbx*8 + obj_testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u; 0x004cda30 cmp r8, rdx | | if (r8 < rdx) { 0x004cda33 jae 0x4cda60 | 0x004cda35 shl rbx, 3 | rbx <<= 3; 0x004cda39 sub rbx, rdi | rbx -= rdi; 0x004cda3c lea rdx, [rbx + r14*8 + 0x74fae0] | rdx = rbx + r14*8 + obj_testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u; 0x004cda44 lea rbx, [r15*8 + 0x74fae0] | rbx = r15*8 + obj_testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u; 0x004cda4c cmp rbx, rdx | | if (rbx >= rdx) { 0x004cda4f jae 0x4cda60 | goto label_23; | } 0x004cda51 mov r12d, dword [rsp + 0x10] | r12d = *((rsp + 0x10)); 0x004cda56 mov rbx, qword [rsp + 8] | rbx = *((rsp + 8)); 0x004cda5b jmp 0x4cdb60 | goto label_15; | } | label_23: 0x004cda60 shr rsi, 3 | rsi >>= 3; 0x004cda64 inc rsi | rsi++; 0x004cda67 mov r8, rsi | r8 = rsi; 0x004cda6a movabs rdx, 0x3ffffffffffffffc | rdx = 0x3ffffffffffffffc; 0x004cda74 and r8, rdx | r8 &= rdx; 0x004cda77 movd xmm0, ebp | xmm0 = ebp; 0x004cda7b lea rdx, [r8 - 4] | rdx = r8 - 4; 0x004cda7f mov r9, rdx | r9 = rdx; 0x004cda82 shr r9, 2 | r9 >>= 2; 0x004cda86 inc r9 | r9++; 0x004cda89 test rdx, rdx | | if (rdx == 0) { 0x004cda8c je 0x4cdcdb | goto label_24; | } 0x004cda92 mov rbx, r9 | rbx = r9; 0x004cda95 and rbx, 0xfffffffffffffffe | rbx &= 0xfffffffffffffffe; 0x004cda99 neg rbx | rbx = -rbx; 0x004cda9c pxor xmm1, xmm1 | xmm1 = 0; 0x004cdaa0 xor ebp, ebp | ebp = 0; 0x004cdaa2 movdqa xmm4, xmmword [rip + 0x229f6] | __asm ("movdqa xmm4, xmmword [0x004f04a0]"); 0x004cdaaa nop word [rax + rax] | | do { 0x004cdab0 movups xmm2, xmmword [rdi + rbp*8 + 0x74fae0] | __asm ("movups xmm2, xmmword [rdi + rbp*8 + obj.testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u]"); 0x004cdab8 movups xmm3, xmmword [rdi + rbp*8 + 0x74faf0] | __asm ("movups xmm3, xmmword [rdi + rbp*8 + 0x74faf0]"); 0x004cdac0 lea rdx, [r14*8] | rdx = r14*8; 0x004cdac8 movups xmmword [rdx + rbp*8 + 0x74fae0], xmm2 | __asm ("movups xmmword [rdx + rbp*8 + obj.testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u], xmm2"); 0x004cdad0 movups xmmword [rdx + rbp*8 + 0x74faf0], xmm3 | __asm ("movups xmmword [rdx + rbp*8 + 0x74faf0], xmm3"); 0x004cdad8 movdqu xmm2, xmmword [rdi + rbp*8 + 0x74fb00] | __asm ("movdqu xmm2, xmmword [rdi + rbp*8 + 0x74fb00]"); 0x004cdae1 movups xmm3, xmmword [rdi + rbp*8 + 0x74fb10] | __asm ("movups xmm3, xmmword [rdi + rbp*8 + 0x74fb10]"); 0x004cdae9 movdqu xmmword [rdx + rbp*8 + 0x74fb00], xmm2 | __asm ("movdqu xmmword [rdx + rbp*8 + 0x74fb00], xmm2"); 0x004cdaf2 movups xmmword [rdx + rbp*8 + 0x74fb10], xmm3 | __asm ("movups xmmword [rdx + rbp*8 + 0x74fb10], xmm3"); 0x004cdafa paddd xmm0, xmm4 | __asm ("paddd xmm0, xmm4"); 0x004cdafe paddd xmm1, xmm4 | __asm ("paddd xmm1, xmm4"); 0x004cdb02 add rbp, 8 | rbp += 8; 0x004cdb06 add rbx, 2 | rbx += 2; 0x004cdb0a jne 0x4cdab0 | | } while (rbx != 0); 0x004cdb0c test r9b, 1 | | if ((r9b & 1) != 0) { 0x004cdb10 je 0x4cdb32 | | label_4: 0x004cdb12 movdqu xmm2, xmmword [rax + rbp*8] | __asm ("movdqu xmm2, xmmword [rax + rbp*8]"); 0x004cdb17 movups xmm3, xmmword [rax + rbp*8 + 0x10] | __asm ("movups xmm3, xmmword [rax + rbp*8 + 0x10]"); 0x004cdb1c movdqu xmmword [rcx + rbp*8], xmm2 | __asm ("movdqu xmmword [rcx + rbp*8], xmm2"); 0x004cdb21 movups xmmword [rcx + rbp*8 + 0x10], xmm3 | __asm ("movups xmmword [rcx + rbp*8 + 0x10], xmm3"); 0x004cdb26 pcmpeqd xmm2, xmm2 | __asm ("pcmpeqd xmm2, xmm2"); 0x004cdb2a psubd xmm1, xmm2 | __asm ("psubd xmm1, xmm2"); 0x004cdb2e psubd xmm0, xmm2 | __asm ("psubd xmm0, xmm2"); | } | label_5: 0x004cdb32 paddd xmm0, xmm1 | __asm ("paddd xmm0, xmm1"); 0x004cdb36 pshufd xmm1, xmm0, 0x55 | __asm ("pshufd xmm1, xmm0, 0x55"); 0x004cdb3b paddd xmm1, xmm0 | __asm ("paddd xmm1, xmm0"); 0x004cdb3f movd ebp, xmm1 | 0x004cdb43 cmp rsi, r8 | 0x004cdb46 mov r12d, dword [rsp + 0x10] | r12d = *((rsp + 0x10)); 0x004cdb4b mov rbx, qword [rsp + 8] | rbx = *((rsp + 8)); | if (rsi == r8) { 0x004cdb50 je 0x4cdb83 | goto label_25; | } 0x004cdb52 lea rax, [rax + r8*8] | rax = rax + r8*8; 0x004cdb56 lea rcx, [rcx + r8*8] | rcx = rcx + r8*8; 0x004cdb5a nop word [rax + rax] | | label_15: 0x004cdb60 sub r10, rax | r10 -= rax; 0x004cdb63 lea rdx, [r10 + 0x74fae0] | rdx = r10 + obj_testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u; 0x004cdb6a xor esi, esi | esi = 0; 0x004cdb6c nop dword [rax] | | do { 0x004cdb70 mov rdi, qword [rax + rsi] | rdi = *((rax + rsi)); 0x004cdb74 mov qword [rcx + rsi], rdi | *((rcx + rsi)) = rdi; 0x004cdb78 inc ebp | ebp++; 0x004cdb7a add rsi, 8 | rsi += 8; 0x004cdb7e cmp rdx, rsi | 0x004cdb81 jne 0x4cdb70 | | } while (rdx != rsi); | label_25: 0x004cdb83 mov dword [rip + 0x24ae1b], ebp | *(obj.numCopyCtorCalls) = ebp; 0x004cdb89 mov rbp, r11 | | label_13: 0x004cdb8c mov rax, qword [rsp + 0x30] | rax = *((rsp + 0x30)); 0x004cdb91 lea rdi, [rsp + 0x30] | rdi = rsp + 0x30; 0x004cdb96 mov rsi, 0xffffffffffffffff | rsi = 0xffffffffffffffff; 0x004cdb9d call qword [rax + 0x10] | uint64_t (*rax + 0x10)() (); 0x004cdba0 cmp byte [rip + 0x24adee], 0 | | if (*(obj.veryVeryVerbose) != 0) { 0x004cdba7 je 0x4cdbb3 | 0x004cdba9 mov edi, 0x4f4571 | 0x004cdbae call 0x401710 | puts ("\t\tEnd bslma exception test."); | } 0x004cdbb3 cmp byte [rip + 0x24add6], 0 | | if (*(obj.veryVerbose) != 0) { 0x004cdbba je 0x4cdbf1 | 0x004cdbbc mov edi, 0xa | 0x004cdbc1 call 0x401720 | eax = putchar (0xa); 0x004cdbc6 mov esi, dword [rsp + 0x18] | esi = *((rsp + 0x18)); 0x004cdbca cmp byte [rip + 0x24adbf], 0 | | if (*(obj.veryVerbose) == 0) { 0x004cdbd1 je 0x4cdbf1 | goto label_22; | } | label_21: 0x004cdbd3 mov edx, dword [rip + 0x24adcb] | edx = numCopyCtorCalls; 0x004cdbd9 sub edx, r13d | edx -= r13d; 0x004cdbdc mov ecx, dword [rip + 0x24adca] | ecx = numCharCtorCalls; 0x004cdbe2 sub ecx, r12d | ecx -= r12d; 0x004cdbe5 mov edi, 0x4f5db4 | 0x004cdbea xor eax, eax | eax = 0; 0x004cdbec call 0x401680 | eax = printf ("LINE = %d, #copy ctors = %d, #char ctors = %d.\n"); | } | label_22: 0x004cdbf1 cmp byte [rsp + 0x44], 0 | | if (*((rsp + 0x44)) == 0) { 0x004cdbf6 je 0x4cdc50 | goto label_26; | } 0x004cdbf8 cmp r13d, dword [rip + 0x24ada5] | | if (r13d != *(obj.numCopyCtorCalls)) { 0x004cdbff je 0x4cdc2a | 0x004cdc01 mov edi, 0x4f4e04 | 0x004cdc06 mov edx, 0x4f5176 | edx = "NUM_COPIES == numCopyCtorCalls"; 0x004cdc0b mov esi, 0x1005 | esi = 0x1005; 0x004cdc10 xor eax, eax | eax = 0; 0x004cdc12 call 0x401680 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s (failed)\n"); 0x004cdc17 mov eax, dword [rip + 0x24ad7b] | eax = (anonymous namespace)::testStatus; 0x004cdc1d cmp eax, 0x64 | | if (eax > 0x64) { 0x004cdc20 ja 0x4cdc2a | goto label_27; | } 0x004cdc22 inc eax | eax++; 0x004cdc24 mov dword [rip + 0x24ad6e], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_27: 0x004cdc2a cmp r12d, dword [rip + 0x24ad7b] | | if (r12d == *(obj.numCharCtorCalls)) { 0x004cdc31 je 0x4cd5e0 | goto label_1; | } 0x004cdc37 mov edi, 0x4f4e04 | edi = "Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s (failed)\n"; 0x004cdc3c mov edx, 0x4f5de4 | edx = "NUM_CTORS == numCharCtorCalls"; 0x004cdc41 mov esi, 0x1006 | esi = 0x1006; 0x004cdc46 jmp 0x4cdca3 | goto label_28; | label_26: 0x004cdc50 add r13d, dword [rsp + 0x20] | r13d += *((rsp + 0x20)); 0x004cdc55 cmp r13d, dword [rip + 0x24ad48] | | if (r13d > *(obj.numCopyCtorCalls)) { 0x004cdc5c jle 0x4cdc87 | 0x004cdc5e mov edi, 0x4f4e04 | 0x004cdc63 mov edx, 0x4f5e02 | edx = "NUM_COPIES + NE <= numCopyCtorCalls"; 0x004cdc68 mov esi, 0x1009 | esi = 0x1009; 0x004cdc6d xor eax, eax | eax = 0; 0x004cdc6f call 0x401680 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s (failed)\n"); 0x004cdc74 mov eax, dword [rip + 0x24ad1e] | eax = (anonymous namespace)::testStatus; 0x004cdc7a cmp eax, 0x64 | | if (eax > 0x64) { 0x004cdc7d ja 0x4cdc87 | goto label_29; | } 0x004cdc7f inc eax | eax++; 0x004cdc81 mov dword [rip + 0x24ad11], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_29: 0x004cdc87 cmp r12d, dword [rip + 0x24ad1e] | | if (r12d == *(obj.numCharCtorCalls)) { 0x004cdc8e je 0x4cd5e0 | goto label_1; | } 0x004cdc94 mov edi, 0x4f4e04 | 0x004cdc99 mov edx, 0x4f5de4 | edx = "NUM_CTORS == numCharCtorCalls"; 0x004cdc9e mov esi, 0x100a | esi = 0x100a; | label_28: 0x004cdca3 xor eax, eax | eax = 0; 0x004cdca5 call 0x401680 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s (failed)\n"); 0x004cdcaa mov eax, dword [rip + 0x24ace8] | eax = (anonymous namespace)::testStatus; 0x004cdcb0 cmp eax, 0x64 | | if (eax > 0x64) { 0x004cdcb3 ja 0x4cd5e0 | goto label_1; | } 0x004cdcb9 inc eax | eax++; 0x004cdcbb mov dword [rip + 0x24acd7], eax | *(obj._anonymous_namespace_::testStatus) = eax; 0x004cdcc1 jmp 0x4cd5e0 | goto label_1; | label_19: 0x004cdcc6 pxor xmm1, xmm1 | xmm1 = 0; 0x004cdcca xor edi, edi | edi = 0; 0x004cdccc test r9b, 1 | | if ((r9b & 1) != 0) { 0x004cdcd0 jne 0x4cd902 | goto label_2; | } 0x004cdcd6 jmp 0x4cd922 | goto label_3; | label_24: 0x004cdcdb pxor xmm1, xmm1 | xmm1 = 0; 0x004cdcdf xor ebp, ebp | ebp = 0; 0x004cdce1 test r9b, 1 | | if ((r9b & 1) != 0) { 0x004cdce5 jne 0x4cdb12 | goto label_4; | } 0x004cdceb jmp 0x4cdb32 | goto label_5; | label_9: 0x004cdcf0 cmp byte [rip + 0x24ac9f], 0 | | if (*(obj.verbose) != 0) { 0x004cdcf7 je 0x4cdd03 | 0x004cdcf9 mov edi, 0x4f695c | 0x004cdcfe call 0x401710 | puts ("\t\tfrom different type."); | } 0x004cdd03 xor r13d, r13d | r13d = 0; 0x004cdd06 jmp 0x4cdd37 | goto label_30; | label_6: 0x004cdd10 mov edi, 0x74fae0 | edi = testCopyConstructWithIterators(bool, bool, bool)::u; 0x004cdd15 mov rsi, rbp | rsi = rbp; 0x004cdd18 call 0x4e4410 | voidverify(AmbiguousConvertibleType*,char const*) (); 0x004cdd1d mov edi, 0x74fae0 | edi = testCopyConstructWithIterators(bool, bool, bool)::u; 0x004cdd22 mov rsi, rbp | rsi = rbp; 0x004cdd25 call 0x4e4670 | voidcleanup(AmbiguousConvertibleType*,char const*) (); 0x004cdd2a inc r13 | r13++; 0x004cdd2d cmp r13, 0x1e | | if (r13 == 0x1e) { 0x004cdd31 je 0x4ce25a | goto label_31; | } | label_30: 0x004cdd37 lea rbp, [r13*8] | rbp = r13*8; 0x004cdd3f mov r12, qword [rbp + rbp*4 + 0x4f3c98] | r12 = *((rbp + rbp*4 + 0x4f3c98)); 0x004cdd47 mov rdi, r12 | 0x004cdd4a call 0x401790 | eax = strlen (*((rbp + rbp*4 + 0x4f3c98))); 0x004cdd4f cmp eax, 0x11 | | if (eax >= 0x11) { 0x004cdd52 jl 0x4cdd7d | 0x004cdd54 mov edi, 0x4f4e04 | 0x004cdd59 mov edx, 0x4f4393 | edx = "MAX_SIZE >= (int)std::strlen(SPEC)"; 0x004cdd5e mov esi, 0x1019 | esi = 0x1019; 0x004cdd63 xor eax, eax | eax = 0; 0x004cdd65 call 0x401680 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s (failed)\n"); 0x004cdd6a mov eax, dword [rip + 0x24ac28] | eax = (anonymous namespace)::testStatus; 0x004cdd70 cmp eax, 0x64 | | if (eax > 0x64) { 0x004cdd73 ja 0x4cdd7d | goto label_32; | } 0x004cdd75 inc eax | eax++; 0x004cdd77 mov dword [rip + 0x24ac1b], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_32: 0x004cdd7d mov rdi, r12 | 0x004cdd80 call 0x401790 | rax = strlen (r12); 0x004cdd85 cmp rax, 0x14 | | if (rax >= 0x14) { 0x004cdd89 jb 0x4cddb4 | 0x004cdd8b mov edi, 0x4f4e04 | 0x004cdd90 mov edx, 0x4f5e26 | edx = "SPEC_CE_LEN > std::strlen(SPEC)"; 0x004cdd95 mov esi, 0x101c | esi = 0x101c; 0x004cdd9a xor eax, eax | eax = 0; 0x004cdd9c call 0x401680 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s (failed)\n"); 0x004cdda1 mov eax, dword [rip + 0x24abf1] | eax = (anonymous namespace)::testStatus; 0x004cdda7 cmp eax, 0x64 | | if (eax > 0x64) { 0x004cddaa ja 0x4cddb4 | goto label_33; | } 0x004cddac inc eax | eax++; 0x004cddae mov dword [rip + 0x24abe4], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_33: 0x004cddb4 mov qword [rsp + 8], r13 | *((rsp + 8)) = r13; 0x004cddb9 pxor xmm0, xmm0 | xmm0 = 0; 0x004cddbd movdqa xmmword [rsp + 0x30], xmm0 | __asm ("movdqa xmmword [rsp + 0x30], xmm0"); 0x004cddc3 mov dword [rsp + 0x40], 0 | *((rsp + 0x40)) = 0; 0x004cddcb mov al, byte [r12] | al = *(r12); 0x004cddcf test al, al | | if (al == 0) { 0x004cddd1 je 0x4cddf1 | goto label_34; | } 0x004cddd3 xor ecx, ecx | ecx = 0; 0x004cddd5 nop word cs:[rax + rax] | 0x004cdddf nop | | do { 0x004cdde0 mov byte [rsp + rcx + 0x30], al | *((rsp + rcx + 0x30)) = al; 0x004cdde4 movzx eax, byte [r12 + rcx + 1] | eax = *((r12 + rcx + 1)); 0x004cddea inc rcx | rcx++; 0x004cdded test al, al | 0x004cddef jne 0x4cdde0 | | } while (al != 0); | label_34: 0x004cddf1 mov r14d, dword [rbp + rbp*4 + 0x4f3c90] | r14d = *((rbp + rbp*4 + obj.DATA_3)); 0x004cddf9 movsxd rbx, dword [rbp + rbp*4 + 0x4f3ca0] | rbx = *((rbp + rbp*4 + 0x4f3ca0)); 0x004cde01 movsxd r15, dword [rbp + rbp*4 + 0x4f3ca4] | r15 = *((rbp + rbp*4 + 0x4f3ca4)); 0x004cde09 movsxd r13, dword [rbp + rbp*4 + 0x4f3ca8] | r13 = *((rbp + rbp*4 + 0x4f3ca8)); 0x004cde11 mov rbp, qword [rbp + rbp*4 + 0x4f3cb0] | rbp = *((rbp + rbp*4 + 0x4f3cb0)); 0x004cde19 cmp byte [rip + 0x24ab70], 0 | | if (*(obj.veryVerbose) != 0) { 0x004cde20 je 0x4cde40 | 0x004cde22 mov qword [rsp], rbp | *(rsp) = rbp; 0x004cde26 mov edi, 0x4f5c41 | 0x004cde2b mov esi, r14d | esi = r14d; 0x004cde2e mov rdx, r12 | rdx = r12; 0x004cde31 mov ecx, ebx | ecx = ebx; 0x004cde33 mov r8d, r15d | r8d = r15d; 0x004cde36 mov r9d, r13d | r9d = r13d; 0x004cde39 xor eax, eax | eax = 0; 0x004cde3b call 0x401680 | printf ("LINE = %d, SPEC = %s, SRC = %d, NE = %d, DST = %d, EXP = %s\n"); | } 0x004cde40 mov edi, 0x74fae0 | edi = testCopyConstructWithIterators(bool, bool, bool)::u; 0x004cde45 mov rsi, r12 | rsi = r12; 0x004cde48 call 0x4e4310 | AmbiguousConvertibleType&gg(AmbiguousConvertibleType*,char const*) (); 0x004cde4d mov edi, 0x74fae0 | edi = testCopyConstructWithIterators(bool, bool, bool)::u; 0x004cde52 mov rsi, r12 | rsi = r12; 0x004cde55 call 0x4e4410 | voidverify(AmbiguousConvertibleType*,char const*) (); 0x004cde5a mov r12d, dword [rip + 0x24ab43] | r12d = numCopyCtorCalls; 0x004cde61 mov eax, dword [rip + 0x24ab45] | eax = numCharCtorCalls; 0x004cde67 mov dword [rsp + 0x20], eax | *((rsp + 0x20)) = eax; 0x004cde6b cmp byte [rsp + 0x2c], 0 | | if (*((rsp + 0x2c)) == 0) { 0x004cde70 je 0x4ce030 | goto label_35; | } 0x004cde76 cmp byte [rip + 0x24ab13], 0 | | if (*(obj.veryVerbose) != 0) { 0x004cde7d je 0x4cde92 | 0x004cde7f cmp dword [rip + 0x24a73e], 0 | | if (*(obj.testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::firstTime) == 0) { 0x004cde86 je 0x4cde92 | goto label_36; | } 0x004cde88 mov edi, 0x4f43ea | 0x004cde8d call 0x401710 | puts ("\t\tBSLMA EXCEPTION TEST -- (ENABLED) --"); | } | label_36: 0x004cde92 mov dword [rip + 0x24a728], 0 | *(obj.testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::firstTime) = 0; 0x004cde9c cmp byte [rip + 0x24aaf2], 0 | | if (*(obj.veryVeryVerbose) != 0) { 0x004cdea3 je 0x4cdeaf | 0x004cdea5 mov edi, 0x4f4411 | 0x004cdeaa call 0x401710 | puts ("\t\tBegin bslma exception test."); | } 0x004cdeaf mov rax, qword [rip + 0x24a96a] | rax = Z; 0x004cdeb6 mov qword [rsp + 0x48], 0x4f69e0 | *((rsp + 0x48)) = vtable.BloombergLP::bslma::TestAllocator_Proxy_BloombergLP::bslma::TestAllocator_.0; 0x004cdebf mov qword [rsp + 0x50], rax | *((rsp + 0x50)) = rax; 0x004cdec4 mov qword [rax + 0x20], 0 | *((rax + 0x20)) = 0; 0x004cdecc test rax, rax | | if (rax == 0) { 0x004cdecf je 0x4ce1da | goto label_37; | } | label_7: 0x004cded5 cmp qword [rsp + 8], 6 | | if (*((rsp + 8)) < 6) { 0x004cdedb jb 0x4cdfe8 | goto label_38; | } 0x004cdee1 add r15d, ebx | r15d += ebx; 0x004cdee4 movsxd rax, r15d | rax = (int64_t) r15d; 0x004cdee7 lea rcx, [rsp + rbx + 0x30] | rcx = rsp + rbx + 0x30; 0x004cdeec lea rsi, [r13*8 + 0x74fae0] | rsi = r13*8 + obj_testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u; 0x004cdef4 mov edx, eax | edx = eax; 0x004cdef6 sub edx, ebx | edx -= ebx; 0x004cdef8 not rbx | rbx = ~rbx; 0x004cdefb add rbx, rax | rbx += rax; 0x004cdefe and rdx, 7 | rdx &= 7; | if (rdx == 0) { 0x004cdf02 je 0x4cdf2b | goto label_39; | } 0x004cdf04 nop word cs:[rax + rax] | 0x004cdf0e nop | | do { 0x004cdf10 movsx rdi, byte [rcx] | rdi = *(rcx); 0x004cdf14 mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004cdf1c mov qword [rsi], rdi | *(rsi) = rdi; 0x004cdf1f inc rcx | rcx++; 0x004cdf22 add rsi, 8 | rsi += 8; 0x004cdf26 dec rdx | rdx--; 0x004cdf29 jne 0x4cdf10 | | } while (rdx != 0); | label_39: 0x004cdf2b cmp rbx, 7 | | if (rbx < 7) { 0x004cdf2f jb 0x4cdfe8 | goto label_38; | } 0x004cdf35 lea rax, [rsp + rax + 0x30] | rax = rsp + rax + 0x30; 0x004cdf3a xor edi, edi | edi = 0; 0x004cdf3c nop dword [rax] | | do { 0x004cdf40 movsx rdx, byte [rcx + rdi] | rdx = *((rcx + rdi)); 0x004cdf45 mov rdx, qword [rdx*8 + 0x7171d0] | rdx = *((rdx*8 + obj.funcPtrArray)); 0x004cdf4d mov qword [rsi + rdi*8], rdx | *((rsi + rdi*8)) = rdx; 0x004cdf51 movsx rdx, byte [rcx + rdi + 1] | rdx = *((rcx + rdi + 1)); 0x004cdf57 mov rdx, qword [rdx*8 + 0x7171d0] | rdx = *((rdx*8 + obj.funcPtrArray)); 0x004cdf5f mov qword [rsi + rdi*8 + 8], rdx | *((rsi + rdi*8 + 8)) = rdx; 0x004cdf64 movsx rdx, byte [rcx + rdi + 2] | rdx = *((rcx + rdi + 2)); 0x004cdf6a mov rdx, qword [rdx*8 + 0x7171d0] | rdx = *((rdx*8 + obj.funcPtrArray)); 0x004cdf72 mov qword [rsi + rdi*8 + 0x10], rdx | *((rsi + rdi*8 + 0x10)) = rdx; 0x004cdf77 movsx rdx, byte [rcx + rdi + 3] | rdx = *((rcx + rdi + 3)); 0x004cdf7d mov rdx, qword [rdx*8 + 0x7171d0] | rdx = *((rdx*8 + obj.funcPtrArray)); 0x004cdf85 mov qword [rsi + rdi*8 + 0x18], rdx | *((rsi + rdi*8 + 0x18)) = rdx; 0x004cdf8a movsx rdx, byte [rcx + rdi + 4] | rdx = *((rcx + rdi + 4)); 0x004cdf90 mov rdx, qword [rdx*8 + 0x7171d0] | rdx = *((rdx*8 + obj.funcPtrArray)); 0x004cdf98 mov qword [rsi + rdi*8 + 0x20], rdx | *((rsi + rdi*8 + 0x20)) = rdx; 0x004cdf9d movsx rdx, byte [rcx + rdi + 5] | rdx = *((rcx + rdi + 5)); 0x004cdfa3 mov rdx, qword [rdx*8 + 0x7171d0] | rdx = *((rdx*8 + obj.funcPtrArray)); 0x004cdfab mov qword [rsi + rdi*8 + 0x28], rdx | *((rsi + rdi*8 + 0x28)) = rdx; 0x004cdfb0 movsx rdx, byte [rcx + rdi + 6] | rdx = *((rcx + rdi + 6)); 0x004cdfb6 mov rdx, qword [rdx*8 + 0x7171d0] | rdx = *((rdx*8 + obj.funcPtrArray)); 0x004cdfbe mov qword [rsi + rdi*8 + 0x30], rdx | *((rsi + rdi*8 + 0x30)) = rdx; 0x004cdfc3 movsx rdx, byte [rcx + rdi + 7] | rdx = *((rcx + rdi + 7)); 0x004cdfc9 mov rdx, qword [rdx*8 + 0x7171d0] | rdx = *((rdx*8 + obj.funcPtrArray)); 0x004cdfd1 mov qword [rsi + rdi*8 + 0x38], rdx | *((rsi + rdi*8 + 0x38)) = rdx; 0x004cdfd6 lea rdx, [rcx + rdi + 8] | rdx = rcx + rdi + 8; 0x004cdfdb add rdi, 8 | rdi += 8; 0x004cdfdf cmp rdx, rax | 0x004cdfe2 jne 0x4cdf40 | | } while (rdx != rax); | label_38: 0x004cdfe8 mov rax, qword [rsp + 0x48] | rax = *((rsp + 0x48)); 0x004cdfed lea rdi, [rsp + 0x48] | rdi = rsp + 0x48; 0x004cdff2 mov rsi, 0xffffffffffffffff | rsi = 0xffffffffffffffff; 0x004cdff9 call qword [rax + 0x10] | uint64_t (*rax + 0x10)() (); 0x004cdffc cmp byte [rip + 0x24a992], 0 | 0x004ce003 mov r13, qword [rsp + 8] | r13 = *((rsp + 8)); | if (*(obj.veryVeryVerbose) != 0) { 0x004ce008 je 0x4ce014 | 0x004ce00a mov edi, 0x4f4571 | 0x004ce00f call 0x401710 | puts ("\t\tEnd bslma exception test."); | } 0x004ce014 cmp byte [rip + 0x24a975], 0 | | if (*(obj.veryVerbose) == 0) { 0x004ce01b je 0x4ce19b | goto label_40; | } 0x004ce021 mov edi, 0xa | 0x004ce026 call 0x401720 | putchar (0xa); 0x004ce02b jmp 0x4ce170 | goto label_41; | label_35: 0x004ce030 cmp qword [rip + 0x24a7e8], 0 | 0x004ce038 mov rcx, r13 | rcx = r13; | if (*(obj.Z) == 0) { 0x004ce03b jne 0x4ce060 | 0x004ce03d mov rax, qword [rip + 0x283274] | rax = BloombergLP::bslma::Default::s_defaultAllocator; 0x004ce044 test rax, rax | | if (rax != 0) { 0x004ce047 jne 0x4ce060 | goto label_42; | } 0x004ce049 call 0x4eede0 | BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() (); 0x004ce04e mov rcx, r13 | rcx = r13; 0x004ce051 nop word cs:[rax + rax] | 0x004ce05b nop dword [rax + rax] | | } | label_42: 0x004ce060 mov r13, qword [rsp + 8] | r13 = *((rsp + 8)); 0x004ce065 cmp r13, 6 | | if (r13 < 6) { 0x004ce069 jb 0x4ce170 | goto label_41; | } 0x004ce06f add r15, rbx | r15 += rbx; 0x004ce072 lea rax, [rcx*8 + 0x74fae0] | rax = rcx*8 + obj_testCopyConstructWithIterators_AmbiguousConvertibleType__bool__bool__bool_::u; 0x004ce07a lea rcx, [rsp + rbx + 0x30] | rcx = rsp + rbx + 0x30; 0x004ce07f mov edx, r15d | edx = r15d; 0x004ce082 sub edx, ebx | edx -= ebx; 0x004ce084 not rbx | rbx = ~rbx; 0x004ce087 add rbx, r15 | rbx += r15; 0x004ce08a and rdx, 7 | rdx &= 7; | if (rdx == 0) { 0x004ce08e je 0x4ce0ab | goto label_43; | } | do { 0x004ce090 movsx rdi, byte [rcx] | rdi = *(rcx); 0x004ce094 mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004ce09c mov qword [rax], rdi | *(rax) = rdi; 0x004ce09f inc rcx | rcx++; 0x004ce0a2 add rax, 8 | rax += 8; 0x004ce0a6 dec rdx | rdx--; 0x004ce0a9 jne 0x4ce090 | | } while (rdx != 0); | label_43: 0x004ce0ab cmp rbx, 7 | | if (rbx < 7) { 0x004ce0af jb 0x4ce170 | goto label_41; | } 0x004ce0b5 lea rdx, [rsp + r15 + 0x30] | rdx = rsp + r15 + 0x30; 0x004ce0ba xor ebx, ebx | ebx = 0; 0x004ce0bc nop dword [rax] | | do { 0x004ce0c0 movsx rdi, byte [rcx + rbx] | rdi = *((rcx + rbx)); 0x004ce0c5 mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004ce0cd mov qword [rax + rbx*8], rdi | *((rax + rbx*8)) = rdi; 0x004ce0d1 movsx rdi, byte [rcx + rbx + 1] | rdi = *((rcx + rbx + 1)); 0x004ce0d7 mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004ce0df mov qword [rax + rbx*8 + 8], rdi | *((rax + rbx*8 + 8)) = rdi; 0x004ce0e4 movsx rdi, byte [rcx + rbx + 2] | rdi = *((rcx + rbx + 2)); 0x004ce0ea mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004ce0f2 mov qword [rax + rbx*8 + 0x10], rdi | *((rax + rbx*8 + 0x10)) = rdi; 0x004ce0f7 movsx rdi, byte [rcx + rbx + 3] | rdi = *((rcx + rbx + 3)); 0x004ce0fd mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004ce105 mov qword [rax + rbx*8 + 0x18], rdi | *((rax + rbx*8 + 0x18)) = rdi; 0x004ce10a movsx rdi, byte [rcx + rbx + 4] | rdi = *((rcx + rbx + 4)); 0x004ce110 mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004ce118 mov qword [rax + rbx*8 + 0x20], rdi | *((rax + rbx*8 + 0x20)) = rdi; 0x004ce11d movsx rdi, byte [rcx + rbx + 5] | rdi = *((rcx + rbx + 5)); 0x004ce123 mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004ce12b mov qword [rax + rbx*8 + 0x28], rdi | *((rax + rbx*8 + 0x28)) = rdi; 0x004ce130 movsx rdi, byte [rcx + rbx + 6] | rdi = *((rcx + rbx + 6)); 0x004ce136 mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004ce13e mov qword [rax + rbx*8 + 0x30], rdi | *((rax + rbx*8 + 0x30)) = rdi; 0x004ce143 movsx rdi, byte [rcx + rbx + 7] | rdi = *((rcx + rbx + 7)); 0x004ce149 mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004ce151 mov qword [rax + rbx*8 + 0x38], rdi | *((rax + rbx*8 + 0x38)) = rdi; 0x004ce156 lea rdi, [rcx + rbx + 8] | rdi = rcx + rbx + 8; 0x004ce15b add rbx, 8 | rbx += 8; 0x004ce15f cmp rdi, rdx | 0x004ce162 jne 0x4ce0c0 | | } while (rdi != rdx); 0x004ce168 nop dword [rax + rax] | | label_41: 0x004ce170 cmp byte [rip + 0x24a819], 0 | | if (*(obj.veryVerbose) != 0) { 0x004ce177 je 0x4ce19b | 0x004ce179 mov edx, dword [rip + 0x24a825] | edx = numCopyCtorCalls; 0x004ce17f sub edx, r12d | edx -= r12d; 0x004ce182 mov ecx, dword [rip + 0x24a824] | ecx = numCharCtorCalls; 0x004ce188 sub ecx, dword [rsp + 0x20] | ecx -= *((rsp + 0x20)); 0x004ce18c mov edi, 0x4f5db4 | 0x004ce191 mov esi, r14d | esi = r14d; 0x004ce194 xor eax, eax | eax = 0; 0x004ce196 call 0x401680 | eax = printf ("LINE = %d, #copy ctors = %d, #char ctors = %d.\n"); | } | label_40: 0x004ce19b cmp r12d, dword [rip + 0x24a802] | | if (r12d == *(obj.numCopyCtorCalls)) { 0x004ce1a2 je 0x4cdd10 | goto label_6; | } 0x004ce1a8 mov edi, 0x4f4e04 | 0x004ce1ad mov edx, 0x4f5176 | edx = "NUM_COPIES == numCopyCtorCalls"; 0x004ce1b2 mov esi, 0x103f | esi = 0x103f; 0x004ce1b7 xor eax, eax | eax = 0; 0x004ce1b9 call 0x401680 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s (failed)\n"); 0x004ce1be mov eax, dword [rip + 0x24a7d4] | eax = (anonymous namespace)::testStatus; 0x004ce1c4 cmp eax, 0x64 | | if (eax > 0x64) { 0x004ce1c7 ja 0x4cdd10 | goto label_6; | } 0x004ce1cd inc eax | eax++; 0x004ce1cf mov dword [rip + 0x24a7c3], eax | *(obj._anonymous_namespace_::testStatus) = eax; 0x004ce1d5 jmp 0x4cdd10 | goto label_6; | label_37: 0x004ce1da mov eax, 1 | eax = 1; 0x004ce1df mov qword [rsp + 0x18], rax | *((rsp + 0x18)) = rax; 0x004ce1e4 mov rax, qword [rip + 0x2830cd] | rax = BloombergLP::bslma::Default::s_defaultAllocator; 0x004ce1eb test rax, rax | | if (rax != 0) { 0x004ce1ee jne 0x4cded5 | goto label_7; | } 0x004ce1f4 call 0x4eede0 | BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() (); 0x004ce1f9 jmp 0x4cded5 | goto label_7; | label_31: 0x004ce25a add rsp, 0x58 | 0x004ce25e pop rbx | 0x004ce25f pop r12 | 0x004ce261 pop r13 | 0x004ce263 pop r14 | 0x004ce265 pop r15 | 0x004ce267 pop rbp | 0x004ce268 ret | return rax; | }