hackbunny fucked around with this message at 21:24 on Nov 8, 2013

void do_first_thing(Bar *b) {
    Foo f;
    heres_how_you_destroy f(b);
    throw std::exception();
}

shrughes fucked around with this message at 00:30 on Nov 9, 2013

#include <mutex>
#include <iostream>

using namespace std;

class Butt
{
    public:
        void fart()
        {
            unique_lock< mutex > lock( m_mutex );
            cout << "lol butts\n";
        }

    private:
        char m_somestuff[256];
        mutex m_mutex;    
};

int main( int argc, char** argv )
{
    Butt b;
    b.fart();
}

template <class _Mutex>
class unique_lock
{
public:
    typedef _Mutex mutex_type;

private:
    mutex_type* __m_;
    bool __owns_;

public:
    explicit unique_lock(mutex_type& __m)
        : __m_(&__m), __owns_(true)
    {
      __m_->lock();
    }

    ~unique_lock()
    {
        if (__owns_)
            __m_->unlock();
    }

main:                                   # @main
-> main bc the butt ctor and the fart function were inlined

	pushq	%r14
	pushq	%rbx

	subq	$296, %rsp              # imm = 0x128
-> this is where the butt is allocated on the stack by subtracting its size

	leaq	256(%rsp), %rbx
-> rsp = butt. rsp + 256 = the m_mutex member within the butt. that __m_ mutex pointer that you wanted to get rid of with your ridiculous
solution is actually stored directly into the rbx register

	xorps	%xmm0, %xmm0
	movups	%xmm0, 272(%rsp)
	movups	%xmm0, 256(%rsp)
	movq	$0, 288(%rsp)
-> here's the part of butt's ctor where the fields are initialized. this was probably a memset call in mutex's constructor that clang replaced
with a few instructions that clear a 128 bits register and write it in memory to clear 16 bytes at a time

	movq	%rbx, %rdi
	callq	_ZNSt3__15mutex4lockEv
-> here's the call to mutex::lock(), directly passing rbx as its this pointer
wait, where did that unique_lock instance even go? turns out clang figured it could split that small class into two variable each containing one of its fields
and then other optimizations got rid of those variables. like that __owns_ poo poo? it was just set to true on the only code path through the function so clang
figured it was loving useless and completely removed it from existence


	movl	$_ZNSt3__14coutE, %edi
	movl	$.L.str, %esi
	callq	_ZNSt3__1lsINS_11char_traitsIcEEEERNS_13basic_ostreamIcT_EES6_PKc
-> the cout call

	movq	%rbx, %rdi
	callq	_ZNSt3__15mutex6unlockEv
-> release the mutex, directly reusing the mutex address that is still in rbx to call mutex::unlock()

	movq	%rbx, %rdi
	callq	_ZNSt3__15mutexD1Ev
-> call the mutex destructor

	xorl	%eax, %eax
-> clear eax to do the return 0 that i forgot like a noob

	addq	$296, %rsp              # imm = 0x128
	popq	%rbx
	popq	%r14
	ret

Zlodo fucked around with this message at 01:36 on Nov 9, 2013