; assembly | /* r2dec pseudo code output */ | /* bslalg_arrayprimitives.t/assume @ 0x4cc790 */ | #include | ; (fcn) sym.void_testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_ () | uint64_t void_testCopyConstructWithIterators_FnPtrConvertibleType_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) */ 0x004cc790 push rbp | 0x004cc791 push r15 | 0x004cc793 push r14 | 0x004cc795 push r13 | 0x004cc797 push r12 | 0x004cc799 push rbx | 0x004cc79a sub rsp, 0x68 | 0x004cc79e mov dword [rsp + 0x3c], edx | *((rsp + 0x3c)) = edx; 0x004cc7a2 mov dword [rsp + 0x54], esi | *((rsp + 0x54)) = esi; 0x004cc7a6 cmp byte [rip + 0x24c1e9], 0 | | if (*(obj.verbose) != 0) { 0x004cc7ad je 0x4cc7b9 | 0x004cc7af mov edi, 0x4f67e9 | 0x004cc7b4 call 0x401710 | puts ("\t\tfrom same type."); | } 0x004cc7b9 xor r13d, r13d | r13d = 0; 0x004cc7bc jmp 0x4cc7e7 | goto label_10; | label_1: 0x004cc7c0 mov edi, 0x74fa60 | edi = testCopyConstructWithIterators(bool, bool, bool)::u; 0x004cc7c5 mov rsi, rbp | rsi = rbp; 0x004cc7c8 call 0x4e3d80 | voidverify(FnPtrConvertibleType*,char const*) (); 0x004cc7cd mov edi, 0x74fa60 | edi = testCopyConstructWithIterators(bool, bool, bool)::u; 0x004cc7d2 mov rsi, rbp | rsi = rbp; 0x004cc7d5 call 0x4e3fe0 | voidcleanup(FnPtrConvertibleType*,char const*) (); 0x004cc7da inc r13 | r13++; 0x004cc7dd cmp r13, 0x1e | | if (r13 == 0x1e) { 0x004cc7e1 je 0x4ccec6 | goto label_11; | } | label_10: 0x004cc7e7 mov qword [rsp + 0x28], r13 | *((rsp + 0x28)) = r13; 0x004cc7ec lea rbp, [r13*8] | rbp = r13*8; 0x004cc7f4 mov r12, qword [rbp + rbp*4 + 0x4f3b08] | r12 = *((rbp + rbp*4 + 0x4f3b08)); 0x004cc7fc mov rdi, r12 | 0x004cc7ff call 0x401790 | eax = strlen (*((rbp + rbp*4 + 0x4f3b08))); 0x004cc804 cmp eax, 0x11 | | if (eax >= 0x11) { 0x004cc807 jl 0x4cc832 | 0x004cc809 mov edi, 0x4f4c78 | 0x004cc80e mov edx, 0x4f4203 | edx = "MAX_SIZE >= (int)std::strlen(SPEC)"; 0x004cc813 mov esi, 0xfe6 | esi = 0xfe6; 0x004cc818 xor eax, eax | eax = 0; 0x004cc81a call 0x401680 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s (failed)\n"); 0x004cc81f mov eax, dword [rip + 0x24c173] | eax = (anonymous namespace)::testStatus; 0x004cc825 cmp eax, 0x64 | | if (eax > 0x64) { 0x004cc828 ja 0x4cc832 | goto label_12; | } 0x004cc82a inc eax | eax++; 0x004cc82c mov dword [rip + 0x24c166], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_12: 0x004cc832 mov r13d, dword [rbp + rbp*4 + 0x4f3b00] | r13d = *((rbp + rbp*4 + obj.DATA_3)); 0x004cc83a movsxd r15, dword [rbp + rbp*4 + 0x4f3b10] | r15 = *((rbp + rbp*4 + 0x4f3b10)); 0x004cc842 mov ebx, dword [rbp + rbp*4 + 0x4f3b14] | ebx = *((rbp + rbp*4 + 0x4f3b14)); 0x004cc849 movsxd r14, dword [rbp + rbp*4 + 0x4f3b18] | r14 = *((rbp + rbp*4 + 0x4f3b18)); 0x004cc851 mov rbp, qword [rbp + rbp*4 + 0x4f3b20] | rbp = *((rbp + rbp*4 + 0x4f3b20)); 0x004cc859 cmp byte [rip + 0x24c130], 0 | | if (*(obj.veryVerbose) != 0) { 0x004cc860 je 0x4cc881 | 0x004cc862 mov qword [rsp], rbp | *(rsp) = rbp; 0x004cc866 mov edi, 0x4f5ab7 | 0x004cc86b mov esi, r13d | esi = r13d; 0x004cc86e mov rdx, r12 | rdx = r12; 0x004cc871 mov ecx, r15d | ecx = r15d; 0x004cc874 mov r8d, ebx | r8d = ebx; 0x004cc877 mov r9d, r14d | r9d = r14d; 0x004cc87a xor eax, eax | eax = 0; 0x004cc87c call 0x401680 | printf ("LINE = %d, SPEC = %s, SRC = %d, NE = %d, DST = %d, EXP = %s\n"); | } 0x004cc881 mov dword [rsp + 0x18], r13d | *((rsp + 0x18)) = r13d; 0x004cc886 mov qword [rsp + 0x30], rbx | *((rsp + 0x30)) = rbx; 0x004cc88b mov edi, 0x74fa60 | edi = testCopyConstructWithIterators(bool, bool, bool)::u; 0x004cc890 mov rsi, r12 | rsi = r12; 0x004cc893 call 0x4e3c80 | FnPtrConvertibleType&gg(FnPtrConvertibleType*,char const*) (); 0x004cc898 mov edi, 0x74fa60 | edi = testCopyConstructWithIterators(bool, bool, bool)::u; 0x004cc89d mov rsi, r12 | rsi = r12; 0x004cc8a0 call 0x4e3d80 | voidverify(FnPtrConvertibleType*,char const*) (); 0x004cc8a5 mov ebx, dword [rip + 0x24c0f9] | ebx = numCopyCtorCalls; 0x004cc8ab mov r12d, dword [rip + 0x24c0fa] | r12d = numCharCtorCalls; 0x004cc8b2 cmp byte [rsp + 0x3c], 0 | | if (*((rsp + 0x3c)) != 0) { 0x004cc8b7 je 0x4cc980 | 0x004cc8bd cmp byte [rip + 0x24c0cc], 0 | 0x004cc8c4 mov r13, qword [rsp + 0x28] | r13 = *((rsp + 0x28)); | if (*(obj.veryVerbose) != 0) { 0x004cc8c9 je 0x4cc8de | 0x004cc8cb cmp dword [rip + 0x24bce6], 0 | | if (*(obj.testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::firstTime) == 0) { 0x004cc8d2 je 0x4cc8de | goto label_13; | } 0x004cc8d4 mov edi, 0x4f425a | 0x004cc8d9 call 0x401710 | puts ("\t\tBSLMA EXCEPTION TEST -- (ENABLED) --"); | } | label_13: 0x004cc8de mov dword [rip + 0x24bcd0], 0 | *(obj.testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::firstTime) = 0; 0x004cc8e8 cmp byte [rip + 0x24c0a6], 0 | | if (*(obj.veryVeryVerbose) != 0) { 0x004cc8ef je 0x4cc8fb | 0x004cc8f1 mov edi, 0x4f4281 | 0x004cc8f6 call 0x401710 | puts ("\t\tBegin bslma exception test."); | } 0x004cc8fb mov rax, qword [rip + 0x24bf1e] | rax = Z; 0x004cc902 mov qword [rsp + 0x40], 0x4f6858 | *((rsp + 0x40)) = vtable.BloombergLP::bslma::TestAllocator_Proxy_BloombergLP::bslma::TestAllocator_.0; 0x004cc90b mov qword [rsp + 0x48], rax | *((rsp + 0x48)) = rax; 0x004cc910 mov qword [rax + 0x20], 0 | *((rax + 0x20)) = 0; 0x004cc918 test rax, rax | | if (rax == 0) { 0x004cc91b je 0x4ccb16 | goto label_14; | } | label_0: 0x004cc921 cmp r13, 6 | | if (r13 < 6) { 0x004cc925 jb 0x4ccd0e | goto label_15; | } 0x004cc92b mov r11d, ebx | r11d = ebx; 0x004cc92e mov qword [rsp + 0x20], rbp | *((rsp + 0x20)) = rbp; 0x004cc933 lea rax, [r15*8 + 0x74fa60] | rax = r15*8 + obj_testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u; 0x004cc93b lea rdi, [r15*8] | rdi = r15*8; 0x004cc943 lea rcx, [r14*8 + 0x74fa60] | rcx = r14*8 + obj_testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u; 0x004cc94b mov ebp, dword [rip + 0x24c053] | ebp = numCopyCtorCalls; 0x004cc951 mov rbx, qword [rsp + 0x30] | rbx = *((rsp + 0x30)); 0x004cc956 lea edx, [rbx + r15] | edx = rbx + r15; 0x004cc95a movsxd r10, edx | r10 = (int64_t) edx; 0x004cc95d shl r10, 3 | r10 <<= 3; 0x004cc961 mov rsi, r10 | rsi = r10; 0x004cc964 sub rsi, rdi | rsi -= rdi; 0x004cc967 add rsi, 0xfffffffffffffff8 | rsi += 0xfffffffffffffff8; 0x004cc96b cmp rsi, 0x18 | | if (rsi >= 0x18) { 0x004cc96f jae 0x4ccb96 | goto label_16; | } 0x004cc975 mov ebx, r11d | ebx = r11d; 0x004cc978 jmp 0x4ccce0 | goto label_17; | } 0x004cc980 cmp qword [rip + 0x24be98], 0 | 0x004cc988 mov r13, qword [rsp + 0x28] | r13 = *((rsp + 0x28)); | if (*(obj.Z) == 0) { 0x004cc98d jne 0x4cc9a0 | 0x004cc98f mov rax, qword [rip + 0x284922] | rax = BloombergLP::bslma::Default::s_defaultAllocator; 0x004cc996 test rax, rax | | if (rax != 0) { 0x004cc999 jne 0x4cc9a0 | goto label_18; | } 0x004cc99b call 0x4eec50 | BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() (); | } | label_18: 0x004cc9a0 cmp r13, 6 | 0x004cc9a4 mov esi, dword [rsp + 0x18] | esi = *((rsp + 0x18)); | if (r13 < 6) { 0x004cc9a8 jb 0x4ccd4c | goto label_19; | } 0x004cc9ae mov dword [rsp + 0x14], ebx | *((rsp + 0x14)) = ebx; 0x004cc9b2 mov qword [rsp + 0x20], rbp | *((rsp + 0x20)) = rbp; 0x004cc9b7 mov rax, qword [rsp + 0x30] | rax = *((rsp + 0x30)); 0x004cc9bc add eax, r15d | eax += r15d; 0x004cc9bf lea rdi, [r15*8 + 0x74fa60] | rdi = r15*8 + obj_testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u; 0x004cc9c7 cdqe | rax = (int64_t) eax; 0x004cc9c9 lea rcx, [r14*8 + 0x74fa60] | rcx = r14*8 + obj_testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u; 0x004cc9d1 mov ebp, dword [rip + 0x24bfcd] | ebp = numCopyCtorCalls; 0x004cc9d7 lea r13, [rax*8] | r13 = rax*8; 0x004cc9df lea rbx, [r15*8] | rbx = r15*8; 0x004cc9e7 mov rdx, r13 | rdx = r13; 0x004cc9ea sub rdx, rbx | rdx -= rbx; 0x004cc9ed lea r10, [rdx - 8] | r10 = rdx - 8; 0x004cc9f1 cmp r10, 0x18 | | if (r10 < 0x18) { 0x004cc9f5 jb 0x4cce50 | goto label_20; | } 0x004cc9fb lea rbx, [r14*8 + 0x74fa60] | rbx = r14*8 + obj_testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u; 0x004cca03 lea rax, [rax*8 + 0x74fa60] | rax = rax*8 + obj_testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u; 0x004cca0b cmp rbx, rax | | if (rbx < rax) { 0x004cca0e jae 0x4cca29 | 0x004cca10 lea rax, [rdx + r14*8 + 0x74fa60] | rax = rdx + r14*8 + obj_testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u; 0x004cca18 lea rdx, [r15*8 + 0x74fa60] | rdx = r15*8 + obj_testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u; 0x004cca20 cmp rdx, rax | | if (rdx < rax) { 0x004cca23 jb 0x4cce50 | goto label_20; | } | } 0x004cca29 shr r10, 3 | r10 >>= 3; 0x004cca2d inc r10 | r10++; 0x004cca30 mov r8, r10 | r8 = r10; 0x004cca33 movabs rax, 0x3ffffffffffffffc | rax = 0x3ffffffffffffffc; 0x004cca3d and r8, rax | r8 &= rax; 0x004cca40 movd xmm0, ebp | xmm0 = ebp; 0x004cca44 lea rax, [r8 - 4] | rax = r8 - 4; 0x004cca48 mov r9, rax | r9 = rax; 0x004cca4b shr r9, 2 | r9 >>= 2; 0x004cca4f inc r9 | r9++; 0x004cca52 test rax, rax | | if (rax == 0) { 0x004cca55 je 0x4cce99 | goto label_21; | } 0x004cca5b mov rsi, r9 | rsi = r9; 0x004cca5e and rsi, 0xfffffffffffffffe | rsi &= 0xfffffffffffffffe; 0x004cca62 neg rsi | rsi = -rsi; 0x004cca65 pxor xmm1, xmm1 | xmm1 = 0; 0x004cca69 mov rax, rdi | rax = rdi; 0x004cca6c xor ebp, ebp | ebp = 0; 0x004cca6e movdqa xmm4, xmmword [rip + 0x2389a] | __asm ("movdqa xmm4, xmmword [0x004f0310]"); 0x004cca76 nop word cs:[rax + rax] | | do { 0x004cca80 movups xmm2, xmmword [rax] | __asm ("movups xmm2, xmmword [rax]"); 0x004cca83 movups xmm3, xmmword [rax + 0x10] | __asm ("movups xmm3, xmmword [rax + 0x10]"); 0x004cca87 lea rbx, [r14*8] | rbx = r14*8; 0x004cca8f movups xmmword [rbx + rbp*8 + 0x74fa60], xmm2 | __asm ("movups xmmword [rbx + rbp*8 + obj.testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u], xmm2"); 0x004cca97 movups xmmword [rbx + rbp*8 + 0x74fa70], xmm3 | __asm ("movups xmmword [rbx + rbp*8 + 0x74fa70], xmm3"); 0x004cca9f movdqu xmm2, xmmword [rax + 0x20] | __asm ("movdqu xmm2, xmmword [rax + 0x20]"); 0x004ccaa4 movups xmm3, xmmword [rax + 0x30] | __asm ("movups xmm3, xmmword [rax + 0x30]"); 0x004ccaa8 movdqu xmmword [rbx + rbp*8 + 0x74fa80], xmm2 | __asm ("movdqu xmmword [rbx + rbp*8 + 0x74fa80], xmm2"); 0x004ccab1 movups xmmword [rbx + rbp*8 + 0x74fa90], xmm3 | __asm ("movups xmmword [rbx + rbp*8 + 0x74fa90], xmm3"); 0x004ccab9 paddd xmm0, xmm4 | __asm ("paddd xmm0, xmm4"); 0x004ccabd paddd xmm1, xmm4 | __asm ("paddd xmm1, xmm4"); 0x004ccac1 add rbp, 8 | rbp += 8; 0x004ccac5 add rax, 0x40 | rax += 0x40; 0x004ccac9 add rsi, 2 | rsi += 2; 0x004ccacd jne 0x4cca80 | | } while (rsi != 0); 0x004ccacf test r9b, 1 | | if ((r9b & 1) != 0) { 0x004ccad3 je 0x4ccaf3 | | label_4: 0x004ccad5 movdqu xmm2, xmmword [rax] | __asm ("movdqu xmm2, xmmword [rax]"); 0x004ccad9 movups xmm3, xmmword [rax + 0x10] | __asm ("movups xmm3, xmmword [rax + 0x10]"); 0x004ccadd movdqu xmmword [rcx + rbp*8], xmm2 | __asm ("movdqu xmmword [rcx + rbp*8], xmm2"); 0x004ccae2 movups xmmword [rcx + rbp*8 + 0x10], xmm3 | __asm ("movups xmmword [rcx + rbp*8 + 0x10], xmm3"); 0x004ccae7 pcmpeqd xmm2, xmm2 | __asm ("pcmpeqd xmm2, xmm2"); 0x004ccaeb psubd xmm1, xmm2 | __asm ("psubd xmm1, xmm2"); 0x004ccaef psubd xmm0, xmm2 | __asm ("psubd xmm0, xmm2"); | } | label_5: 0x004ccaf3 paddd xmm0, xmm1 | __asm ("paddd xmm0, xmm1"); 0x004ccaf7 pshufd xmm1, xmm0, 0x55 | __asm ("pshufd xmm1, xmm0, 0x55"); 0x004ccafc paddd xmm1, xmm0 | __asm ("paddd xmm1, xmm0"); 0x004ccb00 movd ebp, xmm1 | 0x004ccb04 cmp r10, r8 | | if (r10 != r8) { 0x004ccb07 jne 0x4cce44 | goto label_22; | } 0x004ccb0d mov esi, dword [rsp + 0x18] | esi = *((rsp + 0x18)); 0x004ccb11 jmp 0x4cce73 | goto label_23; | label_14: 0x004ccb16 mov eax, 1 | eax = 1; 0x004ccb1b mov qword [rsp + 0x20], rax | *((rsp + 0x20)) = rax; 0x004ccb20 mov rax, qword [rip + 0x284791] | rax = BloombergLP::bslma::Default::s_defaultAllocator; 0x004ccb27 test rax, rax | | if (rax != 0) { 0x004ccb2a jne 0x4cc921 | goto label_0; | } 0x004ccb30 call 0x4eec50 | rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() (); 0x004ccb35 jmp 0x4cc921 | goto label_0; | label_16: 0x004ccb96 mov dword [rsp + 0x14], r12d | *((rsp + 0x14)) = r12d; 0x004ccb9b lea r8, [r14*8 + 0x74fa60] | r8 = r14*8 + obj_testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u; 0x004ccba3 add ebx, r15d | ebx += r15d; 0x004ccba6 movsxd rbx, ebx | rbx = (int64_t) ebx; 0x004ccba9 lea rdx, [rbx*8 + 0x74fa60] | rdx = rbx*8 + obj_testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u; 0x004ccbb1 cmp r8, rdx | | if (r8 < rdx) { 0x004ccbb4 jae 0x4ccbdf | 0x004ccbb6 shl rbx, 3 | rbx <<= 3; 0x004ccbba sub rbx, rdi | rbx -= rdi; 0x004ccbbd lea rdx, [rbx + r14*8 + 0x74fa60] | rdx = rbx + r14*8 + obj_testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u; 0x004ccbc5 lea rbx, [r15*8 + 0x74fa60] | rbx = r15*8 + obj_testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u; 0x004ccbcd cmp rbx, rdx | | if (rbx >= rdx) { 0x004ccbd0 jae 0x4ccbdf | goto label_24; | } 0x004ccbd2 mov r12d, dword [rsp + 0x14] | r12d = *((rsp + 0x14)); 0x004ccbd7 mov ebx, r11d | ebx = r11d; 0x004ccbda jmp 0x4ccce0 | goto label_17; | } | label_24: 0x004ccbdf shr rsi, 3 | rsi >>= 3; 0x004ccbe3 inc rsi | rsi++; 0x004ccbe6 mov r8, rsi | r8 = rsi; 0x004ccbe9 movabs rdx, 0x3ffffffffffffffc | rdx = 0x3ffffffffffffffc; 0x004ccbf3 and r8, rdx | r8 &= rdx; 0x004ccbf6 movd xmm0, ebp | xmm0 = ebp; 0x004ccbfa lea rdx, [r8 - 4] | rdx = r8 - 4; 0x004ccbfe mov r9, rdx | r9 = rdx; 0x004ccc01 shr r9, 2 | r9 >>= 2; 0x004ccc05 inc r9 | r9++; 0x004ccc08 test rdx, rdx | | if (rdx == 0) { 0x004ccc0b je 0x4cceb1 | goto label_25; | } 0x004ccc11 mov rbx, r9 | rbx = r9; 0x004ccc14 and rbx, 0xfffffffffffffffe | rbx &= 0xfffffffffffffffe; 0x004ccc18 neg rbx | rbx = -rbx; 0x004ccc1b pxor xmm1, xmm1 | xmm1 = 0; 0x004ccc1f xor ebp, ebp | ebp = 0; 0x004ccc21 movdqa xmm4, xmmword [rip + 0x236e7] | __asm ("movdqa xmm4, xmmword [0x004f0310]"); 0x004ccc29 nop dword [rax] | | do { 0x004ccc30 movups xmm2, xmmword [rdi + rbp*8 + 0x74fa60] | __asm ("movups xmm2, xmmword [rdi + rbp*8 + obj.testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u]"); 0x004ccc38 movups xmm3, xmmword [rdi + rbp*8 + 0x74fa70] | __asm ("movups xmm3, xmmword [rdi + rbp*8 + 0x74fa70]"); 0x004ccc40 lea rdx, [r14*8] | rdx = r14*8; 0x004ccc48 movups xmmword [rdx + rbp*8 + 0x74fa60], xmm2 | __asm ("movups xmmword [rdx + rbp*8 + obj.testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u], xmm2"); 0x004ccc50 movups xmmword [rdx + rbp*8 + 0x74fa70], xmm3 | __asm ("movups xmmword [rdx + rbp*8 + 0x74fa70], xmm3"); 0x004ccc58 movdqu xmm2, xmmword [rdi + rbp*8 + 0x74fa80] | __asm ("movdqu xmm2, xmmword [rdi + rbp*8 + 0x74fa80]"); 0x004ccc61 movups xmm3, xmmword [rdi + rbp*8 + 0x74fa90] | __asm ("movups xmm3, xmmword [rdi + rbp*8 + 0x74fa90]"); 0x004ccc69 movdqu xmmword [rdx + rbp*8 + 0x74fa80], xmm2 | __asm ("movdqu xmmword [rdx + rbp*8 + 0x74fa80], xmm2"); 0x004ccc72 movups xmmword [rdx + rbp*8 + 0x74fa90], xmm3 | __asm ("movups xmmword [rdx + rbp*8 + 0x74fa90], xmm3"); 0x004ccc7a paddd xmm0, xmm4 | __asm ("paddd xmm0, xmm4"); 0x004ccc7e paddd xmm1, xmm4 | __asm ("paddd xmm1, xmm4"); 0x004ccc82 add rbp, 8 | rbp += 8; 0x004ccc86 add rbx, 2 | rbx += 2; 0x004ccc8a jne 0x4ccc30 | | } while (rbx != 0); 0x004ccc8c test r9b, 1 | | if ((r9b & 1) != 0) { 0x004ccc90 je 0x4cccb2 | | label_6: 0x004ccc92 movdqu xmm2, xmmword [rax + rbp*8] | __asm ("movdqu xmm2, xmmword [rax + rbp*8]"); 0x004ccc97 movups xmm3, xmmword [rax + rbp*8 + 0x10] | __asm ("movups xmm3, xmmword [rax + rbp*8 + 0x10]"); 0x004ccc9c movdqu xmmword [rcx + rbp*8], xmm2 | __asm ("movdqu xmmword [rcx + rbp*8], xmm2"); 0x004ccca1 movups xmmword [rcx + rbp*8 + 0x10], xmm3 | __asm ("movups xmmword [rcx + rbp*8 + 0x10], xmm3"); 0x004ccca6 pcmpeqd xmm2, xmm2 | __asm ("pcmpeqd xmm2, xmm2"); 0x004cccaa psubd xmm1, xmm2 | __asm ("psubd xmm1, xmm2"); 0x004cccae psubd xmm0, xmm2 | __asm ("psubd xmm0, xmm2"); | } | label_7: 0x004cccb2 paddd xmm0, xmm1 | __asm ("paddd xmm0, xmm1"); 0x004cccb6 pshufd xmm1, xmm0, 0x55 | __asm ("pshufd xmm1, xmm0, 0x55"); 0x004cccbb paddd xmm1, xmm0 | __asm ("paddd xmm1, xmm0"); 0x004cccbf movd ebp, xmm1 | 0x004cccc3 cmp rsi, r8 | 0x004cccc6 mov r12d, dword [rsp + 0x14] | r12d = *((rsp + 0x14)); 0x004ccccb mov ebx, r11d | ebx = r11d; | if (rsi == r8) { 0x004cccce je 0x4ccd03 | goto label_26; | } 0x004cccd0 lea rax, [rax + r8*8] | rax = rax + r8*8; 0x004cccd4 lea rcx, [rcx + r8*8] | rcx = rcx + r8*8; 0x004cccd8 nop dword [rax + rax] | | label_17: 0x004ccce0 sub r10, rax | r10 -= rax; 0x004ccce3 lea rdx, [r10 + 0x74fa60] | rdx = r10 + obj_testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u; 0x004cccea xor esi, esi | esi = 0; 0x004cccec nop dword [rax] | | do { 0x004cccf0 mov rdi, qword [rax + rsi] | rdi = *((rax + rsi)); 0x004cccf4 mov qword [rcx + rsi], rdi | *((rcx + rsi)) = rdi; 0x004cccf8 inc ebp | ebp++; 0x004cccfa add rsi, 8 | rsi += 8; 0x004cccfe cmp rdx, rsi | 0x004ccd01 jne 0x4cccf0 | | } while (rdx != rsi); | label_26: 0x004ccd03 mov dword [rip + 0x24bc9b], ebp | *(obj.numCopyCtorCalls) = ebp; 0x004ccd09 mov rbp, qword [rsp + 0x20] | rbp = *((rsp + 0x20)); | label_15: 0x004ccd0e mov rax, qword [rsp + 0x40] | rax = *((rsp + 0x40)); 0x004ccd13 lea rdi, [rsp + 0x40] | rdi = rsp + 0x40; 0x004ccd18 mov rsi, 0xffffffffffffffff | rsi = 0xffffffffffffffff; 0x004ccd1f call qword [rax + 0x10] | uint64_t (*rax + 0x10)() (); 0x004ccd22 cmp byte [rip + 0x24bc6c], 0 | | if (*(obj.veryVeryVerbose) != 0) { 0x004ccd29 je 0x4ccd35 | 0x004ccd2b mov edi, 0x4f43e1 | 0x004ccd30 call 0x401710 | puts ("\t\tEnd bslma exception test."); | } 0x004ccd35 cmp byte [rip + 0x24bc54], 0 | | if (*(obj.veryVerbose) != 0) { 0x004ccd3c je 0x4ccd72 | 0x004ccd3e mov edi, 0xa | 0x004ccd43 call 0x401720 | eax = putchar (0xa); 0x004ccd48 mov esi, dword [rsp + 0x18] | esi = *((rsp + 0x18)); | label_19: 0x004ccd4c cmp byte [rip + 0x24bc3d], 0 | | if (*(obj.veryVerbose) == 0) { 0x004ccd53 je 0x4ccd72 | goto label_3; | } | label_2: 0x004ccd55 mov edx, dword [rip + 0x24bc49] | edx = numCopyCtorCalls; 0x004ccd5b sub edx, ebx | edx -= ebx; 0x004ccd5d mov ecx, dword [rip + 0x24bc49] | ecx = numCharCtorCalls; 0x004ccd63 sub ecx, r12d | ecx -= r12d; 0x004ccd66 mov edi, 0x4f5c2a | 0x004ccd6b xor eax, eax | eax = 0; 0x004ccd6d call 0x401680 | eax = printf ("LINE = %d, #copy ctors = %d, #char ctors = %d.\n"); | } | label_3: 0x004ccd72 cmp byte [rsp + 0x54], 0 | | if (*((rsp + 0x54)) == 0) { 0x004ccd77 je 0x4ccdd0 | goto label_27; | } 0x004ccd79 cmp ebx, dword [rip + 0x24bc25] | | if (ebx != *(obj.numCopyCtorCalls)) { 0x004ccd7f je 0x4ccdaa | 0x004ccd81 mov edi, 0x4f4c78 | 0x004ccd86 mov edx, 0x4f4fec | edx = "NUM_COPIES == numCopyCtorCalls"; 0x004ccd8b mov esi, 0x1005 | esi = 0x1005; 0x004ccd90 xor eax, eax | eax = 0; 0x004ccd92 call 0x401680 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s (failed)\n"); 0x004ccd97 mov eax, dword [rip + 0x24bbfb] | eax = (anonymous namespace)::testStatus; 0x004ccd9d cmp eax, 0x64 | | if (eax > 0x64) { 0x004ccda0 ja 0x4ccdaa | goto label_28; | } 0x004ccda2 inc eax | eax++; 0x004ccda4 mov dword [rip + 0x24bbee], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_28: 0x004ccdaa cmp r12d, dword [rip + 0x24bbfb] | | if (r12d == *(obj.numCharCtorCalls)) { 0x004ccdb1 je 0x4cc7c0 | goto label_1; | } 0x004ccdb7 mov edi, 0x4f4c78 | edi = "Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s (failed)\n"; 0x004ccdbc mov edx, 0x4f5c5a | edx = "NUM_CTORS == numCharCtorCalls"; 0x004ccdc1 mov esi, 0x1006 | esi = 0x1006; 0x004ccdc6 jmp 0x4cce21 | goto label_29; | label_27: 0x004ccdd0 add ebx, dword [rsp + 0x30] | ebx += *((rsp + 0x30)); 0x004ccdd4 cmp ebx, dword [rip + 0x24bbca] | | if (ebx > *(obj.numCopyCtorCalls)) { 0x004ccdda jle 0x4cce05 | 0x004ccddc mov edi, 0x4f4c78 | 0x004ccde1 mov edx, 0x4f5c78 | edx = "NUM_COPIES + NE <= numCopyCtorCalls"; 0x004ccde6 mov esi, 0x1009 | esi = 0x1009; 0x004ccdeb xor eax, eax | eax = 0; 0x004ccded call 0x401680 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s (failed)\n"); 0x004ccdf2 mov eax, dword [rip + 0x24bba0] | eax = (anonymous namespace)::testStatus; 0x004ccdf8 cmp eax, 0x64 | | if (eax > 0x64) { 0x004ccdfb ja 0x4cce05 | goto label_30; | } 0x004ccdfd inc eax | eax++; 0x004ccdff mov dword [rip + 0x24bb93], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_30: 0x004cce05 cmp r12d, dword [rip + 0x24bba0] | | if (r12d == *(obj.numCharCtorCalls)) { 0x004cce0c je 0x4cc7c0 | goto label_1; | } 0x004cce12 mov edi, 0x4f4c78 | 0x004cce17 mov edx, 0x4f5c5a | edx = "NUM_CTORS == numCharCtorCalls"; 0x004cce1c mov esi, 0x100a | esi = 0x100a; | label_29: 0x004cce21 xor eax, eax | eax = 0; 0x004cce23 call 0x401680 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s (failed)\n"); 0x004cce28 mov eax, dword [rip + 0x24bb6a] | eax = (anonymous namespace)::testStatus; 0x004cce2e cmp eax, 0x64 | | if (eax > 0x64) { 0x004cce31 ja 0x4cc7c0 | goto label_1; | } 0x004cce37 inc eax | eax++; 0x004cce39 mov dword [rip + 0x24bb59], eax | *(obj._anonymous_namespace_::testStatus) = eax; 0x004cce3f jmp 0x4cc7c0 | goto label_1; | label_22: 0x004cce44 lea rdi, [rdi + r8*8] | rdi = rdi + r8*8; 0x004cce48 lea rcx, [rcx + r8*8] | rcx = rcx + r8*8; 0x004cce4c mov esi, dword [rsp + 0x18] | esi = *((rsp + 0x18)); | label_20: 0x004cce50 sub r13, rdi | r13 -= rdi; 0x004cce53 lea rax, [r13 + 0x74fa60] | rax = r13 + obj_testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u; 0x004cce5a xor edx, edx | edx = 0; 0x004cce5c nop dword [rax] | | do { 0x004cce60 mov rbx, qword [rdi + rdx] | rbx = *((rdi + rdx)); 0x004cce64 mov qword [rcx + rdx], rbx | *((rcx + rdx)) = rbx; 0x004cce68 inc ebp | ebp++; 0x004cce6a add rdx, 8 | rdx += 8; 0x004cce6e cmp rax, rdx | 0x004cce71 jne 0x4cce60 | | } while (rax != rdx); | label_23: 0x004cce73 mov dword [rip + 0x24bb2b], ebp | *(obj.numCopyCtorCalls) = ebp; 0x004cce79 mov rbp, qword [rsp + 0x20] | rbp = *((rsp + 0x20)); 0x004cce7e mov r13, qword [rsp + 0x28] | r13 = *((rsp + 0x28)); 0x004cce83 mov ebx, dword [rsp + 0x14] | ebx = *((rsp + 0x14)); 0x004cce87 cmp byte [rip + 0x24bb02], 0 | | if (*(obj.veryVerbose) != 0) { 0x004cce8e jne 0x4ccd55 | goto label_2; | } 0x004cce94 jmp 0x4ccd72 | goto label_3; | label_21: 0x004cce99 pxor xmm1, xmm1 | xmm1 = 0; 0x004cce9d mov rax, rdi | rax = rdi; 0x004ccea0 xor ebp, ebp | ebp = 0; 0x004ccea2 test r9b, 1 | | if ((r9b & 1) != 0) { 0x004ccea6 jne 0x4ccad5 | goto label_4; | } 0x004cceac jmp 0x4ccaf3 | goto label_5; | label_25: 0x004cceb1 pxor xmm1, xmm1 | xmm1 = 0; 0x004cceb5 xor ebp, ebp | ebp = 0; 0x004cceb7 test r9b, 1 | | if ((r9b & 1) != 0) { 0x004ccebb jne 0x4ccc92 | goto label_6; | } 0x004ccec1 jmp 0x4cccb2 | goto label_7; | label_11: 0x004ccec6 cmp byte [rip + 0x24bac9], 0 | | if (*(obj.verbose) != 0) { 0x004ccecd je 0x4cced9 | 0x004ccecf mov edi, 0x4f67d2 | 0x004cced4 call 0x401710 | puts ("\t\tfrom different type."); | } 0x004cced9 xor r13d, r13d | r13d = 0; 0x004ccedc jmp 0x4ccf07 | goto label_31; | label_8: 0x004ccee0 mov edi, 0x74fa60 | edi = testCopyConstructWithIterators(bool, bool, bool)::u; 0x004ccee5 mov rsi, rbp | rsi = rbp; 0x004ccee8 call 0x4e3d80 | voidverify(FnPtrConvertibleType*,char const*) (); 0x004cceed mov edi, 0x74fa60 | edi = testCopyConstructWithIterators(bool, bool, bool)::u; 0x004ccef2 mov rsi, rbp | rsi = rbp; 0x004ccef5 call 0x4e3fe0 | voidcleanup(FnPtrConvertibleType*,char const*) (); 0x004ccefa inc r13 | r13++; 0x004ccefd cmp r13, 0x1e | | if (r13 == 0x1e) { 0x004ccf01 je 0x4cd42a | goto label_32; | } | label_31: 0x004ccf07 lea rbp, [r13*8] | rbp = r13*8; 0x004ccf0f mov r12, qword [rbp + rbp*4 + 0x4f3b08] | r12 = *((rbp + rbp*4 + 0x4f3b08)); 0x004ccf17 mov rdi, r12 | 0x004ccf1a call 0x401790 | eax = strlen (*((rbp + rbp*4 + 0x4f3b08))); 0x004ccf1f cmp eax, 0x11 | | if (eax >= 0x11) { 0x004ccf22 jl 0x4ccf4d | 0x004ccf24 mov edi, 0x4f4c78 | 0x004ccf29 mov edx, 0x4f4203 | edx = "MAX_SIZE >= (int)std::strlen(SPEC)"; 0x004ccf2e mov esi, 0x1019 | esi = 0x1019; 0x004ccf33 xor eax, eax | eax = 0; 0x004ccf35 call 0x401680 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s (failed)\n"); 0x004ccf3a mov eax, dword [rip + 0x24ba58] | eax = (anonymous namespace)::testStatus; 0x004ccf40 cmp eax, 0x64 | | if (eax > 0x64) { 0x004ccf43 ja 0x4ccf4d | goto label_33; | } 0x004ccf45 inc eax | eax++; 0x004ccf47 mov dword [rip + 0x24ba4b], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_33: 0x004ccf4d mov rdi, r12 | 0x004ccf50 call 0x401790 | rax = strlen (r12); 0x004ccf55 cmp rax, 0x14 | | if (rax >= 0x14) { 0x004ccf59 jb 0x4ccf84 | 0x004ccf5b mov edi, 0x4f4c78 | 0x004ccf60 mov edx, 0x4f5c9c | edx = "SPEC_CE_LEN > std::strlen(SPEC)"; 0x004ccf65 mov esi, 0x101c | esi = 0x101c; 0x004ccf6a xor eax, eax | eax = 0; 0x004ccf6c call 0x401680 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s (failed)\n"); 0x004ccf71 mov eax, dword [rip + 0x24ba21] | eax = (anonymous namespace)::testStatus; 0x004ccf77 cmp eax, 0x64 | | if (eax > 0x64) { 0x004ccf7a ja 0x4ccf84 | goto label_34; | } 0x004ccf7c inc eax | eax++; 0x004ccf7e mov dword [rip + 0x24ba14], eax | *(obj._anonymous_namespace_::testStatus) = eax; | } | label_34: 0x004ccf84 mov qword [rsp + 0x28], r13 | *((rsp + 0x28)) = r13; 0x004ccf89 pxor xmm0, xmm0 | xmm0 = 0; 0x004ccf8d movdqa xmmword [rsp + 0x40], xmm0 | __asm ("movdqa xmmword [rsp + 0x40], xmm0"); 0x004ccf93 mov dword [rsp + 0x50], 0 | *((rsp + 0x50)) = 0; 0x004ccf9b mov al, byte [r12] | al = *(r12); 0x004ccf9f test al, al | | if (al == 0) { 0x004ccfa1 je 0x4ccfc1 | goto label_35; | } 0x004ccfa3 xor ecx, ecx | ecx = 0; 0x004ccfa5 nop word cs:[rax + rax] | 0x004ccfaf nop | | do { 0x004ccfb0 mov byte [rsp + rcx + 0x40], al | *((rsp + rcx + 0x40)) = al; 0x004ccfb4 movzx eax, byte [r12 + rcx + 1] | eax = *((r12 + rcx + 1)); 0x004ccfba inc rcx | rcx++; 0x004ccfbd test al, al | 0x004ccfbf jne 0x4ccfb0 | | } while (al != 0); | label_35: 0x004ccfc1 mov r14d, dword [rbp + rbp*4 + 0x4f3b00] | r14d = *((rbp + rbp*4 + obj.DATA_3)); 0x004ccfc9 movsxd rbx, dword [rbp + rbp*4 + 0x4f3b10] | rbx = *((rbp + rbp*4 + 0x4f3b10)); 0x004ccfd1 movsxd r15, dword [rbp + rbp*4 + 0x4f3b14] | r15 = *((rbp + rbp*4 + 0x4f3b14)); 0x004ccfd9 movsxd r13, dword [rbp + rbp*4 + 0x4f3b18] | r13 = *((rbp + rbp*4 + 0x4f3b18)); 0x004ccfe1 mov rbp, qword [rbp + rbp*4 + 0x4f3b20] | rbp = *((rbp + rbp*4 + 0x4f3b20)); 0x004ccfe9 cmp byte [rip + 0x24b9a0], 0 | | if (*(obj.veryVerbose) != 0) { 0x004ccff0 je 0x4cd010 | 0x004ccff2 mov qword [rsp], rbp | *(rsp) = rbp; 0x004ccff6 mov edi, 0x4f5ab7 | 0x004ccffb mov esi, r14d | esi = r14d; 0x004ccffe mov rdx, r12 | rdx = r12; 0x004cd001 mov ecx, ebx | ecx = ebx; 0x004cd003 mov r8d, r15d | r8d = r15d; 0x004cd006 mov r9d, r13d | r9d = r13d; 0x004cd009 xor eax, eax | eax = 0; 0x004cd00b call 0x401680 | printf ("LINE = %d, SPEC = %s, SRC = %d, NE = %d, DST = %d, EXP = %s\n"); | } 0x004cd010 mov edi, 0x74fa60 | edi = testCopyConstructWithIterators(bool, bool, bool)::u; 0x004cd015 mov rsi, r12 | rsi = r12; 0x004cd018 call 0x4e3c80 | FnPtrConvertibleType&gg(FnPtrConvertibleType*,char const*) (); 0x004cd01d mov edi, 0x74fa60 | edi = testCopyConstructWithIterators(bool, bool, bool)::u; 0x004cd022 mov rsi, r12 | rsi = r12; 0x004cd025 call 0x4e3d80 | voidverify(FnPtrConvertibleType*,char const*) (); 0x004cd02a mov r12d, dword [rip + 0x24b973] | r12d = numCopyCtorCalls; 0x004cd031 mov eax, dword [rip + 0x24b975] | eax = numCharCtorCalls; 0x004cd037 mov dword [rsp + 0x30], eax | *((rsp + 0x30)) = eax; 0x004cd03b cmp byte [rsp + 0x3c], 0 | | if (*((rsp + 0x3c)) == 0) { 0x004cd040 je 0x4cd200 | goto label_36; | } 0x004cd046 cmp byte [rip + 0x24b943], 0 | | if (*(obj.veryVerbose) != 0) { 0x004cd04d je 0x4cd062 | 0x004cd04f cmp dword [rip + 0x24b566], 0 | | if (*(0x007185bc) == 0) { 0x004cd056 je 0x4cd062 | goto label_37; | } 0x004cd058 mov edi, 0x4f425a | 0x004cd05d call 0x401710 | puts ("\t\tBSLMA EXCEPTION TEST -- (ENABLED) --"); | } | label_37: 0x004cd062 mov dword [rip + 0x24b550], 0 | *(0x007185bc) = 0; 0x004cd06c cmp byte [rip + 0x24b922], 0 | | if (*(obj.veryVeryVerbose) != 0) { 0x004cd073 je 0x4cd07f | 0x004cd075 mov edi, 0x4f4281 | 0x004cd07a call 0x401710 | puts ("\t\tBegin bslma exception test."); | } 0x004cd07f mov rax, qword [rip + 0x24b79a] | rax = Z; 0x004cd086 mov qword [rsp + 0x58], 0x4f6858 | *((rsp + 0x58)) = vtable.BloombergLP::bslma::TestAllocator_Proxy_BloombergLP::bslma::TestAllocator_.0; 0x004cd08f mov qword [rsp + 0x60], rax | *((rsp + 0x60)) = rax; 0x004cd094 mov qword [rax + 0x20], 0 | *((rax + 0x20)) = 0; 0x004cd09c test rax, rax | | if (rax == 0) { 0x004cd09f je 0x4cd3aa | goto label_38; | } | label_9: 0x004cd0a5 cmp qword [rsp + 0x28], 6 | | if (*((rsp + 0x28)) < 6) { 0x004cd0ab jb 0x4cd1b8 | goto label_39; | } 0x004cd0b1 add r15d, ebx | r15d += ebx; 0x004cd0b4 movsxd rax, r15d | rax = (int64_t) r15d; 0x004cd0b7 lea rcx, [rsp + rbx + 0x40] | rcx = rsp + rbx + 0x40; 0x004cd0bc lea rsi, [r13*8 + 0x74fa60] | rsi = r13*8 + obj_testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u; 0x004cd0c4 mov edx, eax | edx = eax; 0x004cd0c6 sub edx, ebx | edx -= ebx; 0x004cd0c8 not rbx | rbx = ~rbx; 0x004cd0cb add rbx, rax | rbx += rax; 0x004cd0ce and rdx, 7 | rdx &= 7; | if (rdx == 0) { 0x004cd0d2 je 0x4cd0fb | goto label_40; | } 0x004cd0d4 nop word cs:[rax + rax] | 0x004cd0de nop | | do { 0x004cd0e0 movsx rdi, byte [rcx] | rdi = *(rcx); 0x004cd0e4 mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004cd0ec mov qword [rsi], rdi | *(rsi) = rdi; 0x004cd0ef inc rcx | rcx++; 0x004cd0f2 add rsi, 8 | rsi += 8; 0x004cd0f6 dec rdx | rdx--; 0x004cd0f9 jne 0x4cd0e0 | | } while (rdx != 0); | label_40: 0x004cd0fb cmp rbx, 7 | | if (rbx < 7) { 0x004cd0ff jb 0x4cd1b8 | goto label_39; | } 0x004cd105 lea rax, [rsp + rax + 0x40] | rax = rsp + rax + 0x40; 0x004cd10a xor edi, edi | edi = 0; 0x004cd10c nop dword [rax] | | do { 0x004cd110 movsx rdx, byte [rcx + rdi] | rdx = *((rcx + rdi)); 0x004cd115 mov rdx, qword [rdx*8 + 0x7171d0] | rdx = *((rdx*8 + obj.funcPtrArray)); 0x004cd11d mov qword [rsi + rdi*8], rdx | *((rsi + rdi*8)) = rdx; 0x004cd121 movsx rdx, byte [rcx + rdi + 1] | rdx = *((rcx + rdi + 1)); 0x004cd127 mov rdx, qword [rdx*8 + 0x7171d0] | rdx = *((rdx*8 + obj.funcPtrArray)); 0x004cd12f mov qword [rsi + rdi*8 + 8], rdx | *((rsi + rdi*8 + 8)) = rdx; 0x004cd134 movsx rdx, byte [rcx + rdi + 2] | rdx = *((rcx + rdi + 2)); 0x004cd13a mov rdx, qword [rdx*8 + 0x7171d0] | rdx = *((rdx*8 + obj.funcPtrArray)); 0x004cd142 mov qword [rsi + rdi*8 + 0x10], rdx | *((rsi + rdi*8 + 0x10)) = rdx; 0x004cd147 movsx rdx, byte [rcx + rdi + 3] | rdx = *((rcx + rdi + 3)); 0x004cd14d mov rdx, qword [rdx*8 + 0x7171d0] | rdx = *((rdx*8 + obj.funcPtrArray)); 0x004cd155 mov qword [rsi + rdi*8 + 0x18], rdx | *((rsi + rdi*8 + 0x18)) = rdx; 0x004cd15a movsx rdx, byte [rcx + rdi + 4] | rdx = *((rcx + rdi + 4)); 0x004cd160 mov rdx, qword [rdx*8 + 0x7171d0] | rdx = *((rdx*8 + obj.funcPtrArray)); 0x004cd168 mov qword [rsi + rdi*8 + 0x20], rdx | *((rsi + rdi*8 + 0x20)) = rdx; 0x004cd16d movsx rdx, byte [rcx + rdi + 5] | rdx = *((rcx + rdi + 5)); 0x004cd173 mov rdx, qword [rdx*8 + 0x7171d0] | rdx = *((rdx*8 + obj.funcPtrArray)); 0x004cd17b mov qword [rsi + rdi*8 + 0x28], rdx | *((rsi + rdi*8 + 0x28)) = rdx; 0x004cd180 movsx rdx, byte [rcx + rdi + 6] | rdx = *((rcx + rdi + 6)); 0x004cd186 mov rdx, qword [rdx*8 + 0x7171d0] | rdx = *((rdx*8 + obj.funcPtrArray)); 0x004cd18e mov qword [rsi + rdi*8 + 0x30], rdx | *((rsi + rdi*8 + 0x30)) = rdx; 0x004cd193 movsx rdx, byte [rcx + rdi + 7] | rdx = *((rcx + rdi + 7)); 0x004cd199 mov rdx, qword [rdx*8 + 0x7171d0] | rdx = *((rdx*8 + obj.funcPtrArray)); 0x004cd1a1 mov qword [rsi + rdi*8 + 0x38], rdx | *((rsi + rdi*8 + 0x38)) = rdx; 0x004cd1a6 lea rdx, [rcx + rdi + 8] | rdx = rcx + rdi + 8; 0x004cd1ab add rdi, 8 | rdi += 8; 0x004cd1af cmp rdx, rax | 0x004cd1b2 jne 0x4cd110 | | } while (rdx != rax); | label_39: 0x004cd1b8 mov rax, qword [rsp + 0x58] | rax = *((rsp + 0x58)); 0x004cd1bd lea rdi, [rsp + 0x58] | rdi = rsp + 0x58; 0x004cd1c2 mov rsi, 0xffffffffffffffff | rsi = 0xffffffffffffffff; 0x004cd1c9 call qword [rax + 0x10] | uint64_t (*rax + 0x10)() (); 0x004cd1cc cmp byte [rip + 0x24b7c2], 0 | 0x004cd1d3 mov r13, qword [rsp + 0x28] | r13 = *((rsp + 0x28)); | if (*(obj.veryVeryVerbose) != 0) { 0x004cd1d8 je 0x4cd1e4 | 0x004cd1da mov edi, 0x4f43e1 | 0x004cd1df call 0x401710 | puts ("\t\tEnd bslma exception test."); | } 0x004cd1e4 cmp byte [rip + 0x24b7a5], 0 | | if (*(obj.veryVerbose) == 0) { 0x004cd1eb je 0x4cd36b | goto label_41; | } 0x004cd1f1 mov edi, 0xa | 0x004cd1f6 call 0x401720 | putchar (0xa); 0x004cd1fb jmp 0x4cd340 | goto label_42; | label_36: 0x004cd200 cmp qword [rip + 0x24b618], 0 | 0x004cd208 mov rcx, r13 | rcx = r13; | if (*(obj.Z) == 0) { 0x004cd20b jne 0x4cd230 | 0x004cd20d mov rax, qword [rip + 0x2840a4] | rax = BloombergLP::bslma::Default::s_defaultAllocator; 0x004cd214 test rax, rax | | if (rax != 0) { 0x004cd217 jne 0x4cd230 | goto label_43; | } 0x004cd219 call 0x4eec50 | BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() (); 0x004cd21e mov rcx, r13 | rcx = r13; 0x004cd221 nop word cs:[rax + rax] | 0x004cd22b nop dword [rax + rax] | | } | label_43: 0x004cd230 mov r13, qword [rsp + 0x28] | r13 = *((rsp + 0x28)); 0x004cd235 cmp r13, 6 | | if (r13 < 6) { 0x004cd239 jb 0x4cd340 | goto label_42; | } 0x004cd23f add r15, rbx | r15 += rbx; 0x004cd242 lea rax, [rcx*8 + 0x74fa60] | rax = rcx*8 + obj_testCopyConstructWithIterators_FnPtrConvertibleType__bool__bool__bool_::u; 0x004cd24a lea rcx, [rsp + rbx + 0x40] | rcx = rsp + rbx + 0x40; 0x004cd24f mov edx, r15d | edx = r15d; 0x004cd252 sub edx, ebx | edx -= ebx; 0x004cd254 not rbx | rbx = ~rbx; 0x004cd257 add rbx, r15 | rbx += r15; 0x004cd25a and rdx, 7 | rdx &= 7; | if (rdx == 0) { 0x004cd25e je 0x4cd27b | goto label_44; | } | do { 0x004cd260 movsx rdi, byte [rcx] | rdi = *(rcx); 0x004cd264 mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004cd26c mov qword [rax], rdi | *(rax) = rdi; 0x004cd26f inc rcx | rcx++; 0x004cd272 add rax, 8 | rax += 8; 0x004cd276 dec rdx | rdx--; 0x004cd279 jne 0x4cd260 | | } while (rdx != 0); | label_44: 0x004cd27b cmp rbx, 7 | | if (rbx < 7) { 0x004cd27f jb 0x4cd340 | goto label_42; | } 0x004cd285 lea rdx, [rsp + r15 + 0x40] | rdx = rsp + r15 + 0x40; 0x004cd28a xor ebx, ebx | ebx = 0; 0x004cd28c nop dword [rax] | | do { 0x004cd290 movsx rdi, byte [rcx + rbx] | rdi = *((rcx + rbx)); 0x004cd295 mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004cd29d mov qword [rax + rbx*8], rdi | *((rax + rbx*8)) = rdi; 0x004cd2a1 movsx rdi, byte [rcx + rbx + 1] | rdi = *((rcx + rbx + 1)); 0x004cd2a7 mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004cd2af mov qword [rax + rbx*8 + 8], rdi | *((rax + rbx*8 + 8)) = rdi; 0x004cd2b4 movsx rdi, byte [rcx + rbx + 2] | rdi = *((rcx + rbx + 2)); 0x004cd2ba mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004cd2c2 mov qword [rax + rbx*8 + 0x10], rdi | *((rax + rbx*8 + 0x10)) = rdi; 0x004cd2c7 movsx rdi, byte [rcx + rbx + 3] | rdi = *((rcx + rbx + 3)); 0x004cd2cd mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004cd2d5 mov qword [rax + rbx*8 + 0x18], rdi | *((rax + rbx*8 + 0x18)) = rdi; 0x004cd2da movsx rdi, byte [rcx + rbx + 4] | rdi = *((rcx + rbx + 4)); 0x004cd2e0 mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004cd2e8 mov qword [rax + rbx*8 + 0x20], rdi | *((rax + rbx*8 + 0x20)) = rdi; 0x004cd2ed movsx rdi, byte [rcx + rbx + 5] | rdi = *((rcx + rbx + 5)); 0x004cd2f3 mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004cd2fb mov qword [rax + rbx*8 + 0x28], rdi | *((rax + rbx*8 + 0x28)) = rdi; 0x004cd300 movsx rdi, byte [rcx + rbx + 6] | rdi = *((rcx + rbx + 6)); 0x004cd306 mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004cd30e mov qword [rax + rbx*8 + 0x30], rdi | *((rax + rbx*8 + 0x30)) = rdi; 0x004cd313 movsx rdi, byte [rcx + rbx + 7] | rdi = *((rcx + rbx + 7)); 0x004cd319 mov rdi, qword [rdi*8 + 0x7171d0] | rdi = *((rdi*8 + obj.funcPtrArray)); 0x004cd321 mov qword [rax + rbx*8 + 0x38], rdi | *((rax + rbx*8 + 0x38)) = rdi; 0x004cd326 lea rdi, [rcx + rbx + 8] | rdi = rcx + rbx + 8; 0x004cd32b add rbx, 8 | rbx += 8; 0x004cd32f cmp rdi, rdx | 0x004cd332 jne 0x4cd290 | | } while (rdi != rdx); 0x004cd338 nop dword [rax + rax] | | label_42: 0x004cd340 cmp byte [rip + 0x24b649], 0 | | if (*(obj.veryVerbose) != 0) { 0x004cd347 je 0x4cd36b | 0x004cd349 mov edx, dword [rip + 0x24b655] | edx = numCopyCtorCalls; 0x004cd34f sub edx, r12d | edx -= r12d; 0x004cd352 mov ecx, dword [rip + 0x24b654] | ecx = numCharCtorCalls; 0x004cd358 sub ecx, dword [rsp + 0x30] | ecx -= *((rsp + 0x30)); 0x004cd35c mov edi, 0x4f5c2a | 0x004cd361 mov esi, r14d | esi = r14d; 0x004cd364 xor eax, eax | eax = 0; 0x004cd366 call 0x401680 | eax = printf ("LINE = %d, #copy ctors = %d, #char ctors = %d.\n"); | } | label_41: 0x004cd36b cmp r12d, dword [rip + 0x24b632] | | if (r12d == *(obj.numCopyCtorCalls)) { 0x004cd372 je 0x4ccee0 | goto label_8; | } 0x004cd378 mov edi, 0x4f4c78 | 0x004cd37d mov edx, 0x4f4fec | edx = "NUM_COPIES == numCopyCtorCalls"; 0x004cd382 mov esi, 0x103f | esi = 0x103f; 0x004cd387 xor eax, eax | eax = 0; 0x004cd389 call 0x401680 | printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s (failed)\n"); 0x004cd38e mov eax, dword [rip + 0x24b604] | eax = (anonymous namespace)::testStatus; 0x004cd394 cmp eax, 0x64 | | if (eax > 0x64) { 0x004cd397 ja 0x4ccee0 | goto label_8; | } 0x004cd39d inc eax | eax++; 0x004cd39f mov dword [rip + 0x24b5f3], eax | *(obj._anonymous_namespace_::testStatus) = eax; 0x004cd3a5 jmp 0x4ccee0 | goto label_8; | label_38: 0x004cd3aa mov eax, 1 | eax = 1; 0x004cd3af mov qword [rsp + 0x18], rax | *((rsp + 0x18)) = rax; 0x004cd3b4 mov rax, qword [rip + 0x283efd] | rax = BloombergLP::bslma::Default::s_defaultAllocator; 0x004cd3bb test rax, rax | | if (rax != 0) { 0x004cd3be jne 0x4cd0a5 | goto label_9; | } 0x004cd3c4 call 0x4eec50 | BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() (); 0x004cd3c9 jmp 0x4cd0a5 | goto label_9; | label_32: 0x004cd42a add rsp, 0x68 | 0x004cd42e pop rbx | 0x004cd42f pop r12 | 0x004cd431 pop r13 | 0x004cd433 pop r14 | 0x004cd435 pop r15 | 0x004cd437 pop rbp | 0x004cd438 ret | return rax; | }