; assembly                                                                                                                                                                                                                               | /* r2dec pseudo code output */
                                                                                                                                                                                                                                             | /* bdlcc_sharedobjectpool.t/none @ 0x409210 */
                                                                                                                                                                                                                                             | #include <stdint.h>
                                                                                                                                                                                                                                             |  
    ; (fcn) method.BloombergLP::bdlcc.ObjectPool__anonymous_namespace_::SpLink__bsl::function_void__void__BloombergLP::bslma::Allocator____BloombergLP::bdlcc::ObjectPoolFunctors::Nil__anonymous_namespace_::SpLink___::getObject__ ()      | int64_t method_BloombergLP::bdlcc_ObjectPool_anonymous_namespace_::SpLink_bsl::function_void_void_BloombergLP::bslma::Allocator_BloombergLP::bdlcc::ObjectPoolFunctors::Nil_anonymous_namespace_::SpLink_::getObject_ (int64_t arg1) {
                                                                                                                                                                                                                                             |     int64_t var_4h;
                                                                                                                                                                                                                                             |     int64_t var_8h;
                                                                                                                                                                                                                                             |     int64_t var_10h;
                                                                                                                                                                                                                                             |     int64_t var_18h;
                                                                                                                                                                                                                                             |     int64_t var_20h;
                                                                                                                                                                                                                                             |     rdi = arg1;
                                                                                                                                                                                                                                             |     /* BloombergLP::bdlcc::ObjectPool<(anonymous namespace)::SpLink, bsl::function<void (void*, BloombergLP::bslma::Allocator*)>, BloombergLP::bdlcc::ObjectPoolFunctors::Nil<(anonymous namespace)::SpLink> >::getObject() */
    0x00409210 push rbp                                                                                                                                                                                                                      |     
    0x00409211 push r15                                                                                                                                                                                                                      |     
    0x00409213 push r14                                                                                                                                                                                                                      |     
    0x00409215 push r13                                                                                                                                                                                                                      |     
    0x00409217 push r12                                                                                                                                                                                                                      |     
    0x00409219 push rbx                                                                                                                                                                                                                      |     
    0x0040921a sub rsp, 0x28                                                                                                                                                                                                                 |     
    0x0040921e mov rbp, rdi                                                                                                                                                                                                                  |     
    0x00409221 lea r14, [rdi + 0x90]                                                                                                                                                                                                         |     r14 = rdi + 0x90;
    0x00409228 lea r15, [rdi + 0x78]                                                                                                                                                                                                         |     r15 = rdi + 0x78;
    0x0040922c lea r12, [rdi + 0x10]                                                                                                                                                                                                         |     r12 = rdi + 0x10;
                                                                                                                                                                                                                                             | label_1:
    0x00409230 mov rbx, qword [rbp + 8]                                                                                                                                                                                                      |     rbx = *((rbp + 8));
    0x00409234 test rbx, rbx                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (rbx == 0) {
    0x00409237 je 0x4092a2                                                                                                                                                                                                                   |         goto label_4;
                                                                                                                                                                                                                                             |     }
                                                                                                                                                                                                                                             | label_2:
    0x00409239 mov eax, 2                                                                                                                                                                                                                    |     eax = 2;
    0x0040923e lock xadd dword [rbx + 8], eax                                                                                                                                                                                                |     __asm ("lock xadd dword [rbx + 8], eax");
    0x00409243 test eax, eax                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (eax != 0) {
    0x00409245 jne 0x4092c0                                                                                                                                                                                                                  |         goto label_5;
                                                                                                                                                                                                                                             |     }
                                                                                                                                                                                                                                             | label_3:
    0x00409247 mov rax, qword [rbp + 8]                                                                                                                                                                                                      |     rax = *((rbp + 8));
    0x0040924b mov qword [rsp + 0x10], rax                                                                                                                                                                                                   |     *((rsp + 0x10)) = rax;
    0x00409250 mov rax, qword [rsp + 0x10]                                                                                                                                                                                                   |     rax = *((rsp + 0x10));
    0x00409255 cmp rax, rbx                                                                                                                                                                                                                  |     
                                                                                                                                                                                                                                             |     if (rax != rbx) {
    0x00409258 jne 0x40928a                                                                                                                                                                                                                  |         goto label_0;
                                                                                                                                                                                                                                             |     }
    0x0040925a mov rax, qword [rsp + 0x10]                                                                                                                                                                                                   |     rax = *((rsp + 0x10));
    0x0040925f mov rcx, qword [rax]                                                                                                                                                                                                          |     rcx = *(rax);
    0x00409262 mov rax, rbx                                                                                                                                                                                                                  |     rax = rbx;
    0x00409265 lock cmpxchg qword [rbp + 8], rcx                                                                                                                                                                                             |     __asm ("lock cmpxchg qword [rbp + 8], rcx");
    0x0040926b cmp rbx, rax                                                                                                                                                                                                                  |     
                                                                                                                                                                                                                                             |     if (rbx == rax) {
    0x0040926e je 0x4093dd                                                                                                                                                                                                                   |         goto label_6;
                                                                                                                                                                                                                                             |     }
    0x00409274 jmp 0x40928a                                                                                                                                                                                                                  |     
                                                                                                                                                                                                                                             |     while ((cl & 1) != 0) {
    0x00409276 mov edx, ecx                                                                                                                                                                                                                  |         edx = ecx;
    0x00409278 xor edx, 1                                                                                                                                                                                                                    |         edx ^= 1;
    0x0040927b mov eax, ecx                                                                                                                                                                                                                  |         eax = ecx;
    0x0040927d lock cmpxchg dword [rbx + 8], edx                                                                                                                                                                                             |         __asm ("lock cmpxchg dword [rbx + 8], edx");
    0x00409282 cmp ecx, eax                                                                                                                                                                                                                  |         
                                                                                                                                                                                                                                             |         if (ecx == eax) {
    0x00409284 je 0x4093dd                                                                                                                                                                                                                   |             goto label_6;
                                                                                                                                                                                                                                             |         }
                                                                                                                                                                                                                                             | label_0:
    0x0040928a mov ecx, dword [rbx + 8]                                                                                                                                                                                                      |         ecx = *((rbx + 8));
    0x0040928d test cl, 1                                                                                                                                                                                                                    |         
    0x00409290 jne 0x409276                                                                                                                                                                                                                  |         
                                                                                                                                                                                                                                             |     }
    0x00409292 lea edx, [rcx - 2]                                                                                                                                                                                                            |     edx = rcx - 2;
    0x00409295 mov eax, ecx                                                                                                                                                                                                                  |     eax = ecx;
    0x00409297 lock cmpxchg dword [rbx + 8], edx                                                                                                                                                                                             |     __asm ("lock cmpxchg dword [rbx + 8], edx");
    0x0040929c cmp ecx, eax                                                                                                                                                                                                                  |     
                                                                                                                                                                                                                                             |     if (ecx != eax) {
    0x0040929e jne 0x40928a                                                                                                                                                                                                                  |         goto label_0;
                                                                                                                                                                                                                                             |     }
    0x004092a0 jmp 0x409230                                                                                                                                                                                                                  |     goto label_1;
                                                                                                                                                                                                                                             | label_4:
    0x004092a2 mov rdi, r14                                                                                                                                                                                                                  |     rdi = r14;
    0x004092a5 call 0x403a50                                                                                                                                                                                                                 |     pthread_mutex_lock ();
    0x004092aa mov rbx, qword [rbp + 8]                                                                                                                                                                                                      |     rbx = *((rbp + 8));
    0x004092ae test rbx, rbx                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (rbx == 0) {
    0x004092b1 je 0x4092e3                                                                                                                                                                                                                   |         goto label_7;
                                                                                                                                                                                                                                             |     }
    0x004092b3 mov rdi, r14                                                                                                                                                                                                                  |     rdi = r14;
    0x004092b6 call 0x403b00                                                                                                                                                                                                                 |     pthread_mutex_unlock ();
    0x004092bb jmp 0x409239                                                                                                                                                                                                                  |     goto label_2;
                                                                                                                                                                                                                                             | label_5:
    0x004092c0 mov rax, qword [rbp + 8]                                                                                                                                                                                                      |     rax = *((rbp + 8));
    0x004092c4 cmp rbx, rax                                                                                                                                                                                                                  |     
                                                                                                                                                                                                                                             |     if (rbx != rax) {
    0x004092c7 jne 0x409247                                                                                                                                                                                                                  |         goto label_3;
                                                                                                                                                                                                                                             |     }
    0x004092cd mov rax, qword [rbp + 8]                                                                                                                                                                                                      |     rax = *((rbp + 8));
    0x004092d1 cmp rbx, rax                                                                                                                                                                                                                  |     
                                                                                                                                                                                                                                             |     if (rbx != rax) {
    0x004092d4 jne 0x409247                                                                                                                                                                                                                  |         goto label_3;
                                                                                                                                                                                                                                             |     }
    0x004092da mov rax, qword [rbp + 8]                                                                                                                                                                                                      |     rax = *((rbp + 8));
    0x004092de jmp 0x409247                                                                                                                                                                                                                  |     goto label_3;
                                                                                                                                                                                                                                             | label_7:
    0x004092e3 mov r13d, dword [rbp + 0x64]                                                                                                                                                                                                  |     r13d = *((rbp + 0x64));
    0x004092e7 mov ebx, r13d                                                                                                                                                                                                                 |     ebx = *((rbp + 0x64));
    0x004092ea neg ebx                                                                                                                                                                                                                       |     ebx = -ebx;
                                                                                                                                                                                                                                             |     if (rbx < rax) {
    0x004092ec cmovl ebx, r13d                                                                                                                                                                                                               |         ebx = r13d;
                                                                                                                                                                                                                                             |     }
    0x004092f0 mov eax, ebx                                                                                                                                                                                                                  |     eax = ebx;
    0x004092f2 shl eax, 5                                                                                                                                                                                                                    |     eax <<= 5;
    0x004092f5 or eax, 0x10                                                                                                                                                                                                                  |     eax |= 0x10;
    0x004092f8 movsxd rsi, eax                                                                                                                                                                                                               |     rsi = (int64_t) eax;
    0x004092fb mov rdi, r15                                                                                                                                                                                                                  |     
    0x004092fe call 0x410520                                                                                                                                                                                                                 |     BloombergLP::bdlma::InfrequentDeleteBlockList::allocate(unsigned long) (r15, rsi);
    0x00409303 mov rcx, qword [rbp + 0x70]                                                                                                                                                                                                   |     rcx = *((rbp + 0x70));
    0x00409307 mov qword [rax], rcx                                                                                                                                                                                                          |     *(rax) = rcx;
    0x0040930a mov dword [rsp + 4], ebx                                                                                                                                                                                                      |     *((rsp + 4)) = ebx;
    0x0040930e mov dword [rax + 8], ebx                                                                                                                                                                                                      |     *((rax + 8)) = ebx;
    0x00409311 lea rbx, [rax + 0x10]                                                                                                                                                                                                         |     rbx = rax + 0x10;
    0x00409315 mov qword [rsp + 0x18], rbx                                                                                                                                                                                                   |     *((rsp + 0x18)) = rbx;
    0x0040931a test r13d, r13d                                                                                                                                                                                                               |     
                                                                                                                                                                                                                                             |     if (r13d == 0) {
    0x0040931d je 0x409387                                                                                                                                                                                                                   |         goto label_8;
                                                                                                                                                                                                                                             |     }
    0x0040931f mov ecx, dword [rsp + 4]                                                                                                                                                                                                      |     ecx = *((rsp + 4));
    0x00409323 neg ecx                                                                                                                                                                                                                       |     ecx = -ecx;
    0x00409325 mov qword [rsp + 0x20], rcx                                                                                                                                                                                                   |     *((rsp + 0x20)) = rcx;
    0x0040932a mov r13d, 1                                                                                                                                                                                                                   |     r13d = 1;
    0x00409330 mov qword [rsp + 8], rax                                                                                                                                                                                                      |     *((rsp + 8)) = rax;
    0x00409335 mov rbx, rax                                                                                                                                                                                                                  |     rbx = rax;
                                                                                                                                                                                                                                             |     do {
    0x00409338 lea rax, [rbx + 0x30]                                                                                                                                                                                                         |         rax = rbx + 0x30;
    0x0040933c mov qword [rbx + 0x10], rax                                                                                                                                                                                                   |         *((rbx + 0x10)) = rax;
    0x00409340 mov dword [rbx + 0x18], 0                                                                                                                                                                                                     |         *((rbx + 0x18)) = 0;
    0x00409347 mov rax, qword [rbp + 0x50]                                                                                                                                                                                                   |         rax = *((rbp + 0x50));
    0x0040934b test rax, rax                                                                                                                                                                                                                 |         
                                                                                                                                                                                                                                             |         if (rax == 0) {
    0x0040934e je 0x4093fe                                                                                                                                                                                                                   |             goto label_9;
                                                                                                                                                                                                                                             |         }
    0x00409354 mov rdx, qword [rbp + 0x88]                                                                                                                                                                                                   |         rdx = *((rbp + 0x88));
    0x0040935b add rbx, 0x20                                                                                                                                                                                                                 |         rbx += 0x20;
    0x0040935f mov rdi, r12                                                                                                                                                                                                                  |         rdi = r12;
    0x00409362 mov rsi, rbx                                                                                                                                                                                                                  |         rsi = rbx;
    0x00409365 call rax                                                                                                                                                                                                                      |         void (*rax)() ();
    0x00409367 mov rax, qword [rsp + 0x20]                                                                                                                                                                                                   |         rax = *((rsp + 0x20));
    0x0040936c lea eax, [rax + r13 + 1]                                                                                                                                                                                                      |         eax = rax + r13 + 1;
    0x00409371 mov ecx, r13d                                                                                                                                                                                                                 |         ecx = r13d;
    0x00409374 inc ecx                                                                                                                                                                                                                       |         ecx++;
    0x00409376 mov r13d, ecx                                                                                                                                                                                                                 |         r13d = ecx;
    0x00409379 cmp eax, 1                                                                                                                                                                                                                    |         
    0x0040937c jne 0x409338                                                                                                                                                                                                                  |         
                                                                                                                                                                                                                                             |     } while (eax != 1);
    0x0040937e add rbx, 0x10                                                                                                                                                                                                                 |     rbx += 0x10;
    0x00409382 mov rax, qword [rsp + 8]                                                                                                                                                                                                      |     rax = *((rsp + 8));
                                                                                                                                                                                                                                             | label_8:
    0x00409387 mov dword [rbx - 0x18], 0                                                                                                                                                                                                     |     *((rbx - 0x18)) = 0;
    0x0040938e mov qword [rbp + 0x70], rax                                                                                                                                                                                                   |     *((rbp + 0x70)) = rax;
    0x00409392 mov rdx, qword [rsp + 0x18]                                                                                                                                                                                                   |     rdx = *((rsp + 0x18));
                                                                                                                                                                                                                                             |     do {
    0x00409397 mov rcx, qword [rbp + 8]                                                                                                                                                                                                      |         rcx = *((rbp + 8));
    0x0040939b mov qword [rbx - 0x20], rcx                                                                                                                                                                                                   |         *((rbx - 0x20)) = rcx;
    0x0040939f mov rax, rcx                                                                                                                                                                                                                  |         rax = rcx;
    0x004093a2 lock cmpxchg qword [rbp + 8], rdx                                                                                                                                                                                             |         __asm ("lock cmpxchg qword [rbp + 8], rdx");
    0x004093a8 cmp rcx, rax                                                                                                                                                                                                                  |         
    0x004093ab jne 0x409397                                                                                                                                                                                                                  |         
                                                                                                                                                                                                                                             |     } while (rcx != rax);
    0x004093ad mov eax, dword [rsp + 4]                                                                                                                                                                                                      |     eax = *((rsp + 4));
    0x004093b1 lock add dword [rbp + 0x6c], eax                                                                                                                                                                                              |     *((rbp + 0x6c)) += eax;
    0x004093b5 lock add dword [rbp + 0x68], eax                                                                                                                                                                                              |     *((rbp + 0x68)) += eax;
    0x004093b9 mov eax, dword [rbp + 0x64]                                                                                                                                                                                                   |     eax = *((rbp + 0x64));
    0x004093bc test eax, eax                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (eax < 0) {
    0x004093be jns 0x4093d0                                                                                                                                                                                                                  |         
    0x004093c0 mov ecx, eax                                                                                                                                                                                                                  |         ecx = eax;
    0x004093c2 neg ecx                                                                                                                                                                                                                       |         ecx = -ecx;
    0x004093c4 lea edx, [rax + rax]                                                                                                                                                                                                          |         edx = rax + rax;
    0x004093c7 cmp eax, 0xffffffe0                                                                                                                                                                                                           |         
                                                                                                                                                                                                                                             |         if (eax <= 0xffffffe0) {
    0x004093ca cmovle edx, ecx                                                                                                                                                                                                               |             edx = ecx;
                                                                                                                                                                                                                                             |         }
    0x004093cd mov dword [rbp + 0x64], edx                                                                                                                                                                                                   |         *((rbp + 0x64)) = edx;
                                                                                                                                                                                                                                             |     }
    0x004093d0 mov rdi, r14                                                                                                                                                                                                                  |     rdi = r14;
    0x004093d3 call 0x403b00                                                                                                                                                                                                                 |     pthread_mutex_unlock ();
    0x004093d8 jmp 0x409230                                                                                                                                                                                                                  |     goto label_1;
                                                                                                                                                                                                                                             | label_6:
    0x004093dd mov qword [rbx], 0                                                                                                                                                                                                            |     *(rbx) = 0;
    0x004093e4 lock dec dword [rbp + 0x68]                                                                                                                                                                                                   |     *((rbp + 0x68))--;
    0x004093e8 add rbx, 0x10                                                                                                                                                                                                                 |     rbx += 0x10;
    0x004093ec mov rax, rbx                                                                                                                                                                                                                  |     rax = rbx;
    0x004093ef add rsp, 0x28                                                                                                                                                                                                                 |     
    0x004093f3 pop rbx                                                                                                                                                                                                                       |     
    0x004093f4 pop r12                                                                                                                                                                                                                       |     
    0x004093f6 pop r13                                                                                                                                                                                                                       |     
    0x004093f8 pop r14                                                                                                                                                                                                                       |     
    0x004093fa pop r15                                                                                                                                                                                                                       |     
    0x004093fc pop rbp                                                                                                                                                                                                                       |     
    0x004093fd ret                                                                                                                                                                                                                           |     return rax;
                                                                                                                                                                                                                                             | label_9:
    0x004093fe mov edi, 8                                                                                                                                                                                                                    |     edi = 8;
    0x00409403 call 0x403690                                                                                                                                                                                                                 |     cxa_allocate_exception ();
    0x00409408 mov qword [rax], 0x439bc0                                                                                                                                                                                                     |     *(rax) = fcn.00403950;
    0x0040940f mov esi, 0x439b98                                                                                                                                                                                                             |     
    0x00409414 mov edx, 0x403950                                                                                                                                                                                                             |     
    0x00409419 mov rdi, rax                                                                                                                                                                                                                  |     
    0x0040941c call 0x403740                                                                                                                                                                                                                 |     return cxa_throw (rax, obj.typeinfo_for_std::__1::bad_function_call, fcn.00403950);
                                                                                                                                                                                                                                             | }