A C++ expression -> x64 JIT

Overview

Build status Build status

NativeJIT

NativeJIT is an open-source cross-platform library for high-performance just-in-time compilation of expressions involving C data structures. The compiler is light weight and fast and it takes no dependencies beyond the standard C++ runtime. It runs on Linux, OSX, and Windows. The generated code is optimized with particular attention paid to register allocation.

The compiler was developed by the Bing team for use in the Bing search engine. One important use is scoring documents containing keywords that match a user's query. The scoring process attempts to gauge how well each document matches the user's intent, and as such, depends on the specifics of how each query was phrased. Bing formulates a custom expression for each query and then uses NativeJIT to compile the expression into x64 code that will be run on a large set of candidate documents spread across a cluster of machines.

We knew from the get go that throughput and latency would be essential when processing queries at scale, so we put a lot of effort in to making NativeJIT run fast.

Our design point was scenarios where

  • The expression isn't known until runtime.
  • The expression will be evaluated enough times to amortize the cost of compilation.
  • Latency and throughput demands require low cost for compilation.

Here's trivial "Hello, world" level example that computes the area of a circle:

#include "NativeJIT/CodeGen/ExecutionBuffer.h"
#include "NativeJIT/CodeGen/FunctionBuffer.h"
#include "NativeJIT/Function.h"
#include "Temporary/Allocator.h"

#include <iostream>

using NativeJIT::Allocator;
using NativeJIT::ExecutionBuffer;
using NativeJIT::Function;
using NativeJIT::FunctionBuffer;

int main()
{
    // Create allocator and buffers for pre-compiled and post-compiled code.
    ExecutionBuffer codeAllocator(8192);
    Allocator allocator(8192);
    FunctionBuffer code(codeAllocator, 8192);

    // Create the factory for expression nodes.
    // Our area expression will take a single float parameter and return a float.
    Function<float, float> expression(allocator, code);

    // Multiply input parameter by itself to get radius squared.
    auto & rsquared = expression.Mul(expression.GetP1(), expression.GetP1());

    // Multiply by PI.
    const float  PI = 3.14159265358979f;
    auto & area = expression.Mul(rsquared, expression.Immediate(PI));

    // Compile expression into a function.
    auto function = expression.Compile(area);

    // Now run our expression!
    float radius = 2.0;
    std::cout << "The area of a circle with radius " << radius
              << " is " << function(radius);

    return 0;
}

Here is the generated assembly code on Windows:

PI_CONSTANT:
   db 0f 49 40                              ; PI constant is stored in memory.
ENTRY_POINT:
  sub         rsp,8                         ; Standard function prologue.
  mov         qword ptr [rsp],rbp           ; Standard function prologue.
  lea         rbp,[rsp+8]                   ; Standard function prologue.
  mulss       xmm0,xmm0                     ; Multiply by radius parameter by itself.
  mulss       xmm0,dword ptr [29E2A580000h] ; Multiply by PI.
  mov         rbp,qword ptr [rsp]           ; Standard function epilogue.
  add         rsp,8                         ; Standard function epilogue.

This example shows an expression that multiplies a number by itself. We also support a wide variety of arithmetic and logical operations, pointer and array operations, conditionals, accessing structure fields, and calling out to C functions. See our preliminary API docs for more information and the Examples/ directory for more examples.

Dependencies

In order to build NativeJIT you will need CMake (2.8.11+), and a modern C++ compiler (gcc 5+, clang 3.4+, or VC 2015+). You can run CMake directly to generate the appropriate build setup for your platform. Alternately, we have some scripts that have the defaults that we use available.

*nix

For *nix platforms (including OS X),

./Configure_Make.sh
cd build-make
make
make test

Ubuntu

If you're on Ubuntu 15+, you can install dependencies with:

sudo apt-get install clang cmake

On Ubuntu 14 and below, you'll need to install a newer version of CMake. To install a new-enough CMake, see this link. If you're using gcc, you'll also need to make sure you have gcc-5 (sudo apt-get install g++-5).

To override the default compiler, set the CXX and CC environment variables. For example, if you have clang-3.8 installed as clang-3.8 and are using bash:

export CXX="clang++-3.8"
export CC="clang-3.8"

OS X

Install XCode and then run the following command to install required packages using Homebrew (http://brew.sh/):

brew install cmake

NativeJIT can be built on OS X using either standard *nix makefiles or XCode. In order to generate and build makefiles, in the root NativeJIT directory run:

If you want to create an Xcode project instead of using Makefiles, run:

./Configure_XCode.sh

Windows

Install the following tools:

You can get the free version of Visual Studio here. Note that if you're installing Visual Studio for the first time and select the default install options, you won't get a C++ compiler. To force the install of the C++ compiler, you need to either create a new C++ project or open an existing C++ project.

In order to configure solution for Visual Studio 2015 run the following commands from the root NativeJIT directory:

.\Configure_MSVC.bat

From now on you can use the generated solution build-msvc\NativeJIT.sln from Visual Studio or build from command line using cmake.

Comments
  • __lzcnt64 fix

    __lzcnt64 fix

    NativeJIT/inc/NativeJIT/BitOperations.h:137:35: error: use of undeclared identifier '__lzcnt64' *highestBitSetIndex = __lzcnt64(value);

    Fixed adding #define __LZCNT__ in BitOperations.h.

    [ PASSED ] 108 tests

    OSX Yosemite.

    opened by rncar 16
  • Compilation error: dereferencing type-punned pointer

    Compilation error: dereferencing type-punned pointer

    When compiling with GCC 6 I get errors: error: dereferencing type-punned pointer will break strict-aliasing rules [-Werror=strict-aliasing] in multiple places. Easy to work around by disabling this check, but a more permanent solution would be better.

    opened by joto 6
  • Fix code to build with all warnings enabled, in clang, gcc, and vc++2015

    Fix code to build with all warnings enabled, in clang, gcc, and vc++2015

    I'm sending this as a PR instead of a Codeflow review since I'm on a linux machine and don't have Codeflow at the moment, and this change is trivial and shouldn't require a lot of back and forth.

    From previous discussions, it sounded like we just wanted to support a single version, and since VS 2015 community is available I think we should use that as our base for Windows.

    opened by danluu 6
  • Set up CI

    Set up CI

    Filing bugs on our action items because our action items from the last two meetings have a very large intersection. We should just have bugs to refer to instead of having to refresh the list in meetings so it's not forgotten. Bug assignment is somewhat arbitrary. Please feel free to re-assign.

    It sounded like we were going to look into Travis and Appveyor?

    P1 
    opened by danluu 5
  • Add support for clang in Linux

    Add support for clang in Linux

    Per our previous discussion, we should refactor the CMake "code", but for now here's a quick change that lets us use clang and get nice clang error messages on Linux.

    opened by danluu 5
  • Remove SuiteCpp

    Remove SuiteCpp

    We should remove SuiteCpp and then rename all of the test asserts to use the GTest syntax (e.g. TestEqual will become ASSERT_EQ). Also remove any shims that allow SuiteCpp to be used in place of GTest.

    opened by MikeHopcroft 3
  • Add tests for TODO items (shift, sub, mul, etc.)

    Add tests for TODO items (shift, sub, mul, etc.)

    Basically what it sounds like, although I have a few things to note.

    1. Rol appears to exist in CodeGen but not NativeJIT? If so, I can try adding that as an exercise to just figure out all the steps necessary to add something. If I do that, I can document the steps necessary and we can put it in into the documentation. We'll also want to document how to add something into CodeGen, but one thing at a time...
    2. This kind of thing seems amendable to random/generative testing. Since NativeJIT known to work for our use case, I think that doing that is on the critical path for us, but I can go back and do that sometime after we've done everything else we want to do before releasing.

    I've just added some trivial tests so that extremely bad regressions should be easier to catch, but I think we can do a lot more here.

    1. I'm not sure I'm actually creating expressions that use immediate values correctly. It works, but if that's correct the API seems slightly odd to me.
    opened by danluu 3
  • Update README

    Update README

    Fix known bugs in the README.

    Also, remove pandoc from the dependencies because, as far as I can tell, you can build fine without pandoc. If that's not true, we should not only add that back in but also add instructions on generating whatever it is that's generated with pandoc because I don't have pandoc and the build seems to work for me.

    Note that this requires both #1 and #2 to be correct.

    opened by danluu 3
  • Windows 7 Installation Issues

    Windows 7 Installation Issues

    Commands: ./Configure_MSVC cmake build-msvc (from native-jit folder)

    Windows7 Latest version of Cmake VS2017 (though it detects to use 2015 tools during build).

    neither build directory release or debug contain any type of libs. When running the native.sln I receive numerous 'cmd.exe error 3'

    Not sure what caused this, both builds succeeded. -JJ

    opened by josephjaspers 2
  • Compilation in 32 bits

    Compilation in 32 bits

    Hi everybody, Many thanks for this new JIT library. I am trying to compile NativeJIT for x86 arch but unfortunately it cannot compile. I have received some errors like:

    NativeJIT\inc\NativeJIT/BitOperations.h(99): error C3861: '_mm_popcnt_u64': identifier not found
    NativeJIT\inc\NativeJIT/BitOperations.h(111): error C3861: '_BitScanForward64': identifier not found
    ...
    

    Is this normal? I cannot see any specific ifdef for x86, so is NativeJIT for x64 only?

    Many thanks.

    opened by tathanhdinh 2
  • JumpTable::PatchCallSites() dangerous casts

    JumpTable::PatchCallSites() dangerous casts

        // 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--;
                    }
                }
            }
        }
    

    I'm enabling -Wold-style-cast (see BitFunnel/BitFunnel#37) and converting these to C++ style casts, but this function still seems dangerous.

    opened by danluu 2
  • Project seems to be abandoned.

    Project seems to be abandoned.

    I'm wondering is there is still a maintainer for this project? Based on the commits nothing really happened in the last 5 years. Did the project got moved, or forked somewhere?

    opened by cnergyone 1
  • Support for double precision math functions

    Support for double precision math functions

    Using double precision version of functions from standard math library fails to compile with the following error,

    The code

    // does not compile
    ExecutionBuffer codeAllocator(8192);
    Allocator allocator(8192);
    FunctionBuffer code(codeAllocator, 8192);
    Function<double, double> scalers(allocator, code);
    auto & sinFunction = scalers.Immediate(sin);
    

    causes the compiler error

    func.cpp:25:34: error: no matching member function for call to 'Immediate'
        auto & sinFunction = scalers.Immediate(sin);
    ./jit/Include/NativeJIT/ExpressionNodeFactory.h:67:46: note: candidate template ignored: couldn't
          infer template argument 'T'
        ImmediateNode<T>& ExpressionNodeFactory::Immediate(T value)
    

    meanwhile the code,

    // works perfectly fine
    Function<float, float> scalers(allocator, code);
    auto & sinFunction = scalers.Immediate(sinf);
    

    works entirely as expected. I am compiling with Apple clang 11.0.3 on x86_64 Is there a workaround for this?

    opened by vlovero 0
  • Potential issues with the C++17 version

    Potential issues with the C++17 version

    Using the lastest CLang compiler, I found the following issues:

    In file included from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:29:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/ImmediateNodeDecls.h: In instantiation of ‘class NativeJIT::ImmediateNode<float (*)(float) throw (), (NativeJIT::ImmediateCategory)1>’:
    <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:248:65:   recursively required by substitution of ‘template<class R, class P1, class P2, class P3, class P4> NativeJIT::Node<T1>& NativeJIT::ExpressionNodeFactory::Call(NativeJIT::Node<R (*)(P1, P2, P3, P4)>&, NativeJIT::Node<T2>&, NativeJIT::Node<INDEX>&, NativeJIT::Node<P3>&, NativeJIT::Node<P4>&) [with R = <missing>; P1 = <missing>; P2 = <missing>; P3 = <missing>; P4 = <missing>]’
    <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:248:65:   required from here
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/ImmediateNode.h:101:10: error: mangled name for ‘void NativeJIT::ImmediateNode<T, (NativeJIT::ImmediateCategory)1>::EmitStaticData(NativeJIT::ExpressionTree&) [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         void ImmediateNode<T, ImmediateCategory::RIPRelativeImmediate>::EmitStaticData(ExpressionTree& tree)
              ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/ImmediateNode.h: In instantiation of ‘NativeJIT::ImmediateNode<T, (NativeJIT::ImmediateCategory)1>::ImmediateNode(NativeJIT::ExpressionTree&, T) [with T = float (*)(float) throw ()]’:
    <my-path-to>NativeJIT/inc/Temporary/AllocatorOperations.h:46:13:   required from ‘T& Allocators::PlacementConstruct(Allocators::IAllocator&, ConstructorArgs&& ...) [with T = NativeJIT::ImmediateNode<float (*)(float) throw (), (NativeJIT::ImmediateCategory)1>; ConstructorArgs = {NativeJIT::ExpressionNodeFactory&, float (*&)(float) throw ()}]’
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:92:49:   required from ‘T& NativeJIT::ExpressionTree::PlacementConstruct(ConstructorArgs&& ...) [with T = NativeJIT::ImmediateNode<float (*)(float) throw (), (NativeJIT::ImmediateCategory)1>; ConstructorArgs = {NativeJIT::ExpressionNodeFactory&, float (*&)(float) throw ()}]’
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionNodeFactory.h:69:52:   required from ‘NativeJIT::ImmediateNode<T>& NativeJIT::ExpressionNodeFactory::Immediate(T) [with T = float (*)(float) throw ()]’
    <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:247:67:   required from here
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/ImmediateNode.h:71:5: error: mangled name for ‘NativeJIT::ImmediateNode<T, (NativeJIT::ImmediateCategory)1>::ImmediateNode(NativeJIT::ExpressionTree&, T) [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         ImmediateNode<T, ImmediateCategory::RIPRelativeImmediate>::ImmediateNode(ExpressionTree& tree, T value)
         ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/ImmediateNode.h:71:5: error: mangled name for ‘NativeJIT::ImmediateNode<T, (NativeJIT::ImmediateCategory)1>::ImmediateNode(NativeJIT::ExpressionTree&, T) [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/ExpressionNodeFactory.h:39:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:27,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/CallNode.h: In instantiation of ‘NativeJIT::CallNode<R, P1>::CallNode(NativeJIT::ExpressionTree&, NativeJIT::Node<R (*)(P1)>&, NativeJIT::Node<T2>&) [with R = float; P1 = float]’:
    <my-path-to>NativeJIT/inc/Temporary/AllocatorOperations.h:46:13:   required from ‘T& Allocators::PlacementConstruct(Allocators::IAllocator&, ConstructorArgs&& ...) [with T = NativeJIT::CallNode<float, float, void, void, void>; ConstructorArgs = {NativeJIT::ExpressionNodeFactory&, NativeJIT::Node<float (*)(float) throw ()>&, NativeJIT::Node<float>&}]’
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:92:49:   required from ‘T& NativeJIT::ExpressionTree::PlacementConstruct(ConstructorArgs&& ...) [with T = NativeJIT::CallNode<float, float, void, void, void>; ConstructorArgs = {NativeJIT::ExpressionNodeFactory&, NativeJIT::Node<float (*)(float) throw ()>&, NativeJIT::Node<float>&}]’
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionNodeFactory.h:387:51:   required from ‘NativeJIT::Node<T1>& NativeJIT::ExpressionNodeFactory::Call(NativeJIT::Node<R (*)(P1)>&, NativeJIT::Node<T2>&) [with R = float; P1 = float]’
    <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:248:65:   required from here
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/CallNode.h:618:5: error: mangled name for ‘NativeJIT::CallNode<R, P1>::CallNode(NativeJIT::ExpressionTree&, NativeJIT::Node<R (*)(P1)>&, NativeJIT::Node<T2>&) [with R = float; P1 = float]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         CallNode<R, P1>::CallNode(ExpressionTree& tree,
         ^~~~~~~~~~~~~~~
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/CallNode.h:618:5: error: mangled name for ‘NativeJIT::CallNode<R, P1>::CallNode(NativeJIT::ExpressionTree&, NativeJIT::Node<R (*)(P1)>&, NativeJIT::Node<T2>&) [with R = float; P1 = float]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/Nodes/ConditionalNode.h:31:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:28,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/Node.h: In instantiation of ‘NativeJIT::Node<T>::Node(NativeJIT::ExpressionTree&) [with T = float (*)(float) throw ()]’:
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/ImmediateNode.h:73:24:   required from ‘NativeJIT::ImmediateNode<T, (NativeJIT::ImmediateCategory)1>::ImmediateNode(NativeJIT::ExpressionTree&, T) [with T = float (*)(float) throw ()]’
    <my-path-to>NativeJIT/inc/Temporary/AllocatorOperations.h:46:13:   required from ‘T& Allocators::PlacementConstruct(Allocators::IAllocator&, ConstructorArgs&& ...) [with T = NativeJIT::ImmediateNode<float (*)(float) throw (), (NativeJIT::ImmediateCategory)1>; ConstructorArgs = {NativeJIT::ExpressionNodeFactory&, float (*&)(float) throw ()}]’
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:92:49:   required from ‘T& NativeJIT::ExpressionTree::PlacementConstruct(ConstructorArgs&& ...) [with T = NativeJIT::ImmediateNode<float (*)(float) throw (), (NativeJIT::ImmediateCategory)1>; ConstructorArgs = {NativeJIT::ExpressionNodeFactory&, float (*&)(float) throw ()}]’
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionNodeFactory.h:69:52:   required from ‘NativeJIT::ImmediateNode<T>& NativeJIT::ExpressionNodeFactory::Immediate(T) [with T = float (*)(float) throw ()]’
    <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:247:67:   required from here
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/Node.h:219:5: error: mangled name for ‘NativeJIT::Node<T>::Node(NativeJIT::ExpressionTree&) [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         Node<T>::Node(ExpressionTree& tree)
         ^~~~~~~
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/Node.h:219:5: error: mangled name for ‘NativeJIT::Node<T>::Node(NativeJIT::ExpressionTree&) [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/Node.h: In instantiation of ‘NativeJIT::Node<T>::~Node() [with T = float (*)(float) throw ()]’:
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/ImmediateNode.h:73:24:   required from ‘NativeJIT::ImmediateNode<T, (NativeJIT::ImmediateCategory)1>::ImmediateNode(NativeJIT::ExpressionTree&, T) [with T = float (*)(float) throw ()]’
    <my-path-to>NativeJIT/inc/Temporary/AllocatorOperations.h:46:13:   required from ‘T& Allocators::PlacementConstruct(Allocators::IAllocator&, ConstructorArgs&& ...) [with T = NativeJIT::ImmediateNode<float (*)(float) throw (), (NativeJIT::ImmediateCategory)1>; ConstructorArgs = {NativeJIT::ExpressionNodeFactory&, float (*&)(float) throw ()}]’
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:92:49:   required from ‘T& NativeJIT::ExpressionTree::PlacementConstruct(ConstructorArgs&& ...) [with T = NativeJIT::ImmediateNode<float (*)(float) throw (), (NativeJIT::ImmediateCategory)1>; ConstructorArgs = {NativeJIT::ExpressionNodeFactory&, float (*&)(float) throw ()}]’
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionNodeFactory.h:69:52:   required from ‘NativeJIT::ImmediateNode<T>& NativeJIT::ExpressionNodeFactory::Immediate(T) [with T = float (*)(float) throw ()]’
    <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:247:67:   required from here
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/Node.h:179:9: error: mangled name for ‘NativeJIT::Node<T>::~Node() [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
             ~Node() {}
             ^
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/Node.h:179:9: error: mangled name for ‘NativeJIT::Node<T>::~Node() [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:27:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h: In instantiation of ‘NativeJIT::ExpressionTree::Storage<T>::~Storage() [with T = float (*)(float) throw ()]’:
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/CallNode.h:126:15:   required from ‘NativeJIT::CallNode<R, P1>::CallNode(NativeJIT::ExpressionTree&, NativeJIT::Node<R (*)(P1)>&, NativeJIT::Node<T2>&) [with R = float; P1 = float]’
    <my-path-to>NativeJIT/inc/Temporary/AllocatorOperations.h:46:13:   required from ‘T& Allocators::PlacementConstruct(Allocators::IAllocator&, ConstructorArgs&& ...) [with T = NativeJIT::CallNode<float, float, void, void, void>; ConstructorArgs = {NativeJIT::ExpressionNodeFactory&, NativeJIT::Node<float (*)(float) throw ()>&, NativeJIT::Node<float>&}]’
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:92:49:   required from ‘T& NativeJIT::ExpressionTree::PlacementConstruct(ConstructorArgs&& ...) [with T = NativeJIT::CallNode<float, float, void, void, void>; ConstructorArgs = {NativeJIT::ExpressionNodeFactory&, NativeJIT::Node<float (*)(float) throw ()>&, NativeJIT::Node<float>&}]’
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionNodeFactory.h:387:51:   required from ‘NativeJIT::Node<T1>& NativeJIT::ExpressionNodeFactory::Call(NativeJIT::Node<R (*)(P1)>&, NativeJIT::Node<T2>&) [with R = float; P1 = float]’
    <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:248:65:   required from here
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:526:5: error: mangled name for ‘NativeJIT::ExpressionTree::Storage<T>::~Storage() [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         ExpressionTree::Storage<T>::~Storage()
         ^~~~~~~~~~~~~~
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:526:5: error: mangled name for ‘NativeJIT::ExpressionTree::Storage<T>::~Storage() [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h: In instantiation of ‘NativeJIT::ExpressionTree::Storage<T>::Storage() [with T = float (*)(float) throw ()]’:
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/Node.h:221:34:   required from ‘NativeJIT::Node<T>::Node(NativeJIT::ExpressionTree&) [with T = float (*)(float) throw ()]’
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/ImmediateNode.h:73:24:   required from ‘NativeJIT::ImmediateNode<T, (NativeJIT::ImmediateCategory)1>::ImmediateNode(NativeJIT::ExpressionTree&, T) [with T = float (*)(float) throw ()]’
    <my-path-to>NativeJIT/inc/Temporary/AllocatorOperations.h:46:13:   required from ‘T& Allocators::PlacementConstruct(Allocators::IAllocator&, ConstructorArgs&& ...) [with T = NativeJIT::ImmediateNode<float (*)(float) throw (), (NativeJIT::ImmediateCategory)1>; ConstructorArgs = {NativeJIT::ExpressionNodeFactory&, float (*&)(float) throw ()}]’
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:92:49:   required from ‘T& NativeJIT::ExpressionTree::PlacementConstruct(ConstructorArgs&& ...) [with T = NativeJIT::ImmediateNode<float (*)(float) throw (), (NativeJIT::ImmediateCategory)1>; ConstructorArgs = {NativeJIT::ExpressionNodeFactory&, float (*&)(float) throw ()}]’
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionNodeFactory.h:69:52:   required from ‘NativeJIT::ImmediateNode<T>& NativeJIT::ExpressionNodeFactory::Immediate(T) [with T = float (*)(float) throw ()]’
    <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:247:67:   required from here
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:363:5: error: mangled name for ‘NativeJIT::ExpressionTree::Storage<T>::Storage() [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         ExpressionTree::Storage<T>::Storage()
         ^~~~~~~~~~~~~~
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:363:5: error: mangled name for ‘NativeJIT::ExpressionTree::Storage<T>::Storage() [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h: In instantiation of ‘NativeJIT::ExpressionTree::Storage<T>::Storage(const NativeJIT::ExpressionTree::Storage<T>&) [with T = float (*)(float) throw ()]’:
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/Node.h:302:17:   required from ‘void NativeJIT::Node<T>::CodeGenCache(NativeJIT::ExpressionTree&) [with T = float (*)(float) throw ()]’
    <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:610:1:   required from here
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:502:5: error: mangled name for ‘NativeJIT::ExpressionTree::Storage<T>::Storage(const NativeJIT::ExpressionTree::Storage<T>&) [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         ExpressionTree::Storage<T>::Storage(Storage const & other)
         ^~~~~~~~~~~~~~
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:502:5: error: mangled name for ‘NativeJIT::ExpressionTree::Storage<T>::Storage(const NativeJIT::ExpressionTree::Storage<T>&) [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h: In instantiation of ‘NativeJIT::ExpressionTree::Storage<T>::Storage(const NativeJIT::ExpressionTree::Storage<U>&) [with U = float (*)(float) throw (); T = void*]’:
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/Node.h:345:32:   required from ‘NativeJIT::ExpressionTree::Storage<void*> NativeJIT::Node<T>::CodeGenAsBase(NativeJIT::ExpressionTree&) [with T = float (*)(float) throw ()]’
    <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:610:1:   required from here
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:371:5: error: mangled name for ‘NativeJIT::ExpressionTree::Storage<T>::Storage(const NativeJIT::ExpressionTree::Storage<U>&) [with U = float (*)(float) throw (); T = void*]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         ExpressionTree::Storage<T>::Storage(const Storage<U>& other)
         ^~~~~~~~~~~~~~
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:371:5: error: mangled name for ‘NativeJIT::ExpressionTree::Storage<T>::Storage(const NativeJIT::ExpressionTree::Storage<U>&) [with U = float (*)(float) throw (); T = void*]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h: In instantiation of ‘NativeJIT::ExpressionTree::Storage<T>::Storage(const NativeJIT::ExpressionTree::Storage<U>&) [with U = long unsigned int; T = float (*)(float) throw ()]’:
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:761:21:   required from ‘void NativeJIT::ExpressionTree::Storage<T>::TakeSoleOwnershipOfDirect() [with T = float (*)(float) throw ()]’
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/CallNode.h:510:13:   required from ‘void NativeJIT::CallNodeBase<R, PARAMETERCOUNT>::FunctionChild<T>::EmitStaging(NativeJIT::ExpressionTree&, NativeJIT::SaveRestoreVolatilesHelper&) [with T = float (*)(float); R = float; unsigned int PARAMETERCOUNT = 1]’
    <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:610:1:   required from here
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:371:5: error: mangled name for ‘NativeJIT::ExpressionTree::Storage<T>::Storage(const NativeJIT::ExpressionTree::Storage<U>&) [with U = long unsigned int; T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:371:5: error: mangled name for ‘NativeJIT::ExpressionTree::Storage<T>::Storage(const NativeJIT::ExpressionTree::Storage<U>&) [with U = long unsigned int; T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h: In instantiation of ‘NativeJIT::ExpressionTree::Storage<T>::Storage(NativeJIT::ExpressionTree::Data*) [with T = float (*)(float) throw ()]’:
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:442:16:   required from ‘static NativeJIT::Storage<T> NativeJIT::ExpressionTree::Storage<T>::ForSharedBaseRegister(NativeJIT::ExpressionTree&, NativeJIT::ExpressionTree::Storage<T>::BaseRegister, int32_t) [with T = float (*)(float) throw (); NativeJIT::Storage<T> = NativeJIT::ExpressionTree::Storage<float (*)(float) throw ()>; NativeJIT::ExpressionTree::Storage<T>::BaseRegister = NativeJIT::Register<8, false>; int32_t = int]’
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:189:49:   required from ‘NativeJIT::ExpressionTree::Storage<T> NativeJIT::ExpressionTree::RIPRelative(int32_t) [with T = float (*)(float) throw (); int32_t = int]’
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/ImmediateNode.h:96:44:   required from ‘NativeJIT::Storage<T> NativeJIT::ImmediateNode<T, (NativeJIT::ImmediateCategory)1>::CodeGenValue(NativeJIT::ExpressionTree&) [with T = float (*)(float) throw (); NativeJIT::Storage<T> = NativeJIT::ExpressionTree::Storage<float (*)(float) throw ()>]’
    <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:610:1:   required from here
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:518:5: error: mangled name for ‘NativeJIT::ExpressionTree::Storage<T>::Storage(NativeJIT::ExpressionTree::Data*) [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         ExpressionTree::Storage<T>::Storage(ExpressionTree::Data* data)
         ^~~~~~~~~~~~~~
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:518:5: error: mangled name for ‘NativeJIT::ExpressionTree::Storage<T>::Storage(NativeJIT::ExpressionTree::Data*) [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/CodeGen/ValuePredicates.h:29:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/CodeGen/X64CodeGenerator.h:34,
                     from <my-path-to>NativeJIT/inc/NativeJIT/CodeGen/FunctionBuffer.h:40,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:6:
    <my-path-to>NativeJIT/inc/NativeJIT/TypeConverter.h: In instantiation of ‘NativeJIT::TypeConverter<FROM, TO>::TypeConverter() [with FROM = float (*)(float) throw (); TO = long unsigned int]’:
    <my-path-to>NativeJIT/inc/NativeJIT/TypeConverter.h:48:33:   required from ‘TO NativeJIT::convertType(FROM) [with FROM = float (*)(float) throw (); TO = long unsigned int]’
    <my-path-to>NativeJIT/inc/NativeJIT/CodeGen/ValuePredicates.h:64:37:   required from ‘TO NativeJIT::ForcedCast(FROM, typename std::enable_if<(! std::is_convertible<FROM, TO>::value)>::type*) [with TO = long unsigned int; FROM = float (*)(float) throw (); typename std::enable_if<(! std::is_convertible<FROM, TO>::value)>::type = void]’
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/ImmediateNode.h:111:82:   required from ‘void NativeJIT::ImmediateNode<T, (NativeJIT::ImmediateCategory)1>::EmitStaticData(NativeJIT::ExpressionTree&) [with T = float (*)(float) throw ()]’
    <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:610:1:   required from here
    <my-path-to>NativeJIT/inc/NativeJIT/TypeConverter.h:38:9: error: mangled name for ‘NativeJIT::TypeConverter<FROM, TO>::TypeConverter() [with FROM = float (*)(float) throw (); TO = long unsigned int]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
             TypeConverter() {}
             ^~~~~~~~~~~~~
    <my-path-to>NativeJIT/inc/NativeJIT/TypeConverter.h:38:9: error: mangled name for ‘NativeJIT::TypeConverter<FROM, TO>::TypeConverter() [with FROM = float (*)(float) throw (); TO = long unsigned int]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:27:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:422:16: error: mangled name for ‘static NativeJIT::Storage<T> NativeJIT::ExpressionTree::Storage<T>::ForFreeRegister(NativeJIT::ExpressionTree&, NativeJIT::ExpressionTree::Storage<T>::DirectRegister) [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         Storage<T> ExpressionTree::Storage<T>::ForFreeRegister(ExpressionTree& tree,
                    ^~~~~~~~~~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/CodeGen/ValuePredicates.h:29:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/CodeGen/X64CodeGenerator.h:34,
                     from <my-path-to>NativeJIT/inc/NativeJIT/CodeGen/FunctionBuffer.h:40,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:6:
    <my-path-to>NativeJIT/inc/NativeJIT/TypeConverter.h:38:9: error: mangled name for ‘NativeJIT::TypeConverter<FROM, TO>::TypeConverter() [with FROM = float (*)(float) throw (); TO = long unsigned int]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
             TypeConverter() {}
             ^~~~~~~~~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:27:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:518:5: error: mangled name for ‘NativeJIT::ExpressionTree::Storage<T>::Storage(NativeJIT::ExpressionTree::Data*) [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         ExpressionTree::Storage<T>::Storage(ExpressionTree::Data* data)
         ^~~~~~~~~~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:27:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:902:10: error: mangled name for ‘void NativeJIT::ExpressionTree::Storage<T>::PrintImmediate(std::ostream&, NativeJIT::ExpressionTree::Storage<T>::InvalidImmediateStorage) const [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         void ExpressionTree::Storage<T>::PrintImmediate(std::ostream& /* out */, InvalidImmediateStorage) const
              ^~~~~~~~~~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:39:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:27,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/CodeGenHelpers.h:118:14: error: mangled name for ‘static void NativeJIT::CodeGenHelpers::Emitter<REGTYPES, IMMEDIATETYPE>::Emit(NativeJIT::X64CodeGenerator&, DESTREGTYPE, const NativeJIT::ExpressionTree::Storage<SRC>&) [with NativeJIT::OpCode OP = (NativeJIT::OpCode)17; DESTREGTYPE = NativeJIT::Register<8, false>; SRC = float (*)(float) throw (); NativeJIT::CodeGenHelpers::RegTypes REGTYPES = (NativeJIT::CodeGenHelpers::RegTypes)0; NativeJIT::CodeGenHelpers::ImmediateType IMMEDIATETYPE = (NativeJIT::CodeGenHelpers::ImmediateType)1]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
             void Emitter<RegTypes::ExactlySame, ImmediateType::NotAllowed>::Emit(
                  ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:27:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:119:5: error: mangled name for ‘NativeJIT::ExpressionTree::Storage<T> NativeJIT::ExpressionTree::Direct(typename NativeJIT::ExpressionTree::Storage<T>::DirectRegister) [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         ExpressionTree::Direct(typename Storage<T>::DirectRegister r)
         ^~~~~~~~~~~~~~
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:410:16: error: mangled name for ‘static NativeJIT::Storage<T> NativeJIT::ExpressionTree::Storage<T>::ForAnyFreeRegister(NativeJIT::ExpressionTree&) [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         Storage<T> ExpressionTree::Storage<T>::ForAnyFreeRegister(ExpressionTree& tree)
                    ^~~~~~~~~~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/CodeGen/ValuePredicates.h:29:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/CodeGen/X64CodeGenerator.h:34,
                     from <my-path-to>NativeJIT/inc/NativeJIT/CodeGen/FunctionBuffer.h:40,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:6:
    <my-path-to>NativeJIT/inc/NativeJIT/TypeConverter.h:46:8: error: mangled name for ‘TO NativeJIT::convertType(FROM) [with FROM = float (*)(float) throw (); TO = long unsigned int]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         TO convertType(FROM value)
            ^~~~~~~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:27:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:435:16: error: mangled name for ‘static NativeJIT::Storage<T> NativeJIT::ExpressionTree::Storage<T>::ForSharedBaseRegister(NativeJIT::ExpressionTree&, NativeJIT::ExpressionTree::Storage<T>::BaseRegister, int32_t) [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         Storage<T> ExpressionTree::Storage<T>::ForSharedBaseRegister(
                    ^~~~~~~~~~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:27:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:854:10: error: mangled name for ‘void NativeJIT::ExpressionTree::Storage<T>::Print(std::ostream&) const [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         void ExpressionTree::Storage<T>::Print(std::ostream& out) const
              ^~~~~~~~~~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:27:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:371:5: error: mangled name for ‘NativeJIT::ExpressionTree::Storage<T>::Storage(const NativeJIT::ExpressionTree::Storage<U>&) [with U = long unsigned int; T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         ExpressionTree::Storage<T>::Storage(const Storage<U>& other)
         ^~~~~~~~~~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:27:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:705:10: error: mangled name for ‘void NativeJIT::ExpressionTree::Storage<T>::Swap(NativeJIT::ExpressionTree::Storage<U>&, NativeJIT::ExpressionTree::Storage<T>::SwapType) [with U = long unsigned int; T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         void ExpressionTree::Storage<T>::Swap(Storage<U>& other, SwapType type)
              ^~~~~~~~~~~~~~
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:705:10: error: mangled name for ‘void NativeJIT::ExpressionTree::Storage<T>::Swap(NativeJIT::ExpressionTree::Storage<U>&, NativeJIT::ExpressionTree::Storage<T>::SwapType) [with U = float (*)(float) throw (); T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:767:22: error: mangled name for ‘NativeJIT::ReferenceCounter NativeJIT::ExpressionTree::Storage<T>::GetPin() [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         ReferenceCounter ExpressionTree::Storage<T>::GetPin()
                          ^~~~~~~~~~~~~~
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:577:13: error: mangled name for ‘int32_t NativeJIT::ExpressionTree::Storage<T>::GetOffset() const [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         int32_t ExpressionTree::Storage<T>::GetOffset() const
                 ^~~~~~~~~~~~~~
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:569:55: error: mangled name for ‘NativeJIT::ExpressionTree::Storage<T>::BaseRegister NativeJIT::ExpressionTree::Storage<T>::GetBaseRegister() const [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         typename ExpressionTree::Storage<T>::BaseRegister ExpressionTree::Storage<T>::GetBaseRegister() const
                                                           ^~~~~~~~~~~~~~
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:847:10: error: mangled name for ‘void NativeJIT::ExpressionTree::Storage<T>::SetData(NativeJIT::ExpressionTree::Storage<T>&) [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         void ExpressionTree::Storage<T>::SetData(Storage& other)
              ^~~~~~~~~~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:39:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:27,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/CodeGenHelpers.h:73:14: error: mangled name for ‘void NativeJIT::CodeGenHelpers::Emit(NativeJIT::X64CodeGenerator&, DESTREGTYPE, const NativeJIT::ExpressionTree::Storage<SRC>&) [with NativeJIT::OpCode OP = (NativeJIT::OpCode)17; DESTREGTYPE = NativeJIT::Register<8, false>; SRC = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
             void Emit(X64CodeGenerator& code, DESTREGTYPE dest, const ExpressionTree::Storage<SRC>& src)
                  ^~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:27:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:98:32: error: mangled name for ‘NativeJIT::ExpressionTree::Storage<T> NativeJIT::ExpressionTree::Direct() [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         ExpressionTree::Storage<T> ExpressionTree::Direct()
                                    ^~~~~~~~~~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:27:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:694:10: error: mangled name for ‘void NativeJIT::ExpressionTree::Storage<T>::ConvertImmediateToDirect(bool, NativeJIT::ExpressionTree::Storage<T>::InvalidImmediateStorage) [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         void ExpressionTree::Storage<T>::ConvertImmediateToDirect(bool /* forModification */, InvalidImmediateStorage)
              ^~~~~~~~~~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/Nodes/ConditionalNode.h:31:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:28,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/Node.h:238:16: error: mangled name for ‘NativeJIT::Storage<T> NativeJIT::Node<T>::GetAndReleaseCache() [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         Storage<T> Node<T>::GetAndReleaseCache()
                    ^~~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/CodeGen/X64CodeGenerator.h:34:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/CodeGen/FunctionBuffer.h:40,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:6:
    <my-path-to>NativeJIT/inc/NativeJIT/CodeGen/ValuePredicates.h:58:8: error: mangled name for ‘TO NativeJIT::ForcedCast(FROM, typename std::enable_if<(! std::is_convertible<FROM, TO>::value)>::type*) [with TO = long unsigned int; FROM = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         TO ForcedCast(FROM from,
            ^~~~~~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/CodeGen/ExecutionBuffer.h:26:0,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:5:
    <my-path-to>NativeJIT/inc/NativeJIT/CodeGen/CodeBuffer.h:165:10: error: mangled name for ‘void NativeJIT::CodeBuffer::AdvanceToAlignment() [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         void CodeBuffer::AdvanceToAlignment()
              ^~~~~~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:27:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:187:32: error: mangled name for ‘NativeJIT::ExpressionTree::Storage<T> NativeJIT::ExpressionTree::RIPRelative(int32_t) [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         ExpressionTree::Storage<T> ExpressionTree::RIPRelative(int32_t offset)
                                    ^~~~~~~~~~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/Nodes/ConditionalNode.h:31:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:28,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/Node.h:270:10: error: mangled name for ‘void NativeJIT::Node<T>::PrintCoreProperties(std::ostream&, const char*) const [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         void Node<T>::PrintCoreProperties(std::ostream& out, char const* nodeName) const
              ^~~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:27:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:371:5: error: mangled name for ‘NativeJIT::ExpressionTree::Storage<T>::Storage(const NativeJIT::ExpressionTree::Storage<U>&) [with U = float (*)(float) throw (); T = void*]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         ExpressionTree::Storage<T>::Storage(const Storage<U>& other)
         ^~~~~~~~~~~~~~
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:502:5: error: mangled name for ‘NativeJIT::ExpressionTree::Storage<T>::Storage(const NativeJIT::ExpressionTree::Storage<T>&) [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         ExpressionTree::Storage<T>::Storage(Storage const & other)
         ^~~~~~~~~~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/Nodes/ConditionalNode.h:31:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:28,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/Node.h:227:10: error: mangled name for ‘void NativeJIT::Node<T>::SetCache(NativeJIT::ExpressionTree::Storage<T>) [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         void Node<T>::SetCache(ExpressionTree::Storage<T> s)
              ^~~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:27:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:533:10: error: mangled name for ‘void NativeJIT::ExpressionTree::Storage<T>::Reset() [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         void ExpressionTree::Storage<T>::Reset()
              ^~~~~~~~~~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:27:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:725:10: error: mangled name for ‘void NativeJIT::ExpressionTree::Storage<T>::TakeSoleOwnershipOfDirect() [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         void ExpressionTree::Storage<T>::TakeSoleOwnershipOfDirect()
              ^~~~~~~~~~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:27:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:547:10: error: mangled name for ‘bool NativeJIT::ExpressionTree::Storage<T>::IsSoleDataOwner() const [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         bool ExpressionTree::Storage<T>::IsSoleDataOwner() const
              ^~~~~~~~~~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:27:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:597:5: error: mangled name for ‘NativeJIT::ExpressionTree::Storage<T>::DirectRegister NativeJIT::ExpressionTree::Storage<T>::ConvertToDirect(bool) [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         ExpressionTree::Storage<T>::ConvertToDirect(bool forModification)
         ^~~~~~~~~~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:27:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:554:18: error: mangled name for ‘NativeJIT::StorageClass NativeJIT::ExpressionTree::Storage<T>::GetStorageClass() const [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         StorageClass ExpressionTree::Storage<T>::GetStorageClass() const
                      ^~~~~~~~~~~~~~
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:510:33: error: mangled name for ‘NativeJIT::ExpressionTree::Storage<T>& NativeJIT::ExpressionTree::Storage<T>::operator=(const NativeJIT::ExpressionTree::Storage<T>&) [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         ExpressionTree::Storage<T>& ExpressionTree::Storage<T>::operator=(Storage const & other)
                                     ^~~~~~~~~~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/Nodes/ConditionalNode.h:31:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:28,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/Node.h:307:41: error: mangled name for ‘NativeJIT::ExpressionTree::Storage<T> NativeJIT::Node<T>::CodeGen(NativeJIT::ExpressionTree&) [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         typename ExpressionTree::Storage<T> Node<T>::CodeGen(ExpressionTree& tree)
                                             ^~~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:27:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:561:57: error: mangled name for ‘NativeJIT::ExpressionTree::Storage<T>::DirectRegister NativeJIT::ExpressionTree::Storage<T>::GetDirectRegister() const [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         typename ExpressionTree::Storage<T>::DirectRegister ExpressionTree::Storage<T>::GetDirectRegister() const
                                                             ^~~~~~~~~~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:29:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/ImmediateNode.h:94:5: error: mangled name for ‘NativeJIT::Storage<T> NativeJIT::ImmediateNode<T, (NativeJIT::ImmediateCategory)1>::CodeGenValue(NativeJIT::ExpressionTree&) [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         ImmediateNode<T, ImmediateCategory::RIPRelativeImmediate>::CodeGenValue(ExpressionTree& tree)
         ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/ImmediateNode.h:84:10: error: mangled name for ‘void NativeJIT::ImmediateNode<T, (NativeJIT::ImmediateCategory)1>::Print(std::ostream&) const [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         void ImmediateNode<T, ImmediateCategory::RIPRelativeImmediate>::Print(std::ostream& out) const
              ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/Nodes/ConditionalNode.h:31:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:28,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/Node.h:337:36: error: mangled name for ‘NativeJIT::ExpressionTree::Storage<void*> NativeJIT::Node<T>::CodeGenAsBase(NativeJIT::ExpressionTree&) [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         ExpressionTree::Storage<void*> Node<T>::CodeGenAsBase(ExpressionTree& tree)
                                        ^~~~~~~
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/Node.h:255:10: error: mangled name for ‘bool NativeJIT::Node<T>::IsCached() const [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         bool Node<T>::IsCached() const
              ^~~~~~~
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/Node.h:292:10: error: mangled name for ‘void NativeJIT::Node<T>::CodeGenCache(NativeJIT::ExpressionTree&) [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         void Node<T>::CodeGenCache(ExpressionTree& tree)
              ^~~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTreeDecls.h:33:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:29,
                     from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:27,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/TypePredicates.h:68:27: error: mangled name for ‘NativeJIT::RegisterStorage<float (*)(float) throw ()>::c_isFloat’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
             static const bool c_isFloat = std::is_floating_point<UnderlyingType>::value;
                               ^~~~~~~~~
    <my-path-to>NativeJIT/inc/NativeJIT/TypePredicates.h:67:31: error: mangled name for ‘NativeJIT::RegisterStorage<float (*)(float) throw ()>::c_size’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
             static const unsigned c_size = sizeof(UnderlyingType);
                                   ^~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:27:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:540:10: error: mangled name for ‘bool NativeJIT::ExpressionTree::Storage<T>::IsNull() const [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         bool ExpressionTree::Storage<T>::IsNull() const
              ^~~~~~~~~~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:27:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:788:10: error: mangled name for ‘void NativeJIT::ExpressionTree::Storage<T>::SetData(NativeJIT::ExpressionTree::Data*) [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         void ExpressionTree::Storage<T>::SetData(ExpressionTree::Data* data)
              ^~~~~~~~~~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:27:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:363:5: error: mangled name for ‘NativeJIT::ExpressionTree::Storage<T>::Storage() [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         ExpressionTree::Storage<T>::Storage()
         ^~~~~~~~~~~~~~
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:526:5: error: mangled name for ‘NativeJIT::ExpressionTree::Storage<T>::~Storage() [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         ExpressionTree::Storage<T>::~Storage()
         ^~~~~~~~~~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/Nodes/ConditionalNode.h:31:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:28,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/Node.h:179:9: error: mangled name for ‘NativeJIT::Node<T>::~Node() [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
             ~Node() {}
             ^
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/Node.h:219:5: error: mangled name for ‘NativeJIT::Node<T>::Node(NativeJIT::ExpressionTree&) [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         Node<T>::Node(ExpressionTree& tree)
         ^~~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/ExpressionNodeFactory.h:39:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:27,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/CallNode.h:618:5: error: mangled name for ‘NativeJIT::CallNode<R, P1>::CallNode(NativeJIT::ExpressionTree&, NativeJIT::Node<R (*)(P1)>&, NativeJIT::Node<T2>&) [with R = float; P1 = float]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         CallNode<R, P1>::CallNode(ExpressionTree& tree,
         ^~~~~~~~~~~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:29:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/Nodes/ImmediateNode.h:71:5: error: mangled name for ‘NativeJIT::ImmediateNode<T, (NativeJIT::ImmediateCategory)1>::ImmediateNode(NativeJIT::ExpressionTree&, T) [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         ImmediateNode<T, ImmediateCategory::RIPRelativeImmediate>::ImmediateNode(ExpressionTree& tree, T value)
         ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:42:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:27,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/Temporary/AllocatorOperations.h:35:5: error: mangled name for ‘T& Allocators::PlacementConstruct(Allocators::IAllocator&, ConstructorArgs&& ...) [with T = NativeJIT::CallNode<float, float, void, void, void>; ConstructorArgs = {NativeJIT::ExpressionNodeFactory&, NativeJIT::Node<float (*)(float) throw ()>&, NativeJIT::Node<float>&}]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         PlacementConstruct(IAllocator& allocator, ConstructorArgs&&... constructorArgs)
         ^~~~~~~~~~~~~~~~~~
    <my-path-to>NativeJIT/inc/Temporary/AllocatorOperations.h:35:5: error: mangled name for ‘T& Allocators::PlacementConstruct(Allocators::IAllocator&, ConstructorArgs&& ...) [with T = NativeJIT::ImmediateNode<float (*)(float) throw (), (NativeJIT::ImmediateCategory)1>; ConstructorArgs = {NativeJIT::ExpressionNodeFactory&, float (*&)(float) throw ()}]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/ExecutionPreconditionTest.h:27:0,
                     from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:26,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:90:8: error: mangled name for ‘T& NativeJIT::ExpressionTree::PlacementConstruct(ConstructorArgs&& ...) [with T = NativeJIT::CallNode<float, float, void, void, void>; ConstructorArgs = {NativeJIT::ExpressionNodeFactory&, NativeJIT::Node<float (*)(float) throw ()>&, NativeJIT::Node<float>&}]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         T& ExpressionTree::PlacementConstruct(ConstructorArgs&&... constructorArgs)
            ^~~~~~~~~~~~~~
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionTree.h:90:8: error: mangled name for ‘T& NativeJIT::ExpressionTree::PlacementConstruct(ConstructorArgs&& ...) [with T = NativeJIT::ImmediateNode<float (*)(float) throw (), (NativeJIT::ImmediateCategory)1>; ConstructorArgs = {NativeJIT::ExpressionNodeFactory&, float (*&)(float) throw ()}]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
    In file included from <my-path-to>NativeJIT/inc/NativeJIT/Function.h:27:0,
                     from <my-path-to>NativeJIT/Examples/Parser/Parser.cpp:7:
    <my-path-to>NativeJIT/inc/NativeJIT/ExpressionNodeFactory.h:67:23: error: mangled name for ‘NativeJIT::ImmediateNode<T>& NativeJIT::ExpressionNodeFactory::Immediate(T) [with T = float (*)(float) throw ()]’ will change in C++17 because the exception specification is part of a function type [-Werror=noexcept-type]
         ImmediateNode<T>& ExpressionNodeFactory::Immediate(T value)
                           ^~~~~~~~~~~~~~~~~~~~~
    cc1plus: all warnings being treated as errors
    Examples/Parser/CMakeFiles/Parser.dir/build.make:62: recipe for target 'Examples/Parser/CMakeFiles/Parser.dir/Parser.cpp.o' failed
    make[2]: *** [Examples/Parser/CMakeFiles/Parser.dir/Parser.cpp.o] Error 1
    CMakeFiles/Makefile2:685: recipe for target 'Examples/Parser/CMakeFiles/Parser.dir/all' failed
    make[1]: *** [Examples/Parser/CMakeFiles/Parser.dir/all] Error 2
    Makefile:140: recipe for target 'all' failed
    

    In the meantime, I'll try to disable the warning flag in CMake.

    opened by jackbergus 0
  • popcnt issue on CentOS 7.2

    popcnt issue on CentOS 7.2

    I built NativeJIT with g++ 5.4.0 on CentOS 7.2. Then I tried to compile your "radius" test code (http://bitfunnel.org/getting-started-with-nativejit/) but got following error:"

    /usr/local/gcc54/lib/gcc/x86_64-unknown-linux-gnu/5.4.0/include/popcntintrin.h: In function 'uint8_t NativeJIT::BitOp::GetNonZeroBitCount(uint32_t)': /usr/local/gcc54/lib/gcc/x86_64-unknown-linux-gnu/5.4.0/include/popcntintrin.h:35:1: error: inlining failed in call to always_inline 'int _mm_popcnt_u32(unsigned int)': target specific option mismatch _mm_popcnt_u32 (unsigned int __X) ^ In file included from ./nativejit/inc/NativeJIT/CodeGen/X64CodeGenerator.h:32:0, from ./nativejit/inc/NativeJIT/CodeGen/FunctionBuffer.h:40, from test.cpp:2: ./nativejit/inc/NativeJIT/BitOperations.h:89:55: error: called from here return static_cast<uint8_t>(_mm_popcnt_u32(value)); "

    Am I missing anything?

    Thanks!

    opened by pengxu7 3
  • JumpTable::PatchCallSites has dead code that seems intended to do something?

    JumpTable::PatchCallSites has dead code that seems intended to do something?

        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();
                ptrdiff_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)
                {
                    LogThrowAssert(delta <= std::numeric_limits<int16_t>::max() &&
                                   delta >= std::numeric_limits<int16_t>::min(),
                                   "Overflow/underflow in cast to int16_t.");
                    *(reinterpret_cast<int16_t*>(siteAddress)) = static_cast<int16_t>(delta);
                    siteAddress += size;  // <----------- CODE DOES NOTHING
                }
                else if (size == 4)
                {
                    LogThrowAssert(delta <= std::numeric_limits<int32_t>::max() &&
                                   delta >= std::numeric_limits<int32_t>::min(),
                                   "Overflow/underflow in cast to int32_t.");
                    *(reinterpret_cast<int32_t*>(siteAddress)) = static_cast<int32_t>(delta);
                    siteAddress += size;  // <----------- CODE DOES NOTHING
                }
                else
                {
                    while (size > 0)
                    {
                        *siteAddress++ = static_cast<uint8_t>(delta);
                        delta = delta >> 8;
                        size--;
                    }
                }
            }
        }
    

    siteAddress += size doesn't do anything. I haven't looked at this to figure out what the intent is. It's possible it would be fine to just delete these useless lines, but it's also possible that we have a bug here and something else was intended.

    opened by danluu 0
  • x86 support

    x86 support

    So I tried to compile NativeJIT with the x86 architecture (using VS2015 on Win7) and stumbled over the following roadblocks:

    1. Missing BitOperations (popcnt64, etc) - easily replacable by two calls to their 32bit counterpart
    2. Missing RUNTIME_FUNCTION macro (+ some other stuff for stack unwinding) - fixed by using the dummy struct from Unix (I can live with missing stack unwinding on x86, since it doesn't work on Unix systems, I hardly use it anyway)
    3. #error because of missing _AMD64_ flag - just commented out :)

    Now these three were easy, but now it gets a little bit more complicated:

    1. A ton of compilation errors in the Emit functions because the compiler can't implicitely convert NativeJIT::BaseRegister to NativeJIT::Register<8U, false>. Adding a explicit C-style cast "fixes" those, but I am pretty sure this is not a solution.
    2. Hitting the static_assert in the ExpressionTree::Temporary() method: "The size of the variable is too large."
    3. Some compilation errors when trying to static_cast<> a value to an unsigned int (something like that). This is where I stopped trying :)

    This is way too far in the guts of NativeJIT's internals for me to be able to say if trying to support x86 makes any sense at all.

    opened by christoph-hart 1
Mirror of MRuby JIT

What is mruby mruby is the lightweight implementation of the Ruby language complying to (part of) the ISO standard. Its syntax is Ruby 1.9 compatible.

The Ruby Compiler Survey 2 Nov 18, 2021
Simple, fast, JIT-compiled scripting language for game engines.

Aftel Aftel (acronym for «A Far Too Easy Language») is a programming language, primarily intended to serve as an embeddable scripting language for gam

Rosie 17 May 20, 2022
Lua + libUV + jIT = pure awesomesauce

Luvit 2.0 - Node.JS for the Lua Inventor Welcome to the source code for Luvit 2.0. This repo contains the luvit/luvit metapackage and all luvit/* pack

Luvit Community 3.6k Dec 27, 2022
Per function, Lua JIT using LLVM C++ toolchain

Lua Low Level Brief This is an alternative Lua (5.3.2) implementation that aims to archive better performance by generating native code with the help

Gabriel de Quadros Ligneul 10 Sep 4, 2021
Parsing Expression Grammar Template Library

Welcome to the PEGTL The Parsing Expression Grammar Template Library (PEGTL) is a zero-dependency C++ header-only parser combinator library for creati

The Art of C++ 1.6k Jan 8, 2023
Header-only ECMAScript (JavaScript) compatible regular expression engine

SRELL (std::regex-like library) is a regular expression template library for C++ and has native support for UTF-8, UTF-16, and UTF-32. This is up-to-d

Dmitry Atamanov 4 Mar 11, 2022
Love 6's Regular Expression Engine. Support Concat/Select/Closure Basic function. Hope u can enjoy this tiny engine :)

Regex_Engine Love 6's Blog Website: https://love6.blog.csdn.net/ Love 6's Regular Expression Engine Hope u can love my tiny regex engine :) maybe a fe

Love6 2 May 24, 2022
Node.js bindings for the Mathematical Expression Toolkit

ExprTk.js This is the Node.js bindings for ExprTk (Github) by @ArashPartow ExprTk.js supports both synchronous and asynchronous background execution o

Momtchil Momtchev 8 Dec 12, 2022
A portable fork of the high-performance regular expression matching library

Vectorscan? A fork of Intel's Hyperscan, modified to run on more platforms. Currently ARM NEON/ASIMD is 100% functional, and Power VSX are in developm

VectorCamp 275 Dec 26, 2022
x64 Windows kernel code execution via user-mode, arbitrary syscall, vulnerable IOCTLs demonstration

anycall x64 Windows kernel code execution via user-mode, arbitrary syscall, vulnerable IOCTLs demonstration Read: https://www.godeye.club/2021/05/14/0

Kento Oki 160 Dec 30, 2022
x64 Windows kernel driver mapper, inject unsigned driver using anycall

anymapper x64 Windows kernel driver mapper, inject unsigned driver using anycall This project is WIP. Todo Fix: Can't make API calls from IAT nor func

Kento Oki 72 Dec 26, 2022
Easily hook WIN32 x64 functions

About Library for easy hooking of arbitrary functions in WIN32 x64 executables. Only requires target function address. Disassembles the function prolo

tcpie 17 Jun 12, 2022
Obfuscate calls to imports by patching in stubs. ICO works on both X86 and X64 binaries.

ICO adds a new section into the image, then begins building stubs for each import that uses a extremely basic routine to decrypt an RVA and places them into the section.

null 43 Dec 15, 2022
A D++ Discord Bot template for Visual Studio 2019 (x64 and x86)

D++ Windows Bot Template A D++ Discord Bot template for Visual Studio 2019 (x64 and x86, release and debug). The result of this tutorial. This templat

brainbox.cc 28 Dec 24, 2022
A Linux x64 tool to trace registers and memory regions.

HellTracer Description A Linux x64 tool to trace registers and memory regions. Build the tool Clone the repository. Compile the tool with make. Add th

Aurélien Tournebise 29 Sep 8, 2022
Module Stomping, No New Thread, HellsGate syscaller, UUID Shellcode Runner for x64 Windows 10!

Ninja UUID Shellcode Runner Module Stomping, No New Thread, HellsGate syscaller, UUID Shellcode Runner for x64 Windows 10! Now supports running Cobalt

Bobby Cooke 362 Dec 30, 2022
very basic and minimalistic hooking "library" for windows (x64 support soon)

IceHook very basic and minimalistic hooking "library" for windows (x64 support soon) Example how to use: typedef void(__stdcall* twglSwapBuffers)(HDC

null 5 Jul 25, 2022
Module Stomping, No New Thread, HellsGate syscaller, UUID Shellcode Runner for x64 Windows 10!

Ninja UUID Shellcode Runner Module Stomping, No New Thread, HellsGate syscaller, UUID Shellcode Runner for x64 Windows 10! Now supports running Cobalt

Bobby Cooke 362 Dec 30, 2022
An open-source x64/x32 debugger for windows.

x64dbg An open-source binary debugger for Windows, aimed at malware analysis and reverse engineering of executables you do not have the source code fo

x64dbg 39.6k Dec 31, 2022