E: Failed to fetch http://llvm.org/apt/precise/pool/main/l/llvm-toolchain-3.8/libllvm3.8_3.8~svn269657-1~exp1_amd64.deb  404  Not Found
E: Unable to fetch some archives, maybe run apt-get update or try with --fix-missing?
apt-get.diagnostics
apt-get install failed

        // Increments the number of node's parents that will evaluate the node
        // through the Node<T>::CodeGen() method. The node will be evaluated
        // only once, but the result will also be stored in cache with a
        // matching number of references. The cache will be released once all
        // parents evaluate the node.
        // IMPORTANT: Currently, there's an assumption that if a node is created,
        // it must be placed inside the tree. TODO: Remove this assumption and
        // allow for optimizing away unused nodes.
        void IncrementParentCount();

    // TODO: Perhaps this should return a Data*.
    // If nothing is displaced, returns nullptr.
    // Otherwise returns Data* for displaced.
    template <unsigned SIZE>
    void ExpressionTree::FreeList<SIZE>::Allocate(unsigned id)
    {

    // TODO: Need to avoid "static initialization order fiasco" for register definitions.
    // See http://www.parashift.com/c++-faq/static-init-order.html.
    // Plan is to use constexpr when VS2013 becomes available to Bing build.

// TODO: This class and PackedMinMaxNode should probably move from NativeJIT to BitFunnel.Library.

        // Integer parameters are passed in RCX, RDX, R8, and R9.
        // Use constants to encode registers. See #31.
#ifdef NATIVEJIT_PLATFORM_WINDOWS
        const uint8_t idMap[] = {1, 2, 8, 9};
#else
        const uint8_t idMap[] = {7, 6, 2, 1, 8, 9};
#endif

==13082== Mismatched free() / delete / delete []
==13082==    at 0x4C2F24B: operator delete(void*) (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==13082==    by 0x538D3A: std::default_delete<char>::operator()(char*) const (unique_ptr.h:76)
==13082==    by 0x538AC2: std::unique_ptr<char, std::default_delete<char> >::~unique_ptr() (unique_ptr.h:236)
==13082==    by 0x538833: NativeJIT::Allocator::~Allocator() (Allocator.cpp:48)
==13082==    by 0x488005: NativeJIT::TestFixture::~TestFixture() (in /home/leah/dev/NativeJIT/build-make/test/CodeGen/CodeGenTest)
==13082==    by 0x487F94: NativeJIT::CodeGenUnitTest::CodeGen::~CodeGen() (in /home/leah/dev/NativeJIT/build-make/test/CodeGen/CodeGenTest)
==13082==    by 0x487DC4: NativeJIT::CodeGenUnitTest::CodeGen_JCC_Test::~CodeGen_JCC_Test() (in /home/leah/dev/NativeJIT/build-make/test/CodeGen/CodeGenTest)
==13082==    by 0x487DE8: NativeJIT::CodeGenUnitTest::CodeGen_JCC_Test::~CodeGen_JCC_Test() (in /home/leah/dev/NativeJIT/build-make/test/CodeGen/CodeGenTest)
==13082==    by 0x568B3A: testing::Test::DeleteSelf_() (in /home/leah/dev/NativeJIT/build-make/test/CodeGen/CodeGenTest)
==13082==    by 0x57E7C9: void testing::internal::HandleSehExceptionsInMethodIfSupported<testing::Test, void>(testing::Test*, void (testing::Test::*)(), char const*) (in /home/leah/dev/Nativ
eJIT/build-make/test/CodeGen/CodeGenTest)
==13082==    by 0x568256: void testing::internal::HandleExceptionsInMethodIfSupported<testing::Test, void>(testing::Test*, void (testing::Test::*)(), char const*) (gtest.cc:2438)
==13082==    by 0x54D688: testing::TestInfo::Run() (gtest.cc:2661)
==13082==  Address 0x5cedf80 is 0 bytes inside a block of size 8,192 alloc'd
==13082==    at 0x4C2E80F: operator new[](unsigned long) (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==13082==    by 0x53875B: NativeJIT::Allocator::Allocator(unsigned long) (Allocator.cpp:40)
==13082==    by 0x53826A: NativeJIT::TestFixture::TestFixture(unsigned int, unsigned int, std::ostream*) (TestSetup.cpp:52)
==13082==    by 0x5381B5: NativeJIT::TestFixture::TestFixture() (TestSetup.cpp:39)
==13082==    by 0x487F5E: NativeJIT::CodeGenUnitTest::CodeGen::CodeGen() (CodeGenTest.cpp:40)
==13082==    by 0x487F1E: NativeJIT::CodeGenUnitTest::CodeGen_JCC_Test::CodeGen_JCC_Test() (CodeGenTest.cpp:46)
==13082==    by 0x487ECD: testing::internal::TestFactoryImpl<NativeJIT::CodeGenUnitTest::CodeGen_JCC_Test>::CreateTest() (in /home/leah/dev/NativeJIT/build-make/test/CodeGen/CodeGenTest)
==13082==    by 0x57E8F9: testing::Test* testing::internal::HandleSehExceptionsInMethodIfSupported<testing::internal::TestFactoryBase, testing::Test*>(testing::internal::TestFactoryBase*, te
sting::Test* (testing::internal::TestFactoryBase::*)(), char const*) (in /home/leah/dev/NativeJIT/build-make/test/CodeGen/CodeGenTest)
==13082==    by 0x5688A6: testing::Test* testing::internal::HandleExceptionsInMethodIfSupported<testing::internal::TestFactoryBase, testing::Test*>(testing::internal::TestFactoryBase*, testi
ng::Test* (testing::internal::TestFactoryBase::*)(), char const*) (gtest.cc:2438)
==13082==    by 0x54D61B: testing::TestInfo::Run() (gtest.cc:2647)
==13082==    by 0x54DE26: testing::TestCase::Run() (gtest.cc:2774)
==13082==    by 0x556093: testing::internal::UnitTestImpl::RunAllTests() (gtest.cc:4649)

        //   Test register save/restore across call.
        //      Caller save volatiles
        //   Test call register indirect.
        //   Test that tries all permutations of parameter from Function to Call.

mov r15, 5
mov rax, r15

    Function<float, float> expression(allocator, code);
    auto & rsquared = expression.Mul(expression.GetP1(), expression.GetP1());
    const float  PI = 3.14159265358979f;
    auto & area = expression.Mul(rsquared, expression.Immediate(PI));
    auto function = expression.Compile(area);

sub    rsp, 28h                     
mov    qword ptr[rsp], rbp
movaps xmmword ptr[rsp + 10h], xmm15
lea    rbp, [rsp + 28h]

movss  xmm15, xmm0                  
mulss  xmm15, xmm0                  
mulss  xmm15, dword ptr[PI_CONSTANT]
movss  xmm0, xmm15                  

movaps xmm15, xmmword ptr[rsp + 10h]
mov    rbp, qword ptr[rsp]
add    rsp, 28h
ret

mulss  xmm0, xmm0                  
mulss  xmm0, dword ptr[PI_CONSTANT]

/home/travis/build/BitFunnel/NativeJIT/src/CodeGen/FunctionBuffer.cpp: In member function ‘virtual void NativeJIT::FunctionBuffer::Reset()’:
/home/travis/build/BitFunnel/NativeJIT/src/CodeGen/FunctionBuffer.cpp:243:27: error: missing initializer for member ‘RUNTIME_FUNCTION::BeginAddress’ [-Werror=missing-field-initializers]
         m_runtimeFunction = {};
                           ^
/home/travis/build/BitFunnel/NativeJIT/src/CodeGen/FunctionBuffer.cpp:243:27: error: missing initializer for member ‘RUNTIME_FUNCTION::EndAddress’ [-Werror=missing-field-initializers]
/home/travis/build/BitFunnel/NativeJIT/src/CodeGen/FunctionBuffer.cpp:243:27: error: missing initializer for member ‘RUNTIME_FUNCTION::UnwindData’ [-Werror=missing-field-initializers]

    // WARNING: Non portable. Assumes little endian machine architecture.                                                                                                                
    // WARNING: Non portable. Assumes that fixup value is labelAddress - siteAddress - size.Size().                                                                                      
    void JumpTable::PatchCallSites()
    {                                                                                                                                                                            
        for (size_t i=0; i < m_callSites.size(); ++i)
        {                                                                                                                                                                        
            const CallSite& site = m_callSites[i];
            const uint8_t* labelAddress = AddressOfLabel(site.GetLabel());
            uint8_t* siteAddress = site.Site();
            size_t delta = labelAddress - siteAddress - site.Size();

            // TODO: Evaluate whether special cases for size == 2 and size == 4 actually improve performance.                                                                            
            size_t size = site.Size();
            if (size == 2)
            {
                *((int16_t*)siteAddress) = (int16_t)delta;
                siteAddress += size;
            }
            else if (size == 4)
            {
                *((int32_t*)siteAddress) = (int32_t)delta;
                siteAddress += size;
            }
            else
            {
                while (size > 0)
                {
                    *siteAddress++ = (uint8_t)delta;
                    delta = delta >> 8;
                    size--;
                }
            }
        }
    }

                // TODO: Need to account for the fact the extra registers may be used
                // when the specific parameter home is different than the one returned
                // duing code generation.

    // TODO: Move this class to a separate header

        // TODO: Evaluating both expressions in advance of the test is
        // sub-optimal, but it is currently required to guarantee consistent
        // state: the execution in NativeJIT has a continuous flow regardless
        // of the outcome of the (runtime) condition whereas the generated x64
        // code has two branches and each of them can have independent impact on
        // allocated and spilled registers. To have each expression evaluated
        // only if its branch is hit, the NativeJIT code would have to ensure
        // that the state of the allocated/spilled registers (i.e. all Storages)
        // is consistent once those two x64 branches converge back.
        //
        // A related note: if this is addressed, then it may be possible to
        // also address the fact that common subexpression (CSE) code is
        // inefficient in some cases because some CSEs may not need to be
        // evaluated. For example:
        //   (v == 1)? a : ((v == 2) ? a + b : b + c)
        //
        // Depending on the value of v, either a or c may not need to be
        // evaluated. One possibility is to lazily evaluate CSEs *at runtime*
        // as they are needed.