A C++ expression -> x64 JIT

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.

__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

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

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

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

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

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.)
Basically what it sounds like, although I have a few things to note.

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...

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.

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

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

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
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

    // 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.

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

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

opened by jackbergus 0

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?

    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
So I tried to compile NativeJIT with the x86 architecture (using VS2015 on Win7) and stumbled over the following roadblocks:

Missing BitOperations (popcnt64, etc) - easily replacable by two calls to their 32bit counterpart

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)

#error because of missing _AMD64_ flag - just commented out :)

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

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.

Hitting the static_assert in the ExpressionTree::Temporary() method: "The size of the variable is too large."

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