| [opengtl-commits] [199] * new generator for FunctionCaller (which doesn' t bring anything since it is still slow as hell to compile, but at least, it's more easilly extensible to new types) |
[ Thread Index |
Date Index
| More lists.tuxfamily.org/opengtl-commits Archives
]
- To: opengtl-commits@xxxxxxxxxxxxxxxxxxx
- Subject: [opengtl-commits] [199] * new generator for FunctionCaller (which doesn' t bring anything since it is still slow as hell to compile, but at least, it's more easilly extensible to new types)
- From: subversion@xxxxxxxxxxxxx
- Date: Mon, 16 Jun 2008 22:03:16 +0200
Revision: 199
Author: cyrille
Date: 2008-06-16 22:03:15 +0200 (Mon, 16 Jun 2008)
Log Message:
-----------
* new generator for FunctionCaller (which doesn't bring anything since it is still slow as hell to compile, but at least, it's more easilly extensible to new types)
* preparation for the generation of the evaluetePixeles function and of the pixel structure
Modified Paths:
--------------
trunk/OpenGTL/OpenGTL/GTLCore/FunctionCaller_generated_p.h
trunk/OpenGTL/OpenGTL/GTLCore/FunctionCaller_p.cpp
trunk/OpenGTL/OpenShiva/OpenShiva/CodeGenerator_p.cpp
trunk/OpenGTL/OpenShiva/OpenShiva/CodeGenerator_p.h
trunk/OpenGTL/OpenShiva/OpenShiva/Kernel.cpp
trunk/OpenGTL/OpenShiva/OpenShiva/Kernel.h
trunk/OpenGTL/OpenShiva/OpenShiva/Types_p.cpp
trunk/OpenGTL/OpenShiva/OpenShiva/Types_p.h
trunk/OpenGTL/sdk/generate-function-callers.rb
Modified: trunk/OpenGTL/OpenGTL/GTLCore/FunctionCaller_generated_p.h
===================================================================
--- trunk/OpenGTL/OpenGTL/GTLCore/FunctionCaller_generated_p.h 2008-06-15 21:10:19 UTC (rev 198)
+++ trunk/OpenGTL/OpenGTL/GTLCore/FunctionCaller_generated_p.h 2008-06-16 20:03:15 UTC (rev 199)
@@ -20,426 +20,53072 @@
* Boston, MA 02110-1301, USA.
*/
// Number of parameters = 4
-template<typename _TYPE_RETURN_, typename _TYPE_1_, typename _TYPE_2_, typename _TYPE_3_, typename _TYPE_4_>
-class FunctionCaller4 : public FunctionCaller {
+// 0 0,0,0,0
+class FunctionCaller_int_int_int_int_int : public FunctionCaller {
public:
- FunctionCaller4(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ FunctionCaller_int_int_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
{
}
virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
{
GTL_ASSERT(function());
GTL_ASSERT(arguments.size() == 4);
- _TYPE_1_ arg1 = GTLCore::PrimitiveTypeTrait<_TYPE_1_>::convert( arguments[0] );
- _TYPE_2_ arg2 = GTLCore::PrimitiveTypeTrait<_TYPE_2_>::convert( arguments[1] );
- _TYPE_3_ arg3 = GTLCore::PrimitiveTypeTrait<_TYPE_3_>::convert( arguments[2] );
- _TYPE_4_ arg4 = GTLCore::PrimitiveTypeTrait<_TYPE_4_>::convert( arguments[3] );
-
- _TYPE_RETURN_ (*PF)(_TYPE_1_,_TYPE_2_,_TYPE_3_,_TYPE_4_) = (_TYPE_RETURN_(*)(_TYPE_1_,_TYPE_2_,_TYPE_3_,_TYPE_4_)) VirtualMachine::instance()->getPointerToFunction(function());
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(int,int,int,int) = (int(*)(int,int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
}
public:
static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
{
- if(function->parameters().size() == 4)
+ if( function->parameters().size() == 4 )
{
- return new FunctionCaller4<_TYPE_RETURN_, _TYPE_1_, _TYPE_2_, _TYPE_3_, _TYPE_4_>(llvmFunction, function);
+ return new FunctionCaller_int_int_int_int_int(llvmFunction, function);
} else {
+ return new FunctionCallerFallBack(llvmFunction, function);
}
- return 0;
}
};
-template< typename _TYPE_1_, typename _TYPE_2_, typename _TYPE_3_, typename _TYPE_4_>
-class FunctionCaller4<void , _TYPE_1_, _TYPE_2_, _TYPE_3_, _TYPE_4_> : public FunctionCaller {
+// 0 1,0,0,0
+class FunctionCaller_int_bool_int_int_int : public FunctionCaller {
public:
- FunctionCaller4(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ FunctionCaller_int_bool_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
{
}
virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
{
GTL_ASSERT(function());
GTL_ASSERT(arguments.size() == 4);
- _TYPE_1_ arg1 = GTLCore::PrimitiveTypeTrait<_TYPE_1_>::convert( arguments[0] );
- _TYPE_2_ arg2 = GTLCore::PrimitiveTypeTrait<_TYPE_2_>::convert( arguments[1] );
- _TYPE_3_ arg3 = GTLCore::PrimitiveTypeTrait<_TYPE_3_>::convert( arguments[2] );
- _TYPE_4_ arg4 = GTLCore::PrimitiveTypeTrait<_TYPE_4_>::convert( arguments[3] );
-
- void (*PF)(_TYPE_1_,_TYPE_2_,_TYPE_3_,_TYPE_4_) = (void(*)(_TYPE_1_,_TYPE_2_,_TYPE_3_,_TYPE_4_)) VirtualMachine::instance()->getPointerToFunction(function());
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(bool,int,int,int) = (int(*)(bool,int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,0,0,0
+class FunctionCaller_int_unsigned_int_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(unsigned int,int,int,int) = (int(*)(unsigned int,int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,0,0,0
+class FunctionCaller_int_float_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(float,int,int,int) = (int(*)(float,int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,1,0,0
+class FunctionCaller_int_int_bool_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_bool_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(int,bool,int,int) = (int(*)(int,bool,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_bool_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,1,0,0
+class FunctionCaller_int_bool_bool_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_bool_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(bool,bool,int,int) = (int(*)(bool,bool,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_bool_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,1,0,0
+class FunctionCaller_int_unsigned_int_bool_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_bool_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(unsigned int,bool,int,int) = (int(*)(unsigned int,bool,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_bool_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,1,0,0
+class FunctionCaller_int_float_bool_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_bool_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(float,bool,int,int) = (int(*)(float,bool,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_bool_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,2,0,0
+class FunctionCaller_int_int_unsigned_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_unsigned_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(int,unsigned int,int,int) = (int(*)(int,unsigned int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_unsigned_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,2,0,0
+class FunctionCaller_int_bool_unsigned_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_unsigned_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(bool,unsigned int,int,int) = (int(*)(bool,unsigned int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_unsigned_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,2,0,0
+class FunctionCaller_int_unsigned_int_unsigned_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_unsigned_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(unsigned int,unsigned int,int,int) = (int(*)(unsigned int,unsigned int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_unsigned_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,2,0,0
+class FunctionCaller_int_float_unsigned_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_unsigned_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(float,unsigned int,int,int) = (int(*)(float,unsigned int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_unsigned_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,3,0,0
+class FunctionCaller_int_int_float_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_float_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(int,float,int,int) = (int(*)(int,float,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_float_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,3,0,0
+class FunctionCaller_int_bool_float_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_float_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(bool,float,int,int) = (int(*)(bool,float,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_float_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,3,0,0
+class FunctionCaller_int_unsigned_int_float_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_float_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(unsigned int,float,int,int) = (int(*)(unsigned int,float,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_float_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,3,0,0
+class FunctionCaller_int_float_float_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_float_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(float,float,int,int) = (int(*)(float,float,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_float_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,0,1,0
+class FunctionCaller_int_int_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(int,int,bool,int) = (int(*)(int,int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,0,1,0
+class FunctionCaller_int_bool_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(bool,int,bool,int) = (int(*)(bool,int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,0,1,0
+class FunctionCaller_int_unsigned_int_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(unsigned int,int,bool,int) = (int(*)(unsigned int,int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,0,1,0
+class FunctionCaller_int_float_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(float,int,bool,int) = (int(*)(float,int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,1,1,0
+class FunctionCaller_int_int_bool_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_bool_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(int,bool,bool,int) = (int(*)(int,bool,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_bool_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,1,1,0
+class FunctionCaller_int_bool_bool_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_bool_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(bool,bool,bool,int) = (int(*)(bool,bool,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_bool_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,1,1,0
+class FunctionCaller_int_unsigned_int_bool_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_bool_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(unsigned int,bool,bool,int) = (int(*)(unsigned int,bool,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_bool_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,1,1,0
+class FunctionCaller_int_float_bool_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_bool_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(float,bool,bool,int) = (int(*)(float,bool,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_bool_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,2,1,0
+class FunctionCaller_int_int_unsigned_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_unsigned_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(int,unsigned int,bool,int) = (int(*)(int,unsigned int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_unsigned_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,2,1,0
+class FunctionCaller_int_bool_unsigned_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_unsigned_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(bool,unsigned int,bool,int) = (int(*)(bool,unsigned int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_unsigned_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,2,1,0
+class FunctionCaller_int_unsigned_int_unsigned_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_unsigned_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(unsigned int,unsigned int,bool,int) = (int(*)(unsigned int,unsigned int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_unsigned_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,2,1,0
+class FunctionCaller_int_float_unsigned_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_unsigned_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(float,unsigned int,bool,int) = (int(*)(float,unsigned int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_unsigned_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,3,1,0
+class FunctionCaller_int_int_float_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_float_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(int,float,bool,int) = (int(*)(int,float,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_float_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,3,1,0
+class FunctionCaller_int_bool_float_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_float_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(bool,float,bool,int) = (int(*)(bool,float,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_float_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,3,1,0
+class FunctionCaller_int_unsigned_int_float_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_float_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(unsigned int,float,bool,int) = (int(*)(unsigned int,float,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_float_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,3,1,0
+class FunctionCaller_int_float_float_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_float_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(float,float,bool,int) = (int(*)(float,float,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_float_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,0,2,0
+class FunctionCaller_int_int_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(int,int,unsigned int,int) = (int(*)(int,int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,0,2,0
+class FunctionCaller_int_bool_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(bool,int,unsigned int,int) = (int(*)(bool,int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,0,2,0
+class FunctionCaller_int_unsigned_int_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(unsigned int,int,unsigned int,int) = (int(*)(unsigned int,int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,0,2,0
+class FunctionCaller_int_float_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(float,int,unsigned int,int) = (int(*)(float,int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,1,2,0
+class FunctionCaller_int_int_bool_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_bool_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(int,bool,unsigned int,int) = (int(*)(int,bool,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_bool_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,1,2,0
+class FunctionCaller_int_bool_bool_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_bool_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(bool,bool,unsigned int,int) = (int(*)(bool,bool,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_bool_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,1,2,0
+class FunctionCaller_int_unsigned_int_bool_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_bool_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(unsigned int,bool,unsigned int,int) = (int(*)(unsigned int,bool,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_bool_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,1,2,0
+class FunctionCaller_int_float_bool_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_bool_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(float,bool,unsigned int,int) = (int(*)(float,bool,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_bool_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,2,2,0
+class FunctionCaller_int_int_unsigned_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_unsigned_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(int,unsigned int,unsigned int,int) = (int(*)(int,unsigned int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_unsigned_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,2,2,0
+class FunctionCaller_int_bool_unsigned_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_unsigned_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(bool,unsigned int,unsigned int,int) = (int(*)(bool,unsigned int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_unsigned_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,2,2,0
+class FunctionCaller_int_unsigned_int_unsigned_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_unsigned_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(unsigned int,unsigned int,unsigned int,int) = (int(*)(unsigned int,unsigned int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_unsigned_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,2,2,0
+class FunctionCaller_int_float_unsigned_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_unsigned_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(float,unsigned int,unsigned int,int) = (int(*)(float,unsigned int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_unsigned_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,3,2,0
+class FunctionCaller_int_int_float_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_float_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(int,float,unsigned int,int) = (int(*)(int,float,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_float_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,3,2,0
+class FunctionCaller_int_bool_float_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_float_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(bool,float,unsigned int,int) = (int(*)(bool,float,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_float_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,3,2,0
+class FunctionCaller_int_unsigned_int_float_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_float_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(unsigned int,float,unsigned int,int) = (int(*)(unsigned int,float,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_float_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,3,2,0
+class FunctionCaller_int_float_float_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_float_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(float,float,unsigned int,int) = (int(*)(float,float,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_float_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,0,3,0
+class FunctionCaller_int_int_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(int,int,float,int) = (int(*)(int,int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,0,3,0
+class FunctionCaller_int_bool_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(bool,int,float,int) = (int(*)(bool,int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,0,3,0
+class FunctionCaller_int_unsigned_int_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(unsigned int,int,float,int) = (int(*)(unsigned int,int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,0,3,0
+class FunctionCaller_int_float_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(float,int,float,int) = (int(*)(float,int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,1,3,0
+class FunctionCaller_int_int_bool_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_bool_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(int,bool,float,int) = (int(*)(int,bool,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_bool_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,1,3,0
+class FunctionCaller_int_bool_bool_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_bool_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(bool,bool,float,int) = (int(*)(bool,bool,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_bool_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,1,3,0
+class FunctionCaller_int_unsigned_int_bool_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_bool_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(unsigned int,bool,float,int) = (int(*)(unsigned int,bool,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_bool_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,1,3,0
+class FunctionCaller_int_float_bool_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_bool_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(float,bool,float,int) = (int(*)(float,bool,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_bool_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,2,3,0
+class FunctionCaller_int_int_unsigned_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_unsigned_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(int,unsigned int,float,int) = (int(*)(int,unsigned int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_unsigned_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,2,3,0
+class FunctionCaller_int_bool_unsigned_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_unsigned_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(bool,unsigned int,float,int) = (int(*)(bool,unsigned int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_unsigned_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,2,3,0
+class FunctionCaller_int_unsigned_int_unsigned_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_unsigned_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(unsigned int,unsigned int,float,int) = (int(*)(unsigned int,unsigned int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_unsigned_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,2,3,0
+class FunctionCaller_int_float_unsigned_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_unsigned_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(float,unsigned int,float,int) = (int(*)(float,unsigned int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_unsigned_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,3,3,0
+class FunctionCaller_int_int_float_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_float_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(int,float,float,int) = (int(*)(int,float,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_float_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,3,3,0
+class FunctionCaller_int_bool_float_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_float_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(bool,float,float,int) = (int(*)(bool,float,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_float_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,3,3,0
+class FunctionCaller_int_unsigned_int_float_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_float_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(unsigned int,float,float,int) = (int(*)(unsigned int,float,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_float_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,3,3,0
+class FunctionCaller_int_float_float_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_float_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ int (*PF)(float,float,float,int) = (int(*)(float,float,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_float_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,0,0,1
+class FunctionCaller_int_int_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(int,int,int,bool) = (int(*)(int,int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,0,0,1
+class FunctionCaller_int_bool_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(bool,int,int,bool) = (int(*)(bool,int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,0,0,1
+class FunctionCaller_int_unsigned_int_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(unsigned int,int,int,bool) = (int(*)(unsigned int,int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,0,0,1
+class FunctionCaller_int_float_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(float,int,int,bool) = (int(*)(float,int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,1,0,1
+class FunctionCaller_int_int_bool_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_bool_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(int,bool,int,bool) = (int(*)(int,bool,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_bool_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,1,0,1
+class FunctionCaller_int_bool_bool_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_bool_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(bool,bool,int,bool) = (int(*)(bool,bool,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_bool_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,1,0,1
+class FunctionCaller_int_unsigned_int_bool_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_bool_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(unsigned int,bool,int,bool) = (int(*)(unsigned int,bool,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_bool_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,1,0,1
+class FunctionCaller_int_float_bool_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_bool_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(float,bool,int,bool) = (int(*)(float,bool,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_bool_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,2,0,1
+class FunctionCaller_int_int_unsigned_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_unsigned_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(int,unsigned int,int,bool) = (int(*)(int,unsigned int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_unsigned_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,2,0,1
+class FunctionCaller_int_bool_unsigned_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_unsigned_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(bool,unsigned int,int,bool) = (int(*)(bool,unsigned int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_unsigned_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,2,0,1
+class FunctionCaller_int_unsigned_int_unsigned_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_unsigned_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(unsigned int,unsigned int,int,bool) = (int(*)(unsigned int,unsigned int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_unsigned_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,2,0,1
+class FunctionCaller_int_float_unsigned_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_unsigned_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(float,unsigned int,int,bool) = (int(*)(float,unsigned int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_unsigned_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,3,0,1
+class FunctionCaller_int_int_float_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_float_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(int,float,int,bool) = (int(*)(int,float,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_float_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,3,0,1
+class FunctionCaller_int_bool_float_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_float_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(bool,float,int,bool) = (int(*)(bool,float,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_float_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,3,0,1
+class FunctionCaller_int_unsigned_int_float_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_float_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(unsigned int,float,int,bool) = (int(*)(unsigned int,float,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_float_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,3,0,1
+class FunctionCaller_int_float_float_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_float_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(float,float,int,bool) = (int(*)(float,float,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_float_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,0,1,1
+class FunctionCaller_int_int_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(int,int,bool,bool) = (int(*)(int,int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,0,1,1
+class FunctionCaller_int_bool_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(bool,int,bool,bool) = (int(*)(bool,int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,0,1,1
+class FunctionCaller_int_unsigned_int_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(unsigned int,int,bool,bool) = (int(*)(unsigned int,int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,0,1,1
+class FunctionCaller_int_float_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(float,int,bool,bool) = (int(*)(float,int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,1,1,1
+class FunctionCaller_int_int_bool_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_bool_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(int,bool,bool,bool) = (int(*)(int,bool,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_bool_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,1,1,1
+class FunctionCaller_int_bool_bool_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_bool_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(bool,bool,bool,bool) = (int(*)(bool,bool,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_bool_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,1,1,1
+class FunctionCaller_int_unsigned_int_bool_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_bool_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(unsigned int,bool,bool,bool) = (int(*)(unsigned int,bool,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_bool_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,1,1,1
+class FunctionCaller_int_float_bool_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_bool_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(float,bool,bool,bool) = (int(*)(float,bool,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_bool_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,2,1,1
+class FunctionCaller_int_int_unsigned_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_unsigned_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(int,unsigned int,bool,bool) = (int(*)(int,unsigned int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_unsigned_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,2,1,1
+class FunctionCaller_int_bool_unsigned_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_unsigned_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(bool,unsigned int,bool,bool) = (int(*)(bool,unsigned int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_unsigned_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,2,1,1
+class FunctionCaller_int_unsigned_int_unsigned_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_unsigned_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(unsigned int,unsigned int,bool,bool) = (int(*)(unsigned int,unsigned int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_unsigned_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,2,1,1
+class FunctionCaller_int_float_unsigned_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_unsigned_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(float,unsigned int,bool,bool) = (int(*)(float,unsigned int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_unsigned_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,3,1,1
+class FunctionCaller_int_int_float_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_float_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(int,float,bool,bool) = (int(*)(int,float,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_float_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,3,1,1
+class FunctionCaller_int_bool_float_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_float_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(bool,float,bool,bool) = (int(*)(bool,float,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_float_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,3,1,1
+class FunctionCaller_int_unsigned_int_float_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_float_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(unsigned int,float,bool,bool) = (int(*)(unsigned int,float,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_float_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,3,1,1
+class FunctionCaller_int_float_float_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_float_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(float,float,bool,bool) = (int(*)(float,float,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_float_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,0,2,1
+class FunctionCaller_int_int_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(int,int,unsigned int,bool) = (int(*)(int,int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,0,2,1
+class FunctionCaller_int_bool_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(bool,int,unsigned int,bool) = (int(*)(bool,int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,0,2,1
+class FunctionCaller_int_unsigned_int_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(unsigned int,int,unsigned int,bool) = (int(*)(unsigned int,int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,0,2,1
+class FunctionCaller_int_float_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(float,int,unsigned int,bool) = (int(*)(float,int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,1,2,1
+class FunctionCaller_int_int_bool_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_bool_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(int,bool,unsigned int,bool) = (int(*)(int,bool,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_bool_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,1,2,1
+class FunctionCaller_int_bool_bool_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_bool_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(bool,bool,unsigned int,bool) = (int(*)(bool,bool,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_bool_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,1,2,1
+class FunctionCaller_int_unsigned_int_bool_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_bool_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(unsigned int,bool,unsigned int,bool) = (int(*)(unsigned int,bool,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_bool_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,1,2,1
+class FunctionCaller_int_float_bool_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_bool_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(float,bool,unsigned int,bool) = (int(*)(float,bool,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_bool_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,2,2,1
+class FunctionCaller_int_int_unsigned_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_unsigned_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(int,unsigned int,unsigned int,bool) = (int(*)(int,unsigned int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_unsigned_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,2,2,1
+class FunctionCaller_int_bool_unsigned_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_unsigned_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(bool,unsigned int,unsigned int,bool) = (int(*)(bool,unsigned int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_unsigned_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,2,2,1
+class FunctionCaller_int_unsigned_int_unsigned_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_unsigned_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(unsigned int,unsigned int,unsigned int,bool) = (int(*)(unsigned int,unsigned int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_unsigned_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,2,2,1
+class FunctionCaller_int_float_unsigned_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_unsigned_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(float,unsigned int,unsigned int,bool) = (int(*)(float,unsigned int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_unsigned_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,3,2,1
+class FunctionCaller_int_int_float_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_float_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(int,float,unsigned int,bool) = (int(*)(int,float,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_float_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,3,2,1
+class FunctionCaller_int_bool_float_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_float_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(bool,float,unsigned int,bool) = (int(*)(bool,float,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_float_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,3,2,1
+class FunctionCaller_int_unsigned_int_float_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_float_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(unsigned int,float,unsigned int,bool) = (int(*)(unsigned int,float,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_float_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,3,2,1
+class FunctionCaller_int_float_float_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_float_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(float,float,unsigned int,bool) = (int(*)(float,float,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_float_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,0,3,1
+class FunctionCaller_int_int_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(int,int,float,bool) = (int(*)(int,int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,0,3,1
+class FunctionCaller_int_bool_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(bool,int,float,bool) = (int(*)(bool,int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,0,3,1
+class FunctionCaller_int_unsigned_int_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(unsigned int,int,float,bool) = (int(*)(unsigned int,int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,0,3,1
+class FunctionCaller_int_float_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(float,int,float,bool) = (int(*)(float,int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,1,3,1
+class FunctionCaller_int_int_bool_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_bool_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(int,bool,float,bool) = (int(*)(int,bool,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_bool_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,1,3,1
+class FunctionCaller_int_bool_bool_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_bool_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(bool,bool,float,bool) = (int(*)(bool,bool,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_bool_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,1,3,1
+class FunctionCaller_int_unsigned_int_bool_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_bool_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(unsigned int,bool,float,bool) = (int(*)(unsigned int,bool,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_bool_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,1,3,1
+class FunctionCaller_int_float_bool_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_bool_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(float,bool,float,bool) = (int(*)(float,bool,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_bool_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,2,3,1
+class FunctionCaller_int_int_unsigned_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_unsigned_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(int,unsigned int,float,bool) = (int(*)(int,unsigned int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_unsigned_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,2,3,1
+class FunctionCaller_int_bool_unsigned_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_unsigned_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(bool,unsigned int,float,bool) = (int(*)(bool,unsigned int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_unsigned_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,2,3,1
+class FunctionCaller_int_unsigned_int_unsigned_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_unsigned_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(unsigned int,unsigned int,float,bool) = (int(*)(unsigned int,unsigned int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_unsigned_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,2,3,1
+class FunctionCaller_int_float_unsigned_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_unsigned_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(float,unsigned int,float,bool) = (int(*)(float,unsigned int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_unsigned_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,3,3,1
+class FunctionCaller_int_int_float_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_float_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(int,float,float,bool) = (int(*)(int,float,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_float_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,3,3,1
+class FunctionCaller_int_bool_float_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_float_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(bool,float,float,bool) = (int(*)(bool,float,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_float_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,3,3,1
+class FunctionCaller_int_unsigned_int_float_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_float_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(unsigned int,float,float,bool) = (int(*)(unsigned int,float,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_float_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,3,3,1
+class FunctionCaller_int_float_float_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_float_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ int (*PF)(float,float,float,bool) = (int(*)(float,float,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_float_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,0,0,2
+class FunctionCaller_int_int_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(int,int,int,unsigned int) = (int(*)(int,int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,0,0,2
+class FunctionCaller_int_bool_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(bool,int,int,unsigned int) = (int(*)(bool,int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,0,0,2
+class FunctionCaller_int_unsigned_int_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(unsigned int,int,int,unsigned int) = (int(*)(unsigned int,int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,0,0,2
+class FunctionCaller_int_float_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(float,int,int,unsigned int) = (int(*)(float,int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,1,0,2
+class FunctionCaller_int_int_bool_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_bool_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(int,bool,int,unsigned int) = (int(*)(int,bool,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_bool_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,1,0,2
+class FunctionCaller_int_bool_bool_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_bool_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(bool,bool,int,unsigned int) = (int(*)(bool,bool,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_bool_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,1,0,2
+class FunctionCaller_int_unsigned_int_bool_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_bool_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(unsigned int,bool,int,unsigned int) = (int(*)(unsigned int,bool,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_bool_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,1,0,2
+class FunctionCaller_int_float_bool_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_bool_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(float,bool,int,unsigned int) = (int(*)(float,bool,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_bool_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,2,0,2
+class FunctionCaller_int_int_unsigned_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_unsigned_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(int,unsigned int,int,unsigned int) = (int(*)(int,unsigned int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_unsigned_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,2,0,2
+class FunctionCaller_int_bool_unsigned_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_unsigned_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(bool,unsigned int,int,unsigned int) = (int(*)(bool,unsigned int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_unsigned_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,2,0,2
+class FunctionCaller_int_unsigned_int_unsigned_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_unsigned_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(unsigned int,unsigned int,int,unsigned int) = (int(*)(unsigned int,unsigned int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_unsigned_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,2,0,2
+class FunctionCaller_int_float_unsigned_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_unsigned_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(float,unsigned int,int,unsigned int) = (int(*)(float,unsigned int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_unsigned_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,3,0,2
+class FunctionCaller_int_int_float_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_float_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(int,float,int,unsigned int) = (int(*)(int,float,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_float_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,3,0,2
+class FunctionCaller_int_bool_float_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_float_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(bool,float,int,unsigned int) = (int(*)(bool,float,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_float_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,3,0,2
+class FunctionCaller_int_unsigned_int_float_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_float_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(unsigned int,float,int,unsigned int) = (int(*)(unsigned int,float,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_float_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,3,0,2
+class FunctionCaller_int_float_float_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_float_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(float,float,int,unsigned int) = (int(*)(float,float,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_float_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,0,1,2
+class FunctionCaller_int_int_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(int,int,bool,unsigned int) = (int(*)(int,int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,0,1,2
+class FunctionCaller_int_bool_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(bool,int,bool,unsigned int) = (int(*)(bool,int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,0,1,2
+class FunctionCaller_int_unsigned_int_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(unsigned int,int,bool,unsigned int) = (int(*)(unsigned int,int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,0,1,2
+class FunctionCaller_int_float_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(float,int,bool,unsigned int) = (int(*)(float,int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,1,1,2
+class FunctionCaller_int_int_bool_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_bool_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(int,bool,bool,unsigned int) = (int(*)(int,bool,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_bool_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,1,1,2
+class FunctionCaller_int_bool_bool_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_bool_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(bool,bool,bool,unsigned int) = (int(*)(bool,bool,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_bool_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,1,1,2
+class FunctionCaller_int_unsigned_int_bool_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_bool_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(unsigned int,bool,bool,unsigned int) = (int(*)(unsigned int,bool,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_bool_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,1,1,2
+class FunctionCaller_int_float_bool_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_bool_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(float,bool,bool,unsigned int) = (int(*)(float,bool,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_bool_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,2,1,2
+class FunctionCaller_int_int_unsigned_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_unsigned_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(int,unsigned int,bool,unsigned int) = (int(*)(int,unsigned int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_unsigned_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,2,1,2
+class FunctionCaller_int_bool_unsigned_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_unsigned_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(bool,unsigned int,bool,unsigned int) = (int(*)(bool,unsigned int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_unsigned_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,2,1,2
+class FunctionCaller_int_unsigned_int_unsigned_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_unsigned_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(unsigned int,unsigned int,bool,unsigned int) = (int(*)(unsigned int,unsigned int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_unsigned_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,2,1,2
+class FunctionCaller_int_float_unsigned_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_unsigned_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(float,unsigned int,bool,unsigned int) = (int(*)(float,unsigned int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_unsigned_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,3,1,2
+class FunctionCaller_int_int_float_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_float_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(int,float,bool,unsigned int) = (int(*)(int,float,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_float_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,3,1,2
+class FunctionCaller_int_bool_float_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_float_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(bool,float,bool,unsigned int) = (int(*)(bool,float,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_float_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,3,1,2
+class FunctionCaller_int_unsigned_int_float_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_float_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(unsigned int,float,bool,unsigned int) = (int(*)(unsigned int,float,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_float_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,3,1,2
+class FunctionCaller_int_float_float_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_float_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(float,float,bool,unsigned int) = (int(*)(float,float,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_float_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,0,2,2
+class FunctionCaller_int_int_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(int,int,unsigned int,unsigned int) = (int(*)(int,int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,0,2,2
+class FunctionCaller_int_bool_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(bool,int,unsigned int,unsigned int) = (int(*)(bool,int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,0,2,2
+class FunctionCaller_int_unsigned_int_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(unsigned int,int,unsigned int,unsigned int) = (int(*)(unsigned int,int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,0,2,2
+class FunctionCaller_int_float_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(float,int,unsigned int,unsigned int) = (int(*)(float,int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,1,2,2
+class FunctionCaller_int_int_bool_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_bool_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(int,bool,unsigned int,unsigned int) = (int(*)(int,bool,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_bool_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,1,2,2
+class FunctionCaller_int_bool_bool_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_bool_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(bool,bool,unsigned int,unsigned int) = (int(*)(bool,bool,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_bool_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,1,2,2
+class FunctionCaller_int_unsigned_int_bool_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_bool_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(unsigned int,bool,unsigned int,unsigned int) = (int(*)(unsigned int,bool,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_bool_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,1,2,2
+class FunctionCaller_int_float_bool_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_bool_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(float,bool,unsigned int,unsigned int) = (int(*)(float,bool,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_bool_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,2,2,2
+class FunctionCaller_int_int_unsigned_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_unsigned_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(int,unsigned int,unsigned int,unsigned int) = (int(*)(int,unsigned int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_unsigned_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,2,2,2
+class FunctionCaller_int_bool_unsigned_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_unsigned_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(bool,unsigned int,unsigned int,unsigned int) = (int(*)(bool,unsigned int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_unsigned_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,2,2,2
+class FunctionCaller_int_unsigned_int_unsigned_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_unsigned_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(unsigned int,unsigned int,unsigned int,unsigned int) = (int(*)(unsigned int,unsigned int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_unsigned_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,2,2,2
+class FunctionCaller_int_float_unsigned_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_unsigned_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(float,unsigned int,unsigned int,unsigned int) = (int(*)(float,unsigned int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_unsigned_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,3,2,2
+class FunctionCaller_int_int_float_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_float_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(int,float,unsigned int,unsigned int) = (int(*)(int,float,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_float_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,3,2,2
+class FunctionCaller_int_bool_float_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_float_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(bool,float,unsigned int,unsigned int) = (int(*)(bool,float,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_float_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,3,2,2
+class FunctionCaller_int_unsigned_int_float_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_float_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(unsigned int,float,unsigned int,unsigned int) = (int(*)(unsigned int,float,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_float_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,3,2,2
+class FunctionCaller_int_float_float_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_float_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(float,float,unsigned int,unsigned int) = (int(*)(float,float,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_float_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,0,3,2
+class FunctionCaller_int_int_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(int,int,float,unsigned int) = (int(*)(int,int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,0,3,2
+class FunctionCaller_int_bool_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(bool,int,float,unsigned int) = (int(*)(bool,int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,0,3,2
+class FunctionCaller_int_unsigned_int_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(unsigned int,int,float,unsigned int) = (int(*)(unsigned int,int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,0,3,2
+class FunctionCaller_int_float_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(float,int,float,unsigned int) = (int(*)(float,int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,1,3,2
+class FunctionCaller_int_int_bool_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_bool_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(int,bool,float,unsigned int) = (int(*)(int,bool,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_bool_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,1,3,2
+class FunctionCaller_int_bool_bool_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_bool_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(bool,bool,float,unsigned int) = (int(*)(bool,bool,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_bool_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,1,3,2
+class FunctionCaller_int_unsigned_int_bool_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_bool_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(unsigned int,bool,float,unsigned int) = (int(*)(unsigned int,bool,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_bool_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,1,3,2
+class FunctionCaller_int_float_bool_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_bool_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(float,bool,float,unsigned int) = (int(*)(float,bool,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_bool_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,2,3,2
+class FunctionCaller_int_int_unsigned_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_unsigned_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(int,unsigned int,float,unsigned int) = (int(*)(int,unsigned int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_unsigned_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,2,3,2
+class FunctionCaller_int_bool_unsigned_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_unsigned_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(bool,unsigned int,float,unsigned int) = (int(*)(bool,unsigned int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_unsigned_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,2,3,2
+class FunctionCaller_int_unsigned_int_unsigned_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_unsigned_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(unsigned int,unsigned int,float,unsigned int) = (int(*)(unsigned int,unsigned int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_unsigned_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,2,3,2
+class FunctionCaller_int_float_unsigned_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_unsigned_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(float,unsigned int,float,unsigned int) = (int(*)(float,unsigned int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_unsigned_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,3,3,2
+class FunctionCaller_int_int_float_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_float_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(int,float,float,unsigned int) = (int(*)(int,float,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_float_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,3,3,2
+class FunctionCaller_int_bool_float_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_float_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(bool,float,float,unsigned int) = (int(*)(bool,float,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_float_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,3,3,2
+class FunctionCaller_int_unsigned_int_float_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_float_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(unsigned int,float,float,unsigned int) = (int(*)(unsigned int,float,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_float_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,3,3,2
+class FunctionCaller_int_float_float_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_float_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ int (*PF)(float,float,float,unsigned int) = (int(*)(float,float,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_float_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,0,0,3
+class FunctionCaller_int_int_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(int,int,int,float) = (int(*)(int,int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,0,0,3
+class FunctionCaller_int_bool_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(bool,int,int,float) = (int(*)(bool,int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,0,0,3
+class FunctionCaller_int_unsigned_int_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(unsigned int,int,int,float) = (int(*)(unsigned int,int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,0,0,3
+class FunctionCaller_int_float_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(float,int,int,float) = (int(*)(float,int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,1,0,3
+class FunctionCaller_int_int_bool_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_bool_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(int,bool,int,float) = (int(*)(int,bool,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_bool_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,1,0,3
+class FunctionCaller_int_bool_bool_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_bool_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(bool,bool,int,float) = (int(*)(bool,bool,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_bool_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,1,0,3
+class FunctionCaller_int_unsigned_int_bool_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_bool_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(unsigned int,bool,int,float) = (int(*)(unsigned int,bool,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_bool_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,1,0,3
+class FunctionCaller_int_float_bool_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_bool_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(float,bool,int,float) = (int(*)(float,bool,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_bool_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,2,0,3
+class FunctionCaller_int_int_unsigned_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_unsigned_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(int,unsigned int,int,float) = (int(*)(int,unsigned int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_unsigned_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,2,0,3
+class FunctionCaller_int_bool_unsigned_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_unsigned_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(bool,unsigned int,int,float) = (int(*)(bool,unsigned int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_unsigned_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,2,0,3
+class FunctionCaller_int_unsigned_int_unsigned_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_unsigned_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(unsigned int,unsigned int,int,float) = (int(*)(unsigned int,unsigned int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_unsigned_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,2,0,3
+class FunctionCaller_int_float_unsigned_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_unsigned_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(float,unsigned int,int,float) = (int(*)(float,unsigned int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_unsigned_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,3,0,3
+class FunctionCaller_int_int_float_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_float_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(int,float,int,float) = (int(*)(int,float,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_float_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,3,0,3
+class FunctionCaller_int_bool_float_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_float_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(bool,float,int,float) = (int(*)(bool,float,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_float_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,3,0,3
+class FunctionCaller_int_unsigned_int_float_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_float_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(unsigned int,float,int,float) = (int(*)(unsigned int,float,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_float_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,3,0,3
+class FunctionCaller_int_float_float_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_float_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(float,float,int,float) = (int(*)(float,float,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_float_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,0,1,3
+class FunctionCaller_int_int_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(int,int,bool,float) = (int(*)(int,int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,0,1,3
+class FunctionCaller_int_bool_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(bool,int,bool,float) = (int(*)(bool,int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,0,1,3
+class FunctionCaller_int_unsigned_int_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(unsigned int,int,bool,float) = (int(*)(unsigned int,int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,0,1,3
+class FunctionCaller_int_float_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(float,int,bool,float) = (int(*)(float,int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,1,1,3
+class FunctionCaller_int_int_bool_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_bool_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(int,bool,bool,float) = (int(*)(int,bool,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_bool_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,1,1,3
+class FunctionCaller_int_bool_bool_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_bool_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(bool,bool,bool,float) = (int(*)(bool,bool,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_bool_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,1,1,3
+class FunctionCaller_int_unsigned_int_bool_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_bool_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(unsigned int,bool,bool,float) = (int(*)(unsigned int,bool,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_bool_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,1,1,3
+class FunctionCaller_int_float_bool_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_bool_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(float,bool,bool,float) = (int(*)(float,bool,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_bool_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,2,1,3
+class FunctionCaller_int_int_unsigned_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_unsigned_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(int,unsigned int,bool,float) = (int(*)(int,unsigned int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_unsigned_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,2,1,3
+class FunctionCaller_int_bool_unsigned_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_unsigned_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(bool,unsigned int,bool,float) = (int(*)(bool,unsigned int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_unsigned_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,2,1,3
+class FunctionCaller_int_unsigned_int_unsigned_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_unsigned_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(unsigned int,unsigned int,bool,float) = (int(*)(unsigned int,unsigned int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_unsigned_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,2,1,3
+class FunctionCaller_int_float_unsigned_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_unsigned_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(float,unsigned int,bool,float) = (int(*)(float,unsigned int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_unsigned_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,3,1,3
+class FunctionCaller_int_int_float_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_float_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(int,float,bool,float) = (int(*)(int,float,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_float_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,3,1,3
+class FunctionCaller_int_bool_float_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_float_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(bool,float,bool,float) = (int(*)(bool,float,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_float_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,3,1,3
+class FunctionCaller_int_unsigned_int_float_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_float_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(unsigned int,float,bool,float) = (int(*)(unsigned int,float,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_float_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,3,1,3
+class FunctionCaller_int_float_float_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_float_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(float,float,bool,float) = (int(*)(float,float,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_float_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,0,2,3
+class FunctionCaller_int_int_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(int,int,unsigned int,float) = (int(*)(int,int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,0,2,3
+class FunctionCaller_int_bool_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(bool,int,unsigned int,float) = (int(*)(bool,int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,0,2,3
+class FunctionCaller_int_unsigned_int_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(unsigned int,int,unsigned int,float) = (int(*)(unsigned int,int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,0,2,3
+class FunctionCaller_int_float_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(float,int,unsigned int,float) = (int(*)(float,int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,1,2,3
+class FunctionCaller_int_int_bool_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_bool_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(int,bool,unsigned int,float) = (int(*)(int,bool,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_bool_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,1,2,3
+class FunctionCaller_int_bool_bool_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_bool_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(bool,bool,unsigned int,float) = (int(*)(bool,bool,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_bool_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,1,2,3
+class FunctionCaller_int_unsigned_int_bool_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_bool_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(unsigned int,bool,unsigned int,float) = (int(*)(unsigned int,bool,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_bool_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,1,2,3
+class FunctionCaller_int_float_bool_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_bool_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(float,bool,unsigned int,float) = (int(*)(float,bool,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_bool_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,2,2,3
+class FunctionCaller_int_int_unsigned_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_unsigned_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(int,unsigned int,unsigned int,float) = (int(*)(int,unsigned int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_unsigned_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,2,2,3
+class FunctionCaller_int_bool_unsigned_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_unsigned_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(bool,unsigned int,unsigned int,float) = (int(*)(bool,unsigned int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_unsigned_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,2,2,3
+class FunctionCaller_int_unsigned_int_unsigned_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_unsigned_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(unsigned int,unsigned int,unsigned int,float) = (int(*)(unsigned int,unsigned int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_unsigned_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,2,2,3
+class FunctionCaller_int_float_unsigned_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_unsigned_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(float,unsigned int,unsigned int,float) = (int(*)(float,unsigned int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_unsigned_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,3,2,3
+class FunctionCaller_int_int_float_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_float_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(int,float,unsigned int,float) = (int(*)(int,float,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_float_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,3,2,3
+class FunctionCaller_int_bool_float_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_float_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(bool,float,unsigned int,float) = (int(*)(bool,float,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_float_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,3,2,3
+class FunctionCaller_int_unsigned_int_float_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_float_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(unsigned int,float,unsigned int,float) = (int(*)(unsigned int,float,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_float_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,3,2,3
+class FunctionCaller_int_float_float_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_float_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(float,float,unsigned int,float) = (int(*)(float,float,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_float_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,0,3,3
+class FunctionCaller_int_int_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(int,int,float,float) = (int(*)(int,int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,0,3,3
+class FunctionCaller_int_bool_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(bool,int,float,float) = (int(*)(bool,int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,0,3,3
+class FunctionCaller_int_unsigned_int_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(unsigned int,int,float,float) = (int(*)(unsigned int,int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,0,3,3
+class FunctionCaller_int_float_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(float,int,float,float) = (int(*)(float,int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,1,3,3
+class FunctionCaller_int_int_bool_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_bool_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(int,bool,float,float) = (int(*)(int,bool,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_bool_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,1,3,3
+class FunctionCaller_int_bool_bool_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_bool_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(bool,bool,float,float) = (int(*)(bool,bool,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_bool_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,1,3,3
+class FunctionCaller_int_unsigned_int_bool_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_bool_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(unsigned int,bool,float,float) = (int(*)(unsigned int,bool,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_bool_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,1,3,3
+class FunctionCaller_int_float_bool_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_bool_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(float,bool,float,float) = (int(*)(float,bool,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_bool_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,2,3,3
+class FunctionCaller_int_int_unsigned_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_unsigned_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(int,unsigned int,float,float) = (int(*)(int,unsigned int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_unsigned_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,2,3,3
+class FunctionCaller_int_bool_unsigned_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_unsigned_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(bool,unsigned int,float,float) = (int(*)(bool,unsigned int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_unsigned_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,2,3,3
+class FunctionCaller_int_unsigned_int_unsigned_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_unsigned_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(unsigned int,unsigned int,float,float) = (int(*)(unsigned int,unsigned int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_unsigned_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,2,3,3
+class FunctionCaller_int_float_unsigned_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_unsigned_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(float,unsigned int,float,float) = (int(*)(float,unsigned int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_unsigned_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 0,3,3,3
+class FunctionCaller_int_int_float_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_float_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(int,float,float,float) = (int(*)(int,float,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_int_float_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 1,3,3,3
+class FunctionCaller_int_bool_float_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_float_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(bool,float,float,float) = (int(*)(bool,float,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_bool_float_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 2,3,3,3
+class FunctionCaller_int_unsigned_int_float_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_float_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(unsigned int,float,float,float) = (int(*)(unsigned int,float,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_unsigned_int_float_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 0 3,3,3,3
+class FunctionCaller_int_float_float_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_float_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ int (*PF)(float,float,float,float) = (int(*)(float,float,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_int_float_float_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,0,0,0
+class FunctionCaller_bool_int_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(int,int,int,int) = (bool(*)(int,int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,0,0,0
+class FunctionCaller_bool_bool_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(bool,int,int,int) = (bool(*)(bool,int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,0,0,0
+class FunctionCaller_bool_unsigned_int_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(unsigned int,int,int,int) = (bool(*)(unsigned int,int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,0,0,0
+class FunctionCaller_bool_float_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(float,int,int,int) = (bool(*)(float,int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,1,0,0
+class FunctionCaller_bool_int_bool_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_bool_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(int,bool,int,int) = (bool(*)(int,bool,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_bool_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,1,0,0
+class FunctionCaller_bool_bool_bool_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_bool_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(bool,bool,int,int) = (bool(*)(bool,bool,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_bool_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,1,0,0
+class FunctionCaller_bool_unsigned_int_bool_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_bool_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(unsigned int,bool,int,int) = (bool(*)(unsigned int,bool,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_bool_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,1,0,0
+class FunctionCaller_bool_float_bool_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_bool_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(float,bool,int,int) = (bool(*)(float,bool,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_bool_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,2,0,0
+class FunctionCaller_bool_int_unsigned_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_unsigned_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(int,unsigned int,int,int) = (bool(*)(int,unsigned int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_unsigned_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,2,0,0
+class FunctionCaller_bool_bool_unsigned_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_unsigned_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(bool,unsigned int,int,int) = (bool(*)(bool,unsigned int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_unsigned_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,2,0,0
+class FunctionCaller_bool_unsigned_int_unsigned_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_unsigned_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(unsigned int,unsigned int,int,int) = (bool(*)(unsigned int,unsigned int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_unsigned_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,2,0,0
+class FunctionCaller_bool_float_unsigned_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_unsigned_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(float,unsigned int,int,int) = (bool(*)(float,unsigned int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_unsigned_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,3,0,0
+class FunctionCaller_bool_int_float_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_float_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(int,float,int,int) = (bool(*)(int,float,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_float_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,3,0,0
+class FunctionCaller_bool_bool_float_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_float_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(bool,float,int,int) = (bool(*)(bool,float,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_float_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,3,0,0
+class FunctionCaller_bool_unsigned_int_float_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_float_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(unsigned int,float,int,int) = (bool(*)(unsigned int,float,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_float_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,3,0,0
+class FunctionCaller_bool_float_float_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_float_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(float,float,int,int) = (bool(*)(float,float,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_float_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,0,1,0
+class FunctionCaller_bool_int_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(int,int,bool,int) = (bool(*)(int,int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,0,1,0
+class FunctionCaller_bool_bool_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(bool,int,bool,int) = (bool(*)(bool,int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,0,1,0
+class FunctionCaller_bool_unsigned_int_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(unsigned int,int,bool,int) = (bool(*)(unsigned int,int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,0,1,0
+class FunctionCaller_bool_float_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(float,int,bool,int) = (bool(*)(float,int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,1,1,0
+class FunctionCaller_bool_int_bool_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_bool_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(int,bool,bool,int) = (bool(*)(int,bool,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_bool_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,1,1,0
+class FunctionCaller_bool_bool_bool_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_bool_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(bool,bool,bool,int) = (bool(*)(bool,bool,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_bool_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,1,1,0
+class FunctionCaller_bool_unsigned_int_bool_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_bool_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(unsigned int,bool,bool,int) = (bool(*)(unsigned int,bool,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_bool_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,1,1,0
+class FunctionCaller_bool_float_bool_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_bool_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(float,bool,bool,int) = (bool(*)(float,bool,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_bool_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,2,1,0
+class FunctionCaller_bool_int_unsigned_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_unsigned_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(int,unsigned int,bool,int) = (bool(*)(int,unsigned int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_unsigned_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,2,1,0
+class FunctionCaller_bool_bool_unsigned_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_unsigned_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(bool,unsigned int,bool,int) = (bool(*)(bool,unsigned int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_unsigned_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,2,1,0
+class FunctionCaller_bool_unsigned_int_unsigned_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_unsigned_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(unsigned int,unsigned int,bool,int) = (bool(*)(unsigned int,unsigned int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_unsigned_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,2,1,0
+class FunctionCaller_bool_float_unsigned_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_unsigned_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(float,unsigned int,bool,int) = (bool(*)(float,unsigned int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_unsigned_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,3,1,0
+class FunctionCaller_bool_int_float_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_float_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(int,float,bool,int) = (bool(*)(int,float,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_float_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,3,1,0
+class FunctionCaller_bool_bool_float_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_float_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(bool,float,bool,int) = (bool(*)(bool,float,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_float_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,3,1,0
+class FunctionCaller_bool_unsigned_int_float_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_float_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(unsigned int,float,bool,int) = (bool(*)(unsigned int,float,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_float_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,3,1,0
+class FunctionCaller_bool_float_float_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_float_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(float,float,bool,int) = (bool(*)(float,float,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_float_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,0,2,0
+class FunctionCaller_bool_int_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(int,int,unsigned int,int) = (bool(*)(int,int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,0,2,0
+class FunctionCaller_bool_bool_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(bool,int,unsigned int,int) = (bool(*)(bool,int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,0,2,0
+class FunctionCaller_bool_unsigned_int_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(unsigned int,int,unsigned int,int) = (bool(*)(unsigned int,int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,0,2,0
+class FunctionCaller_bool_float_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(float,int,unsigned int,int) = (bool(*)(float,int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,1,2,0
+class FunctionCaller_bool_int_bool_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_bool_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(int,bool,unsigned int,int) = (bool(*)(int,bool,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_bool_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,1,2,0
+class FunctionCaller_bool_bool_bool_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_bool_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(bool,bool,unsigned int,int) = (bool(*)(bool,bool,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_bool_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,1,2,0
+class FunctionCaller_bool_unsigned_int_bool_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_bool_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(unsigned int,bool,unsigned int,int) = (bool(*)(unsigned int,bool,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_bool_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,1,2,0
+class FunctionCaller_bool_float_bool_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_bool_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(float,bool,unsigned int,int) = (bool(*)(float,bool,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_bool_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,2,2,0
+class FunctionCaller_bool_int_unsigned_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_unsigned_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(int,unsigned int,unsigned int,int) = (bool(*)(int,unsigned int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_unsigned_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,2,2,0
+class FunctionCaller_bool_bool_unsigned_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_unsigned_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(bool,unsigned int,unsigned int,int) = (bool(*)(bool,unsigned int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_unsigned_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,2,2,0
+class FunctionCaller_bool_unsigned_int_unsigned_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_unsigned_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(unsigned int,unsigned int,unsigned int,int) = (bool(*)(unsigned int,unsigned int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_unsigned_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,2,2,0
+class FunctionCaller_bool_float_unsigned_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_unsigned_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(float,unsigned int,unsigned int,int) = (bool(*)(float,unsigned int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_unsigned_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,3,2,0
+class FunctionCaller_bool_int_float_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_float_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(int,float,unsigned int,int) = (bool(*)(int,float,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_float_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,3,2,0
+class FunctionCaller_bool_bool_float_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_float_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(bool,float,unsigned int,int) = (bool(*)(bool,float,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_float_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,3,2,0
+class FunctionCaller_bool_unsigned_int_float_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_float_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(unsigned int,float,unsigned int,int) = (bool(*)(unsigned int,float,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_float_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,3,2,0
+class FunctionCaller_bool_float_float_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_float_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(float,float,unsigned int,int) = (bool(*)(float,float,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_float_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,0,3,0
+class FunctionCaller_bool_int_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(int,int,float,int) = (bool(*)(int,int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,0,3,0
+class FunctionCaller_bool_bool_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(bool,int,float,int) = (bool(*)(bool,int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,0,3,0
+class FunctionCaller_bool_unsigned_int_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(unsigned int,int,float,int) = (bool(*)(unsigned int,int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,0,3,0
+class FunctionCaller_bool_float_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(float,int,float,int) = (bool(*)(float,int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,1,3,0
+class FunctionCaller_bool_int_bool_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_bool_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(int,bool,float,int) = (bool(*)(int,bool,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_bool_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,1,3,0
+class FunctionCaller_bool_bool_bool_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_bool_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(bool,bool,float,int) = (bool(*)(bool,bool,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_bool_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,1,3,0
+class FunctionCaller_bool_unsigned_int_bool_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_bool_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(unsigned int,bool,float,int) = (bool(*)(unsigned int,bool,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_bool_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,1,3,0
+class FunctionCaller_bool_float_bool_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_bool_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(float,bool,float,int) = (bool(*)(float,bool,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_bool_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,2,3,0
+class FunctionCaller_bool_int_unsigned_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_unsigned_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(int,unsigned int,float,int) = (bool(*)(int,unsigned int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_unsigned_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,2,3,0
+class FunctionCaller_bool_bool_unsigned_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_unsigned_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(bool,unsigned int,float,int) = (bool(*)(bool,unsigned int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_unsigned_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,2,3,0
+class FunctionCaller_bool_unsigned_int_unsigned_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_unsigned_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(unsigned int,unsigned int,float,int) = (bool(*)(unsigned int,unsigned int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_unsigned_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,2,3,0
+class FunctionCaller_bool_float_unsigned_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_unsigned_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(float,unsigned int,float,int) = (bool(*)(float,unsigned int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_unsigned_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,3,3,0
+class FunctionCaller_bool_int_float_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_float_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(int,float,float,int) = (bool(*)(int,float,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_float_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,3,3,0
+class FunctionCaller_bool_bool_float_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_float_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(bool,float,float,int) = (bool(*)(bool,float,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_float_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,3,3,0
+class FunctionCaller_bool_unsigned_int_float_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_float_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(unsigned int,float,float,int) = (bool(*)(unsigned int,float,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_float_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,3,3,0
+class FunctionCaller_bool_float_float_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_float_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ bool (*PF)(float,float,float,int) = (bool(*)(float,float,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_float_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,0,0,1
+class FunctionCaller_bool_int_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(int,int,int,bool) = (bool(*)(int,int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,0,0,1
+class FunctionCaller_bool_bool_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(bool,int,int,bool) = (bool(*)(bool,int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,0,0,1
+class FunctionCaller_bool_unsigned_int_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(unsigned int,int,int,bool) = (bool(*)(unsigned int,int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,0,0,1
+class FunctionCaller_bool_float_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(float,int,int,bool) = (bool(*)(float,int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,1,0,1
+class FunctionCaller_bool_int_bool_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_bool_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(int,bool,int,bool) = (bool(*)(int,bool,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_bool_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,1,0,1
+class FunctionCaller_bool_bool_bool_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_bool_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(bool,bool,int,bool) = (bool(*)(bool,bool,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_bool_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,1,0,1
+class FunctionCaller_bool_unsigned_int_bool_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_bool_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(unsigned int,bool,int,bool) = (bool(*)(unsigned int,bool,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_bool_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,1,0,1
+class FunctionCaller_bool_float_bool_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_bool_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(float,bool,int,bool) = (bool(*)(float,bool,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_bool_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,2,0,1
+class FunctionCaller_bool_int_unsigned_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_unsigned_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(int,unsigned int,int,bool) = (bool(*)(int,unsigned int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_unsigned_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,2,0,1
+class FunctionCaller_bool_bool_unsigned_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_unsigned_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(bool,unsigned int,int,bool) = (bool(*)(bool,unsigned int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_unsigned_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,2,0,1
+class FunctionCaller_bool_unsigned_int_unsigned_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_unsigned_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(unsigned int,unsigned int,int,bool) = (bool(*)(unsigned int,unsigned int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_unsigned_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,2,0,1
+class FunctionCaller_bool_float_unsigned_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_unsigned_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(float,unsigned int,int,bool) = (bool(*)(float,unsigned int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_unsigned_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,3,0,1
+class FunctionCaller_bool_int_float_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_float_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(int,float,int,bool) = (bool(*)(int,float,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_float_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,3,0,1
+class FunctionCaller_bool_bool_float_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_float_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(bool,float,int,bool) = (bool(*)(bool,float,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_float_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,3,0,1
+class FunctionCaller_bool_unsigned_int_float_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_float_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(unsigned int,float,int,bool) = (bool(*)(unsigned int,float,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_float_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,3,0,1
+class FunctionCaller_bool_float_float_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_float_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(float,float,int,bool) = (bool(*)(float,float,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_float_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,0,1,1
+class FunctionCaller_bool_int_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(int,int,bool,bool) = (bool(*)(int,int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,0,1,1
+class FunctionCaller_bool_bool_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(bool,int,bool,bool) = (bool(*)(bool,int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,0,1,1
+class FunctionCaller_bool_unsigned_int_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(unsigned int,int,bool,bool) = (bool(*)(unsigned int,int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,0,1,1
+class FunctionCaller_bool_float_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(float,int,bool,bool) = (bool(*)(float,int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,1,1,1
+class FunctionCaller_bool_int_bool_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_bool_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(int,bool,bool,bool) = (bool(*)(int,bool,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_bool_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,1,1,1
+class FunctionCaller_bool_bool_bool_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_bool_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(bool,bool,bool,bool) = (bool(*)(bool,bool,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_bool_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,1,1,1
+class FunctionCaller_bool_unsigned_int_bool_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_bool_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(unsigned int,bool,bool,bool) = (bool(*)(unsigned int,bool,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_bool_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,1,1,1
+class FunctionCaller_bool_float_bool_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_bool_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(float,bool,bool,bool) = (bool(*)(float,bool,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_bool_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,2,1,1
+class FunctionCaller_bool_int_unsigned_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_unsigned_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(int,unsigned int,bool,bool) = (bool(*)(int,unsigned int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_unsigned_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,2,1,1
+class FunctionCaller_bool_bool_unsigned_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_unsigned_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(bool,unsigned int,bool,bool) = (bool(*)(bool,unsigned int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_unsigned_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,2,1,1
+class FunctionCaller_bool_unsigned_int_unsigned_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_unsigned_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(unsigned int,unsigned int,bool,bool) = (bool(*)(unsigned int,unsigned int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_unsigned_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,2,1,1
+class FunctionCaller_bool_float_unsigned_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_unsigned_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(float,unsigned int,bool,bool) = (bool(*)(float,unsigned int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_unsigned_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,3,1,1
+class FunctionCaller_bool_int_float_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_float_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(int,float,bool,bool) = (bool(*)(int,float,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_float_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,3,1,1
+class FunctionCaller_bool_bool_float_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_float_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(bool,float,bool,bool) = (bool(*)(bool,float,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_float_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,3,1,1
+class FunctionCaller_bool_unsigned_int_float_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_float_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(unsigned int,float,bool,bool) = (bool(*)(unsigned int,float,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_float_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,3,1,1
+class FunctionCaller_bool_float_float_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_float_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(float,float,bool,bool) = (bool(*)(float,float,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_float_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,0,2,1
+class FunctionCaller_bool_int_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(int,int,unsigned int,bool) = (bool(*)(int,int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,0,2,1
+class FunctionCaller_bool_bool_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(bool,int,unsigned int,bool) = (bool(*)(bool,int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,0,2,1
+class FunctionCaller_bool_unsigned_int_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(unsigned int,int,unsigned int,bool) = (bool(*)(unsigned int,int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,0,2,1
+class FunctionCaller_bool_float_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(float,int,unsigned int,bool) = (bool(*)(float,int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,1,2,1
+class FunctionCaller_bool_int_bool_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_bool_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(int,bool,unsigned int,bool) = (bool(*)(int,bool,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_bool_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,1,2,1
+class FunctionCaller_bool_bool_bool_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_bool_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(bool,bool,unsigned int,bool) = (bool(*)(bool,bool,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_bool_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,1,2,1
+class FunctionCaller_bool_unsigned_int_bool_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_bool_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(unsigned int,bool,unsigned int,bool) = (bool(*)(unsigned int,bool,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_bool_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,1,2,1
+class FunctionCaller_bool_float_bool_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_bool_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(float,bool,unsigned int,bool) = (bool(*)(float,bool,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_bool_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,2,2,1
+class FunctionCaller_bool_int_unsigned_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_unsigned_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(int,unsigned int,unsigned int,bool) = (bool(*)(int,unsigned int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_unsigned_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,2,2,1
+class FunctionCaller_bool_bool_unsigned_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_unsigned_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(bool,unsigned int,unsigned int,bool) = (bool(*)(bool,unsigned int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_unsigned_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,2,2,1
+class FunctionCaller_bool_unsigned_int_unsigned_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_unsigned_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(unsigned int,unsigned int,unsigned int,bool) = (bool(*)(unsigned int,unsigned int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_unsigned_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,2,2,1
+class FunctionCaller_bool_float_unsigned_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_unsigned_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(float,unsigned int,unsigned int,bool) = (bool(*)(float,unsigned int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_unsigned_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,3,2,1
+class FunctionCaller_bool_int_float_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_float_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(int,float,unsigned int,bool) = (bool(*)(int,float,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_float_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,3,2,1
+class FunctionCaller_bool_bool_float_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_float_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(bool,float,unsigned int,bool) = (bool(*)(bool,float,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_float_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,3,2,1
+class FunctionCaller_bool_unsigned_int_float_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_float_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(unsigned int,float,unsigned int,bool) = (bool(*)(unsigned int,float,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_float_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,3,2,1
+class FunctionCaller_bool_float_float_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_float_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(float,float,unsigned int,bool) = (bool(*)(float,float,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_float_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,0,3,1
+class FunctionCaller_bool_int_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(int,int,float,bool) = (bool(*)(int,int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,0,3,1
+class FunctionCaller_bool_bool_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(bool,int,float,bool) = (bool(*)(bool,int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,0,3,1
+class FunctionCaller_bool_unsigned_int_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(unsigned int,int,float,bool) = (bool(*)(unsigned int,int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,0,3,1
+class FunctionCaller_bool_float_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(float,int,float,bool) = (bool(*)(float,int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,1,3,1
+class FunctionCaller_bool_int_bool_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_bool_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(int,bool,float,bool) = (bool(*)(int,bool,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_bool_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,1,3,1
+class FunctionCaller_bool_bool_bool_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_bool_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(bool,bool,float,bool) = (bool(*)(bool,bool,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_bool_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,1,3,1
+class FunctionCaller_bool_unsigned_int_bool_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_bool_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(unsigned int,bool,float,bool) = (bool(*)(unsigned int,bool,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_bool_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,1,3,1
+class FunctionCaller_bool_float_bool_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_bool_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(float,bool,float,bool) = (bool(*)(float,bool,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_bool_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,2,3,1
+class FunctionCaller_bool_int_unsigned_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_unsigned_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(int,unsigned int,float,bool) = (bool(*)(int,unsigned int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_unsigned_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,2,3,1
+class FunctionCaller_bool_bool_unsigned_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_unsigned_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(bool,unsigned int,float,bool) = (bool(*)(bool,unsigned int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_unsigned_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,2,3,1
+class FunctionCaller_bool_unsigned_int_unsigned_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_unsigned_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(unsigned int,unsigned int,float,bool) = (bool(*)(unsigned int,unsigned int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_unsigned_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,2,3,1
+class FunctionCaller_bool_float_unsigned_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_unsigned_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(float,unsigned int,float,bool) = (bool(*)(float,unsigned int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_unsigned_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,3,3,1
+class FunctionCaller_bool_int_float_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_float_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(int,float,float,bool) = (bool(*)(int,float,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_float_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,3,3,1
+class FunctionCaller_bool_bool_float_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_float_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(bool,float,float,bool) = (bool(*)(bool,float,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_float_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,3,3,1
+class FunctionCaller_bool_unsigned_int_float_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_float_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(unsigned int,float,float,bool) = (bool(*)(unsigned int,float,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_float_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,3,3,1
+class FunctionCaller_bool_float_float_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_float_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ bool (*PF)(float,float,float,bool) = (bool(*)(float,float,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_float_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,0,0,2
+class FunctionCaller_bool_int_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(int,int,int,unsigned int) = (bool(*)(int,int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,0,0,2
+class FunctionCaller_bool_bool_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(bool,int,int,unsigned int) = (bool(*)(bool,int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,0,0,2
+class FunctionCaller_bool_unsigned_int_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(unsigned int,int,int,unsigned int) = (bool(*)(unsigned int,int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,0,0,2
+class FunctionCaller_bool_float_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(float,int,int,unsigned int) = (bool(*)(float,int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,1,0,2
+class FunctionCaller_bool_int_bool_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_bool_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(int,bool,int,unsigned int) = (bool(*)(int,bool,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_bool_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,1,0,2
+class FunctionCaller_bool_bool_bool_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_bool_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(bool,bool,int,unsigned int) = (bool(*)(bool,bool,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_bool_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,1,0,2
+class FunctionCaller_bool_unsigned_int_bool_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_bool_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(unsigned int,bool,int,unsigned int) = (bool(*)(unsigned int,bool,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_bool_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,1,0,2
+class FunctionCaller_bool_float_bool_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_bool_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(float,bool,int,unsigned int) = (bool(*)(float,bool,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_bool_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,2,0,2
+class FunctionCaller_bool_int_unsigned_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_unsigned_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(int,unsigned int,int,unsigned int) = (bool(*)(int,unsigned int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_unsigned_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,2,0,2
+class FunctionCaller_bool_bool_unsigned_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_unsigned_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(bool,unsigned int,int,unsigned int) = (bool(*)(bool,unsigned int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_unsigned_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,2,0,2
+class FunctionCaller_bool_unsigned_int_unsigned_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_unsigned_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(unsigned int,unsigned int,int,unsigned int) = (bool(*)(unsigned int,unsigned int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_unsigned_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,2,0,2
+class FunctionCaller_bool_float_unsigned_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_unsigned_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(float,unsigned int,int,unsigned int) = (bool(*)(float,unsigned int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_unsigned_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,3,0,2
+class FunctionCaller_bool_int_float_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_float_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(int,float,int,unsigned int) = (bool(*)(int,float,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_float_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,3,0,2
+class FunctionCaller_bool_bool_float_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_float_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(bool,float,int,unsigned int) = (bool(*)(bool,float,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_float_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,3,0,2
+class FunctionCaller_bool_unsigned_int_float_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_float_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(unsigned int,float,int,unsigned int) = (bool(*)(unsigned int,float,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_float_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,3,0,2
+class FunctionCaller_bool_float_float_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_float_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(float,float,int,unsigned int) = (bool(*)(float,float,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_float_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,0,1,2
+class FunctionCaller_bool_int_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(int,int,bool,unsigned int) = (bool(*)(int,int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,0,1,2
+class FunctionCaller_bool_bool_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(bool,int,bool,unsigned int) = (bool(*)(bool,int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,0,1,2
+class FunctionCaller_bool_unsigned_int_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(unsigned int,int,bool,unsigned int) = (bool(*)(unsigned int,int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,0,1,2
+class FunctionCaller_bool_float_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(float,int,bool,unsigned int) = (bool(*)(float,int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,1,1,2
+class FunctionCaller_bool_int_bool_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_bool_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(int,bool,bool,unsigned int) = (bool(*)(int,bool,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_bool_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,1,1,2
+class FunctionCaller_bool_bool_bool_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_bool_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(bool,bool,bool,unsigned int) = (bool(*)(bool,bool,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_bool_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,1,1,2
+class FunctionCaller_bool_unsigned_int_bool_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_bool_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(unsigned int,bool,bool,unsigned int) = (bool(*)(unsigned int,bool,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_bool_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,1,1,2
+class FunctionCaller_bool_float_bool_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_bool_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(float,bool,bool,unsigned int) = (bool(*)(float,bool,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_bool_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,2,1,2
+class FunctionCaller_bool_int_unsigned_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_unsigned_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(int,unsigned int,bool,unsigned int) = (bool(*)(int,unsigned int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_unsigned_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,2,1,2
+class FunctionCaller_bool_bool_unsigned_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_unsigned_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(bool,unsigned int,bool,unsigned int) = (bool(*)(bool,unsigned int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_unsigned_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,2,1,2
+class FunctionCaller_bool_unsigned_int_unsigned_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_unsigned_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(unsigned int,unsigned int,bool,unsigned int) = (bool(*)(unsigned int,unsigned int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_unsigned_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,2,1,2
+class FunctionCaller_bool_float_unsigned_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_unsigned_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(float,unsigned int,bool,unsigned int) = (bool(*)(float,unsigned int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_unsigned_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,3,1,2
+class FunctionCaller_bool_int_float_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_float_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(int,float,bool,unsigned int) = (bool(*)(int,float,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_float_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,3,1,2
+class FunctionCaller_bool_bool_float_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_float_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(bool,float,bool,unsigned int) = (bool(*)(bool,float,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_float_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,3,1,2
+class FunctionCaller_bool_unsigned_int_float_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_float_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(unsigned int,float,bool,unsigned int) = (bool(*)(unsigned int,float,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_float_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,3,1,2
+class FunctionCaller_bool_float_float_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_float_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(float,float,bool,unsigned int) = (bool(*)(float,float,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_float_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,0,2,2
+class FunctionCaller_bool_int_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(int,int,unsigned int,unsigned int) = (bool(*)(int,int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,0,2,2
+class FunctionCaller_bool_bool_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(bool,int,unsigned int,unsigned int) = (bool(*)(bool,int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,0,2,2
+class FunctionCaller_bool_unsigned_int_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(unsigned int,int,unsigned int,unsigned int) = (bool(*)(unsigned int,int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,0,2,2
+class FunctionCaller_bool_float_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(float,int,unsigned int,unsigned int) = (bool(*)(float,int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,1,2,2
+class FunctionCaller_bool_int_bool_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_bool_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(int,bool,unsigned int,unsigned int) = (bool(*)(int,bool,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_bool_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,1,2,2
+class FunctionCaller_bool_bool_bool_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_bool_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(bool,bool,unsigned int,unsigned int) = (bool(*)(bool,bool,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_bool_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,1,2,2
+class FunctionCaller_bool_unsigned_int_bool_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_bool_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(unsigned int,bool,unsigned int,unsigned int) = (bool(*)(unsigned int,bool,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_bool_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,1,2,2
+class FunctionCaller_bool_float_bool_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_bool_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(float,bool,unsigned int,unsigned int) = (bool(*)(float,bool,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_bool_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,2,2,2
+class FunctionCaller_bool_int_unsigned_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_unsigned_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(int,unsigned int,unsigned int,unsigned int) = (bool(*)(int,unsigned int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_unsigned_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,2,2,2
+class FunctionCaller_bool_bool_unsigned_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_unsigned_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(bool,unsigned int,unsigned int,unsigned int) = (bool(*)(bool,unsigned int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_unsigned_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,2,2,2
+class FunctionCaller_bool_unsigned_int_unsigned_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_unsigned_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(unsigned int,unsigned int,unsigned int,unsigned int) = (bool(*)(unsigned int,unsigned int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_unsigned_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,2,2,2
+class FunctionCaller_bool_float_unsigned_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_unsigned_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(float,unsigned int,unsigned int,unsigned int) = (bool(*)(float,unsigned int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_unsigned_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,3,2,2
+class FunctionCaller_bool_int_float_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_float_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(int,float,unsigned int,unsigned int) = (bool(*)(int,float,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_float_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,3,2,2
+class FunctionCaller_bool_bool_float_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_float_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(bool,float,unsigned int,unsigned int) = (bool(*)(bool,float,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_float_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,3,2,2
+class FunctionCaller_bool_unsigned_int_float_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_float_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(unsigned int,float,unsigned int,unsigned int) = (bool(*)(unsigned int,float,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_float_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,3,2,2
+class FunctionCaller_bool_float_float_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_float_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(float,float,unsigned int,unsigned int) = (bool(*)(float,float,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_float_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,0,3,2
+class FunctionCaller_bool_int_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(int,int,float,unsigned int) = (bool(*)(int,int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,0,3,2
+class FunctionCaller_bool_bool_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(bool,int,float,unsigned int) = (bool(*)(bool,int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,0,3,2
+class FunctionCaller_bool_unsigned_int_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(unsigned int,int,float,unsigned int) = (bool(*)(unsigned int,int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,0,3,2
+class FunctionCaller_bool_float_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(float,int,float,unsigned int) = (bool(*)(float,int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,1,3,2
+class FunctionCaller_bool_int_bool_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_bool_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(int,bool,float,unsigned int) = (bool(*)(int,bool,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_bool_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,1,3,2
+class FunctionCaller_bool_bool_bool_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_bool_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(bool,bool,float,unsigned int) = (bool(*)(bool,bool,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_bool_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,1,3,2
+class FunctionCaller_bool_unsigned_int_bool_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_bool_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(unsigned int,bool,float,unsigned int) = (bool(*)(unsigned int,bool,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_bool_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,1,3,2
+class FunctionCaller_bool_float_bool_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_bool_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(float,bool,float,unsigned int) = (bool(*)(float,bool,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_bool_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,2,3,2
+class FunctionCaller_bool_int_unsigned_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_unsigned_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(int,unsigned int,float,unsigned int) = (bool(*)(int,unsigned int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_unsigned_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,2,3,2
+class FunctionCaller_bool_bool_unsigned_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_unsigned_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(bool,unsigned int,float,unsigned int) = (bool(*)(bool,unsigned int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_unsigned_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,2,3,2
+class FunctionCaller_bool_unsigned_int_unsigned_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_unsigned_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(unsigned int,unsigned int,float,unsigned int) = (bool(*)(unsigned int,unsigned int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_unsigned_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,2,3,2
+class FunctionCaller_bool_float_unsigned_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_unsigned_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(float,unsigned int,float,unsigned int) = (bool(*)(float,unsigned int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_unsigned_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,3,3,2
+class FunctionCaller_bool_int_float_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_float_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(int,float,float,unsigned int) = (bool(*)(int,float,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_float_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,3,3,2
+class FunctionCaller_bool_bool_float_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_float_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(bool,float,float,unsigned int) = (bool(*)(bool,float,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_float_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,3,3,2
+class FunctionCaller_bool_unsigned_int_float_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_float_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(unsigned int,float,float,unsigned int) = (bool(*)(unsigned int,float,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_float_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,3,3,2
+class FunctionCaller_bool_float_float_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_float_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ bool (*PF)(float,float,float,unsigned int) = (bool(*)(float,float,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_float_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,0,0,3
+class FunctionCaller_bool_int_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(int,int,int,float) = (bool(*)(int,int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,0,0,3
+class FunctionCaller_bool_bool_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(bool,int,int,float) = (bool(*)(bool,int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,0,0,3
+class FunctionCaller_bool_unsigned_int_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(unsigned int,int,int,float) = (bool(*)(unsigned int,int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,0,0,3
+class FunctionCaller_bool_float_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(float,int,int,float) = (bool(*)(float,int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,1,0,3
+class FunctionCaller_bool_int_bool_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_bool_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(int,bool,int,float) = (bool(*)(int,bool,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_bool_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,1,0,3
+class FunctionCaller_bool_bool_bool_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_bool_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(bool,bool,int,float) = (bool(*)(bool,bool,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_bool_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,1,0,3
+class FunctionCaller_bool_unsigned_int_bool_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_bool_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(unsigned int,bool,int,float) = (bool(*)(unsigned int,bool,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_bool_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,1,0,3
+class FunctionCaller_bool_float_bool_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_bool_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(float,bool,int,float) = (bool(*)(float,bool,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_bool_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,2,0,3
+class FunctionCaller_bool_int_unsigned_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_unsigned_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(int,unsigned int,int,float) = (bool(*)(int,unsigned int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_unsigned_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,2,0,3
+class FunctionCaller_bool_bool_unsigned_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_unsigned_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(bool,unsigned int,int,float) = (bool(*)(bool,unsigned int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_unsigned_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,2,0,3
+class FunctionCaller_bool_unsigned_int_unsigned_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_unsigned_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(unsigned int,unsigned int,int,float) = (bool(*)(unsigned int,unsigned int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_unsigned_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,2,0,3
+class FunctionCaller_bool_float_unsigned_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_unsigned_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(float,unsigned int,int,float) = (bool(*)(float,unsigned int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_unsigned_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,3,0,3
+class FunctionCaller_bool_int_float_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_float_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(int,float,int,float) = (bool(*)(int,float,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_float_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,3,0,3
+class FunctionCaller_bool_bool_float_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_float_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(bool,float,int,float) = (bool(*)(bool,float,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_float_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,3,0,3
+class FunctionCaller_bool_unsigned_int_float_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_float_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(unsigned int,float,int,float) = (bool(*)(unsigned int,float,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_float_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,3,0,3
+class FunctionCaller_bool_float_float_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_float_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(float,float,int,float) = (bool(*)(float,float,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_float_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,0,1,3
+class FunctionCaller_bool_int_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(int,int,bool,float) = (bool(*)(int,int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,0,1,3
+class FunctionCaller_bool_bool_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(bool,int,bool,float) = (bool(*)(bool,int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,0,1,3
+class FunctionCaller_bool_unsigned_int_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(unsigned int,int,bool,float) = (bool(*)(unsigned int,int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,0,1,3
+class FunctionCaller_bool_float_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(float,int,bool,float) = (bool(*)(float,int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,1,1,3
+class FunctionCaller_bool_int_bool_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_bool_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(int,bool,bool,float) = (bool(*)(int,bool,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_bool_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,1,1,3
+class FunctionCaller_bool_bool_bool_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_bool_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(bool,bool,bool,float) = (bool(*)(bool,bool,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_bool_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,1,1,3
+class FunctionCaller_bool_unsigned_int_bool_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_bool_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(unsigned int,bool,bool,float) = (bool(*)(unsigned int,bool,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_bool_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,1,1,3
+class FunctionCaller_bool_float_bool_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_bool_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(float,bool,bool,float) = (bool(*)(float,bool,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_bool_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,2,1,3
+class FunctionCaller_bool_int_unsigned_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_unsigned_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(int,unsigned int,bool,float) = (bool(*)(int,unsigned int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_unsigned_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,2,1,3
+class FunctionCaller_bool_bool_unsigned_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_unsigned_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(bool,unsigned int,bool,float) = (bool(*)(bool,unsigned int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_unsigned_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,2,1,3
+class FunctionCaller_bool_unsigned_int_unsigned_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_unsigned_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(unsigned int,unsigned int,bool,float) = (bool(*)(unsigned int,unsigned int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_unsigned_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,2,1,3
+class FunctionCaller_bool_float_unsigned_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_unsigned_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(float,unsigned int,bool,float) = (bool(*)(float,unsigned int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_unsigned_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,3,1,3
+class FunctionCaller_bool_int_float_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_float_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(int,float,bool,float) = (bool(*)(int,float,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_float_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,3,1,3
+class FunctionCaller_bool_bool_float_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_float_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(bool,float,bool,float) = (bool(*)(bool,float,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_float_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,3,1,3
+class FunctionCaller_bool_unsigned_int_float_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_float_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(unsigned int,float,bool,float) = (bool(*)(unsigned int,float,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_float_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,3,1,3
+class FunctionCaller_bool_float_float_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_float_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(float,float,bool,float) = (bool(*)(float,float,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_float_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,0,2,3
+class FunctionCaller_bool_int_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(int,int,unsigned int,float) = (bool(*)(int,int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,0,2,3
+class FunctionCaller_bool_bool_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(bool,int,unsigned int,float) = (bool(*)(bool,int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,0,2,3
+class FunctionCaller_bool_unsigned_int_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(unsigned int,int,unsigned int,float) = (bool(*)(unsigned int,int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,0,2,3
+class FunctionCaller_bool_float_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(float,int,unsigned int,float) = (bool(*)(float,int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,1,2,3
+class FunctionCaller_bool_int_bool_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_bool_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(int,bool,unsigned int,float) = (bool(*)(int,bool,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_bool_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,1,2,3
+class FunctionCaller_bool_bool_bool_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_bool_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(bool,bool,unsigned int,float) = (bool(*)(bool,bool,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_bool_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,1,2,3
+class FunctionCaller_bool_unsigned_int_bool_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_bool_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(unsigned int,bool,unsigned int,float) = (bool(*)(unsigned int,bool,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_bool_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,1,2,3
+class FunctionCaller_bool_float_bool_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_bool_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(float,bool,unsigned int,float) = (bool(*)(float,bool,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_bool_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,2,2,3
+class FunctionCaller_bool_int_unsigned_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_unsigned_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(int,unsigned int,unsigned int,float) = (bool(*)(int,unsigned int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_unsigned_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,2,2,3
+class FunctionCaller_bool_bool_unsigned_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_unsigned_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(bool,unsigned int,unsigned int,float) = (bool(*)(bool,unsigned int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_unsigned_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,2,2,3
+class FunctionCaller_bool_unsigned_int_unsigned_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_unsigned_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(unsigned int,unsigned int,unsigned int,float) = (bool(*)(unsigned int,unsigned int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_unsigned_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,2,2,3
+class FunctionCaller_bool_float_unsigned_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_unsigned_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(float,unsigned int,unsigned int,float) = (bool(*)(float,unsigned int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_unsigned_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,3,2,3
+class FunctionCaller_bool_int_float_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_float_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(int,float,unsigned int,float) = (bool(*)(int,float,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_float_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,3,2,3
+class FunctionCaller_bool_bool_float_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_float_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(bool,float,unsigned int,float) = (bool(*)(bool,float,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_float_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,3,2,3
+class FunctionCaller_bool_unsigned_int_float_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_float_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(unsigned int,float,unsigned int,float) = (bool(*)(unsigned int,float,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_float_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,3,2,3
+class FunctionCaller_bool_float_float_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_float_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(float,float,unsigned int,float) = (bool(*)(float,float,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_float_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,0,3,3
+class FunctionCaller_bool_int_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(int,int,float,float) = (bool(*)(int,int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,0,3,3
+class FunctionCaller_bool_bool_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(bool,int,float,float) = (bool(*)(bool,int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,0,3,3
+class FunctionCaller_bool_unsigned_int_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(unsigned int,int,float,float) = (bool(*)(unsigned int,int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,0,3,3
+class FunctionCaller_bool_float_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(float,int,float,float) = (bool(*)(float,int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,1,3,3
+class FunctionCaller_bool_int_bool_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_bool_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(int,bool,float,float) = (bool(*)(int,bool,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_bool_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,1,3,3
+class FunctionCaller_bool_bool_bool_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_bool_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(bool,bool,float,float) = (bool(*)(bool,bool,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_bool_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,1,3,3
+class FunctionCaller_bool_unsigned_int_bool_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_bool_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(unsigned int,bool,float,float) = (bool(*)(unsigned int,bool,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_bool_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,1,3,3
+class FunctionCaller_bool_float_bool_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_bool_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(float,bool,float,float) = (bool(*)(float,bool,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_bool_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,2,3,3
+class FunctionCaller_bool_int_unsigned_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_unsigned_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(int,unsigned int,float,float) = (bool(*)(int,unsigned int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_unsigned_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,2,3,3
+class FunctionCaller_bool_bool_unsigned_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_unsigned_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(bool,unsigned int,float,float) = (bool(*)(bool,unsigned int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_unsigned_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,2,3,3
+class FunctionCaller_bool_unsigned_int_unsigned_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_unsigned_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(unsigned int,unsigned int,float,float) = (bool(*)(unsigned int,unsigned int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_unsigned_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,2,3,3
+class FunctionCaller_bool_float_unsigned_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_unsigned_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(float,unsigned int,float,float) = (bool(*)(float,unsigned int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_unsigned_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 0,3,3,3
+class FunctionCaller_bool_int_float_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_float_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(int,float,float,float) = (bool(*)(int,float,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_int_float_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 1,3,3,3
+class FunctionCaller_bool_bool_float_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_float_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(bool,float,float,float) = (bool(*)(bool,float,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_bool_float_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 2,3,3,3
+class FunctionCaller_bool_unsigned_int_float_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_float_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(unsigned int,float,float,float) = (bool(*)(unsigned int,float,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_unsigned_int_float_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 1 3,3,3,3
+class FunctionCaller_bool_float_float_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_float_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ bool (*PF)(float,float,float,float) = (bool(*)(float,float,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_bool_float_float_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,0,0,0
+class FunctionCaller_unsigned_int_int_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(int,int,int,int) = (unsigned int(*)(int,int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,0,0,0
+class FunctionCaller_unsigned_int_bool_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(bool,int,int,int) = (unsigned int(*)(bool,int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,0,0,0
+class FunctionCaller_unsigned_int_unsigned_int_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,int,int,int) = (unsigned int(*)(unsigned int,int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,0,0,0
+class FunctionCaller_unsigned_int_float_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(float,int,int,int) = (unsigned int(*)(float,int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,1,0,0
+class FunctionCaller_unsigned_int_int_bool_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_bool_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(int,bool,int,int) = (unsigned int(*)(int,bool,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_bool_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,1,0,0
+class FunctionCaller_unsigned_int_bool_bool_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_bool_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(bool,bool,int,int) = (unsigned int(*)(bool,bool,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_bool_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,1,0,0
+class FunctionCaller_unsigned_int_unsigned_int_bool_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_bool_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,bool,int,int) = (unsigned int(*)(unsigned int,bool,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_bool_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,1,0,0
+class FunctionCaller_unsigned_int_float_bool_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_bool_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(float,bool,int,int) = (unsigned int(*)(float,bool,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_bool_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,2,0,0
+class FunctionCaller_unsigned_int_int_unsigned_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_unsigned_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(int,unsigned int,int,int) = (unsigned int(*)(int,unsigned int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_unsigned_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,2,0,0
+class FunctionCaller_unsigned_int_bool_unsigned_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_unsigned_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(bool,unsigned int,int,int) = (unsigned int(*)(bool,unsigned int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_unsigned_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,2,0,0
+class FunctionCaller_unsigned_int_unsigned_int_unsigned_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_unsigned_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,unsigned int,int,int) = (unsigned int(*)(unsigned int,unsigned int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_unsigned_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,2,0,0
+class FunctionCaller_unsigned_int_float_unsigned_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_unsigned_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(float,unsigned int,int,int) = (unsigned int(*)(float,unsigned int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_unsigned_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,3,0,0
+class FunctionCaller_unsigned_int_int_float_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_float_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(int,float,int,int) = (unsigned int(*)(int,float,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_float_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,3,0,0
+class FunctionCaller_unsigned_int_bool_float_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_float_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(bool,float,int,int) = (unsigned int(*)(bool,float,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_float_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,3,0,0
+class FunctionCaller_unsigned_int_unsigned_int_float_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_float_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,float,int,int) = (unsigned int(*)(unsigned int,float,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_float_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,3,0,0
+class FunctionCaller_unsigned_int_float_float_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_float_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(float,float,int,int) = (unsigned int(*)(float,float,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_float_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,0,1,0
+class FunctionCaller_unsigned_int_int_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(int,int,bool,int) = (unsigned int(*)(int,int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,0,1,0
+class FunctionCaller_unsigned_int_bool_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(bool,int,bool,int) = (unsigned int(*)(bool,int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,0,1,0
+class FunctionCaller_unsigned_int_unsigned_int_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,int,bool,int) = (unsigned int(*)(unsigned int,int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,0,1,0
+class FunctionCaller_unsigned_int_float_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(float,int,bool,int) = (unsigned int(*)(float,int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,1,1,0
+class FunctionCaller_unsigned_int_int_bool_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_bool_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(int,bool,bool,int) = (unsigned int(*)(int,bool,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_bool_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,1,1,0
+class FunctionCaller_unsigned_int_bool_bool_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_bool_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(bool,bool,bool,int) = (unsigned int(*)(bool,bool,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_bool_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,1,1,0
+class FunctionCaller_unsigned_int_unsigned_int_bool_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_bool_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,bool,bool,int) = (unsigned int(*)(unsigned int,bool,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_bool_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,1,1,0
+class FunctionCaller_unsigned_int_float_bool_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_bool_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(float,bool,bool,int) = (unsigned int(*)(float,bool,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_bool_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,2,1,0
+class FunctionCaller_unsigned_int_int_unsigned_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_unsigned_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(int,unsigned int,bool,int) = (unsigned int(*)(int,unsigned int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_unsigned_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,2,1,0
+class FunctionCaller_unsigned_int_bool_unsigned_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_unsigned_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(bool,unsigned int,bool,int) = (unsigned int(*)(bool,unsigned int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_unsigned_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,2,1,0
+class FunctionCaller_unsigned_int_unsigned_int_unsigned_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_unsigned_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,unsigned int,bool,int) = (unsigned int(*)(unsigned int,unsigned int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_unsigned_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,2,1,0
+class FunctionCaller_unsigned_int_float_unsigned_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_unsigned_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(float,unsigned int,bool,int) = (unsigned int(*)(float,unsigned int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_unsigned_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,3,1,0
+class FunctionCaller_unsigned_int_int_float_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_float_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(int,float,bool,int) = (unsigned int(*)(int,float,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_float_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,3,1,0
+class FunctionCaller_unsigned_int_bool_float_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_float_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(bool,float,bool,int) = (unsigned int(*)(bool,float,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_float_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,3,1,0
+class FunctionCaller_unsigned_int_unsigned_int_float_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_float_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,float,bool,int) = (unsigned int(*)(unsigned int,float,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_float_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,3,1,0
+class FunctionCaller_unsigned_int_float_float_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_float_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(float,float,bool,int) = (unsigned int(*)(float,float,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_float_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,0,2,0
+class FunctionCaller_unsigned_int_int_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(int,int,unsigned int,int) = (unsigned int(*)(int,int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,0,2,0
+class FunctionCaller_unsigned_int_bool_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(bool,int,unsigned int,int) = (unsigned int(*)(bool,int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,0,2,0
+class FunctionCaller_unsigned_int_unsigned_int_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,int,unsigned int,int) = (unsigned int(*)(unsigned int,int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,0,2,0
+class FunctionCaller_unsigned_int_float_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(float,int,unsigned int,int) = (unsigned int(*)(float,int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,1,2,0
+class FunctionCaller_unsigned_int_int_bool_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_bool_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(int,bool,unsigned int,int) = (unsigned int(*)(int,bool,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_bool_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,1,2,0
+class FunctionCaller_unsigned_int_bool_bool_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_bool_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(bool,bool,unsigned int,int) = (unsigned int(*)(bool,bool,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_bool_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,1,2,0
+class FunctionCaller_unsigned_int_unsigned_int_bool_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_bool_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,bool,unsigned int,int) = (unsigned int(*)(unsigned int,bool,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_bool_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,1,2,0
+class FunctionCaller_unsigned_int_float_bool_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_bool_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(float,bool,unsigned int,int) = (unsigned int(*)(float,bool,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_bool_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,2,2,0
+class FunctionCaller_unsigned_int_int_unsigned_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_unsigned_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(int,unsigned int,unsigned int,int) = (unsigned int(*)(int,unsigned int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_unsigned_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,2,2,0
+class FunctionCaller_unsigned_int_bool_unsigned_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_unsigned_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(bool,unsigned int,unsigned int,int) = (unsigned int(*)(bool,unsigned int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_unsigned_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,2,2,0
+class FunctionCaller_unsigned_int_unsigned_int_unsigned_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_unsigned_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,unsigned int,unsigned int,int) = (unsigned int(*)(unsigned int,unsigned int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_unsigned_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,2,2,0
+class FunctionCaller_unsigned_int_float_unsigned_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_unsigned_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(float,unsigned int,unsigned int,int) = (unsigned int(*)(float,unsigned int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_unsigned_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,3,2,0
+class FunctionCaller_unsigned_int_int_float_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_float_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(int,float,unsigned int,int) = (unsigned int(*)(int,float,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_float_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,3,2,0
+class FunctionCaller_unsigned_int_bool_float_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_float_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(bool,float,unsigned int,int) = (unsigned int(*)(bool,float,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_float_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,3,2,0
+class FunctionCaller_unsigned_int_unsigned_int_float_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_float_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,float,unsigned int,int) = (unsigned int(*)(unsigned int,float,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_float_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,3,2,0
+class FunctionCaller_unsigned_int_float_float_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_float_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(float,float,unsigned int,int) = (unsigned int(*)(float,float,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_float_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,0,3,0
+class FunctionCaller_unsigned_int_int_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(int,int,float,int) = (unsigned int(*)(int,int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,0,3,0
+class FunctionCaller_unsigned_int_bool_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(bool,int,float,int) = (unsigned int(*)(bool,int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,0,3,0
+class FunctionCaller_unsigned_int_unsigned_int_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,int,float,int) = (unsigned int(*)(unsigned int,int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,0,3,0
+class FunctionCaller_unsigned_int_float_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(float,int,float,int) = (unsigned int(*)(float,int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,1,3,0
+class FunctionCaller_unsigned_int_int_bool_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_bool_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(int,bool,float,int) = (unsigned int(*)(int,bool,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_bool_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,1,3,0
+class FunctionCaller_unsigned_int_bool_bool_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_bool_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(bool,bool,float,int) = (unsigned int(*)(bool,bool,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_bool_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,1,3,0
+class FunctionCaller_unsigned_int_unsigned_int_bool_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_bool_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,bool,float,int) = (unsigned int(*)(unsigned int,bool,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_bool_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,1,3,0
+class FunctionCaller_unsigned_int_float_bool_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_bool_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(float,bool,float,int) = (unsigned int(*)(float,bool,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_bool_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,2,3,0
+class FunctionCaller_unsigned_int_int_unsigned_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_unsigned_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(int,unsigned int,float,int) = (unsigned int(*)(int,unsigned int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_unsigned_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,2,3,0
+class FunctionCaller_unsigned_int_bool_unsigned_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_unsigned_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(bool,unsigned int,float,int) = (unsigned int(*)(bool,unsigned int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_unsigned_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,2,3,0
+class FunctionCaller_unsigned_int_unsigned_int_unsigned_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_unsigned_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,unsigned int,float,int) = (unsigned int(*)(unsigned int,unsigned int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_unsigned_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,2,3,0
+class FunctionCaller_unsigned_int_float_unsigned_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_unsigned_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(float,unsigned int,float,int) = (unsigned int(*)(float,unsigned int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_unsigned_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,3,3,0
+class FunctionCaller_unsigned_int_int_float_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_float_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(int,float,float,int) = (unsigned int(*)(int,float,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_float_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,3,3,0
+class FunctionCaller_unsigned_int_bool_float_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_float_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(bool,float,float,int) = (unsigned int(*)(bool,float,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_float_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,3,3,0
+class FunctionCaller_unsigned_int_unsigned_int_float_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_float_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,float,float,int) = (unsigned int(*)(unsigned int,float,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_float_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,3,3,0
+class FunctionCaller_unsigned_int_float_float_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_float_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ unsigned int (*PF)(float,float,float,int) = (unsigned int(*)(float,float,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_float_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,0,0,1
+class FunctionCaller_unsigned_int_int_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(int,int,int,bool) = (unsigned int(*)(int,int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,0,0,1
+class FunctionCaller_unsigned_int_bool_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(bool,int,int,bool) = (unsigned int(*)(bool,int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,0,0,1
+class FunctionCaller_unsigned_int_unsigned_int_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,int,int,bool) = (unsigned int(*)(unsigned int,int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,0,0,1
+class FunctionCaller_unsigned_int_float_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(float,int,int,bool) = (unsigned int(*)(float,int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,1,0,1
+class FunctionCaller_unsigned_int_int_bool_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_bool_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(int,bool,int,bool) = (unsigned int(*)(int,bool,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_bool_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,1,0,1
+class FunctionCaller_unsigned_int_bool_bool_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_bool_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(bool,bool,int,bool) = (unsigned int(*)(bool,bool,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_bool_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,1,0,1
+class FunctionCaller_unsigned_int_unsigned_int_bool_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_bool_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,bool,int,bool) = (unsigned int(*)(unsigned int,bool,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_bool_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,1,0,1
+class FunctionCaller_unsigned_int_float_bool_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_bool_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(float,bool,int,bool) = (unsigned int(*)(float,bool,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_bool_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,2,0,1
+class FunctionCaller_unsigned_int_int_unsigned_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_unsigned_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(int,unsigned int,int,bool) = (unsigned int(*)(int,unsigned int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_unsigned_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,2,0,1
+class FunctionCaller_unsigned_int_bool_unsigned_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_unsigned_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(bool,unsigned int,int,bool) = (unsigned int(*)(bool,unsigned int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_unsigned_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,2,0,1
+class FunctionCaller_unsigned_int_unsigned_int_unsigned_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_unsigned_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,unsigned int,int,bool) = (unsigned int(*)(unsigned int,unsigned int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_unsigned_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,2,0,1
+class FunctionCaller_unsigned_int_float_unsigned_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_unsigned_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(float,unsigned int,int,bool) = (unsigned int(*)(float,unsigned int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_unsigned_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,3,0,1
+class FunctionCaller_unsigned_int_int_float_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_float_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(int,float,int,bool) = (unsigned int(*)(int,float,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_float_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,3,0,1
+class FunctionCaller_unsigned_int_bool_float_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_float_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(bool,float,int,bool) = (unsigned int(*)(bool,float,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_float_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,3,0,1
+class FunctionCaller_unsigned_int_unsigned_int_float_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_float_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,float,int,bool) = (unsigned int(*)(unsigned int,float,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_float_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,3,0,1
+class FunctionCaller_unsigned_int_float_float_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_float_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(float,float,int,bool) = (unsigned int(*)(float,float,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_float_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,0,1,1
+class FunctionCaller_unsigned_int_int_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(int,int,bool,bool) = (unsigned int(*)(int,int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,0,1,1
+class FunctionCaller_unsigned_int_bool_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(bool,int,bool,bool) = (unsigned int(*)(bool,int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,0,1,1
+class FunctionCaller_unsigned_int_unsigned_int_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,int,bool,bool) = (unsigned int(*)(unsigned int,int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,0,1,1
+class FunctionCaller_unsigned_int_float_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(float,int,bool,bool) = (unsigned int(*)(float,int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,1,1,1
+class FunctionCaller_unsigned_int_int_bool_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_bool_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(int,bool,bool,bool) = (unsigned int(*)(int,bool,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_bool_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,1,1,1
+class FunctionCaller_unsigned_int_bool_bool_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_bool_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(bool,bool,bool,bool) = (unsigned int(*)(bool,bool,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_bool_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,1,1,1
+class FunctionCaller_unsigned_int_unsigned_int_bool_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_bool_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,bool,bool,bool) = (unsigned int(*)(unsigned int,bool,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_bool_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,1,1,1
+class FunctionCaller_unsigned_int_float_bool_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_bool_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(float,bool,bool,bool) = (unsigned int(*)(float,bool,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_bool_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,2,1,1
+class FunctionCaller_unsigned_int_int_unsigned_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_unsigned_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(int,unsigned int,bool,bool) = (unsigned int(*)(int,unsigned int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_unsigned_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,2,1,1
+class FunctionCaller_unsigned_int_bool_unsigned_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_unsigned_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(bool,unsigned int,bool,bool) = (unsigned int(*)(bool,unsigned int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_unsigned_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,2,1,1
+class FunctionCaller_unsigned_int_unsigned_int_unsigned_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_unsigned_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,unsigned int,bool,bool) = (unsigned int(*)(unsigned int,unsigned int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_unsigned_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,2,1,1
+class FunctionCaller_unsigned_int_float_unsigned_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_unsigned_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(float,unsigned int,bool,bool) = (unsigned int(*)(float,unsigned int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_unsigned_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,3,1,1
+class FunctionCaller_unsigned_int_int_float_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_float_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(int,float,bool,bool) = (unsigned int(*)(int,float,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_float_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,3,1,1
+class FunctionCaller_unsigned_int_bool_float_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_float_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(bool,float,bool,bool) = (unsigned int(*)(bool,float,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_float_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,3,1,1
+class FunctionCaller_unsigned_int_unsigned_int_float_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_float_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,float,bool,bool) = (unsigned int(*)(unsigned int,float,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_float_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,3,1,1
+class FunctionCaller_unsigned_int_float_float_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_float_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(float,float,bool,bool) = (unsigned int(*)(float,float,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_float_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,0,2,1
+class FunctionCaller_unsigned_int_int_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(int,int,unsigned int,bool) = (unsigned int(*)(int,int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,0,2,1
+class FunctionCaller_unsigned_int_bool_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(bool,int,unsigned int,bool) = (unsigned int(*)(bool,int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,0,2,1
+class FunctionCaller_unsigned_int_unsigned_int_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,int,unsigned int,bool) = (unsigned int(*)(unsigned int,int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,0,2,1
+class FunctionCaller_unsigned_int_float_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(float,int,unsigned int,bool) = (unsigned int(*)(float,int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,1,2,1
+class FunctionCaller_unsigned_int_int_bool_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_bool_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(int,bool,unsigned int,bool) = (unsigned int(*)(int,bool,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_bool_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,1,2,1
+class FunctionCaller_unsigned_int_bool_bool_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_bool_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(bool,bool,unsigned int,bool) = (unsigned int(*)(bool,bool,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_bool_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,1,2,1
+class FunctionCaller_unsigned_int_unsigned_int_bool_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_bool_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,bool,unsigned int,bool) = (unsigned int(*)(unsigned int,bool,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_bool_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,1,2,1
+class FunctionCaller_unsigned_int_float_bool_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_bool_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(float,bool,unsigned int,bool) = (unsigned int(*)(float,bool,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_bool_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,2,2,1
+class FunctionCaller_unsigned_int_int_unsigned_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_unsigned_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(int,unsigned int,unsigned int,bool) = (unsigned int(*)(int,unsigned int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_unsigned_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,2,2,1
+class FunctionCaller_unsigned_int_bool_unsigned_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_unsigned_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(bool,unsigned int,unsigned int,bool) = (unsigned int(*)(bool,unsigned int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_unsigned_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,2,2,1
+class FunctionCaller_unsigned_int_unsigned_int_unsigned_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_unsigned_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,unsigned int,unsigned int,bool) = (unsigned int(*)(unsigned int,unsigned int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_unsigned_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,2,2,1
+class FunctionCaller_unsigned_int_float_unsigned_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_unsigned_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(float,unsigned int,unsigned int,bool) = (unsigned int(*)(float,unsigned int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_unsigned_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,3,2,1
+class FunctionCaller_unsigned_int_int_float_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_float_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(int,float,unsigned int,bool) = (unsigned int(*)(int,float,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_float_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,3,2,1
+class FunctionCaller_unsigned_int_bool_float_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_float_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(bool,float,unsigned int,bool) = (unsigned int(*)(bool,float,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_float_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,3,2,1
+class FunctionCaller_unsigned_int_unsigned_int_float_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_float_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,float,unsigned int,bool) = (unsigned int(*)(unsigned int,float,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_float_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,3,2,1
+class FunctionCaller_unsigned_int_float_float_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_float_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(float,float,unsigned int,bool) = (unsigned int(*)(float,float,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_float_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,0,3,1
+class FunctionCaller_unsigned_int_int_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(int,int,float,bool) = (unsigned int(*)(int,int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,0,3,1
+class FunctionCaller_unsigned_int_bool_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(bool,int,float,bool) = (unsigned int(*)(bool,int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,0,3,1
+class FunctionCaller_unsigned_int_unsigned_int_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,int,float,bool) = (unsigned int(*)(unsigned int,int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,0,3,1
+class FunctionCaller_unsigned_int_float_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(float,int,float,bool) = (unsigned int(*)(float,int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,1,3,1
+class FunctionCaller_unsigned_int_int_bool_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_bool_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(int,bool,float,bool) = (unsigned int(*)(int,bool,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_bool_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,1,3,1
+class FunctionCaller_unsigned_int_bool_bool_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_bool_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(bool,bool,float,bool) = (unsigned int(*)(bool,bool,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_bool_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,1,3,1
+class FunctionCaller_unsigned_int_unsigned_int_bool_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_bool_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,bool,float,bool) = (unsigned int(*)(unsigned int,bool,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_bool_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,1,3,1
+class FunctionCaller_unsigned_int_float_bool_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_bool_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(float,bool,float,bool) = (unsigned int(*)(float,bool,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_bool_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,2,3,1
+class FunctionCaller_unsigned_int_int_unsigned_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_unsigned_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(int,unsigned int,float,bool) = (unsigned int(*)(int,unsigned int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_unsigned_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,2,3,1
+class FunctionCaller_unsigned_int_bool_unsigned_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_unsigned_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(bool,unsigned int,float,bool) = (unsigned int(*)(bool,unsigned int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_unsigned_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,2,3,1
+class FunctionCaller_unsigned_int_unsigned_int_unsigned_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_unsigned_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,unsigned int,float,bool) = (unsigned int(*)(unsigned int,unsigned int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_unsigned_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,2,3,1
+class FunctionCaller_unsigned_int_float_unsigned_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_unsigned_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(float,unsigned int,float,bool) = (unsigned int(*)(float,unsigned int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_unsigned_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,3,3,1
+class FunctionCaller_unsigned_int_int_float_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_float_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(int,float,float,bool) = (unsigned int(*)(int,float,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_float_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,3,3,1
+class FunctionCaller_unsigned_int_bool_float_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_float_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(bool,float,float,bool) = (unsigned int(*)(bool,float,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_float_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,3,3,1
+class FunctionCaller_unsigned_int_unsigned_int_float_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_float_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,float,float,bool) = (unsigned int(*)(unsigned int,float,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_float_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,3,3,1
+class FunctionCaller_unsigned_int_float_float_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_float_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ unsigned int (*PF)(float,float,float,bool) = (unsigned int(*)(float,float,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_float_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,0,0,2
+class FunctionCaller_unsigned_int_int_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(int,int,int,unsigned int) = (unsigned int(*)(int,int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,0,0,2
+class FunctionCaller_unsigned_int_bool_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(bool,int,int,unsigned int) = (unsigned int(*)(bool,int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,0,0,2
+class FunctionCaller_unsigned_int_unsigned_int_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,int,int,unsigned int) = (unsigned int(*)(unsigned int,int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,0,0,2
+class FunctionCaller_unsigned_int_float_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(float,int,int,unsigned int) = (unsigned int(*)(float,int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,1,0,2
+class FunctionCaller_unsigned_int_int_bool_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_bool_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(int,bool,int,unsigned int) = (unsigned int(*)(int,bool,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_bool_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,1,0,2
+class FunctionCaller_unsigned_int_bool_bool_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_bool_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(bool,bool,int,unsigned int) = (unsigned int(*)(bool,bool,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_bool_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,1,0,2
+class FunctionCaller_unsigned_int_unsigned_int_bool_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_bool_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,bool,int,unsigned int) = (unsigned int(*)(unsigned int,bool,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_bool_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,1,0,2
+class FunctionCaller_unsigned_int_float_bool_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_bool_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(float,bool,int,unsigned int) = (unsigned int(*)(float,bool,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_bool_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,2,0,2
+class FunctionCaller_unsigned_int_int_unsigned_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_unsigned_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(int,unsigned int,int,unsigned int) = (unsigned int(*)(int,unsigned int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_unsigned_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,2,0,2
+class FunctionCaller_unsigned_int_bool_unsigned_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_unsigned_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(bool,unsigned int,int,unsigned int) = (unsigned int(*)(bool,unsigned int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_unsigned_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,2,0,2
+class FunctionCaller_unsigned_int_unsigned_int_unsigned_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_unsigned_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,unsigned int,int,unsigned int) = (unsigned int(*)(unsigned int,unsigned int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_unsigned_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,2,0,2
+class FunctionCaller_unsigned_int_float_unsigned_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_unsigned_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(float,unsigned int,int,unsigned int) = (unsigned int(*)(float,unsigned int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_unsigned_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,3,0,2
+class FunctionCaller_unsigned_int_int_float_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_float_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(int,float,int,unsigned int) = (unsigned int(*)(int,float,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_float_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,3,0,2
+class FunctionCaller_unsigned_int_bool_float_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_float_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(bool,float,int,unsigned int) = (unsigned int(*)(bool,float,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_float_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,3,0,2
+class FunctionCaller_unsigned_int_unsigned_int_float_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_float_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,float,int,unsigned int) = (unsigned int(*)(unsigned int,float,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_float_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,3,0,2
+class FunctionCaller_unsigned_int_float_float_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_float_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(float,float,int,unsigned int) = (unsigned int(*)(float,float,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_float_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,0,1,2
+class FunctionCaller_unsigned_int_int_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(int,int,bool,unsigned int) = (unsigned int(*)(int,int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,0,1,2
+class FunctionCaller_unsigned_int_bool_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(bool,int,bool,unsigned int) = (unsigned int(*)(bool,int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,0,1,2
+class FunctionCaller_unsigned_int_unsigned_int_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,int,bool,unsigned int) = (unsigned int(*)(unsigned int,int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,0,1,2
+class FunctionCaller_unsigned_int_float_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(float,int,bool,unsigned int) = (unsigned int(*)(float,int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,1,1,2
+class FunctionCaller_unsigned_int_int_bool_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_bool_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(int,bool,bool,unsigned int) = (unsigned int(*)(int,bool,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_bool_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,1,1,2
+class FunctionCaller_unsigned_int_bool_bool_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_bool_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(bool,bool,bool,unsigned int) = (unsigned int(*)(bool,bool,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_bool_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,1,1,2
+class FunctionCaller_unsigned_int_unsigned_int_bool_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_bool_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,bool,bool,unsigned int) = (unsigned int(*)(unsigned int,bool,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_bool_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,1,1,2
+class FunctionCaller_unsigned_int_float_bool_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_bool_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(float,bool,bool,unsigned int) = (unsigned int(*)(float,bool,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_bool_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,2,1,2
+class FunctionCaller_unsigned_int_int_unsigned_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_unsigned_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(int,unsigned int,bool,unsigned int) = (unsigned int(*)(int,unsigned int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_unsigned_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,2,1,2
+class FunctionCaller_unsigned_int_bool_unsigned_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_unsigned_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(bool,unsigned int,bool,unsigned int) = (unsigned int(*)(bool,unsigned int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_unsigned_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,2,1,2
+class FunctionCaller_unsigned_int_unsigned_int_unsigned_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_unsigned_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,unsigned int,bool,unsigned int) = (unsigned int(*)(unsigned int,unsigned int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_unsigned_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,2,1,2
+class FunctionCaller_unsigned_int_float_unsigned_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_unsigned_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(float,unsigned int,bool,unsigned int) = (unsigned int(*)(float,unsigned int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_unsigned_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,3,1,2
+class FunctionCaller_unsigned_int_int_float_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_float_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(int,float,bool,unsigned int) = (unsigned int(*)(int,float,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_float_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,3,1,2
+class FunctionCaller_unsigned_int_bool_float_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_float_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(bool,float,bool,unsigned int) = (unsigned int(*)(bool,float,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_float_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,3,1,2
+class FunctionCaller_unsigned_int_unsigned_int_float_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_float_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,float,bool,unsigned int) = (unsigned int(*)(unsigned int,float,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_float_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,3,1,2
+class FunctionCaller_unsigned_int_float_float_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_float_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(float,float,bool,unsigned int) = (unsigned int(*)(float,float,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_float_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,0,2,2
+class FunctionCaller_unsigned_int_int_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(int,int,unsigned int,unsigned int) = (unsigned int(*)(int,int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,0,2,2
+class FunctionCaller_unsigned_int_bool_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(bool,int,unsigned int,unsigned int) = (unsigned int(*)(bool,int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,0,2,2
+class FunctionCaller_unsigned_int_unsigned_int_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,int,unsigned int,unsigned int) = (unsigned int(*)(unsigned int,int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,0,2,2
+class FunctionCaller_unsigned_int_float_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(float,int,unsigned int,unsigned int) = (unsigned int(*)(float,int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,1,2,2
+class FunctionCaller_unsigned_int_int_bool_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_bool_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(int,bool,unsigned int,unsigned int) = (unsigned int(*)(int,bool,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_bool_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,1,2,2
+class FunctionCaller_unsigned_int_bool_bool_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_bool_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(bool,bool,unsigned int,unsigned int) = (unsigned int(*)(bool,bool,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_bool_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,1,2,2
+class FunctionCaller_unsigned_int_unsigned_int_bool_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_bool_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,bool,unsigned int,unsigned int) = (unsigned int(*)(unsigned int,bool,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_bool_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,1,2,2
+class FunctionCaller_unsigned_int_float_bool_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_bool_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(float,bool,unsigned int,unsigned int) = (unsigned int(*)(float,bool,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_bool_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,2,2,2
+class FunctionCaller_unsigned_int_int_unsigned_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_unsigned_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(int,unsigned int,unsigned int,unsigned int) = (unsigned int(*)(int,unsigned int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_unsigned_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,2,2,2
+class FunctionCaller_unsigned_int_bool_unsigned_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_unsigned_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(bool,unsigned int,unsigned int,unsigned int) = (unsigned int(*)(bool,unsigned int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_unsigned_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,2,2,2
+class FunctionCaller_unsigned_int_unsigned_int_unsigned_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_unsigned_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,unsigned int,unsigned int,unsigned int) = (unsigned int(*)(unsigned int,unsigned int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_unsigned_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,2,2,2
+class FunctionCaller_unsigned_int_float_unsigned_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_unsigned_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(float,unsigned int,unsigned int,unsigned int) = (unsigned int(*)(float,unsigned int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_unsigned_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,3,2,2
+class FunctionCaller_unsigned_int_int_float_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_float_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(int,float,unsigned int,unsigned int) = (unsigned int(*)(int,float,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_float_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,3,2,2
+class FunctionCaller_unsigned_int_bool_float_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_float_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(bool,float,unsigned int,unsigned int) = (unsigned int(*)(bool,float,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_float_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,3,2,2
+class FunctionCaller_unsigned_int_unsigned_int_float_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_float_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,float,unsigned int,unsigned int) = (unsigned int(*)(unsigned int,float,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_float_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,3,2,2
+class FunctionCaller_unsigned_int_float_float_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_float_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(float,float,unsigned int,unsigned int) = (unsigned int(*)(float,float,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_float_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,0,3,2
+class FunctionCaller_unsigned_int_int_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(int,int,float,unsigned int) = (unsigned int(*)(int,int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,0,3,2
+class FunctionCaller_unsigned_int_bool_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(bool,int,float,unsigned int) = (unsigned int(*)(bool,int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,0,3,2
+class FunctionCaller_unsigned_int_unsigned_int_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,int,float,unsigned int) = (unsigned int(*)(unsigned int,int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,0,3,2
+class FunctionCaller_unsigned_int_float_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(float,int,float,unsigned int) = (unsigned int(*)(float,int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,1,3,2
+class FunctionCaller_unsigned_int_int_bool_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_bool_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(int,bool,float,unsigned int) = (unsigned int(*)(int,bool,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_bool_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,1,3,2
+class FunctionCaller_unsigned_int_bool_bool_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_bool_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(bool,bool,float,unsigned int) = (unsigned int(*)(bool,bool,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_bool_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,1,3,2
+class FunctionCaller_unsigned_int_unsigned_int_bool_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_bool_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,bool,float,unsigned int) = (unsigned int(*)(unsigned int,bool,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_bool_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,1,3,2
+class FunctionCaller_unsigned_int_float_bool_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_bool_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(float,bool,float,unsigned int) = (unsigned int(*)(float,bool,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_bool_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,2,3,2
+class FunctionCaller_unsigned_int_int_unsigned_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_unsigned_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(int,unsigned int,float,unsigned int) = (unsigned int(*)(int,unsigned int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_unsigned_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,2,3,2
+class FunctionCaller_unsigned_int_bool_unsigned_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_unsigned_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(bool,unsigned int,float,unsigned int) = (unsigned int(*)(bool,unsigned int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_unsigned_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,2,3,2
+class FunctionCaller_unsigned_int_unsigned_int_unsigned_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_unsigned_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,unsigned int,float,unsigned int) = (unsigned int(*)(unsigned int,unsigned int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_unsigned_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,2,3,2
+class FunctionCaller_unsigned_int_float_unsigned_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_unsigned_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(float,unsigned int,float,unsigned int) = (unsigned int(*)(float,unsigned int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_unsigned_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,3,3,2
+class FunctionCaller_unsigned_int_int_float_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_float_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(int,float,float,unsigned int) = (unsigned int(*)(int,float,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_float_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,3,3,2
+class FunctionCaller_unsigned_int_bool_float_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_float_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(bool,float,float,unsigned int) = (unsigned int(*)(bool,float,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_float_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,3,3,2
+class FunctionCaller_unsigned_int_unsigned_int_float_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_float_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,float,float,unsigned int) = (unsigned int(*)(unsigned int,float,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_float_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,3,3,2
+class FunctionCaller_unsigned_int_float_float_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_float_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ unsigned int (*PF)(float,float,float,unsigned int) = (unsigned int(*)(float,float,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_float_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,0,0,3
+class FunctionCaller_unsigned_int_int_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(int,int,int,float) = (unsigned int(*)(int,int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,0,0,3
+class FunctionCaller_unsigned_int_bool_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(bool,int,int,float) = (unsigned int(*)(bool,int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,0,0,3
+class FunctionCaller_unsigned_int_unsigned_int_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,int,int,float) = (unsigned int(*)(unsigned int,int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,0,0,3
+class FunctionCaller_unsigned_int_float_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(float,int,int,float) = (unsigned int(*)(float,int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,1,0,3
+class FunctionCaller_unsigned_int_int_bool_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_bool_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(int,bool,int,float) = (unsigned int(*)(int,bool,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_bool_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,1,0,3
+class FunctionCaller_unsigned_int_bool_bool_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_bool_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(bool,bool,int,float) = (unsigned int(*)(bool,bool,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_bool_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,1,0,3
+class FunctionCaller_unsigned_int_unsigned_int_bool_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_bool_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,bool,int,float) = (unsigned int(*)(unsigned int,bool,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_bool_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,1,0,3
+class FunctionCaller_unsigned_int_float_bool_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_bool_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(float,bool,int,float) = (unsigned int(*)(float,bool,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_bool_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,2,0,3
+class FunctionCaller_unsigned_int_int_unsigned_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_unsigned_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(int,unsigned int,int,float) = (unsigned int(*)(int,unsigned int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_unsigned_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,2,0,3
+class FunctionCaller_unsigned_int_bool_unsigned_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_unsigned_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(bool,unsigned int,int,float) = (unsigned int(*)(bool,unsigned int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_unsigned_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,2,0,3
+class FunctionCaller_unsigned_int_unsigned_int_unsigned_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_unsigned_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,unsigned int,int,float) = (unsigned int(*)(unsigned int,unsigned int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_unsigned_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,2,0,3
+class FunctionCaller_unsigned_int_float_unsigned_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_unsigned_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(float,unsigned int,int,float) = (unsigned int(*)(float,unsigned int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_unsigned_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,3,0,3
+class FunctionCaller_unsigned_int_int_float_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_float_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(int,float,int,float) = (unsigned int(*)(int,float,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_float_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,3,0,3
+class FunctionCaller_unsigned_int_bool_float_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_float_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(bool,float,int,float) = (unsigned int(*)(bool,float,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_float_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,3,0,3
+class FunctionCaller_unsigned_int_unsigned_int_float_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_float_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,float,int,float) = (unsigned int(*)(unsigned int,float,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_float_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,3,0,3
+class FunctionCaller_unsigned_int_float_float_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_float_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(float,float,int,float) = (unsigned int(*)(float,float,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_float_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,0,1,3
+class FunctionCaller_unsigned_int_int_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(int,int,bool,float) = (unsigned int(*)(int,int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,0,1,3
+class FunctionCaller_unsigned_int_bool_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(bool,int,bool,float) = (unsigned int(*)(bool,int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,0,1,3
+class FunctionCaller_unsigned_int_unsigned_int_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,int,bool,float) = (unsigned int(*)(unsigned int,int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,0,1,3
+class FunctionCaller_unsigned_int_float_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(float,int,bool,float) = (unsigned int(*)(float,int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,1,1,3
+class FunctionCaller_unsigned_int_int_bool_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_bool_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(int,bool,bool,float) = (unsigned int(*)(int,bool,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_bool_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,1,1,3
+class FunctionCaller_unsigned_int_bool_bool_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_bool_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(bool,bool,bool,float) = (unsigned int(*)(bool,bool,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_bool_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,1,1,3
+class FunctionCaller_unsigned_int_unsigned_int_bool_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_bool_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,bool,bool,float) = (unsigned int(*)(unsigned int,bool,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_bool_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,1,1,3
+class FunctionCaller_unsigned_int_float_bool_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_bool_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(float,bool,bool,float) = (unsigned int(*)(float,bool,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_bool_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,2,1,3
+class FunctionCaller_unsigned_int_int_unsigned_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_unsigned_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(int,unsigned int,bool,float) = (unsigned int(*)(int,unsigned int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_unsigned_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,2,1,3
+class FunctionCaller_unsigned_int_bool_unsigned_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_unsigned_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(bool,unsigned int,bool,float) = (unsigned int(*)(bool,unsigned int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_unsigned_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,2,1,3
+class FunctionCaller_unsigned_int_unsigned_int_unsigned_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_unsigned_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,unsigned int,bool,float) = (unsigned int(*)(unsigned int,unsigned int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_unsigned_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,2,1,3
+class FunctionCaller_unsigned_int_float_unsigned_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_unsigned_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(float,unsigned int,bool,float) = (unsigned int(*)(float,unsigned int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_unsigned_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,3,1,3
+class FunctionCaller_unsigned_int_int_float_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_float_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(int,float,bool,float) = (unsigned int(*)(int,float,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_float_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,3,1,3
+class FunctionCaller_unsigned_int_bool_float_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_float_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(bool,float,bool,float) = (unsigned int(*)(bool,float,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_float_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,3,1,3
+class FunctionCaller_unsigned_int_unsigned_int_float_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_float_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,float,bool,float) = (unsigned int(*)(unsigned int,float,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_float_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,3,1,3
+class FunctionCaller_unsigned_int_float_float_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_float_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(float,float,bool,float) = (unsigned int(*)(float,float,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_float_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,0,2,3
+class FunctionCaller_unsigned_int_int_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(int,int,unsigned int,float) = (unsigned int(*)(int,int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,0,2,3
+class FunctionCaller_unsigned_int_bool_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(bool,int,unsigned int,float) = (unsigned int(*)(bool,int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,0,2,3
+class FunctionCaller_unsigned_int_unsigned_int_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,int,unsigned int,float) = (unsigned int(*)(unsigned int,int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,0,2,3
+class FunctionCaller_unsigned_int_float_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(float,int,unsigned int,float) = (unsigned int(*)(float,int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,1,2,3
+class FunctionCaller_unsigned_int_int_bool_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_bool_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(int,bool,unsigned int,float) = (unsigned int(*)(int,bool,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_bool_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,1,2,3
+class FunctionCaller_unsigned_int_bool_bool_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_bool_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(bool,bool,unsigned int,float) = (unsigned int(*)(bool,bool,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_bool_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,1,2,3
+class FunctionCaller_unsigned_int_unsigned_int_bool_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_bool_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,bool,unsigned int,float) = (unsigned int(*)(unsigned int,bool,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_bool_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,1,2,3
+class FunctionCaller_unsigned_int_float_bool_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_bool_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(float,bool,unsigned int,float) = (unsigned int(*)(float,bool,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_bool_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,2,2,3
+class FunctionCaller_unsigned_int_int_unsigned_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_unsigned_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(int,unsigned int,unsigned int,float) = (unsigned int(*)(int,unsigned int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_unsigned_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,2,2,3
+class FunctionCaller_unsigned_int_bool_unsigned_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_unsigned_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(bool,unsigned int,unsigned int,float) = (unsigned int(*)(bool,unsigned int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_unsigned_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,2,2,3
+class FunctionCaller_unsigned_int_unsigned_int_unsigned_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_unsigned_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,unsigned int,unsigned int,float) = (unsigned int(*)(unsigned int,unsigned int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_unsigned_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,2,2,3
+class FunctionCaller_unsigned_int_float_unsigned_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_unsigned_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(float,unsigned int,unsigned int,float) = (unsigned int(*)(float,unsigned int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_unsigned_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,3,2,3
+class FunctionCaller_unsigned_int_int_float_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_float_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(int,float,unsigned int,float) = (unsigned int(*)(int,float,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_float_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,3,2,3
+class FunctionCaller_unsigned_int_bool_float_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_float_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(bool,float,unsigned int,float) = (unsigned int(*)(bool,float,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_float_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,3,2,3
+class FunctionCaller_unsigned_int_unsigned_int_float_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_float_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,float,unsigned int,float) = (unsigned int(*)(unsigned int,float,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_float_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,3,2,3
+class FunctionCaller_unsigned_int_float_float_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_float_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(float,float,unsigned int,float) = (unsigned int(*)(float,float,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_float_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,0,3,3
+class FunctionCaller_unsigned_int_int_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(int,int,float,float) = (unsigned int(*)(int,int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,0,3,3
+class FunctionCaller_unsigned_int_bool_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(bool,int,float,float) = (unsigned int(*)(bool,int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,0,3,3
+class FunctionCaller_unsigned_int_unsigned_int_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,int,float,float) = (unsigned int(*)(unsigned int,int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,0,3,3
+class FunctionCaller_unsigned_int_float_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(float,int,float,float) = (unsigned int(*)(float,int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,1,3,3
+class FunctionCaller_unsigned_int_int_bool_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_bool_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(int,bool,float,float) = (unsigned int(*)(int,bool,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_bool_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,1,3,3
+class FunctionCaller_unsigned_int_bool_bool_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_bool_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(bool,bool,float,float) = (unsigned int(*)(bool,bool,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_bool_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,1,3,3
+class FunctionCaller_unsigned_int_unsigned_int_bool_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_bool_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,bool,float,float) = (unsigned int(*)(unsigned int,bool,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_bool_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,1,3,3
+class FunctionCaller_unsigned_int_float_bool_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_bool_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(float,bool,float,float) = (unsigned int(*)(float,bool,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_bool_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,2,3,3
+class FunctionCaller_unsigned_int_int_unsigned_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_unsigned_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(int,unsigned int,float,float) = (unsigned int(*)(int,unsigned int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_unsigned_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,2,3,3
+class FunctionCaller_unsigned_int_bool_unsigned_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_unsigned_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(bool,unsigned int,float,float) = (unsigned int(*)(bool,unsigned int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_unsigned_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,2,3,3
+class FunctionCaller_unsigned_int_unsigned_int_unsigned_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_unsigned_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,unsigned int,float,float) = (unsigned int(*)(unsigned int,unsigned int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_unsigned_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,2,3,3
+class FunctionCaller_unsigned_int_float_unsigned_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_unsigned_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(float,unsigned int,float,float) = (unsigned int(*)(float,unsigned int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_unsigned_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 0,3,3,3
+class FunctionCaller_unsigned_int_int_float_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_float_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(int,float,float,float) = (unsigned int(*)(int,float,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_int_float_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 1,3,3,3
+class FunctionCaller_unsigned_int_bool_float_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_float_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(bool,float,float,float) = (unsigned int(*)(bool,float,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_bool_float_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 2,3,3,3
+class FunctionCaller_unsigned_int_unsigned_int_float_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_float_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(unsigned int,float,float,float) = (unsigned int(*)(unsigned int,float,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_float_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 2 3,3,3,3
+class FunctionCaller_unsigned_int_float_float_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_float_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ unsigned int (*PF)(float,float,float,float) = (unsigned int(*)(float,float,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_unsigned_int_float_float_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,0,0,0
+class FunctionCaller_float_int_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(int,int,int,int) = (float(*)(int,int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,0,0,0
+class FunctionCaller_float_bool_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(bool,int,int,int) = (float(*)(bool,int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,0,0,0
+class FunctionCaller_float_unsigned_int_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(unsigned int,int,int,int) = (float(*)(unsigned int,int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,0,0,0
+class FunctionCaller_float_float_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(float,int,int,int) = (float(*)(float,int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,1,0,0
+class FunctionCaller_float_int_bool_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_bool_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(int,bool,int,int) = (float(*)(int,bool,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_bool_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,1,0,0
+class FunctionCaller_float_bool_bool_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_bool_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(bool,bool,int,int) = (float(*)(bool,bool,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_bool_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,1,0,0
+class FunctionCaller_float_unsigned_int_bool_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_bool_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(unsigned int,bool,int,int) = (float(*)(unsigned int,bool,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_bool_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,1,0,0
+class FunctionCaller_float_float_bool_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_bool_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(float,bool,int,int) = (float(*)(float,bool,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_bool_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,2,0,0
+class FunctionCaller_float_int_unsigned_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_unsigned_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(int,unsigned int,int,int) = (float(*)(int,unsigned int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_unsigned_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,2,0,0
+class FunctionCaller_float_bool_unsigned_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_unsigned_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(bool,unsigned int,int,int) = (float(*)(bool,unsigned int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_unsigned_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,2,0,0
+class FunctionCaller_float_unsigned_int_unsigned_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_unsigned_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(unsigned int,unsigned int,int,int) = (float(*)(unsigned int,unsigned int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_unsigned_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,2,0,0
+class FunctionCaller_float_float_unsigned_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_unsigned_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(float,unsigned int,int,int) = (float(*)(float,unsigned int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_unsigned_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,3,0,0
+class FunctionCaller_float_int_float_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_float_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(int,float,int,int) = (float(*)(int,float,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_float_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,3,0,0
+class FunctionCaller_float_bool_float_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_float_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(bool,float,int,int) = (float(*)(bool,float,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_float_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,3,0,0
+class FunctionCaller_float_unsigned_int_float_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_float_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(unsigned int,float,int,int) = (float(*)(unsigned int,float,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_float_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,3,0,0
+class FunctionCaller_float_float_float_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_float_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(float,float,int,int) = (float(*)(float,float,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_float_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,0,1,0
+class FunctionCaller_float_int_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(int,int,bool,int) = (float(*)(int,int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,0,1,0
+class FunctionCaller_float_bool_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(bool,int,bool,int) = (float(*)(bool,int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,0,1,0
+class FunctionCaller_float_unsigned_int_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(unsigned int,int,bool,int) = (float(*)(unsigned int,int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,0,1,0
+class FunctionCaller_float_float_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(float,int,bool,int) = (float(*)(float,int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,1,1,0
+class FunctionCaller_float_int_bool_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_bool_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(int,bool,bool,int) = (float(*)(int,bool,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_bool_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,1,1,0
+class FunctionCaller_float_bool_bool_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_bool_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(bool,bool,bool,int) = (float(*)(bool,bool,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_bool_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,1,1,0
+class FunctionCaller_float_unsigned_int_bool_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_bool_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(unsigned int,bool,bool,int) = (float(*)(unsigned int,bool,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_bool_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,1,1,0
+class FunctionCaller_float_float_bool_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_bool_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(float,bool,bool,int) = (float(*)(float,bool,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_bool_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,2,1,0
+class FunctionCaller_float_int_unsigned_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_unsigned_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(int,unsigned int,bool,int) = (float(*)(int,unsigned int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_unsigned_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,2,1,0
+class FunctionCaller_float_bool_unsigned_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_unsigned_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(bool,unsigned int,bool,int) = (float(*)(bool,unsigned int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_unsigned_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,2,1,0
+class FunctionCaller_float_unsigned_int_unsigned_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_unsigned_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(unsigned int,unsigned int,bool,int) = (float(*)(unsigned int,unsigned int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_unsigned_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,2,1,0
+class FunctionCaller_float_float_unsigned_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_unsigned_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(float,unsigned int,bool,int) = (float(*)(float,unsigned int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_unsigned_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,3,1,0
+class FunctionCaller_float_int_float_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_float_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(int,float,bool,int) = (float(*)(int,float,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_float_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,3,1,0
+class FunctionCaller_float_bool_float_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_float_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(bool,float,bool,int) = (float(*)(bool,float,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_float_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,3,1,0
+class FunctionCaller_float_unsigned_int_float_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_float_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(unsigned int,float,bool,int) = (float(*)(unsigned int,float,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_float_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,3,1,0
+class FunctionCaller_float_float_float_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_float_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(float,float,bool,int) = (float(*)(float,float,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_float_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,0,2,0
+class FunctionCaller_float_int_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(int,int,unsigned int,int) = (float(*)(int,int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,0,2,0
+class FunctionCaller_float_bool_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(bool,int,unsigned int,int) = (float(*)(bool,int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,0,2,0
+class FunctionCaller_float_unsigned_int_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(unsigned int,int,unsigned int,int) = (float(*)(unsigned int,int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,0,2,0
+class FunctionCaller_float_float_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(float,int,unsigned int,int) = (float(*)(float,int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,1,2,0
+class FunctionCaller_float_int_bool_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_bool_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(int,bool,unsigned int,int) = (float(*)(int,bool,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_bool_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,1,2,0
+class FunctionCaller_float_bool_bool_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_bool_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(bool,bool,unsigned int,int) = (float(*)(bool,bool,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_bool_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,1,2,0
+class FunctionCaller_float_unsigned_int_bool_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_bool_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(unsigned int,bool,unsigned int,int) = (float(*)(unsigned int,bool,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_bool_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,1,2,0
+class FunctionCaller_float_float_bool_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_bool_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(float,bool,unsigned int,int) = (float(*)(float,bool,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_bool_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,2,2,0
+class FunctionCaller_float_int_unsigned_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_unsigned_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(int,unsigned int,unsigned int,int) = (float(*)(int,unsigned int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_unsigned_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,2,2,0
+class FunctionCaller_float_bool_unsigned_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_unsigned_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(bool,unsigned int,unsigned int,int) = (float(*)(bool,unsigned int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_unsigned_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,2,2,0
+class FunctionCaller_float_unsigned_int_unsigned_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_unsigned_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(unsigned int,unsigned int,unsigned int,int) = (float(*)(unsigned int,unsigned int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_unsigned_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,2,2,0
+class FunctionCaller_float_float_unsigned_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_unsigned_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(float,unsigned int,unsigned int,int) = (float(*)(float,unsigned int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_unsigned_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,3,2,0
+class FunctionCaller_float_int_float_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_float_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(int,float,unsigned int,int) = (float(*)(int,float,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_float_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,3,2,0
+class FunctionCaller_float_bool_float_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_float_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(bool,float,unsigned int,int) = (float(*)(bool,float,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_float_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,3,2,0
+class FunctionCaller_float_unsigned_int_float_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_float_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(unsigned int,float,unsigned int,int) = (float(*)(unsigned int,float,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_float_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,3,2,0
+class FunctionCaller_float_float_float_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_float_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(float,float,unsigned int,int) = (float(*)(float,float,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_float_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,0,3,0
+class FunctionCaller_float_int_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(int,int,float,int) = (float(*)(int,int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,0,3,0
+class FunctionCaller_float_bool_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(bool,int,float,int) = (float(*)(bool,int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,0,3,0
+class FunctionCaller_float_unsigned_int_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(unsigned int,int,float,int) = (float(*)(unsigned int,int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,0,3,0
+class FunctionCaller_float_float_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(float,int,float,int) = (float(*)(float,int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,1,3,0
+class FunctionCaller_float_int_bool_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_bool_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(int,bool,float,int) = (float(*)(int,bool,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_bool_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,1,3,0
+class FunctionCaller_float_bool_bool_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_bool_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(bool,bool,float,int) = (float(*)(bool,bool,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_bool_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,1,3,0
+class FunctionCaller_float_unsigned_int_bool_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_bool_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(unsigned int,bool,float,int) = (float(*)(unsigned int,bool,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_bool_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,1,3,0
+class FunctionCaller_float_float_bool_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_bool_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(float,bool,float,int) = (float(*)(float,bool,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_bool_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,2,3,0
+class FunctionCaller_float_int_unsigned_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_unsigned_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(int,unsigned int,float,int) = (float(*)(int,unsigned int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_unsigned_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,2,3,0
+class FunctionCaller_float_bool_unsigned_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_unsigned_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(bool,unsigned int,float,int) = (float(*)(bool,unsigned int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_unsigned_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,2,3,0
+class FunctionCaller_float_unsigned_int_unsigned_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_unsigned_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(unsigned int,unsigned int,float,int) = (float(*)(unsigned int,unsigned int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_unsigned_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,2,3,0
+class FunctionCaller_float_float_unsigned_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_unsigned_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(float,unsigned int,float,int) = (float(*)(float,unsigned int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_unsigned_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,3,3,0
+class FunctionCaller_float_int_float_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_float_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(int,float,float,int) = (float(*)(int,float,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_float_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,3,3,0
+class FunctionCaller_float_bool_float_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_float_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(bool,float,float,int) = (float(*)(bool,float,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_float_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,3,3,0
+class FunctionCaller_float_unsigned_int_float_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_float_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(unsigned int,float,float,int) = (float(*)(unsigned int,float,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_float_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,3,3,0
+class FunctionCaller_float_float_float_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_float_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ float (*PF)(float,float,float,int) = (float(*)(float,float,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_float_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,0,0,1
+class FunctionCaller_float_int_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(int,int,int,bool) = (float(*)(int,int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,0,0,1
+class FunctionCaller_float_bool_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(bool,int,int,bool) = (float(*)(bool,int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,0,0,1
+class FunctionCaller_float_unsigned_int_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(unsigned int,int,int,bool) = (float(*)(unsigned int,int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,0,0,1
+class FunctionCaller_float_float_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(float,int,int,bool) = (float(*)(float,int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,1,0,1
+class FunctionCaller_float_int_bool_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_bool_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(int,bool,int,bool) = (float(*)(int,bool,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_bool_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,1,0,1
+class FunctionCaller_float_bool_bool_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_bool_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(bool,bool,int,bool) = (float(*)(bool,bool,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_bool_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,1,0,1
+class FunctionCaller_float_unsigned_int_bool_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_bool_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(unsigned int,bool,int,bool) = (float(*)(unsigned int,bool,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_bool_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,1,0,1
+class FunctionCaller_float_float_bool_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_bool_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(float,bool,int,bool) = (float(*)(float,bool,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_bool_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,2,0,1
+class FunctionCaller_float_int_unsigned_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_unsigned_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(int,unsigned int,int,bool) = (float(*)(int,unsigned int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_unsigned_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,2,0,1
+class FunctionCaller_float_bool_unsigned_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_unsigned_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(bool,unsigned int,int,bool) = (float(*)(bool,unsigned int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_unsigned_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,2,0,1
+class FunctionCaller_float_unsigned_int_unsigned_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_unsigned_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(unsigned int,unsigned int,int,bool) = (float(*)(unsigned int,unsigned int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_unsigned_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,2,0,1
+class FunctionCaller_float_float_unsigned_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_unsigned_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(float,unsigned int,int,bool) = (float(*)(float,unsigned int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_unsigned_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,3,0,1
+class FunctionCaller_float_int_float_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_float_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(int,float,int,bool) = (float(*)(int,float,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_float_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,3,0,1
+class FunctionCaller_float_bool_float_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_float_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(bool,float,int,bool) = (float(*)(bool,float,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_float_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,3,0,1
+class FunctionCaller_float_unsigned_int_float_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_float_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(unsigned int,float,int,bool) = (float(*)(unsigned int,float,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_float_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,3,0,1
+class FunctionCaller_float_float_float_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_float_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(float,float,int,bool) = (float(*)(float,float,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_float_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,0,1,1
+class FunctionCaller_float_int_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(int,int,bool,bool) = (float(*)(int,int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,0,1,1
+class FunctionCaller_float_bool_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(bool,int,bool,bool) = (float(*)(bool,int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,0,1,1
+class FunctionCaller_float_unsigned_int_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(unsigned int,int,bool,bool) = (float(*)(unsigned int,int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,0,1,1
+class FunctionCaller_float_float_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(float,int,bool,bool) = (float(*)(float,int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,1,1,1
+class FunctionCaller_float_int_bool_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_bool_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(int,bool,bool,bool) = (float(*)(int,bool,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_bool_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,1,1,1
+class FunctionCaller_float_bool_bool_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_bool_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(bool,bool,bool,bool) = (float(*)(bool,bool,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_bool_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,1,1,1
+class FunctionCaller_float_unsigned_int_bool_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_bool_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(unsigned int,bool,bool,bool) = (float(*)(unsigned int,bool,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_bool_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,1,1,1
+class FunctionCaller_float_float_bool_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_bool_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(float,bool,bool,bool) = (float(*)(float,bool,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_bool_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,2,1,1
+class FunctionCaller_float_int_unsigned_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_unsigned_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(int,unsigned int,bool,bool) = (float(*)(int,unsigned int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_unsigned_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,2,1,1
+class FunctionCaller_float_bool_unsigned_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_unsigned_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(bool,unsigned int,bool,bool) = (float(*)(bool,unsigned int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_unsigned_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,2,1,1
+class FunctionCaller_float_unsigned_int_unsigned_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_unsigned_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(unsigned int,unsigned int,bool,bool) = (float(*)(unsigned int,unsigned int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_unsigned_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,2,1,1
+class FunctionCaller_float_float_unsigned_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_unsigned_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(float,unsigned int,bool,bool) = (float(*)(float,unsigned int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_unsigned_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,3,1,1
+class FunctionCaller_float_int_float_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_float_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(int,float,bool,bool) = (float(*)(int,float,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_float_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,3,1,1
+class FunctionCaller_float_bool_float_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_float_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(bool,float,bool,bool) = (float(*)(bool,float,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_float_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,3,1,1
+class FunctionCaller_float_unsigned_int_float_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_float_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(unsigned int,float,bool,bool) = (float(*)(unsigned int,float,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_float_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,3,1,1
+class FunctionCaller_float_float_float_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_float_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(float,float,bool,bool) = (float(*)(float,float,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_float_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,0,2,1
+class FunctionCaller_float_int_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(int,int,unsigned int,bool) = (float(*)(int,int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,0,2,1
+class FunctionCaller_float_bool_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(bool,int,unsigned int,bool) = (float(*)(bool,int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,0,2,1
+class FunctionCaller_float_unsigned_int_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(unsigned int,int,unsigned int,bool) = (float(*)(unsigned int,int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,0,2,1
+class FunctionCaller_float_float_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(float,int,unsigned int,bool) = (float(*)(float,int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,1,2,1
+class FunctionCaller_float_int_bool_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_bool_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(int,bool,unsigned int,bool) = (float(*)(int,bool,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_bool_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,1,2,1
+class FunctionCaller_float_bool_bool_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_bool_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(bool,bool,unsigned int,bool) = (float(*)(bool,bool,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_bool_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,1,2,1
+class FunctionCaller_float_unsigned_int_bool_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_bool_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(unsigned int,bool,unsigned int,bool) = (float(*)(unsigned int,bool,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_bool_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,1,2,1
+class FunctionCaller_float_float_bool_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_bool_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(float,bool,unsigned int,bool) = (float(*)(float,bool,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_bool_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,2,2,1
+class FunctionCaller_float_int_unsigned_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_unsigned_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(int,unsigned int,unsigned int,bool) = (float(*)(int,unsigned int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_unsigned_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,2,2,1
+class FunctionCaller_float_bool_unsigned_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_unsigned_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(bool,unsigned int,unsigned int,bool) = (float(*)(bool,unsigned int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_unsigned_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,2,2,1
+class FunctionCaller_float_unsigned_int_unsigned_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_unsigned_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(unsigned int,unsigned int,unsigned int,bool) = (float(*)(unsigned int,unsigned int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_unsigned_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,2,2,1
+class FunctionCaller_float_float_unsigned_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_unsigned_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(float,unsigned int,unsigned int,bool) = (float(*)(float,unsigned int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_unsigned_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,3,2,1
+class FunctionCaller_float_int_float_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_float_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(int,float,unsigned int,bool) = (float(*)(int,float,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_float_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,3,2,1
+class FunctionCaller_float_bool_float_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_float_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(bool,float,unsigned int,bool) = (float(*)(bool,float,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_float_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,3,2,1
+class FunctionCaller_float_unsigned_int_float_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_float_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(unsigned int,float,unsigned int,bool) = (float(*)(unsigned int,float,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_float_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,3,2,1
+class FunctionCaller_float_float_float_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_float_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(float,float,unsigned int,bool) = (float(*)(float,float,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_float_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,0,3,1
+class FunctionCaller_float_int_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(int,int,float,bool) = (float(*)(int,int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,0,3,1
+class FunctionCaller_float_bool_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(bool,int,float,bool) = (float(*)(bool,int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,0,3,1
+class FunctionCaller_float_unsigned_int_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(unsigned int,int,float,bool) = (float(*)(unsigned int,int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,0,3,1
+class FunctionCaller_float_float_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(float,int,float,bool) = (float(*)(float,int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,1,3,1
+class FunctionCaller_float_int_bool_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_bool_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(int,bool,float,bool) = (float(*)(int,bool,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_bool_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,1,3,1
+class FunctionCaller_float_bool_bool_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_bool_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(bool,bool,float,bool) = (float(*)(bool,bool,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_bool_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,1,3,1
+class FunctionCaller_float_unsigned_int_bool_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_bool_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(unsigned int,bool,float,bool) = (float(*)(unsigned int,bool,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_bool_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,1,3,1
+class FunctionCaller_float_float_bool_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_bool_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(float,bool,float,bool) = (float(*)(float,bool,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_bool_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,2,3,1
+class FunctionCaller_float_int_unsigned_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_unsigned_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(int,unsigned int,float,bool) = (float(*)(int,unsigned int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_unsigned_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,2,3,1
+class FunctionCaller_float_bool_unsigned_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_unsigned_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(bool,unsigned int,float,bool) = (float(*)(bool,unsigned int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_unsigned_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,2,3,1
+class FunctionCaller_float_unsigned_int_unsigned_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_unsigned_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(unsigned int,unsigned int,float,bool) = (float(*)(unsigned int,unsigned int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_unsigned_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,2,3,1
+class FunctionCaller_float_float_unsigned_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_unsigned_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(float,unsigned int,float,bool) = (float(*)(float,unsigned int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_unsigned_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,3,3,1
+class FunctionCaller_float_int_float_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_float_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(int,float,float,bool) = (float(*)(int,float,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_float_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,3,3,1
+class FunctionCaller_float_bool_float_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_float_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(bool,float,float,bool) = (float(*)(bool,float,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_float_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,3,3,1
+class FunctionCaller_float_unsigned_int_float_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_float_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(unsigned int,float,float,bool) = (float(*)(unsigned int,float,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_float_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,3,3,1
+class FunctionCaller_float_float_float_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_float_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ float (*PF)(float,float,float,bool) = (float(*)(float,float,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_float_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,0,0,2
+class FunctionCaller_float_int_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(int,int,int,unsigned int) = (float(*)(int,int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,0,0,2
+class FunctionCaller_float_bool_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(bool,int,int,unsigned int) = (float(*)(bool,int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,0,0,2
+class FunctionCaller_float_unsigned_int_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(unsigned int,int,int,unsigned int) = (float(*)(unsigned int,int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,0,0,2
+class FunctionCaller_float_float_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(float,int,int,unsigned int) = (float(*)(float,int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,1,0,2
+class FunctionCaller_float_int_bool_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_bool_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(int,bool,int,unsigned int) = (float(*)(int,bool,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_bool_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,1,0,2
+class FunctionCaller_float_bool_bool_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_bool_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(bool,bool,int,unsigned int) = (float(*)(bool,bool,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_bool_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,1,0,2
+class FunctionCaller_float_unsigned_int_bool_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_bool_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(unsigned int,bool,int,unsigned int) = (float(*)(unsigned int,bool,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_bool_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,1,0,2
+class FunctionCaller_float_float_bool_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_bool_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(float,bool,int,unsigned int) = (float(*)(float,bool,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_bool_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,2,0,2
+class FunctionCaller_float_int_unsigned_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_unsigned_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(int,unsigned int,int,unsigned int) = (float(*)(int,unsigned int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_unsigned_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,2,0,2
+class FunctionCaller_float_bool_unsigned_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_unsigned_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(bool,unsigned int,int,unsigned int) = (float(*)(bool,unsigned int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_unsigned_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,2,0,2
+class FunctionCaller_float_unsigned_int_unsigned_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_unsigned_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(unsigned int,unsigned int,int,unsigned int) = (float(*)(unsigned int,unsigned int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_unsigned_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,2,0,2
+class FunctionCaller_float_float_unsigned_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_unsigned_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(float,unsigned int,int,unsigned int) = (float(*)(float,unsigned int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_unsigned_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,3,0,2
+class FunctionCaller_float_int_float_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_float_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(int,float,int,unsigned int) = (float(*)(int,float,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_float_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,3,0,2
+class FunctionCaller_float_bool_float_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_float_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(bool,float,int,unsigned int) = (float(*)(bool,float,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_float_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,3,0,2
+class FunctionCaller_float_unsigned_int_float_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_float_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(unsigned int,float,int,unsigned int) = (float(*)(unsigned int,float,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_float_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,3,0,2
+class FunctionCaller_float_float_float_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_float_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(float,float,int,unsigned int) = (float(*)(float,float,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_float_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,0,1,2
+class FunctionCaller_float_int_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(int,int,bool,unsigned int) = (float(*)(int,int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,0,1,2
+class FunctionCaller_float_bool_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(bool,int,bool,unsigned int) = (float(*)(bool,int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,0,1,2
+class FunctionCaller_float_unsigned_int_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(unsigned int,int,bool,unsigned int) = (float(*)(unsigned int,int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,0,1,2
+class FunctionCaller_float_float_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(float,int,bool,unsigned int) = (float(*)(float,int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,1,1,2
+class FunctionCaller_float_int_bool_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_bool_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(int,bool,bool,unsigned int) = (float(*)(int,bool,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_bool_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,1,1,2
+class FunctionCaller_float_bool_bool_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_bool_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(bool,bool,bool,unsigned int) = (float(*)(bool,bool,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_bool_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,1,1,2
+class FunctionCaller_float_unsigned_int_bool_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_bool_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(unsigned int,bool,bool,unsigned int) = (float(*)(unsigned int,bool,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_bool_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,1,1,2
+class FunctionCaller_float_float_bool_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_bool_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(float,bool,bool,unsigned int) = (float(*)(float,bool,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_bool_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,2,1,2
+class FunctionCaller_float_int_unsigned_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_unsigned_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(int,unsigned int,bool,unsigned int) = (float(*)(int,unsigned int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_unsigned_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,2,1,2
+class FunctionCaller_float_bool_unsigned_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_unsigned_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(bool,unsigned int,bool,unsigned int) = (float(*)(bool,unsigned int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_unsigned_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,2,1,2
+class FunctionCaller_float_unsigned_int_unsigned_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_unsigned_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(unsigned int,unsigned int,bool,unsigned int) = (float(*)(unsigned int,unsigned int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_unsigned_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,2,1,2
+class FunctionCaller_float_float_unsigned_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_unsigned_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(float,unsigned int,bool,unsigned int) = (float(*)(float,unsigned int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_unsigned_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,3,1,2
+class FunctionCaller_float_int_float_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_float_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(int,float,bool,unsigned int) = (float(*)(int,float,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_float_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,3,1,2
+class FunctionCaller_float_bool_float_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_float_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(bool,float,bool,unsigned int) = (float(*)(bool,float,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_float_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,3,1,2
+class FunctionCaller_float_unsigned_int_float_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_float_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(unsigned int,float,bool,unsigned int) = (float(*)(unsigned int,float,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_float_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,3,1,2
+class FunctionCaller_float_float_float_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_float_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(float,float,bool,unsigned int) = (float(*)(float,float,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_float_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,0,2,2
+class FunctionCaller_float_int_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(int,int,unsigned int,unsigned int) = (float(*)(int,int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,0,2,2
+class FunctionCaller_float_bool_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(bool,int,unsigned int,unsigned int) = (float(*)(bool,int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,0,2,2
+class FunctionCaller_float_unsigned_int_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(unsigned int,int,unsigned int,unsigned int) = (float(*)(unsigned int,int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,0,2,2
+class FunctionCaller_float_float_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(float,int,unsigned int,unsigned int) = (float(*)(float,int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,1,2,2
+class FunctionCaller_float_int_bool_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_bool_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(int,bool,unsigned int,unsigned int) = (float(*)(int,bool,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_bool_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,1,2,2
+class FunctionCaller_float_bool_bool_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_bool_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(bool,bool,unsigned int,unsigned int) = (float(*)(bool,bool,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_bool_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,1,2,2
+class FunctionCaller_float_unsigned_int_bool_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_bool_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(unsigned int,bool,unsigned int,unsigned int) = (float(*)(unsigned int,bool,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_bool_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,1,2,2
+class FunctionCaller_float_float_bool_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_bool_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(float,bool,unsigned int,unsigned int) = (float(*)(float,bool,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_bool_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,2,2,2
+class FunctionCaller_float_int_unsigned_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_unsigned_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(int,unsigned int,unsigned int,unsigned int) = (float(*)(int,unsigned int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_unsigned_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,2,2,2
+class FunctionCaller_float_bool_unsigned_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_unsigned_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(bool,unsigned int,unsigned int,unsigned int) = (float(*)(bool,unsigned int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_unsigned_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,2,2,2
+class FunctionCaller_float_unsigned_int_unsigned_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_unsigned_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(unsigned int,unsigned int,unsigned int,unsigned int) = (float(*)(unsigned int,unsigned int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_unsigned_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,2,2,2
+class FunctionCaller_float_float_unsigned_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_unsigned_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(float,unsigned int,unsigned int,unsigned int) = (float(*)(float,unsigned int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_unsigned_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,3,2,2
+class FunctionCaller_float_int_float_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_float_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(int,float,unsigned int,unsigned int) = (float(*)(int,float,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_float_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,3,2,2
+class FunctionCaller_float_bool_float_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_float_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(bool,float,unsigned int,unsigned int) = (float(*)(bool,float,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_float_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,3,2,2
+class FunctionCaller_float_unsigned_int_float_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_float_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(unsigned int,float,unsigned int,unsigned int) = (float(*)(unsigned int,float,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_float_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,3,2,2
+class FunctionCaller_float_float_float_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_float_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(float,float,unsigned int,unsigned int) = (float(*)(float,float,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_float_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,0,3,2
+class FunctionCaller_float_int_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(int,int,float,unsigned int) = (float(*)(int,int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,0,3,2
+class FunctionCaller_float_bool_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(bool,int,float,unsigned int) = (float(*)(bool,int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,0,3,2
+class FunctionCaller_float_unsigned_int_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(unsigned int,int,float,unsigned int) = (float(*)(unsigned int,int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,0,3,2
+class FunctionCaller_float_float_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(float,int,float,unsigned int) = (float(*)(float,int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,1,3,2
+class FunctionCaller_float_int_bool_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_bool_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(int,bool,float,unsigned int) = (float(*)(int,bool,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_bool_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,1,3,2
+class FunctionCaller_float_bool_bool_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_bool_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(bool,bool,float,unsigned int) = (float(*)(bool,bool,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_bool_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,1,3,2
+class FunctionCaller_float_unsigned_int_bool_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_bool_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(unsigned int,bool,float,unsigned int) = (float(*)(unsigned int,bool,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_bool_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,1,3,2
+class FunctionCaller_float_float_bool_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_bool_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(float,bool,float,unsigned int) = (float(*)(float,bool,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_bool_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,2,3,2
+class FunctionCaller_float_int_unsigned_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_unsigned_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(int,unsigned int,float,unsigned int) = (float(*)(int,unsigned int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_unsigned_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,2,3,2
+class FunctionCaller_float_bool_unsigned_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_unsigned_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(bool,unsigned int,float,unsigned int) = (float(*)(bool,unsigned int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_unsigned_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,2,3,2
+class FunctionCaller_float_unsigned_int_unsigned_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_unsigned_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(unsigned int,unsigned int,float,unsigned int) = (float(*)(unsigned int,unsigned int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_unsigned_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,2,3,2
+class FunctionCaller_float_float_unsigned_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_unsigned_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(float,unsigned int,float,unsigned int) = (float(*)(float,unsigned int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_unsigned_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,3,3,2
+class FunctionCaller_float_int_float_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_float_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(int,float,float,unsigned int) = (float(*)(int,float,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_float_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,3,3,2
+class FunctionCaller_float_bool_float_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_float_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(bool,float,float,unsigned int) = (float(*)(bool,float,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_float_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,3,3,2
+class FunctionCaller_float_unsigned_int_float_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_float_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(unsigned int,float,float,unsigned int) = (float(*)(unsigned int,float,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_float_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,3,3,2
+class FunctionCaller_float_float_float_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_float_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ float (*PF)(float,float,float,unsigned int) = (float(*)(float,float,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_float_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,0,0,3
+class FunctionCaller_float_int_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(int,int,int,float) = (float(*)(int,int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,0,0,3
+class FunctionCaller_float_bool_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(bool,int,int,float) = (float(*)(bool,int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,0,0,3
+class FunctionCaller_float_unsigned_int_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(unsigned int,int,int,float) = (float(*)(unsigned int,int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,0,0,3
+class FunctionCaller_float_float_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(float,int,int,float) = (float(*)(float,int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,1,0,3
+class FunctionCaller_float_int_bool_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_bool_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(int,bool,int,float) = (float(*)(int,bool,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_bool_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,1,0,3
+class FunctionCaller_float_bool_bool_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_bool_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(bool,bool,int,float) = (float(*)(bool,bool,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_bool_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,1,0,3
+class FunctionCaller_float_unsigned_int_bool_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_bool_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(unsigned int,bool,int,float) = (float(*)(unsigned int,bool,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_bool_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,1,0,3
+class FunctionCaller_float_float_bool_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_bool_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(float,bool,int,float) = (float(*)(float,bool,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_bool_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,2,0,3
+class FunctionCaller_float_int_unsigned_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_unsigned_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(int,unsigned int,int,float) = (float(*)(int,unsigned int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_unsigned_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,2,0,3
+class FunctionCaller_float_bool_unsigned_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_unsigned_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(bool,unsigned int,int,float) = (float(*)(bool,unsigned int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_unsigned_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,2,0,3
+class FunctionCaller_float_unsigned_int_unsigned_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_unsigned_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(unsigned int,unsigned int,int,float) = (float(*)(unsigned int,unsigned int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_unsigned_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,2,0,3
+class FunctionCaller_float_float_unsigned_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_unsigned_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(float,unsigned int,int,float) = (float(*)(float,unsigned int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_unsigned_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,3,0,3
+class FunctionCaller_float_int_float_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_float_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(int,float,int,float) = (float(*)(int,float,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_float_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,3,0,3
+class FunctionCaller_float_bool_float_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_float_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(bool,float,int,float) = (float(*)(bool,float,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_float_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,3,0,3
+class FunctionCaller_float_unsigned_int_float_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_float_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(unsigned int,float,int,float) = (float(*)(unsigned int,float,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_float_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,3,0,3
+class FunctionCaller_float_float_float_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_float_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(float,float,int,float) = (float(*)(float,float,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_float_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,0,1,3
+class FunctionCaller_float_int_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(int,int,bool,float) = (float(*)(int,int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,0,1,3
+class FunctionCaller_float_bool_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(bool,int,bool,float) = (float(*)(bool,int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,0,1,3
+class FunctionCaller_float_unsigned_int_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(unsigned int,int,bool,float) = (float(*)(unsigned int,int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,0,1,3
+class FunctionCaller_float_float_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(float,int,bool,float) = (float(*)(float,int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,1,1,3
+class FunctionCaller_float_int_bool_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_bool_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(int,bool,bool,float) = (float(*)(int,bool,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_bool_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,1,1,3
+class FunctionCaller_float_bool_bool_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_bool_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(bool,bool,bool,float) = (float(*)(bool,bool,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_bool_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,1,1,3
+class FunctionCaller_float_unsigned_int_bool_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_bool_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(unsigned int,bool,bool,float) = (float(*)(unsigned int,bool,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_bool_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,1,1,3
+class FunctionCaller_float_float_bool_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_bool_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(float,bool,bool,float) = (float(*)(float,bool,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_bool_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,2,1,3
+class FunctionCaller_float_int_unsigned_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_unsigned_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(int,unsigned int,bool,float) = (float(*)(int,unsigned int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_unsigned_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,2,1,3
+class FunctionCaller_float_bool_unsigned_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_unsigned_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(bool,unsigned int,bool,float) = (float(*)(bool,unsigned int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_unsigned_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,2,1,3
+class FunctionCaller_float_unsigned_int_unsigned_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_unsigned_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(unsigned int,unsigned int,bool,float) = (float(*)(unsigned int,unsigned int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_unsigned_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,2,1,3
+class FunctionCaller_float_float_unsigned_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_unsigned_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(float,unsigned int,bool,float) = (float(*)(float,unsigned int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_unsigned_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,3,1,3
+class FunctionCaller_float_int_float_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_float_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(int,float,bool,float) = (float(*)(int,float,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_float_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,3,1,3
+class FunctionCaller_float_bool_float_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_float_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(bool,float,bool,float) = (float(*)(bool,float,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_float_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,3,1,3
+class FunctionCaller_float_unsigned_int_float_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_float_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(unsigned int,float,bool,float) = (float(*)(unsigned int,float,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_float_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,3,1,3
+class FunctionCaller_float_float_float_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_float_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(float,float,bool,float) = (float(*)(float,float,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_float_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,0,2,3
+class FunctionCaller_float_int_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(int,int,unsigned int,float) = (float(*)(int,int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,0,2,3
+class FunctionCaller_float_bool_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(bool,int,unsigned int,float) = (float(*)(bool,int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,0,2,3
+class FunctionCaller_float_unsigned_int_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(unsigned int,int,unsigned int,float) = (float(*)(unsigned int,int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,0,2,3
+class FunctionCaller_float_float_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(float,int,unsigned int,float) = (float(*)(float,int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,1,2,3
+class FunctionCaller_float_int_bool_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_bool_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(int,bool,unsigned int,float) = (float(*)(int,bool,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_bool_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,1,2,3
+class FunctionCaller_float_bool_bool_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_bool_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(bool,bool,unsigned int,float) = (float(*)(bool,bool,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_bool_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,1,2,3
+class FunctionCaller_float_unsigned_int_bool_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_bool_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(unsigned int,bool,unsigned int,float) = (float(*)(unsigned int,bool,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_bool_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,1,2,3
+class FunctionCaller_float_float_bool_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_bool_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(float,bool,unsigned int,float) = (float(*)(float,bool,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_bool_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,2,2,3
+class FunctionCaller_float_int_unsigned_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_unsigned_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(int,unsigned int,unsigned int,float) = (float(*)(int,unsigned int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_unsigned_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,2,2,3
+class FunctionCaller_float_bool_unsigned_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_unsigned_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(bool,unsigned int,unsigned int,float) = (float(*)(bool,unsigned int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_unsigned_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,2,2,3
+class FunctionCaller_float_unsigned_int_unsigned_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_unsigned_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(unsigned int,unsigned int,unsigned int,float) = (float(*)(unsigned int,unsigned int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_unsigned_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,2,2,3
+class FunctionCaller_float_float_unsigned_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_unsigned_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(float,unsigned int,unsigned int,float) = (float(*)(float,unsigned int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_unsigned_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,3,2,3
+class FunctionCaller_float_int_float_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_float_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(int,float,unsigned int,float) = (float(*)(int,float,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_float_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,3,2,3
+class FunctionCaller_float_bool_float_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_float_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(bool,float,unsigned int,float) = (float(*)(bool,float,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_float_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,3,2,3
+class FunctionCaller_float_unsigned_int_float_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_float_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(unsigned int,float,unsigned int,float) = (float(*)(unsigned int,float,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_float_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,3,2,3
+class FunctionCaller_float_float_float_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_float_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(float,float,unsigned int,float) = (float(*)(float,float,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_float_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,0,3,3
+class FunctionCaller_float_int_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(int,int,float,float) = (float(*)(int,int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,0,3,3
+class FunctionCaller_float_bool_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(bool,int,float,float) = (float(*)(bool,int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,0,3,3
+class FunctionCaller_float_unsigned_int_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(unsigned int,int,float,float) = (float(*)(unsigned int,int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,0,3,3
+class FunctionCaller_float_float_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(float,int,float,float) = (float(*)(float,int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,1,3,3
+class FunctionCaller_float_int_bool_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_bool_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(int,bool,float,float) = (float(*)(int,bool,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_bool_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,1,3,3
+class FunctionCaller_float_bool_bool_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_bool_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(bool,bool,float,float) = (float(*)(bool,bool,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_bool_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,1,3,3
+class FunctionCaller_float_unsigned_int_bool_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_bool_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(unsigned int,bool,float,float) = (float(*)(unsigned int,bool,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_bool_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,1,3,3
+class FunctionCaller_float_float_bool_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_bool_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(float,bool,float,float) = (float(*)(float,bool,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_bool_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,2,3,3
+class FunctionCaller_float_int_unsigned_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_unsigned_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(int,unsigned int,float,float) = (float(*)(int,unsigned int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_unsigned_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,2,3,3
+class FunctionCaller_float_bool_unsigned_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_unsigned_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(bool,unsigned int,float,float) = (float(*)(bool,unsigned int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_unsigned_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,2,3,3
+class FunctionCaller_float_unsigned_int_unsigned_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_unsigned_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(unsigned int,unsigned int,float,float) = (float(*)(unsigned int,unsigned int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_unsigned_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,2,3,3
+class FunctionCaller_float_float_unsigned_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_unsigned_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(float,unsigned int,float,float) = (float(*)(float,unsigned int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_unsigned_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 0,3,3,3
+class FunctionCaller_float_int_float_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_float_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(int,float,float,float) = (float(*)(int,float,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_int_float_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 1,3,3,3
+class FunctionCaller_float_bool_float_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_float_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(bool,float,float,float) = (float(*)(bool,float,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_bool_float_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 2,3,3,3
+class FunctionCaller_float_unsigned_int_float_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_float_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(unsigned int,float,float,float) = (float(*)(unsigned int,float,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_unsigned_int_float_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 3 3,3,3,3
+class FunctionCaller_float_float_float_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_float_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ float (*PF)(float,float,float,float) = (float(*)(float,float,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3,arg4) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_float_float_float_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,0,0,0
+class FunctionCaller_void_int_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(int,int,int,int) = (void(*)(int,int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
PF(arg1,arg2,arg3,arg4);
- return GTLCore::Value( );
+ return GTLCore::Value();
}
public:
static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
{
- if(function->parameters().size() == 4)
+ if( function->parameters().size() == 4 )
{
- return new FunctionCaller4<void, _TYPE_1_, _TYPE_2_, _TYPE_3_, _TYPE_4_>(llvmFunction, function);
+ return new FunctionCaller_void_int_int_int_int(llvmFunction, function);
} else {
+ return new FunctionCallerFallBack(llvmFunction, function);
}
- return 0;
}
};
+// 4 1,0,0,0
+class FunctionCaller_void_bool_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(bool,int,int,int) = (void(*)(bool,int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,0,0,0
+class FunctionCaller_void_unsigned_int_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(unsigned int,int,int,int) = (void(*)(unsigned int,int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,0,0,0
+class FunctionCaller_void_float_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(float,int,int,int) = (void(*)(float,int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,1,0,0
+class FunctionCaller_void_int_bool_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_bool_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(int,bool,int,int) = (void(*)(int,bool,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_bool_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,1,0,0
+class FunctionCaller_void_bool_bool_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_bool_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(bool,bool,int,int) = (void(*)(bool,bool,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_bool_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,1,0,0
+class FunctionCaller_void_unsigned_int_bool_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_bool_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(unsigned int,bool,int,int) = (void(*)(unsigned int,bool,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_bool_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,1,0,0
+class FunctionCaller_void_float_bool_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_bool_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(float,bool,int,int) = (void(*)(float,bool,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_bool_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,2,0,0
+class FunctionCaller_void_int_unsigned_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_unsigned_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(int,unsigned int,int,int) = (void(*)(int,unsigned int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_unsigned_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,2,0,0
+class FunctionCaller_void_bool_unsigned_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_unsigned_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(bool,unsigned int,int,int) = (void(*)(bool,unsigned int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_unsigned_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,2,0,0
+class FunctionCaller_void_unsigned_int_unsigned_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_unsigned_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(unsigned int,unsigned int,int,int) = (void(*)(unsigned int,unsigned int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_unsigned_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,2,0,0
+class FunctionCaller_void_float_unsigned_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_unsigned_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(float,unsigned int,int,int) = (void(*)(float,unsigned int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_unsigned_int_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,3,0,0
+class FunctionCaller_void_int_float_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_float_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(int,float,int,int) = (void(*)(int,float,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_float_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,3,0,0
+class FunctionCaller_void_bool_float_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_float_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(bool,float,int,int) = (void(*)(bool,float,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_float_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,3,0,0
+class FunctionCaller_void_unsigned_int_float_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_float_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(unsigned int,float,int,int) = (void(*)(unsigned int,float,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_float_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,3,0,0
+class FunctionCaller_void_float_float_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_float_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(float,float,int,int) = (void(*)(float,float,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_float_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,0,1,0
+class FunctionCaller_void_int_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(int,int,bool,int) = (void(*)(int,int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,0,1,0
+class FunctionCaller_void_bool_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(bool,int,bool,int) = (void(*)(bool,int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,0,1,0
+class FunctionCaller_void_unsigned_int_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(unsigned int,int,bool,int) = (void(*)(unsigned int,int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,0,1,0
+class FunctionCaller_void_float_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(float,int,bool,int) = (void(*)(float,int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,1,1,0
+class FunctionCaller_void_int_bool_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_bool_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(int,bool,bool,int) = (void(*)(int,bool,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_bool_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,1,1,0
+class FunctionCaller_void_bool_bool_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_bool_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(bool,bool,bool,int) = (void(*)(bool,bool,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_bool_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,1,1,0
+class FunctionCaller_void_unsigned_int_bool_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_bool_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(unsigned int,bool,bool,int) = (void(*)(unsigned int,bool,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_bool_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,1,1,0
+class FunctionCaller_void_float_bool_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_bool_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(float,bool,bool,int) = (void(*)(float,bool,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_bool_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,2,1,0
+class FunctionCaller_void_int_unsigned_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_unsigned_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(int,unsigned int,bool,int) = (void(*)(int,unsigned int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_unsigned_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,2,1,0
+class FunctionCaller_void_bool_unsigned_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_unsigned_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(bool,unsigned int,bool,int) = (void(*)(bool,unsigned int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_unsigned_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,2,1,0
+class FunctionCaller_void_unsigned_int_unsigned_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_unsigned_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(unsigned int,unsigned int,bool,int) = (void(*)(unsigned int,unsigned int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_unsigned_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,2,1,0
+class FunctionCaller_void_float_unsigned_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_unsigned_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(float,unsigned int,bool,int) = (void(*)(float,unsigned int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_unsigned_int_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,3,1,0
+class FunctionCaller_void_int_float_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_float_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(int,float,bool,int) = (void(*)(int,float,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_float_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,3,1,0
+class FunctionCaller_void_bool_float_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_float_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(bool,float,bool,int) = (void(*)(bool,float,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_float_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,3,1,0
+class FunctionCaller_void_unsigned_int_float_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_float_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(unsigned int,float,bool,int) = (void(*)(unsigned int,float,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_float_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,3,1,0
+class FunctionCaller_void_float_float_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_float_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(float,float,bool,int) = (void(*)(float,float,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_float_bool_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,0,2,0
+class FunctionCaller_void_int_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(int,int,unsigned int,int) = (void(*)(int,int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,0,2,0
+class FunctionCaller_void_bool_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(bool,int,unsigned int,int) = (void(*)(bool,int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,0,2,0
+class FunctionCaller_void_unsigned_int_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(unsigned int,int,unsigned int,int) = (void(*)(unsigned int,int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,0,2,0
+class FunctionCaller_void_float_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(float,int,unsigned int,int) = (void(*)(float,int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,1,2,0
+class FunctionCaller_void_int_bool_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_bool_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(int,bool,unsigned int,int) = (void(*)(int,bool,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_bool_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,1,2,0
+class FunctionCaller_void_bool_bool_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_bool_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(bool,bool,unsigned int,int) = (void(*)(bool,bool,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_bool_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,1,2,0
+class FunctionCaller_void_unsigned_int_bool_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_bool_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(unsigned int,bool,unsigned int,int) = (void(*)(unsigned int,bool,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_bool_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,1,2,0
+class FunctionCaller_void_float_bool_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_bool_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(float,bool,unsigned int,int) = (void(*)(float,bool,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_bool_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,2,2,0
+class FunctionCaller_void_int_unsigned_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_unsigned_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(int,unsigned int,unsigned int,int) = (void(*)(int,unsigned int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_unsigned_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,2,2,0
+class FunctionCaller_void_bool_unsigned_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_unsigned_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(bool,unsigned int,unsigned int,int) = (void(*)(bool,unsigned int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_unsigned_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,2,2,0
+class FunctionCaller_void_unsigned_int_unsigned_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_unsigned_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(unsigned int,unsigned int,unsigned int,int) = (void(*)(unsigned int,unsigned int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_unsigned_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,2,2,0
+class FunctionCaller_void_float_unsigned_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_unsigned_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(float,unsigned int,unsigned int,int) = (void(*)(float,unsigned int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_unsigned_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,3,2,0
+class FunctionCaller_void_int_float_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_float_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(int,float,unsigned int,int) = (void(*)(int,float,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_float_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,3,2,0
+class FunctionCaller_void_bool_float_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_float_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(bool,float,unsigned int,int) = (void(*)(bool,float,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_float_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,3,2,0
+class FunctionCaller_void_unsigned_int_float_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_float_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(unsigned int,float,unsigned int,int) = (void(*)(unsigned int,float,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_float_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,3,2,0
+class FunctionCaller_void_float_float_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_float_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(float,float,unsigned int,int) = (void(*)(float,float,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_float_unsigned_int_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,0,3,0
+class FunctionCaller_void_int_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(int,int,float,int) = (void(*)(int,int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,0,3,0
+class FunctionCaller_void_bool_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(bool,int,float,int) = (void(*)(bool,int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,0,3,0
+class FunctionCaller_void_unsigned_int_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(unsigned int,int,float,int) = (void(*)(unsigned int,int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,0,3,0
+class FunctionCaller_void_float_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(float,int,float,int) = (void(*)(float,int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,1,3,0
+class FunctionCaller_void_int_bool_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_bool_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(int,bool,float,int) = (void(*)(int,bool,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_bool_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,1,3,0
+class FunctionCaller_void_bool_bool_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_bool_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(bool,bool,float,int) = (void(*)(bool,bool,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_bool_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,1,3,0
+class FunctionCaller_void_unsigned_int_bool_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_bool_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(unsigned int,bool,float,int) = (void(*)(unsigned int,bool,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_bool_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,1,3,0
+class FunctionCaller_void_float_bool_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_bool_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(float,bool,float,int) = (void(*)(float,bool,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_bool_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,2,3,0
+class FunctionCaller_void_int_unsigned_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_unsigned_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(int,unsigned int,float,int) = (void(*)(int,unsigned int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_unsigned_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,2,3,0
+class FunctionCaller_void_bool_unsigned_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_unsigned_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(bool,unsigned int,float,int) = (void(*)(bool,unsigned int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_unsigned_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,2,3,0
+class FunctionCaller_void_unsigned_int_unsigned_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_unsigned_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(unsigned int,unsigned int,float,int) = (void(*)(unsigned int,unsigned int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_unsigned_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,2,3,0
+class FunctionCaller_void_float_unsigned_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_unsigned_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(float,unsigned int,float,int) = (void(*)(float,unsigned int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_unsigned_int_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,3,3,0
+class FunctionCaller_void_int_float_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_float_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(int,float,float,int) = (void(*)(int,float,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_float_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,3,3,0
+class FunctionCaller_void_bool_float_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_float_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(bool,float,float,int) = (void(*)(bool,float,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_float_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,3,3,0
+class FunctionCaller_void_unsigned_int_float_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_float_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(unsigned int,float,float,int) = (void(*)(unsigned int,float,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_float_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,3,3,0
+class FunctionCaller_void_float_float_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_float_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int arg4 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[3] );
+ void (*PF)(float,float,float,int) = (void(*)(float,float,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_float_float_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,0,0,1
+class FunctionCaller_void_int_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(int,int,int,bool) = (void(*)(int,int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,0,0,1
+class FunctionCaller_void_bool_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(bool,int,int,bool) = (void(*)(bool,int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,0,0,1
+class FunctionCaller_void_unsigned_int_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(unsigned int,int,int,bool) = (void(*)(unsigned int,int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,0,0,1
+class FunctionCaller_void_float_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(float,int,int,bool) = (void(*)(float,int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,1,0,1
+class FunctionCaller_void_int_bool_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_bool_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(int,bool,int,bool) = (void(*)(int,bool,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_bool_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,1,0,1
+class FunctionCaller_void_bool_bool_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_bool_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(bool,bool,int,bool) = (void(*)(bool,bool,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_bool_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,1,0,1
+class FunctionCaller_void_unsigned_int_bool_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_bool_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(unsigned int,bool,int,bool) = (void(*)(unsigned int,bool,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_bool_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,1,0,1
+class FunctionCaller_void_float_bool_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_bool_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(float,bool,int,bool) = (void(*)(float,bool,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_bool_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,2,0,1
+class FunctionCaller_void_int_unsigned_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_unsigned_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(int,unsigned int,int,bool) = (void(*)(int,unsigned int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_unsigned_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,2,0,1
+class FunctionCaller_void_bool_unsigned_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_unsigned_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(bool,unsigned int,int,bool) = (void(*)(bool,unsigned int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_unsigned_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,2,0,1
+class FunctionCaller_void_unsigned_int_unsigned_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_unsigned_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(unsigned int,unsigned int,int,bool) = (void(*)(unsigned int,unsigned int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_unsigned_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,2,0,1
+class FunctionCaller_void_float_unsigned_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_unsigned_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(float,unsigned int,int,bool) = (void(*)(float,unsigned int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_unsigned_int_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,3,0,1
+class FunctionCaller_void_int_float_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_float_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(int,float,int,bool) = (void(*)(int,float,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_float_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,3,0,1
+class FunctionCaller_void_bool_float_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_float_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(bool,float,int,bool) = (void(*)(bool,float,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_float_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,3,0,1
+class FunctionCaller_void_unsigned_int_float_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_float_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(unsigned int,float,int,bool) = (void(*)(unsigned int,float,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_float_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,3,0,1
+class FunctionCaller_void_float_float_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_float_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(float,float,int,bool) = (void(*)(float,float,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_float_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,0,1,1
+class FunctionCaller_void_int_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(int,int,bool,bool) = (void(*)(int,int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,0,1,1
+class FunctionCaller_void_bool_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(bool,int,bool,bool) = (void(*)(bool,int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,0,1,1
+class FunctionCaller_void_unsigned_int_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(unsigned int,int,bool,bool) = (void(*)(unsigned int,int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,0,1,1
+class FunctionCaller_void_float_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(float,int,bool,bool) = (void(*)(float,int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,1,1,1
+class FunctionCaller_void_int_bool_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_bool_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(int,bool,bool,bool) = (void(*)(int,bool,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_bool_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,1,1,1
+class FunctionCaller_void_bool_bool_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_bool_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(bool,bool,bool,bool) = (void(*)(bool,bool,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_bool_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,1,1,1
+class FunctionCaller_void_unsigned_int_bool_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_bool_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(unsigned int,bool,bool,bool) = (void(*)(unsigned int,bool,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_bool_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,1,1,1
+class FunctionCaller_void_float_bool_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_bool_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(float,bool,bool,bool) = (void(*)(float,bool,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_bool_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,2,1,1
+class FunctionCaller_void_int_unsigned_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_unsigned_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(int,unsigned int,bool,bool) = (void(*)(int,unsigned int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_unsigned_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,2,1,1
+class FunctionCaller_void_bool_unsigned_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_unsigned_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(bool,unsigned int,bool,bool) = (void(*)(bool,unsigned int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_unsigned_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,2,1,1
+class FunctionCaller_void_unsigned_int_unsigned_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_unsigned_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(unsigned int,unsigned int,bool,bool) = (void(*)(unsigned int,unsigned int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_unsigned_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,2,1,1
+class FunctionCaller_void_float_unsigned_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_unsigned_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(float,unsigned int,bool,bool) = (void(*)(float,unsigned int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_unsigned_int_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,3,1,1
+class FunctionCaller_void_int_float_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_float_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(int,float,bool,bool) = (void(*)(int,float,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_float_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,3,1,1
+class FunctionCaller_void_bool_float_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_float_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(bool,float,bool,bool) = (void(*)(bool,float,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_float_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,3,1,1
+class FunctionCaller_void_unsigned_int_float_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_float_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(unsigned int,float,bool,bool) = (void(*)(unsigned int,float,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_float_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,3,1,1
+class FunctionCaller_void_float_float_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_float_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(float,float,bool,bool) = (void(*)(float,float,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_float_bool_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,0,2,1
+class FunctionCaller_void_int_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(int,int,unsigned int,bool) = (void(*)(int,int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,0,2,1
+class FunctionCaller_void_bool_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(bool,int,unsigned int,bool) = (void(*)(bool,int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,0,2,1
+class FunctionCaller_void_unsigned_int_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(unsigned int,int,unsigned int,bool) = (void(*)(unsigned int,int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,0,2,1
+class FunctionCaller_void_float_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(float,int,unsigned int,bool) = (void(*)(float,int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,1,2,1
+class FunctionCaller_void_int_bool_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_bool_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(int,bool,unsigned int,bool) = (void(*)(int,bool,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_bool_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,1,2,1
+class FunctionCaller_void_bool_bool_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_bool_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(bool,bool,unsigned int,bool) = (void(*)(bool,bool,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_bool_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,1,2,1
+class FunctionCaller_void_unsigned_int_bool_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_bool_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(unsigned int,bool,unsigned int,bool) = (void(*)(unsigned int,bool,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_bool_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,1,2,1
+class FunctionCaller_void_float_bool_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_bool_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(float,bool,unsigned int,bool) = (void(*)(float,bool,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_bool_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,2,2,1
+class FunctionCaller_void_int_unsigned_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_unsigned_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(int,unsigned int,unsigned int,bool) = (void(*)(int,unsigned int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_unsigned_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,2,2,1
+class FunctionCaller_void_bool_unsigned_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_unsigned_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(bool,unsigned int,unsigned int,bool) = (void(*)(bool,unsigned int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_unsigned_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,2,2,1
+class FunctionCaller_void_unsigned_int_unsigned_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_unsigned_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(unsigned int,unsigned int,unsigned int,bool) = (void(*)(unsigned int,unsigned int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_unsigned_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,2,2,1
+class FunctionCaller_void_float_unsigned_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_unsigned_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(float,unsigned int,unsigned int,bool) = (void(*)(float,unsigned int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_unsigned_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,3,2,1
+class FunctionCaller_void_int_float_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_float_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(int,float,unsigned int,bool) = (void(*)(int,float,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_float_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,3,2,1
+class FunctionCaller_void_bool_float_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_float_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(bool,float,unsigned int,bool) = (void(*)(bool,float,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_float_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,3,2,1
+class FunctionCaller_void_unsigned_int_float_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_float_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(unsigned int,float,unsigned int,bool) = (void(*)(unsigned int,float,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_float_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,3,2,1
+class FunctionCaller_void_float_float_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_float_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(float,float,unsigned int,bool) = (void(*)(float,float,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_float_unsigned_int_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,0,3,1
+class FunctionCaller_void_int_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(int,int,float,bool) = (void(*)(int,int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,0,3,1
+class FunctionCaller_void_bool_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(bool,int,float,bool) = (void(*)(bool,int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,0,3,1
+class FunctionCaller_void_unsigned_int_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(unsigned int,int,float,bool) = (void(*)(unsigned int,int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,0,3,1
+class FunctionCaller_void_float_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(float,int,float,bool) = (void(*)(float,int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,1,3,1
+class FunctionCaller_void_int_bool_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_bool_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(int,bool,float,bool) = (void(*)(int,bool,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_bool_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,1,3,1
+class FunctionCaller_void_bool_bool_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_bool_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(bool,bool,float,bool) = (void(*)(bool,bool,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_bool_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,1,3,1
+class FunctionCaller_void_unsigned_int_bool_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_bool_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(unsigned int,bool,float,bool) = (void(*)(unsigned int,bool,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_bool_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,1,3,1
+class FunctionCaller_void_float_bool_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_bool_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(float,bool,float,bool) = (void(*)(float,bool,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_bool_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,2,3,1
+class FunctionCaller_void_int_unsigned_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_unsigned_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(int,unsigned int,float,bool) = (void(*)(int,unsigned int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_unsigned_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,2,3,1
+class FunctionCaller_void_bool_unsigned_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_unsigned_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(bool,unsigned int,float,bool) = (void(*)(bool,unsigned int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_unsigned_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,2,3,1
+class FunctionCaller_void_unsigned_int_unsigned_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_unsigned_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(unsigned int,unsigned int,float,bool) = (void(*)(unsigned int,unsigned int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_unsigned_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,2,3,1
+class FunctionCaller_void_float_unsigned_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_unsigned_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(float,unsigned int,float,bool) = (void(*)(float,unsigned int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_unsigned_int_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,3,3,1
+class FunctionCaller_void_int_float_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_float_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(int,float,float,bool) = (void(*)(int,float,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_float_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,3,3,1
+class FunctionCaller_void_bool_float_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_float_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(bool,float,float,bool) = (void(*)(bool,float,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_float_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,3,3,1
+class FunctionCaller_void_unsigned_int_float_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_float_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(unsigned int,float,float,bool) = (void(*)(unsigned int,float,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_float_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,3,3,1
+class FunctionCaller_void_float_float_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_float_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool arg4 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[3] );
+ void (*PF)(float,float,float,bool) = (void(*)(float,float,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_float_float_bool(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,0,0,2
+class FunctionCaller_void_int_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(int,int,int,unsigned int) = (void(*)(int,int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,0,0,2
+class FunctionCaller_void_bool_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(bool,int,int,unsigned int) = (void(*)(bool,int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,0,0,2
+class FunctionCaller_void_unsigned_int_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(unsigned int,int,int,unsigned int) = (void(*)(unsigned int,int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,0,0,2
+class FunctionCaller_void_float_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(float,int,int,unsigned int) = (void(*)(float,int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,1,0,2
+class FunctionCaller_void_int_bool_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_bool_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(int,bool,int,unsigned int) = (void(*)(int,bool,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_bool_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,1,0,2
+class FunctionCaller_void_bool_bool_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_bool_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(bool,bool,int,unsigned int) = (void(*)(bool,bool,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_bool_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,1,0,2
+class FunctionCaller_void_unsigned_int_bool_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_bool_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(unsigned int,bool,int,unsigned int) = (void(*)(unsigned int,bool,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_bool_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,1,0,2
+class FunctionCaller_void_float_bool_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_bool_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(float,bool,int,unsigned int) = (void(*)(float,bool,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_bool_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,2,0,2
+class FunctionCaller_void_int_unsigned_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_unsigned_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(int,unsigned int,int,unsigned int) = (void(*)(int,unsigned int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_unsigned_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,2,0,2
+class FunctionCaller_void_bool_unsigned_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_unsigned_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(bool,unsigned int,int,unsigned int) = (void(*)(bool,unsigned int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_unsigned_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,2,0,2
+class FunctionCaller_void_unsigned_int_unsigned_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_unsigned_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(unsigned int,unsigned int,int,unsigned int) = (void(*)(unsigned int,unsigned int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_unsigned_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,2,0,2
+class FunctionCaller_void_float_unsigned_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_unsigned_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(float,unsigned int,int,unsigned int) = (void(*)(float,unsigned int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_unsigned_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,3,0,2
+class FunctionCaller_void_int_float_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_float_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(int,float,int,unsigned int) = (void(*)(int,float,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_float_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,3,0,2
+class FunctionCaller_void_bool_float_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_float_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(bool,float,int,unsigned int) = (void(*)(bool,float,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_float_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,3,0,2
+class FunctionCaller_void_unsigned_int_float_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_float_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(unsigned int,float,int,unsigned int) = (void(*)(unsigned int,float,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_float_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,3,0,2
+class FunctionCaller_void_float_float_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_float_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(float,float,int,unsigned int) = (void(*)(float,float,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_float_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,0,1,2
+class FunctionCaller_void_int_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(int,int,bool,unsigned int) = (void(*)(int,int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,0,1,2
+class FunctionCaller_void_bool_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(bool,int,bool,unsigned int) = (void(*)(bool,int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,0,1,2
+class FunctionCaller_void_unsigned_int_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(unsigned int,int,bool,unsigned int) = (void(*)(unsigned int,int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,0,1,2
+class FunctionCaller_void_float_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(float,int,bool,unsigned int) = (void(*)(float,int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,1,1,2
+class FunctionCaller_void_int_bool_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_bool_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(int,bool,bool,unsigned int) = (void(*)(int,bool,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_bool_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,1,1,2
+class FunctionCaller_void_bool_bool_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_bool_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(bool,bool,bool,unsigned int) = (void(*)(bool,bool,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_bool_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,1,1,2
+class FunctionCaller_void_unsigned_int_bool_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_bool_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(unsigned int,bool,bool,unsigned int) = (void(*)(unsigned int,bool,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_bool_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,1,1,2
+class FunctionCaller_void_float_bool_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_bool_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(float,bool,bool,unsigned int) = (void(*)(float,bool,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_bool_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,2,1,2
+class FunctionCaller_void_int_unsigned_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_unsigned_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(int,unsigned int,bool,unsigned int) = (void(*)(int,unsigned int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_unsigned_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,2,1,2
+class FunctionCaller_void_bool_unsigned_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_unsigned_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(bool,unsigned int,bool,unsigned int) = (void(*)(bool,unsigned int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_unsigned_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,2,1,2
+class FunctionCaller_void_unsigned_int_unsigned_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_unsigned_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(unsigned int,unsigned int,bool,unsigned int) = (void(*)(unsigned int,unsigned int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_unsigned_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,2,1,2
+class FunctionCaller_void_float_unsigned_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_unsigned_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(float,unsigned int,bool,unsigned int) = (void(*)(float,unsigned int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_unsigned_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,3,1,2
+class FunctionCaller_void_int_float_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_float_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(int,float,bool,unsigned int) = (void(*)(int,float,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_float_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,3,1,2
+class FunctionCaller_void_bool_float_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_float_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(bool,float,bool,unsigned int) = (void(*)(bool,float,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_float_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,3,1,2
+class FunctionCaller_void_unsigned_int_float_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_float_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(unsigned int,float,bool,unsigned int) = (void(*)(unsigned int,float,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_float_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,3,1,2
+class FunctionCaller_void_float_float_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_float_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(float,float,bool,unsigned int) = (void(*)(float,float,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_float_bool_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,0,2,2
+class FunctionCaller_void_int_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(int,int,unsigned int,unsigned int) = (void(*)(int,int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,0,2,2
+class FunctionCaller_void_bool_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(bool,int,unsigned int,unsigned int) = (void(*)(bool,int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,0,2,2
+class FunctionCaller_void_unsigned_int_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(unsigned int,int,unsigned int,unsigned int) = (void(*)(unsigned int,int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,0,2,2
+class FunctionCaller_void_float_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(float,int,unsigned int,unsigned int) = (void(*)(float,int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,1,2,2
+class FunctionCaller_void_int_bool_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_bool_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(int,bool,unsigned int,unsigned int) = (void(*)(int,bool,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_bool_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,1,2,2
+class FunctionCaller_void_bool_bool_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_bool_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(bool,bool,unsigned int,unsigned int) = (void(*)(bool,bool,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_bool_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,1,2,2
+class FunctionCaller_void_unsigned_int_bool_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_bool_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(unsigned int,bool,unsigned int,unsigned int) = (void(*)(unsigned int,bool,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_bool_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,1,2,2
+class FunctionCaller_void_float_bool_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_bool_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(float,bool,unsigned int,unsigned int) = (void(*)(float,bool,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_bool_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,2,2,2
+class FunctionCaller_void_int_unsigned_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_unsigned_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(int,unsigned int,unsigned int,unsigned int) = (void(*)(int,unsigned int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_unsigned_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,2,2,2
+class FunctionCaller_void_bool_unsigned_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_unsigned_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(bool,unsigned int,unsigned int,unsigned int) = (void(*)(bool,unsigned int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_unsigned_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,2,2,2
+class FunctionCaller_void_unsigned_int_unsigned_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_unsigned_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(unsigned int,unsigned int,unsigned int,unsigned int) = (void(*)(unsigned int,unsigned int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_unsigned_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,2,2,2
+class FunctionCaller_void_float_unsigned_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_unsigned_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(float,unsigned int,unsigned int,unsigned int) = (void(*)(float,unsigned int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_unsigned_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,3,2,2
+class FunctionCaller_void_int_float_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_float_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(int,float,unsigned int,unsigned int) = (void(*)(int,float,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_float_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,3,2,2
+class FunctionCaller_void_bool_float_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_float_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(bool,float,unsigned int,unsigned int) = (void(*)(bool,float,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_float_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,3,2,2
+class FunctionCaller_void_unsigned_int_float_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_float_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(unsigned int,float,unsigned int,unsigned int) = (void(*)(unsigned int,float,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_float_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,3,2,2
+class FunctionCaller_void_float_float_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_float_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(float,float,unsigned int,unsigned int) = (void(*)(float,float,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_float_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,0,3,2
+class FunctionCaller_void_int_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(int,int,float,unsigned int) = (void(*)(int,int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,0,3,2
+class FunctionCaller_void_bool_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(bool,int,float,unsigned int) = (void(*)(bool,int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,0,3,2
+class FunctionCaller_void_unsigned_int_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(unsigned int,int,float,unsigned int) = (void(*)(unsigned int,int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,0,3,2
+class FunctionCaller_void_float_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(float,int,float,unsigned int) = (void(*)(float,int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,1,3,2
+class FunctionCaller_void_int_bool_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_bool_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(int,bool,float,unsigned int) = (void(*)(int,bool,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_bool_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,1,3,2
+class FunctionCaller_void_bool_bool_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_bool_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(bool,bool,float,unsigned int) = (void(*)(bool,bool,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_bool_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,1,3,2
+class FunctionCaller_void_unsigned_int_bool_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_bool_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(unsigned int,bool,float,unsigned int) = (void(*)(unsigned int,bool,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_bool_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,1,3,2
+class FunctionCaller_void_float_bool_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_bool_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(float,bool,float,unsigned int) = (void(*)(float,bool,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_bool_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,2,3,2
+class FunctionCaller_void_int_unsigned_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_unsigned_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(int,unsigned int,float,unsigned int) = (void(*)(int,unsigned int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_unsigned_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,2,3,2
+class FunctionCaller_void_bool_unsigned_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_unsigned_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(bool,unsigned int,float,unsigned int) = (void(*)(bool,unsigned int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_unsigned_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,2,3,2
+class FunctionCaller_void_unsigned_int_unsigned_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_unsigned_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(unsigned int,unsigned int,float,unsigned int) = (void(*)(unsigned int,unsigned int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_unsigned_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,2,3,2
+class FunctionCaller_void_float_unsigned_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_unsigned_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(float,unsigned int,float,unsigned int) = (void(*)(float,unsigned int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_unsigned_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,3,3,2
+class FunctionCaller_void_int_float_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_float_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(int,float,float,unsigned int) = (void(*)(int,float,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_float_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,3,3,2
+class FunctionCaller_void_bool_float_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_float_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(bool,float,float,unsigned int) = (void(*)(bool,float,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_float_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,3,3,2
+class FunctionCaller_void_unsigned_int_float_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_float_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(unsigned int,float,float,unsigned int) = (void(*)(unsigned int,float,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_float_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,3,3,2
+class FunctionCaller_void_float_float_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_float_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int arg4 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[3] );
+ void (*PF)(float,float,float,unsigned int) = (void(*)(float,float,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_float_float_unsigned_int(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,0,0,3
+class FunctionCaller_void_int_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(int,int,int,float) = (void(*)(int,int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,0,0,3
+class FunctionCaller_void_bool_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(bool,int,int,float) = (void(*)(bool,int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,0,0,3
+class FunctionCaller_void_unsigned_int_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(unsigned int,int,int,float) = (void(*)(unsigned int,int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,0,0,3
+class FunctionCaller_void_float_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(float,int,int,float) = (void(*)(float,int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,1,0,3
+class FunctionCaller_void_int_bool_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_bool_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(int,bool,int,float) = (void(*)(int,bool,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_bool_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,1,0,3
+class FunctionCaller_void_bool_bool_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_bool_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(bool,bool,int,float) = (void(*)(bool,bool,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_bool_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,1,0,3
+class FunctionCaller_void_unsigned_int_bool_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_bool_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(unsigned int,bool,int,float) = (void(*)(unsigned int,bool,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_bool_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,1,0,3
+class FunctionCaller_void_float_bool_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_bool_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(float,bool,int,float) = (void(*)(float,bool,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_bool_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,2,0,3
+class FunctionCaller_void_int_unsigned_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_unsigned_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(int,unsigned int,int,float) = (void(*)(int,unsigned int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_unsigned_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,2,0,3
+class FunctionCaller_void_bool_unsigned_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_unsigned_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(bool,unsigned int,int,float) = (void(*)(bool,unsigned int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_unsigned_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,2,0,3
+class FunctionCaller_void_unsigned_int_unsigned_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_unsigned_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(unsigned int,unsigned int,int,float) = (void(*)(unsigned int,unsigned int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_unsigned_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,2,0,3
+class FunctionCaller_void_float_unsigned_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_unsigned_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(float,unsigned int,int,float) = (void(*)(float,unsigned int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_unsigned_int_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,3,0,3
+class FunctionCaller_void_int_float_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_float_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(int,float,int,float) = (void(*)(int,float,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_float_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,3,0,3
+class FunctionCaller_void_bool_float_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_float_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(bool,float,int,float) = (void(*)(bool,float,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_float_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,3,0,3
+class FunctionCaller_void_unsigned_int_float_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_float_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(unsigned int,float,int,float) = (void(*)(unsigned int,float,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_float_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,3,0,3
+class FunctionCaller_void_float_float_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_float_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(float,float,int,float) = (void(*)(float,float,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_float_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,0,1,3
+class FunctionCaller_void_int_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(int,int,bool,float) = (void(*)(int,int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,0,1,3
+class FunctionCaller_void_bool_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(bool,int,bool,float) = (void(*)(bool,int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,0,1,3
+class FunctionCaller_void_unsigned_int_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(unsigned int,int,bool,float) = (void(*)(unsigned int,int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,0,1,3
+class FunctionCaller_void_float_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(float,int,bool,float) = (void(*)(float,int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,1,1,3
+class FunctionCaller_void_int_bool_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_bool_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(int,bool,bool,float) = (void(*)(int,bool,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_bool_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,1,1,3
+class FunctionCaller_void_bool_bool_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_bool_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(bool,bool,bool,float) = (void(*)(bool,bool,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_bool_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,1,1,3
+class FunctionCaller_void_unsigned_int_bool_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_bool_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(unsigned int,bool,bool,float) = (void(*)(unsigned int,bool,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_bool_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,1,1,3
+class FunctionCaller_void_float_bool_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_bool_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(float,bool,bool,float) = (void(*)(float,bool,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_bool_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,2,1,3
+class FunctionCaller_void_int_unsigned_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_unsigned_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(int,unsigned int,bool,float) = (void(*)(int,unsigned int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_unsigned_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,2,1,3
+class FunctionCaller_void_bool_unsigned_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_unsigned_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(bool,unsigned int,bool,float) = (void(*)(bool,unsigned int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_unsigned_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,2,1,3
+class FunctionCaller_void_unsigned_int_unsigned_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_unsigned_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(unsigned int,unsigned int,bool,float) = (void(*)(unsigned int,unsigned int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_unsigned_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,2,1,3
+class FunctionCaller_void_float_unsigned_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_unsigned_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(float,unsigned int,bool,float) = (void(*)(float,unsigned int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_unsigned_int_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,3,1,3
+class FunctionCaller_void_int_float_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_float_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(int,float,bool,float) = (void(*)(int,float,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_float_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,3,1,3
+class FunctionCaller_void_bool_float_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_float_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(bool,float,bool,float) = (void(*)(bool,float,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_float_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,3,1,3
+class FunctionCaller_void_unsigned_int_float_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_float_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(unsigned int,float,bool,float) = (void(*)(unsigned int,float,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_float_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,3,1,3
+class FunctionCaller_void_float_float_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_float_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(float,float,bool,float) = (void(*)(float,float,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_float_bool_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,0,2,3
+class FunctionCaller_void_int_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(int,int,unsigned int,float) = (void(*)(int,int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,0,2,3
+class FunctionCaller_void_bool_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(bool,int,unsigned int,float) = (void(*)(bool,int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,0,2,3
+class FunctionCaller_void_unsigned_int_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(unsigned int,int,unsigned int,float) = (void(*)(unsigned int,int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,0,2,3
+class FunctionCaller_void_float_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(float,int,unsigned int,float) = (void(*)(float,int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,1,2,3
+class FunctionCaller_void_int_bool_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_bool_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(int,bool,unsigned int,float) = (void(*)(int,bool,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_bool_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,1,2,3
+class FunctionCaller_void_bool_bool_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_bool_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(bool,bool,unsigned int,float) = (void(*)(bool,bool,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_bool_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,1,2,3
+class FunctionCaller_void_unsigned_int_bool_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_bool_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(unsigned int,bool,unsigned int,float) = (void(*)(unsigned int,bool,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_bool_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,1,2,3
+class FunctionCaller_void_float_bool_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_bool_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(float,bool,unsigned int,float) = (void(*)(float,bool,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_bool_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,2,2,3
+class FunctionCaller_void_int_unsigned_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_unsigned_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(int,unsigned int,unsigned int,float) = (void(*)(int,unsigned int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_unsigned_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,2,2,3
+class FunctionCaller_void_bool_unsigned_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_unsigned_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(bool,unsigned int,unsigned int,float) = (void(*)(bool,unsigned int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_unsigned_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,2,2,3
+class FunctionCaller_void_unsigned_int_unsigned_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_unsigned_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(unsigned int,unsigned int,unsigned int,float) = (void(*)(unsigned int,unsigned int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_unsigned_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,2,2,3
+class FunctionCaller_void_float_unsigned_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_unsigned_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(float,unsigned int,unsigned int,float) = (void(*)(float,unsigned int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_unsigned_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,3,2,3
+class FunctionCaller_void_int_float_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_float_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(int,float,unsigned int,float) = (void(*)(int,float,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_float_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,3,2,3
+class FunctionCaller_void_bool_float_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_float_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(bool,float,unsigned int,float) = (void(*)(bool,float,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_float_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,3,2,3
+class FunctionCaller_void_unsigned_int_float_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_float_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(unsigned int,float,unsigned int,float) = (void(*)(unsigned int,float,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_float_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,3,2,3
+class FunctionCaller_void_float_float_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_float_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(float,float,unsigned int,float) = (void(*)(float,float,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_float_unsigned_int_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,0,3,3
+class FunctionCaller_void_int_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(int,int,float,float) = (void(*)(int,int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,0,3,3
+class FunctionCaller_void_bool_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(bool,int,float,float) = (void(*)(bool,int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,0,3,3
+class FunctionCaller_void_unsigned_int_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(unsigned int,int,float,float) = (void(*)(unsigned int,int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,0,3,3
+class FunctionCaller_void_float_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(float,int,float,float) = (void(*)(float,int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,1,3,3
+class FunctionCaller_void_int_bool_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_bool_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(int,bool,float,float) = (void(*)(int,bool,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_bool_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,1,3,3
+class FunctionCaller_void_bool_bool_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_bool_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(bool,bool,float,float) = (void(*)(bool,bool,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_bool_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,1,3,3
+class FunctionCaller_void_unsigned_int_bool_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_bool_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(unsigned int,bool,float,float) = (void(*)(unsigned int,bool,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_bool_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,1,3,3
+class FunctionCaller_void_float_bool_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_bool_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(float,bool,float,float) = (void(*)(float,bool,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_bool_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,2,3,3
+class FunctionCaller_void_int_unsigned_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_unsigned_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(int,unsigned int,float,float) = (void(*)(int,unsigned int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_unsigned_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,2,3,3
+class FunctionCaller_void_bool_unsigned_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_unsigned_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(bool,unsigned int,float,float) = (void(*)(bool,unsigned int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_unsigned_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,2,3,3
+class FunctionCaller_void_unsigned_int_unsigned_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_unsigned_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(unsigned int,unsigned int,float,float) = (void(*)(unsigned int,unsigned int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_unsigned_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,2,3,3
+class FunctionCaller_void_float_unsigned_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_unsigned_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(float,unsigned int,float,float) = (void(*)(float,unsigned int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_unsigned_int_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 0,3,3,3
+class FunctionCaller_void_int_float_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_float_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(int,float,float,float) = (void(*)(int,float,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_int_float_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 1,3,3,3
+class FunctionCaller_void_bool_float_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_float_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(bool,float,float,float) = (void(*)(bool,float,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_bool_float_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 2,3,3,3
+class FunctionCaller_void_unsigned_int_float_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_float_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(unsigned int,float,float,float) = (void(*)(unsigned int,float,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_unsigned_int_float_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
+// 4 3,3,3,3
+class FunctionCaller_void_float_float_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_float_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 4);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float arg4 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[3] );
+ void (*PF)(float,float,float,float) = (void(*)(float,float,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3,arg4);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 4 )
+ {
+ return new FunctionCaller_void_float_float_float_float(llvmFunction, function);
+ } else {
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+};
// Number of parameters = 3
-template<typename _TYPE_RETURN_, typename _TYPE_1_, typename _TYPE_2_, typename _TYPE_3_>
-class FunctionCaller3 : public FunctionCaller {
+// 0 0,0,0
+class FunctionCaller_int_int_int_int : public FunctionCaller {
public:
- FunctionCaller3(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ FunctionCaller_int_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
{
}
virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
{
GTL_ASSERT(function());
GTL_ASSERT(arguments.size() == 3);
- _TYPE_1_ arg1 = GTLCore::PrimitiveTypeTrait<_TYPE_1_>::convert( arguments[0] );
- _TYPE_2_ arg2 = GTLCore::PrimitiveTypeTrait<_TYPE_2_>::convert( arguments[1] );
- _TYPE_3_ arg3 = GTLCore::PrimitiveTypeTrait<_TYPE_3_>::convert( arguments[2] );
-
- _TYPE_RETURN_ (*PF)(_TYPE_1_,_TYPE_2_,_TYPE_3_) = (_TYPE_RETURN_(*)(_TYPE_1_,_TYPE_2_,_TYPE_3_)) VirtualMachine::instance()->getPointerToFunction(function());
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int (*PF)(int,int,int) = (int(*)(int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
return GTLCore::Value( PF(arg1,arg2,arg3) );
}
public:
static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
{
- if(function->parameters().size() == 3)
+ if( function->parameters().size() == 3 )
{
- return new FunctionCaller3<_TYPE_RETURN_, _TYPE_1_, _TYPE_2_, _TYPE_3_>(llvmFunction, function);
+ return new FunctionCaller_int_int_int_int(llvmFunction, function);
} else {
- switch( function->parameters()[0].type()->dataType() )
+ switch( function->parameters()[3].type()->dataType() )
{
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_int_int_int_int::create(llvmFunction, function);
case GTLCore::Type::BOOLEAN:
- return FunctionCaller4<_TYPE_RETURN_, _TYPE_1_, _TYPE_2_, _TYPE_3_, bool>::create(llvmFunction, function);
- break;
+ return FunctionCaller_int_int_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_int_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_int_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 1,0,0
+class FunctionCaller_int_bool_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int (*PF)(bool,int,int) = (int(*)(bool,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_bool_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
case GTLCore::Type::INTEGER32:
- return FunctionCaller4<_TYPE_RETURN_, _TYPE_1_, _TYPE_2_, _TYPE_3_, int>::create(llvmFunction, function);
- break;
+ return FunctionCaller_int_bool_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_bool_int_int_bool::create(llvmFunction, function);
case GTLCore::Type::UNSIGNED_INTEGER32:
- return FunctionCaller4<_TYPE_RETURN_, _TYPE_1_, _TYPE_2_, _TYPE_3_, unsigned int>::create(llvmFunction, function);
- break;
+ return FunctionCaller_int_bool_int_int_unsigned_int::create(llvmFunction, function);
case GTLCore::Type::HALF:
case GTLCore::Type::FLOAT:
- return FunctionCaller4<_TYPE_RETURN_, _TYPE_1_, _TYPE_2_, _TYPE_3_, float>::create(llvmFunction, function);
- break;
+ return FunctionCaller_int_bool_int_int_float::create(llvmFunction, function);
default:
- break;
- };
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
}
- return 0;
}
};
-template< typename _TYPE_1_, typename _TYPE_2_, typename _TYPE_3_>
-class FunctionCaller3<void , _TYPE_1_, _TYPE_2_, _TYPE_3_> : public FunctionCaller {
+// 0 2,0,0
+class FunctionCaller_int_unsigned_int_int_int : public FunctionCaller {
public:
- FunctionCaller3(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ FunctionCaller_int_unsigned_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
{
}
virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
{
GTL_ASSERT(function());
GTL_ASSERT(arguments.size() == 3);
- _TYPE_1_ arg1 = GTLCore::PrimitiveTypeTrait<_TYPE_1_>::convert( arguments[0] );
- _TYPE_2_ arg2 = GTLCore::PrimitiveTypeTrait<_TYPE_2_>::convert( arguments[1] );
- _TYPE_3_ arg3 = GTLCore::PrimitiveTypeTrait<_TYPE_3_>::convert( arguments[2] );
-
- void (*PF)(_TYPE_1_,_TYPE_2_,_TYPE_3_) = (void(*)(_TYPE_1_,_TYPE_2_,_TYPE_3_)) VirtualMachine::instance()->getPointerToFunction(function());
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int (*PF)(unsigned int,int,int) = (int(*)(unsigned int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_unsigned_int_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_unsigned_int_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_unsigned_int_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_unsigned_int_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_unsigned_int_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 3,0,0
+class FunctionCaller_int_float_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int (*PF)(float,int,int) = (int(*)(float,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_float_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_float_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_float_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_float_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_float_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 0,1,0
+class FunctionCaller_int_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int (*PF)(int,bool,int) = (int(*)(int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_int_bool_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_int_bool_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_int_bool_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_int_bool_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_int_bool_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 1,1,0
+class FunctionCaller_int_bool_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int (*PF)(bool,bool,int) = (int(*)(bool,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_bool_bool_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_bool_bool_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_bool_bool_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_bool_bool_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_bool_bool_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 2,1,0
+class FunctionCaller_int_unsigned_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int (*PF)(unsigned int,bool,int) = (int(*)(unsigned int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_unsigned_int_bool_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_unsigned_int_bool_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_unsigned_int_bool_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_unsigned_int_bool_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_unsigned_int_bool_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 3,1,0
+class FunctionCaller_int_float_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int (*PF)(float,bool,int) = (int(*)(float,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_float_bool_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_float_bool_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_float_bool_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_float_bool_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_float_bool_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 0,2,0
+class FunctionCaller_int_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int (*PF)(int,unsigned int,int) = (int(*)(int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_int_unsigned_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_int_unsigned_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_int_unsigned_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_int_unsigned_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 1,2,0
+class FunctionCaller_int_bool_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int (*PF)(bool,unsigned int,int) = (int(*)(bool,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_bool_unsigned_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_bool_unsigned_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_bool_unsigned_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_bool_unsigned_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_bool_unsigned_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 2,2,0
+class FunctionCaller_int_unsigned_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int (*PF)(unsigned int,unsigned int,int) = (int(*)(unsigned int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_unsigned_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_unsigned_int_unsigned_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_unsigned_int_unsigned_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_unsigned_int_unsigned_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_unsigned_int_unsigned_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 3,2,0
+class FunctionCaller_int_float_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int (*PF)(float,unsigned int,int) = (int(*)(float,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_float_unsigned_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_float_unsigned_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_float_unsigned_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_float_unsigned_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_float_unsigned_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 0,3,0
+class FunctionCaller_int_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int (*PF)(int,float,int) = (int(*)(int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_int_float_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_int_float_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_int_float_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_int_float_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_int_float_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 1,3,0
+class FunctionCaller_int_bool_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int (*PF)(bool,float,int) = (int(*)(bool,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_bool_float_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_bool_float_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_bool_float_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_bool_float_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_bool_float_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 2,3,0
+class FunctionCaller_int_unsigned_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int (*PF)(unsigned int,float,int) = (int(*)(unsigned int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_unsigned_int_float_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_unsigned_int_float_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_unsigned_int_float_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_unsigned_int_float_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_unsigned_int_float_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 3,3,0
+class FunctionCaller_int_float_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ int (*PF)(float,float,int) = (int(*)(float,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_float_float_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_float_float_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_float_float_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_float_float_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_float_float_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 0,0,1
+class FunctionCaller_int_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int (*PF)(int,int,bool) = (int(*)(int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_int_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_int_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_int_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_int_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_int_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 1,0,1
+class FunctionCaller_int_bool_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int (*PF)(bool,int,bool) = (int(*)(bool,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_bool_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_bool_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_bool_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_bool_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_bool_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 2,0,1
+class FunctionCaller_int_unsigned_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int (*PF)(unsigned int,int,bool) = (int(*)(unsigned int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_unsigned_int_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_unsigned_int_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_unsigned_int_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_unsigned_int_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_unsigned_int_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 3,0,1
+class FunctionCaller_int_float_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int (*PF)(float,int,bool) = (int(*)(float,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_float_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_float_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_float_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_float_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_float_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 0,1,1
+class FunctionCaller_int_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int (*PF)(int,bool,bool) = (int(*)(int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_int_bool_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_int_bool_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_int_bool_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_int_bool_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_int_bool_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 1,1,1
+class FunctionCaller_int_bool_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int (*PF)(bool,bool,bool) = (int(*)(bool,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_bool_bool_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_bool_bool_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_bool_bool_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_bool_bool_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_bool_bool_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 2,1,1
+class FunctionCaller_int_unsigned_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int (*PF)(unsigned int,bool,bool) = (int(*)(unsigned int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_unsigned_int_bool_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_unsigned_int_bool_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_unsigned_int_bool_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_unsigned_int_bool_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_unsigned_int_bool_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 3,1,1
+class FunctionCaller_int_float_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int (*PF)(float,bool,bool) = (int(*)(float,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_float_bool_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_float_bool_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_float_bool_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_float_bool_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_float_bool_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 0,2,1
+class FunctionCaller_int_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int (*PF)(int,unsigned int,bool) = (int(*)(int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_int_unsigned_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_int_unsigned_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_int_unsigned_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_int_unsigned_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 1,2,1
+class FunctionCaller_int_bool_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int (*PF)(bool,unsigned int,bool) = (int(*)(bool,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_bool_unsigned_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_bool_unsigned_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_bool_unsigned_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_bool_unsigned_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_bool_unsigned_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 2,2,1
+class FunctionCaller_int_unsigned_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int (*PF)(unsigned int,unsigned int,bool) = (int(*)(unsigned int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_unsigned_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_unsigned_int_unsigned_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_unsigned_int_unsigned_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_unsigned_int_unsigned_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_unsigned_int_unsigned_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 3,2,1
+class FunctionCaller_int_float_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int (*PF)(float,unsigned int,bool) = (int(*)(float,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_float_unsigned_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_float_unsigned_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_float_unsigned_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_float_unsigned_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_float_unsigned_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 0,3,1
+class FunctionCaller_int_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int (*PF)(int,float,bool) = (int(*)(int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_int_float_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_int_float_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_int_float_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_int_float_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_int_float_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 1,3,1
+class FunctionCaller_int_bool_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int (*PF)(bool,float,bool) = (int(*)(bool,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_bool_float_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_bool_float_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_bool_float_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_bool_float_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_bool_float_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 2,3,1
+class FunctionCaller_int_unsigned_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int (*PF)(unsigned int,float,bool) = (int(*)(unsigned int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_unsigned_int_float_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_unsigned_int_float_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_unsigned_int_float_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_unsigned_int_float_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_unsigned_int_float_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 3,3,1
+class FunctionCaller_int_float_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ int (*PF)(float,float,bool) = (int(*)(float,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_float_float_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_float_float_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_float_float_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_float_float_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_float_float_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 0,0,2
+class FunctionCaller_int_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int (*PF)(int,int,unsigned int) = (int(*)(int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_int_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_int_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_int_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_int_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 1,0,2
+class FunctionCaller_int_bool_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int (*PF)(bool,int,unsigned int) = (int(*)(bool,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_bool_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_bool_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_bool_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_bool_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_bool_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 2,0,2
+class FunctionCaller_int_unsigned_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int (*PF)(unsigned int,int,unsigned int) = (int(*)(unsigned int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_unsigned_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_unsigned_int_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_unsigned_int_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_unsigned_int_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_unsigned_int_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 3,0,2
+class FunctionCaller_int_float_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int (*PF)(float,int,unsigned int) = (int(*)(float,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_float_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_float_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_float_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_float_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_float_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 0,1,2
+class FunctionCaller_int_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int (*PF)(int,bool,unsigned int) = (int(*)(int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_int_bool_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_int_bool_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_int_bool_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_int_bool_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 1,1,2
+class FunctionCaller_int_bool_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int (*PF)(bool,bool,unsigned int) = (int(*)(bool,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_bool_bool_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_bool_bool_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_bool_bool_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_bool_bool_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_bool_bool_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 2,1,2
+class FunctionCaller_int_unsigned_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int (*PF)(unsigned int,bool,unsigned int) = (int(*)(unsigned int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_unsigned_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_unsigned_int_bool_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_unsigned_int_bool_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_unsigned_int_bool_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_unsigned_int_bool_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 3,1,2
+class FunctionCaller_int_float_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int (*PF)(float,bool,unsigned int) = (int(*)(float,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_float_bool_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_float_bool_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_float_bool_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_float_bool_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_float_bool_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 0,2,2
+class FunctionCaller_int_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int (*PF)(int,unsigned int,unsigned int) = (int(*)(int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_int_unsigned_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_int_unsigned_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_int_unsigned_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_int_unsigned_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 1,2,2
+class FunctionCaller_int_bool_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int (*PF)(bool,unsigned int,unsigned int) = (int(*)(bool,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_bool_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_bool_unsigned_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_bool_unsigned_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_bool_unsigned_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_bool_unsigned_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 2,2,2
+class FunctionCaller_int_unsigned_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int (*PF)(unsigned int,unsigned int,unsigned int) = (int(*)(unsigned int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_unsigned_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_unsigned_int_unsigned_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_unsigned_int_unsigned_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_unsigned_int_unsigned_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_unsigned_int_unsigned_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 3,2,2
+class FunctionCaller_int_float_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int (*PF)(float,unsigned int,unsigned int) = (int(*)(float,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_float_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_float_unsigned_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_float_unsigned_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_float_unsigned_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_float_unsigned_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 0,3,2
+class FunctionCaller_int_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int (*PF)(int,float,unsigned int) = (int(*)(int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_int_float_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_int_float_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_int_float_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_int_float_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 1,3,2
+class FunctionCaller_int_bool_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int (*PF)(bool,float,unsigned int) = (int(*)(bool,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_bool_float_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_bool_float_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_bool_float_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_bool_float_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_bool_float_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 2,3,2
+class FunctionCaller_int_unsigned_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int (*PF)(unsigned int,float,unsigned int) = (int(*)(unsigned int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_unsigned_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_unsigned_int_float_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_unsigned_int_float_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_unsigned_int_float_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_unsigned_int_float_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 3,3,2
+class FunctionCaller_int_float_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ int (*PF)(float,float,unsigned int) = (int(*)(float,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_float_float_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_float_float_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_float_float_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_float_float_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_float_float_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 0,0,3
+class FunctionCaller_int_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int (*PF)(int,int,float) = (int(*)(int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_int_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_int_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_int_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_int_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_int_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 1,0,3
+class FunctionCaller_int_bool_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int (*PF)(bool,int,float) = (int(*)(bool,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_bool_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_bool_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_bool_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_bool_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_bool_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 2,0,3
+class FunctionCaller_int_unsigned_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int (*PF)(unsigned int,int,float) = (int(*)(unsigned int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_unsigned_int_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_unsigned_int_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_unsigned_int_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_unsigned_int_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_unsigned_int_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 3,0,3
+class FunctionCaller_int_float_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int (*PF)(float,int,float) = (int(*)(float,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_float_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_float_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_float_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_float_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_float_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 0,1,3
+class FunctionCaller_int_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int (*PF)(int,bool,float) = (int(*)(int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_int_bool_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_int_bool_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_int_bool_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_int_bool_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_int_bool_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 1,1,3
+class FunctionCaller_int_bool_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int (*PF)(bool,bool,float) = (int(*)(bool,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_bool_bool_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_bool_bool_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_bool_bool_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_bool_bool_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_bool_bool_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 2,1,3
+class FunctionCaller_int_unsigned_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int (*PF)(unsigned int,bool,float) = (int(*)(unsigned int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_unsigned_int_bool_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_unsigned_int_bool_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_unsigned_int_bool_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_unsigned_int_bool_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_unsigned_int_bool_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 3,1,3
+class FunctionCaller_int_float_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int (*PF)(float,bool,float) = (int(*)(float,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_float_bool_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_float_bool_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_float_bool_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_float_bool_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_float_bool_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 0,2,3
+class FunctionCaller_int_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int (*PF)(int,unsigned int,float) = (int(*)(int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_int_unsigned_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_int_unsigned_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_int_unsigned_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_int_unsigned_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 1,2,3
+class FunctionCaller_int_bool_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int (*PF)(bool,unsigned int,float) = (int(*)(bool,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_bool_unsigned_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_bool_unsigned_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_bool_unsigned_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_bool_unsigned_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_bool_unsigned_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 2,2,3
+class FunctionCaller_int_unsigned_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int (*PF)(unsigned int,unsigned int,float) = (int(*)(unsigned int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_unsigned_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_unsigned_int_unsigned_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_unsigned_int_unsigned_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_unsigned_int_unsigned_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_unsigned_int_unsigned_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 3,2,3
+class FunctionCaller_int_float_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int (*PF)(float,unsigned int,float) = (int(*)(float,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_float_unsigned_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_float_unsigned_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_float_unsigned_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_float_unsigned_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_float_unsigned_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 0,3,3
+class FunctionCaller_int_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int (*PF)(int,float,float) = (int(*)(int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_int_float_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_int_float_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_int_float_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_int_float_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_int_float_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 1,3,3
+class FunctionCaller_int_bool_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int (*PF)(bool,float,float) = (int(*)(bool,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_bool_float_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_bool_float_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_bool_float_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_bool_float_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_bool_float_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 2,3,3
+class FunctionCaller_int_unsigned_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int (*PF)(unsigned int,float,float) = (int(*)(unsigned int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_unsigned_int_float_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_unsigned_int_float_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_unsigned_int_float_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_unsigned_int_float_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_unsigned_int_float_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 3,3,3
+class FunctionCaller_int_float_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ int (*PF)(float,float,float) = (int(*)(float,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_int_float_float_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_float_float_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_float_float_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_float_float_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_float_float_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 0,0,0
+class FunctionCaller_bool_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool (*PF)(int,int,int) = (bool(*)(int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_int_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_int_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_int_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_int_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_int_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 1,0,0
+class FunctionCaller_bool_bool_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool (*PF)(bool,int,int) = (bool(*)(bool,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_bool_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_bool_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_bool_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_bool_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_bool_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 2,0,0
+class FunctionCaller_bool_unsigned_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool (*PF)(unsigned int,int,int) = (bool(*)(unsigned int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_unsigned_int_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_unsigned_int_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_unsigned_int_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_unsigned_int_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_unsigned_int_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 3,0,0
+class FunctionCaller_bool_float_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool (*PF)(float,int,int) = (bool(*)(float,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_float_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_float_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_float_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_float_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_float_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 0,1,0
+class FunctionCaller_bool_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool (*PF)(int,bool,int) = (bool(*)(int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_int_bool_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_int_bool_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_int_bool_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_int_bool_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_int_bool_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 1,1,0
+class FunctionCaller_bool_bool_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool (*PF)(bool,bool,int) = (bool(*)(bool,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_bool_bool_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_bool_bool_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_bool_bool_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_bool_bool_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_bool_bool_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 2,1,0
+class FunctionCaller_bool_unsigned_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool (*PF)(unsigned int,bool,int) = (bool(*)(unsigned int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_unsigned_int_bool_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_unsigned_int_bool_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_unsigned_int_bool_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_unsigned_int_bool_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_unsigned_int_bool_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 3,1,0
+class FunctionCaller_bool_float_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool (*PF)(float,bool,int) = (bool(*)(float,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_float_bool_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_float_bool_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_float_bool_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_float_bool_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_float_bool_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 0,2,0
+class FunctionCaller_bool_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool (*PF)(int,unsigned int,int) = (bool(*)(int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_int_unsigned_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_int_unsigned_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_int_unsigned_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_int_unsigned_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 1,2,0
+class FunctionCaller_bool_bool_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool (*PF)(bool,unsigned int,int) = (bool(*)(bool,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_bool_unsigned_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_bool_unsigned_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_bool_unsigned_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_bool_unsigned_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_bool_unsigned_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 2,2,0
+class FunctionCaller_bool_unsigned_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool (*PF)(unsigned int,unsigned int,int) = (bool(*)(unsigned int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_unsigned_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_unsigned_int_unsigned_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_unsigned_int_unsigned_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_unsigned_int_unsigned_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_unsigned_int_unsigned_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 3,2,0
+class FunctionCaller_bool_float_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool (*PF)(float,unsigned int,int) = (bool(*)(float,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_float_unsigned_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_float_unsigned_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_float_unsigned_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_float_unsigned_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_float_unsigned_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 0,3,0
+class FunctionCaller_bool_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool (*PF)(int,float,int) = (bool(*)(int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_int_float_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_int_float_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_int_float_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_int_float_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_int_float_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 1,3,0
+class FunctionCaller_bool_bool_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool (*PF)(bool,float,int) = (bool(*)(bool,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_bool_float_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_bool_float_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_bool_float_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_bool_float_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_bool_float_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 2,3,0
+class FunctionCaller_bool_unsigned_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool (*PF)(unsigned int,float,int) = (bool(*)(unsigned int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_unsigned_int_float_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_unsigned_int_float_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_unsigned_int_float_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_unsigned_int_float_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_unsigned_int_float_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 3,3,0
+class FunctionCaller_bool_float_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ bool (*PF)(float,float,int) = (bool(*)(float,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_float_float_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_float_float_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_float_float_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_float_float_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_float_float_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 0,0,1
+class FunctionCaller_bool_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool (*PF)(int,int,bool) = (bool(*)(int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_int_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_int_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_int_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_int_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_int_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 1,0,1
+class FunctionCaller_bool_bool_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool (*PF)(bool,int,bool) = (bool(*)(bool,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_bool_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_bool_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_bool_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_bool_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_bool_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 2,0,1
+class FunctionCaller_bool_unsigned_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool (*PF)(unsigned int,int,bool) = (bool(*)(unsigned int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_unsigned_int_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_unsigned_int_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_unsigned_int_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_unsigned_int_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_unsigned_int_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 3,0,1
+class FunctionCaller_bool_float_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool (*PF)(float,int,bool) = (bool(*)(float,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_float_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_float_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_float_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_float_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_float_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 0,1,1
+class FunctionCaller_bool_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool (*PF)(int,bool,bool) = (bool(*)(int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_int_bool_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_int_bool_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_int_bool_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_int_bool_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_int_bool_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 1,1,1
+class FunctionCaller_bool_bool_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool (*PF)(bool,bool,bool) = (bool(*)(bool,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_bool_bool_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_bool_bool_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_bool_bool_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_bool_bool_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_bool_bool_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 2,1,1
+class FunctionCaller_bool_unsigned_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool (*PF)(unsigned int,bool,bool) = (bool(*)(unsigned int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_unsigned_int_bool_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_unsigned_int_bool_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_unsigned_int_bool_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_unsigned_int_bool_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_unsigned_int_bool_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 3,1,1
+class FunctionCaller_bool_float_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool (*PF)(float,bool,bool) = (bool(*)(float,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_float_bool_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_float_bool_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_float_bool_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_float_bool_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_float_bool_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 0,2,1
+class FunctionCaller_bool_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool (*PF)(int,unsigned int,bool) = (bool(*)(int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_int_unsigned_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_int_unsigned_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_int_unsigned_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_int_unsigned_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 1,2,1
+class FunctionCaller_bool_bool_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool (*PF)(bool,unsigned int,bool) = (bool(*)(bool,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_bool_unsigned_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_bool_unsigned_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_bool_unsigned_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_bool_unsigned_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_bool_unsigned_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 2,2,1
+class FunctionCaller_bool_unsigned_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool (*PF)(unsigned int,unsigned int,bool) = (bool(*)(unsigned int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_unsigned_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_unsigned_int_unsigned_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_unsigned_int_unsigned_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_unsigned_int_unsigned_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_unsigned_int_unsigned_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 3,2,1
+class FunctionCaller_bool_float_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool (*PF)(float,unsigned int,bool) = (bool(*)(float,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_float_unsigned_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_float_unsigned_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_float_unsigned_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_float_unsigned_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_float_unsigned_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 0,3,1
+class FunctionCaller_bool_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool (*PF)(int,float,bool) = (bool(*)(int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_int_float_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_int_float_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_int_float_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_int_float_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_int_float_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 1,3,1
+class FunctionCaller_bool_bool_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool (*PF)(bool,float,bool) = (bool(*)(bool,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_bool_float_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_bool_float_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_bool_float_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_bool_float_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_bool_float_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 2,3,1
+class FunctionCaller_bool_unsigned_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool (*PF)(unsigned int,float,bool) = (bool(*)(unsigned int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_unsigned_int_float_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_unsigned_int_float_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_unsigned_int_float_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_unsigned_int_float_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_unsigned_int_float_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 3,3,1
+class FunctionCaller_bool_float_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ bool (*PF)(float,float,bool) = (bool(*)(float,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_float_float_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_float_float_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_float_float_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_float_float_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_float_float_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 0,0,2
+class FunctionCaller_bool_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool (*PF)(int,int,unsigned int) = (bool(*)(int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_int_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_int_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_int_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_int_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 1,0,2
+class FunctionCaller_bool_bool_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool (*PF)(bool,int,unsigned int) = (bool(*)(bool,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_bool_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_bool_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_bool_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_bool_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_bool_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 2,0,2
+class FunctionCaller_bool_unsigned_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool (*PF)(unsigned int,int,unsigned int) = (bool(*)(unsigned int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_unsigned_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_unsigned_int_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_unsigned_int_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_unsigned_int_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_unsigned_int_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 3,0,2
+class FunctionCaller_bool_float_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool (*PF)(float,int,unsigned int) = (bool(*)(float,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_float_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_float_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_float_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_float_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_float_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 0,1,2
+class FunctionCaller_bool_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool (*PF)(int,bool,unsigned int) = (bool(*)(int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_int_bool_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_int_bool_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_int_bool_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_int_bool_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 1,1,2
+class FunctionCaller_bool_bool_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool (*PF)(bool,bool,unsigned int) = (bool(*)(bool,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_bool_bool_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_bool_bool_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_bool_bool_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_bool_bool_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_bool_bool_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 2,1,2
+class FunctionCaller_bool_unsigned_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool (*PF)(unsigned int,bool,unsigned int) = (bool(*)(unsigned int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_unsigned_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_unsigned_int_bool_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_unsigned_int_bool_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_unsigned_int_bool_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_unsigned_int_bool_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 3,1,2
+class FunctionCaller_bool_float_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool (*PF)(float,bool,unsigned int) = (bool(*)(float,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_float_bool_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_float_bool_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_float_bool_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_float_bool_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_float_bool_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 0,2,2
+class FunctionCaller_bool_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool (*PF)(int,unsigned int,unsigned int) = (bool(*)(int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_int_unsigned_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_int_unsigned_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_int_unsigned_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_int_unsigned_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 1,2,2
+class FunctionCaller_bool_bool_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool (*PF)(bool,unsigned int,unsigned int) = (bool(*)(bool,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_bool_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_bool_unsigned_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_bool_unsigned_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_bool_unsigned_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_bool_unsigned_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 2,2,2
+class FunctionCaller_bool_unsigned_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool (*PF)(unsigned int,unsigned int,unsigned int) = (bool(*)(unsigned int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_unsigned_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_unsigned_int_unsigned_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_unsigned_int_unsigned_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_unsigned_int_unsigned_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_unsigned_int_unsigned_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 3,2,2
+class FunctionCaller_bool_float_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool (*PF)(float,unsigned int,unsigned int) = (bool(*)(float,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_float_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_float_unsigned_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_float_unsigned_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_float_unsigned_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_float_unsigned_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 0,3,2
+class FunctionCaller_bool_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool (*PF)(int,float,unsigned int) = (bool(*)(int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_int_float_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_int_float_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_int_float_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_int_float_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 1,3,2
+class FunctionCaller_bool_bool_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool (*PF)(bool,float,unsigned int) = (bool(*)(bool,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_bool_float_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_bool_float_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_bool_float_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_bool_float_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_bool_float_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 2,3,2
+class FunctionCaller_bool_unsigned_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool (*PF)(unsigned int,float,unsigned int) = (bool(*)(unsigned int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_unsigned_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_unsigned_int_float_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_unsigned_int_float_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_unsigned_int_float_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_unsigned_int_float_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 3,3,2
+class FunctionCaller_bool_float_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ bool (*PF)(float,float,unsigned int) = (bool(*)(float,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_float_float_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_float_float_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_float_float_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_float_float_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_float_float_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 0,0,3
+class FunctionCaller_bool_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool (*PF)(int,int,float) = (bool(*)(int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_int_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_int_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_int_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_int_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_int_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 1,0,3
+class FunctionCaller_bool_bool_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool (*PF)(bool,int,float) = (bool(*)(bool,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_bool_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_bool_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_bool_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_bool_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_bool_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 2,0,3
+class FunctionCaller_bool_unsigned_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool (*PF)(unsigned int,int,float) = (bool(*)(unsigned int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_unsigned_int_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_unsigned_int_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_unsigned_int_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_unsigned_int_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_unsigned_int_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 3,0,3
+class FunctionCaller_bool_float_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool (*PF)(float,int,float) = (bool(*)(float,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_float_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_float_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_float_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_float_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_float_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 0,1,3
+class FunctionCaller_bool_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool (*PF)(int,bool,float) = (bool(*)(int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_int_bool_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_int_bool_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_int_bool_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_int_bool_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_int_bool_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 1,1,3
+class FunctionCaller_bool_bool_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool (*PF)(bool,bool,float) = (bool(*)(bool,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_bool_bool_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_bool_bool_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_bool_bool_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_bool_bool_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_bool_bool_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 2,1,3
+class FunctionCaller_bool_unsigned_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool (*PF)(unsigned int,bool,float) = (bool(*)(unsigned int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_unsigned_int_bool_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_unsigned_int_bool_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_unsigned_int_bool_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_unsigned_int_bool_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_unsigned_int_bool_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 3,1,3
+class FunctionCaller_bool_float_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool (*PF)(float,bool,float) = (bool(*)(float,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_float_bool_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_float_bool_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_float_bool_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_float_bool_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_float_bool_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 0,2,3
+class FunctionCaller_bool_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool (*PF)(int,unsigned int,float) = (bool(*)(int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_int_unsigned_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_int_unsigned_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_int_unsigned_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_int_unsigned_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 1,2,3
+class FunctionCaller_bool_bool_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool (*PF)(bool,unsigned int,float) = (bool(*)(bool,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_bool_unsigned_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_bool_unsigned_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_bool_unsigned_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_bool_unsigned_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_bool_unsigned_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 2,2,3
+class FunctionCaller_bool_unsigned_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool (*PF)(unsigned int,unsigned int,float) = (bool(*)(unsigned int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_unsigned_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_unsigned_int_unsigned_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_unsigned_int_unsigned_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_unsigned_int_unsigned_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_unsigned_int_unsigned_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 3,2,3
+class FunctionCaller_bool_float_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool (*PF)(float,unsigned int,float) = (bool(*)(float,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_float_unsigned_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_float_unsigned_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_float_unsigned_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_float_unsigned_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_float_unsigned_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 0,3,3
+class FunctionCaller_bool_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool (*PF)(int,float,float) = (bool(*)(int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_int_float_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_int_float_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_int_float_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_int_float_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_int_float_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 1,3,3
+class FunctionCaller_bool_bool_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool (*PF)(bool,float,float) = (bool(*)(bool,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_bool_float_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_bool_float_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_bool_float_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_bool_float_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_bool_float_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 2,3,3
+class FunctionCaller_bool_unsigned_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool (*PF)(unsigned int,float,float) = (bool(*)(unsigned int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_unsigned_int_float_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_unsigned_int_float_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_unsigned_int_float_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_unsigned_int_float_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_unsigned_int_float_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 3,3,3
+class FunctionCaller_bool_float_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ bool (*PF)(float,float,float) = (bool(*)(float,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_bool_float_float_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_float_float_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_float_float_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_float_float_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_float_float_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 0,0,0
+class FunctionCaller_unsigned_int_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int (*PF)(int,int,int) = (unsigned int(*)(int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_int_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_int_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_int_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_int_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_int_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 1,0,0
+class FunctionCaller_unsigned_int_bool_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int (*PF)(bool,int,int) = (unsigned int(*)(bool,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_bool_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_bool_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_bool_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_bool_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_bool_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 2,0,0
+class FunctionCaller_unsigned_int_unsigned_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int (*PF)(unsigned int,int,int) = (unsigned int(*)(unsigned int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_unsigned_int_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_unsigned_int_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 3,0,0
+class FunctionCaller_unsigned_int_float_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int (*PF)(float,int,int) = (unsigned int(*)(float,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_float_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_float_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_float_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_float_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_float_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 0,1,0
+class FunctionCaller_unsigned_int_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int (*PF)(int,bool,int) = (unsigned int(*)(int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_int_bool_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_int_bool_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_int_bool_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_int_bool_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_int_bool_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 1,1,0
+class FunctionCaller_unsigned_int_bool_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int (*PF)(bool,bool,int) = (unsigned int(*)(bool,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_bool_bool_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_bool_bool_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_bool_bool_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_bool_bool_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_bool_bool_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 2,1,0
+class FunctionCaller_unsigned_int_unsigned_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int (*PF)(unsigned int,bool,int) = (unsigned int(*)(unsigned int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_bool_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_bool_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_unsigned_int_bool_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_bool_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_unsigned_int_bool_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 3,1,0
+class FunctionCaller_unsigned_int_float_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int (*PF)(float,bool,int) = (unsigned int(*)(float,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_float_bool_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_float_bool_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_float_bool_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_float_bool_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_float_bool_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 0,2,0
+class FunctionCaller_unsigned_int_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int (*PF)(int,unsigned int,int) = (unsigned int(*)(int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_int_unsigned_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_int_unsigned_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_int_unsigned_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_int_unsigned_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 1,2,0
+class FunctionCaller_unsigned_int_bool_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int (*PF)(bool,unsigned int,int) = (unsigned int(*)(bool,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_bool_unsigned_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_bool_unsigned_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_bool_unsigned_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_bool_unsigned_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_bool_unsigned_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 2,2,0
+class FunctionCaller_unsigned_int_unsigned_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int (*PF)(unsigned int,unsigned int,int) = (unsigned int(*)(unsigned int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_unsigned_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_unsigned_int_unsigned_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_unsigned_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_unsigned_int_unsigned_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 3,2,0
+class FunctionCaller_unsigned_int_float_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int (*PF)(float,unsigned int,int) = (unsigned int(*)(float,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_float_unsigned_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_float_unsigned_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_float_unsigned_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_float_unsigned_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_float_unsigned_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 0,3,0
+class FunctionCaller_unsigned_int_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int (*PF)(int,float,int) = (unsigned int(*)(int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_int_float_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_int_float_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_int_float_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_int_float_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_int_float_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 1,3,0
+class FunctionCaller_unsigned_int_bool_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int (*PF)(bool,float,int) = (unsigned int(*)(bool,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_bool_float_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_bool_float_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_bool_float_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_bool_float_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_bool_float_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 2,3,0
+class FunctionCaller_unsigned_int_unsigned_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int (*PF)(unsigned int,float,int) = (unsigned int(*)(unsigned int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_float_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_float_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_unsigned_int_float_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_float_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_unsigned_int_float_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 3,3,0
+class FunctionCaller_unsigned_int_float_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ unsigned int (*PF)(float,float,int) = (unsigned int(*)(float,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_float_float_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_float_float_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_float_float_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_float_float_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_float_float_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 0,0,1
+class FunctionCaller_unsigned_int_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int (*PF)(int,int,bool) = (unsigned int(*)(int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_int_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_int_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_int_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_int_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_int_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 1,0,1
+class FunctionCaller_unsigned_int_bool_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int (*PF)(bool,int,bool) = (unsigned int(*)(bool,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_bool_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_bool_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_bool_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_bool_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_bool_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 2,0,1
+class FunctionCaller_unsigned_int_unsigned_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int (*PF)(unsigned int,int,bool) = (unsigned int(*)(unsigned int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_unsigned_int_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_unsigned_int_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 3,0,1
+class FunctionCaller_unsigned_int_float_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int (*PF)(float,int,bool) = (unsigned int(*)(float,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_float_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_float_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_float_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_float_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_float_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 0,1,1
+class FunctionCaller_unsigned_int_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int (*PF)(int,bool,bool) = (unsigned int(*)(int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_int_bool_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_int_bool_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_int_bool_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_int_bool_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_int_bool_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 1,1,1
+class FunctionCaller_unsigned_int_bool_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int (*PF)(bool,bool,bool) = (unsigned int(*)(bool,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_bool_bool_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_bool_bool_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_bool_bool_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_bool_bool_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_bool_bool_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 2,1,1
+class FunctionCaller_unsigned_int_unsigned_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int (*PF)(unsigned int,bool,bool) = (unsigned int(*)(unsigned int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_bool_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_bool_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_unsigned_int_bool_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_bool_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_unsigned_int_bool_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 3,1,1
+class FunctionCaller_unsigned_int_float_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int (*PF)(float,bool,bool) = (unsigned int(*)(float,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_float_bool_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_float_bool_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_float_bool_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_float_bool_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_float_bool_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 0,2,1
+class FunctionCaller_unsigned_int_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int (*PF)(int,unsigned int,bool) = (unsigned int(*)(int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_int_unsigned_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_int_unsigned_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_int_unsigned_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_int_unsigned_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 1,2,1
+class FunctionCaller_unsigned_int_bool_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int (*PF)(bool,unsigned int,bool) = (unsigned int(*)(bool,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_bool_unsigned_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_bool_unsigned_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_bool_unsigned_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_bool_unsigned_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_bool_unsigned_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 2,2,1
+class FunctionCaller_unsigned_int_unsigned_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int (*PF)(unsigned int,unsigned int,bool) = (unsigned int(*)(unsigned int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_unsigned_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_unsigned_int_unsigned_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_unsigned_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_unsigned_int_unsigned_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 3,2,1
+class FunctionCaller_unsigned_int_float_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int (*PF)(float,unsigned int,bool) = (unsigned int(*)(float,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_float_unsigned_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_float_unsigned_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_float_unsigned_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_float_unsigned_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_float_unsigned_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 0,3,1
+class FunctionCaller_unsigned_int_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int (*PF)(int,float,bool) = (unsigned int(*)(int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_int_float_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_int_float_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_int_float_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_int_float_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_int_float_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 1,3,1
+class FunctionCaller_unsigned_int_bool_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int (*PF)(bool,float,bool) = (unsigned int(*)(bool,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_bool_float_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_bool_float_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_bool_float_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_bool_float_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_bool_float_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 2,3,1
+class FunctionCaller_unsigned_int_unsigned_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int (*PF)(unsigned int,float,bool) = (unsigned int(*)(unsigned int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_float_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_float_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_unsigned_int_float_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_float_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_unsigned_int_float_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 3,3,1
+class FunctionCaller_unsigned_int_float_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ unsigned int (*PF)(float,float,bool) = (unsigned int(*)(float,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_float_float_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_float_float_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_float_float_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_float_float_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_float_float_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 0,0,2
+class FunctionCaller_unsigned_int_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int (*PF)(int,int,unsigned int) = (unsigned int(*)(int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_int_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_int_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_int_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_int_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 1,0,2
+class FunctionCaller_unsigned_int_bool_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int (*PF)(bool,int,unsigned int) = (unsigned int(*)(bool,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_bool_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_bool_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_bool_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_bool_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_bool_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 2,0,2
+class FunctionCaller_unsigned_int_unsigned_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int (*PF)(unsigned int,int,unsigned int) = (unsigned int(*)(unsigned int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_unsigned_int_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_unsigned_int_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 3,0,2
+class FunctionCaller_unsigned_int_float_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int (*PF)(float,int,unsigned int) = (unsigned int(*)(float,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_float_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_float_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_float_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_float_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_float_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 0,1,2
+class FunctionCaller_unsigned_int_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int (*PF)(int,bool,unsigned int) = (unsigned int(*)(int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_int_bool_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_int_bool_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_int_bool_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_int_bool_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 1,1,2
+class FunctionCaller_unsigned_int_bool_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int (*PF)(bool,bool,unsigned int) = (unsigned int(*)(bool,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_bool_bool_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_bool_bool_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_bool_bool_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_bool_bool_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_bool_bool_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 2,1,2
+class FunctionCaller_unsigned_int_unsigned_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int (*PF)(unsigned int,bool,unsigned int) = (unsigned int(*)(unsigned int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_bool_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_unsigned_int_bool_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_bool_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_unsigned_int_bool_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 3,1,2
+class FunctionCaller_unsigned_int_float_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int (*PF)(float,bool,unsigned int) = (unsigned int(*)(float,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_float_bool_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_float_bool_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_float_bool_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_float_bool_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_float_bool_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 0,2,2
+class FunctionCaller_unsigned_int_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int (*PF)(int,unsigned int,unsigned int) = (unsigned int(*)(int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_int_unsigned_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_int_unsigned_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_int_unsigned_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_int_unsigned_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 1,2,2
+class FunctionCaller_unsigned_int_bool_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int (*PF)(bool,unsigned int,unsigned int) = (unsigned int(*)(bool,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_bool_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_bool_unsigned_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_bool_unsigned_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_bool_unsigned_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_bool_unsigned_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 2,2,2
+class FunctionCaller_unsigned_int_unsigned_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int (*PF)(unsigned int,unsigned int,unsigned int) = (unsigned int(*)(unsigned int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_unsigned_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_unsigned_int_unsigned_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_unsigned_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_unsigned_int_unsigned_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 3,2,2
+class FunctionCaller_unsigned_int_float_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int (*PF)(float,unsigned int,unsigned int) = (unsigned int(*)(float,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_float_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_float_unsigned_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_float_unsigned_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_float_unsigned_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_float_unsigned_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 0,3,2
+class FunctionCaller_unsigned_int_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int (*PF)(int,float,unsigned int) = (unsigned int(*)(int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_int_float_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_int_float_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_int_float_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_int_float_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 1,3,2
+class FunctionCaller_unsigned_int_bool_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int (*PF)(bool,float,unsigned int) = (unsigned int(*)(bool,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_bool_float_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_bool_float_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_bool_float_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_bool_float_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_bool_float_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 2,3,2
+class FunctionCaller_unsigned_int_unsigned_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int (*PF)(unsigned int,float,unsigned int) = (unsigned int(*)(unsigned int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_float_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_unsigned_int_float_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_float_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_unsigned_int_float_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 3,3,2
+class FunctionCaller_unsigned_int_float_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ unsigned int (*PF)(float,float,unsigned int) = (unsigned int(*)(float,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_float_float_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_float_float_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_float_float_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_float_float_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_float_float_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 0,0,3
+class FunctionCaller_unsigned_int_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int (*PF)(int,int,float) = (unsigned int(*)(int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_int_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_int_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_int_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_int_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_int_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 1,0,3
+class FunctionCaller_unsigned_int_bool_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int (*PF)(bool,int,float) = (unsigned int(*)(bool,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_bool_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_bool_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_bool_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_bool_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_bool_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 2,0,3
+class FunctionCaller_unsigned_int_unsigned_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int (*PF)(unsigned int,int,float) = (unsigned int(*)(unsigned int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_unsigned_int_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_unsigned_int_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 3,0,3
+class FunctionCaller_unsigned_int_float_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int (*PF)(float,int,float) = (unsigned int(*)(float,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_float_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_float_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_float_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_float_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_float_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 0,1,3
+class FunctionCaller_unsigned_int_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int (*PF)(int,bool,float) = (unsigned int(*)(int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_int_bool_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_int_bool_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_int_bool_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_int_bool_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_int_bool_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 1,1,3
+class FunctionCaller_unsigned_int_bool_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int (*PF)(bool,bool,float) = (unsigned int(*)(bool,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_bool_bool_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_bool_bool_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_bool_bool_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_bool_bool_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_bool_bool_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 2,1,3
+class FunctionCaller_unsigned_int_unsigned_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int (*PF)(unsigned int,bool,float) = (unsigned int(*)(unsigned int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_bool_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_bool_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_unsigned_int_bool_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_bool_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_unsigned_int_bool_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 3,1,3
+class FunctionCaller_unsigned_int_float_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int (*PF)(float,bool,float) = (unsigned int(*)(float,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_float_bool_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_float_bool_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_float_bool_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_float_bool_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_float_bool_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 0,2,3
+class FunctionCaller_unsigned_int_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int (*PF)(int,unsigned int,float) = (unsigned int(*)(int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_int_unsigned_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_int_unsigned_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_int_unsigned_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_int_unsigned_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 1,2,3
+class FunctionCaller_unsigned_int_bool_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int (*PF)(bool,unsigned int,float) = (unsigned int(*)(bool,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_bool_unsigned_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_bool_unsigned_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_bool_unsigned_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_bool_unsigned_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_bool_unsigned_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 2,2,3
+class FunctionCaller_unsigned_int_unsigned_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int (*PF)(unsigned int,unsigned int,float) = (unsigned int(*)(unsigned int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_unsigned_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_unsigned_int_unsigned_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_unsigned_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_unsigned_int_unsigned_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 3,2,3
+class FunctionCaller_unsigned_int_float_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int (*PF)(float,unsigned int,float) = (unsigned int(*)(float,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_float_unsigned_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_float_unsigned_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_float_unsigned_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_float_unsigned_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_float_unsigned_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 0,3,3
+class FunctionCaller_unsigned_int_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int (*PF)(int,float,float) = (unsigned int(*)(int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_int_float_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_int_float_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_int_float_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_int_float_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_int_float_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 1,3,3
+class FunctionCaller_unsigned_int_bool_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int (*PF)(bool,float,float) = (unsigned int(*)(bool,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_bool_float_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_bool_float_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_bool_float_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_bool_float_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_bool_float_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 2,3,3
+class FunctionCaller_unsigned_int_unsigned_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int (*PF)(unsigned int,float,float) = (unsigned int(*)(unsigned int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_float_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_float_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_unsigned_int_float_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_float_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_unsigned_int_float_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 3,3,3
+class FunctionCaller_unsigned_int_float_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ unsigned int (*PF)(float,float,float) = (unsigned int(*)(float,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_unsigned_int_float_float_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_float_float_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_float_float_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_float_float_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_float_float_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 0,0,0
+class FunctionCaller_float_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float (*PF)(int,int,int) = (float(*)(int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_int_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_int_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_int_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_int_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_int_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 1,0,0
+class FunctionCaller_float_bool_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float (*PF)(bool,int,int) = (float(*)(bool,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_bool_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_bool_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_bool_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_bool_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_bool_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 2,0,0
+class FunctionCaller_float_unsigned_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float (*PF)(unsigned int,int,int) = (float(*)(unsigned int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_unsigned_int_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_unsigned_int_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_unsigned_int_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_unsigned_int_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_unsigned_int_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 3,0,0
+class FunctionCaller_float_float_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float (*PF)(float,int,int) = (float(*)(float,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_float_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_float_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_float_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_float_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_float_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 0,1,0
+class FunctionCaller_float_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float (*PF)(int,bool,int) = (float(*)(int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_int_bool_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_int_bool_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_int_bool_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_int_bool_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_int_bool_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 1,1,0
+class FunctionCaller_float_bool_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float (*PF)(bool,bool,int) = (float(*)(bool,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_bool_bool_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_bool_bool_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_bool_bool_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_bool_bool_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_bool_bool_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 2,1,0
+class FunctionCaller_float_unsigned_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float (*PF)(unsigned int,bool,int) = (float(*)(unsigned int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_unsigned_int_bool_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_unsigned_int_bool_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_unsigned_int_bool_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_unsigned_int_bool_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_unsigned_int_bool_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 3,1,0
+class FunctionCaller_float_float_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float (*PF)(float,bool,int) = (float(*)(float,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_float_bool_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_float_bool_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_float_bool_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_float_bool_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_float_bool_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 0,2,0
+class FunctionCaller_float_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float (*PF)(int,unsigned int,int) = (float(*)(int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_int_unsigned_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_int_unsigned_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_int_unsigned_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_int_unsigned_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 1,2,0
+class FunctionCaller_float_bool_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float (*PF)(bool,unsigned int,int) = (float(*)(bool,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_bool_unsigned_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_bool_unsigned_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_bool_unsigned_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_bool_unsigned_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_bool_unsigned_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 2,2,0
+class FunctionCaller_float_unsigned_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float (*PF)(unsigned int,unsigned int,int) = (float(*)(unsigned int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_unsigned_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_unsigned_int_unsigned_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_unsigned_int_unsigned_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_unsigned_int_unsigned_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_unsigned_int_unsigned_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 3,2,0
+class FunctionCaller_float_float_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float (*PF)(float,unsigned int,int) = (float(*)(float,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_float_unsigned_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_float_unsigned_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_float_unsigned_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_float_unsigned_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_float_unsigned_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 0,3,0
+class FunctionCaller_float_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float (*PF)(int,float,int) = (float(*)(int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_int_float_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_int_float_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_int_float_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_int_float_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_int_float_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 1,3,0
+class FunctionCaller_float_bool_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float (*PF)(bool,float,int) = (float(*)(bool,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_bool_float_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_bool_float_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_bool_float_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_bool_float_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_bool_float_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 2,3,0
+class FunctionCaller_float_unsigned_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float (*PF)(unsigned int,float,int) = (float(*)(unsigned int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_unsigned_int_float_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_unsigned_int_float_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_unsigned_int_float_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_unsigned_int_float_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_unsigned_int_float_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 3,3,0
+class FunctionCaller_float_float_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ float (*PF)(float,float,int) = (float(*)(float,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_float_float_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_float_float_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_float_float_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_float_float_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_float_float_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 0,0,1
+class FunctionCaller_float_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float (*PF)(int,int,bool) = (float(*)(int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_int_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_int_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_int_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_int_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_int_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 1,0,1
+class FunctionCaller_float_bool_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float (*PF)(bool,int,bool) = (float(*)(bool,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_bool_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_bool_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_bool_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_bool_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_bool_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 2,0,1
+class FunctionCaller_float_unsigned_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float (*PF)(unsigned int,int,bool) = (float(*)(unsigned int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_unsigned_int_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_unsigned_int_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_unsigned_int_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_unsigned_int_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_unsigned_int_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 3,0,1
+class FunctionCaller_float_float_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float (*PF)(float,int,bool) = (float(*)(float,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_float_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_float_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_float_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_float_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_float_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 0,1,1
+class FunctionCaller_float_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float (*PF)(int,bool,bool) = (float(*)(int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_int_bool_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_int_bool_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_int_bool_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_int_bool_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_int_bool_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 1,1,1
+class FunctionCaller_float_bool_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float (*PF)(bool,bool,bool) = (float(*)(bool,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_bool_bool_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_bool_bool_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_bool_bool_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_bool_bool_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_bool_bool_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 2,1,1
+class FunctionCaller_float_unsigned_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float (*PF)(unsigned int,bool,bool) = (float(*)(unsigned int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_unsigned_int_bool_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_unsigned_int_bool_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_unsigned_int_bool_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_unsigned_int_bool_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_unsigned_int_bool_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 3,1,1
+class FunctionCaller_float_float_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float (*PF)(float,bool,bool) = (float(*)(float,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_float_bool_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_float_bool_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_float_bool_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_float_bool_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_float_bool_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 0,2,1
+class FunctionCaller_float_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float (*PF)(int,unsigned int,bool) = (float(*)(int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_int_unsigned_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_int_unsigned_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_int_unsigned_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_int_unsigned_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 1,2,1
+class FunctionCaller_float_bool_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float (*PF)(bool,unsigned int,bool) = (float(*)(bool,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_bool_unsigned_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_bool_unsigned_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_bool_unsigned_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_bool_unsigned_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_bool_unsigned_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 2,2,1
+class FunctionCaller_float_unsigned_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float (*PF)(unsigned int,unsigned int,bool) = (float(*)(unsigned int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_unsigned_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_unsigned_int_unsigned_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_unsigned_int_unsigned_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_unsigned_int_unsigned_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_unsigned_int_unsigned_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 3,2,1
+class FunctionCaller_float_float_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float (*PF)(float,unsigned int,bool) = (float(*)(float,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_float_unsigned_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_float_unsigned_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_float_unsigned_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_float_unsigned_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_float_unsigned_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 0,3,1
+class FunctionCaller_float_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float (*PF)(int,float,bool) = (float(*)(int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_int_float_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_int_float_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_int_float_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_int_float_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_int_float_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 1,3,1
+class FunctionCaller_float_bool_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float (*PF)(bool,float,bool) = (float(*)(bool,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_bool_float_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_bool_float_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_bool_float_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_bool_float_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_bool_float_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 2,3,1
+class FunctionCaller_float_unsigned_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float (*PF)(unsigned int,float,bool) = (float(*)(unsigned int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_unsigned_int_float_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_unsigned_int_float_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_unsigned_int_float_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_unsigned_int_float_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_unsigned_int_float_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 3,3,1
+class FunctionCaller_float_float_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ float (*PF)(float,float,bool) = (float(*)(float,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_float_float_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_float_float_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_float_float_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_float_float_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_float_float_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 0,0,2
+class FunctionCaller_float_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float (*PF)(int,int,unsigned int) = (float(*)(int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_int_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_int_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_int_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_int_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 1,0,2
+class FunctionCaller_float_bool_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float (*PF)(bool,int,unsigned int) = (float(*)(bool,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_bool_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_bool_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_bool_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_bool_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_bool_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 2,0,2
+class FunctionCaller_float_unsigned_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float (*PF)(unsigned int,int,unsigned int) = (float(*)(unsigned int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_unsigned_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_unsigned_int_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_unsigned_int_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_unsigned_int_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_unsigned_int_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 3,0,2
+class FunctionCaller_float_float_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float (*PF)(float,int,unsigned int) = (float(*)(float,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_float_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_float_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_float_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_float_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_float_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 0,1,2
+class FunctionCaller_float_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float (*PF)(int,bool,unsigned int) = (float(*)(int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_int_bool_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_int_bool_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_int_bool_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_int_bool_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 1,1,2
+class FunctionCaller_float_bool_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float (*PF)(bool,bool,unsigned int) = (float(*)(bool,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_bool_bool_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_bool_bool_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_bool_bool_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_bool_bool_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_bool_bool_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 2,1,2
+class FunctionCaller_float_unsigned_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float (*PF)(unsigned int,bool,unsigned int) = (float(*)(unsigned int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_unsigned_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_unsigned_int_bool_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_unsigned_int_bool_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_unsigned_int_bool_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_unsigned_int_bool_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 3,1,2
+class FunctionCaller_float_float_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float (*PF)(float,bool,unsigned int) = (float(*)(float,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_float_bool_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_float_bool_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_float_bool_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_float_bool_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_float_bool_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 0,2,2
+class FunctionCaller_float_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float (*PF)(int,unsigned int,unsigned int) = (float(*)(int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_int_unsigned_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_int_unsigned_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_int_unsigned_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_int_unsigned_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 1,2,2
+class FunctionCaller_float_bool_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float (*PF)(bool,unsigned int,unsigned int) = (float(*)(bool,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_bool_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_bool_unsigned_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_bool_unsigned_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_bool_unsigned_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_bool_unsigned_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 2,2,2
+class FunctionCaller_float_unsigned_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float (*PF)(unsigned int,unsigned int,unsigned int) = (float(*)(unsigned int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_unsigned_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_unsigned_int_unsigned_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_unsigned_int_unsigned_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_unsigned_int_unsigned_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_unsigned_int_unsigned_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 3,2,2
+class FunctionCaller_float_float_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float (*PF)(float,unsigned int,unsigned int) = (float(*)(float,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_float_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_float_unsigned_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_float_unsigned_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_float_unsigned_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_float_unsigned_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 0,3,2
+class FunctionCaller_float_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float (*PF)(int,float,unsigned int) = (float(*)(int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_int_float_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_int_float_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_int_float_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_int_float_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 1,3,2
+class FunctionCaller_float_bool_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float (*PF)(bool,float,unsigned int) = (float(*)(bool,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_bool_float_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_bool_float_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_bool_float_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_bool_float_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_bool_float_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 2,3,2
+class FunctionCaller_float_unsigned_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float (*PF)(unsigned int,float,unsigned int) = (float(*)(unsigned int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_unsigned_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_unsigned_int_float_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_unsigned_int_float_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_unsigned_int_float_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_unsigned_int_float_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 3,3,2
+class FunctionCaller_float_float_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ float (*PF)(float,float,unsigned int) = (float(*)(float,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_float_float_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_float_float_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_float_float_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_float_float_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_float_float_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 0,0,3
+class FunctionCaller_float_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float (*PF)(int,int,float) = (float(*)(int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_int_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_int_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_int_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_int_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_int_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 1,0,3
+class FunctionCaller_float_bool_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float (*PF)(bool,int,float) = (float(*)(bool,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_bool_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_bool_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_bool_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_bool_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_bool_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 2,0,3
+class FunctionCaller_float_unsigned_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float (*PF)(unsigned int,int,float) = (float(*)(unsigned int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_unsigned_int_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_unsigned_int_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_unsigned_int_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_unsigned_int_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_unsigned_int_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 3,0,3
+class FunctionCaller_float_float_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float (*PF)(float,int,float) = (float(*)(float,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_float_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_float_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_float_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_float_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_float_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 0,1,3
+class FunctionCaller_float_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float (*PF)(int,bool,float) = (float(*)(int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_int_bool_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_int_bool_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_int_bool_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_int_bool_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_int_bool_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 1,1,3
+class FunctionCaller_float_bool_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float (*PF)(bool,bool,float) = (float(*)(bool,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_bool_bool_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_bool_bool_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_bool_bool_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_bool_bool_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_bool_bool_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 2,1,3
+class FunctionCaller_float_unsigned_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float (*PF)(unsigned int,bool,float) = (float(*)(unsigned int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_unsigned_int_bool_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_unsigned_int_bool_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_unsigned_int_bool_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_unsigned_int_bool_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_unsigned_int_bool_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 3,1,3
+class FunctionCaller_float_float_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float (*PF)(float,bool,float) = (float(*)(float,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_float_bool_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_float_bool_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_float_bool_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_float_bool_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_float_bool_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 0,2,3
+class FunctionCaller_float_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float (*PF)(int,unsigned int,float) = (float(*)(int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_int_unsigned_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_int_unsigned_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_int_unsigned_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_int_unsigned_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 1,2,3
+class FunctionCaller_float_bool_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float (*PF)(bool,unsigned int,float) = (float(*)(bool,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_bool_unsigned_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_bool_unsigned_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_bool_unsigned_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_bool_unsigned_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_bool_unsigned_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 2,2,3
+class FunctionCaller_float_unsigned_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float (*PF)(unsigned int,unsigned int,float) = (float(*)(unsigned int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_unsigned_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_unsigned_int_unsigned_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_unsigned_int_unsigned_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_unsigned_int_unsigned_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_unsigned_int_unsigned_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 3,2,3
+class FunctionCaller_float_float_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float (*PF)(float,unsigned int,float) = (float(*)(float,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_float_unsigned_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_float_unsigned_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_float_unsigned_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_float_unsigned_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_float_unsigned_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 0,3,3
+class FunctionCaller_float_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float (*PF)(int,float,float) = (float(*)(int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_int_float_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_int_float_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_int_float_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_int_float_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_int_float_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 1,3,3
+class FunctionCaller_float_bool_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float (*PF)(bool,float,float) = (float(*)(bool,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_bool_float_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_bool_float_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_bool_float_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_bool_float_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_bool_float_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 2,3,3
+class FunctionCaller_float_unsigned_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float (*PF)(unsigned int,float,float) = (float(*)(unsigned int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_unsigned_int_float_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_unsigned_int_float_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_unsigned_int_float_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_unsigned_int_float_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_unsigned_int_float_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 3,3,3
+class FunctionCaller_float_float_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ float (*PF)(float,float,float) = (float(*)(float,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2,arg3) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_float_float_float_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_float_float_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_float_float_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_float_float_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_float_float_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 0,0,0
+class FunctionCaller_void_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ void (*PF)(int,int,int) = (void(*)(int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
PF(arg1,arg2,arg3);
- return GTLCore::Value( );
+ return GTLCore::Value();
}
public:
static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
{
- if(function->parameters().size() == 3)
+ if( function->parameters().size() == 3 )
{
- return new FunctionCaller3<void, _TYPE_1_, _TYPE_2_, _TYPE_3_>(llvmFunction, function);
+ return new FunctionCaller_void_int_int_int(llvmFunction, function);
} else {
- switch( function->parameters()[0].type()->dataType() )
+ switch( function->parameters()[3].type()->dataType() )
{
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_int_int_int_int::create(llvmFunction, function);
case GTLCore::Type::BOOLEAN:
- return FunctionCaller4<void, _TYPE_1_, _TYPE_2_, _TYPE_3_, bool>::create(llvmFunction, function);
- break;
+ return FunctionCaller_void_int_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_int_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_int_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 1,0,0
+class FunctionCaller_void_bool_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ void (*PF)(bool,int,int) = (void(*)(bool,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_bool_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
case GTLCore::Type::INTEGER32:
- return FunctionCaller4<void, _TYPE_1_, _TYPE_2_, _TYPE_3_, int>::create(llvmFunction, function);
- break;
+ return FunctionCaller_void_bool_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_bool_int_int_bool::create(llvmFunction, function);
case GTLCore::Type::UNSIGNED_INTEGER32:
- return FunctionCaller4<void, _TYPE_1_, _TYPE_2_, _TYPE_3_, unsigned int>::create(llvmFunction, function);
- break;
+ return FunctionCaller_void_bool_int_int_unsigned_int::create(llvmFunction, function);
case GTLCore::Type::HALF:
case GTLCore::Type::FLOAT:
- return FunctionCaller4<void, _TYPE_1_, _TYPE_2_, _TYPE_3_, float>::create(llvmFunction, function);
- break;
+ return FunctionCaller_void_bool_int_int_float::create(llvmFunction, function);
default:
- break;
- };
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
}
- return 0;
}
};
+// 4 2,0,0
+class FunctionCaller_void_unsigned_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ void (*PF)(unsigned int,int,int) = (void(*)(unsigned int,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_unsigned_int_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_unsigned_int_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_unsigned_int_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_unsigned_int_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_unsigned_int_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 3,0,0
+class FunctionCaller_void_float_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ void (*PF)(float,int,int) = (void(*)(float,int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_float_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_float_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_float_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_float_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_float_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 0,1,0
+class FunctionCaller_void_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ void (*PF)(int,bool,int) = (void(*)(int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_int_bool_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_int_bool_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_int_bool_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_int_bool_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_int_bool_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 1,1,0
+class FunctionCaller_void_bool_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ void (*PF)(bool,bool,int) = (void(*)(bool,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_bool_bool_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_bool_bool_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_bool_bool_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_bool_bool_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_bool_bool_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 2,1,0
+class FunctionCaller_void_unsigned_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ void (*PF)(unsigned int,bool,int) = (void(*)(unsigned int,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_unsigned_int_bool_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_unsigned_int_bool_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_unsigned_int_bool_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_unsigned_int_bool_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_unsigned_int_bool_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 3,1,0
+class FunctionCaller_void_float_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ void (*PF)(float,bool,int) = (void(*)(float,bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_float_bool_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_float_bool_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_float_bool_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_float_bool_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_float_bool_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 0,2,0
+class FunctionCaller_void_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ void (*PF)(int,unsigned int,int) = (void(*)(int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_int_unsigned_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_int_unsigned_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_int_unsigned_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_int_unsigned_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 1,2,0
+class FunctionCaller_void_bool_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ void (*PF)(bool,unsigned int,int) = (void(*)(bool,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_bool_unsigned_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_bool_unsigned_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_bool_unsigned_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_bool_unsigned_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_bool_unsigned_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 2,2,0
+class FunctionCaller_void_unsigned_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ void (*PF)(unsigned int,unsigned int,int) = (void(*)(unsigned int,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_unsigned_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_unsigned_int_unsigned_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_unsigned_int_unsigned_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_unsigned_int_unsigned_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_unsigned_int_unsigned_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 3,2,0
+class FunctionCaller_void_float_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ void (*PF)(float,unsigned int,int) = (void(*)(float,unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_float_unsigned_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_float_unsigned_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_float_unsigned_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_float_unsigned_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_float_unsigned_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 0,3,0
+class FunctionCaller_void_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ void (*PF)(int,float,int) = (void(*)(int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_int_float_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_int_float_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_int_float_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_int_float_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_int_float_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 1,3,0
+class FunctionCaller_void_bool_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ void (*PF)(bool,float,int) = (void(*)(bool,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_bool_float_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_bool_float_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_bool_float_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_bool_float_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_bool_float_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 2,3,0
+class FunctionCaller_void_unsigned_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ void (*PF)(unsigned int,float,int) = (void(*)(unsigned int,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_unsigned_int_float_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_unsigned_int_float_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_unsigned_int_float_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_unsigned_int_float_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_unsigned_int_float_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 3,3,0
+class FunctionCaller_void_float_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int arg3 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[2] );
+ void (*PF)(float,float,int) = (void(*)(float,float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_float_float_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_float_float_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_float_float_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_float_float_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_float_float_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 0,0,1
+class FunctionCaller_void_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ void (*PF)(int,int,bool) = (void(*)(int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_int_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_int_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_int_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_int_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_int_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 1,0,1
+class FunctionCaller_void_bool_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ void (*PF)(bool,int,bool) = (void(*)(bool,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_bool_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_bool_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_bool_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_bool_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_bool_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 2,0,1
+class FunctionCaller_void_unsigned_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ void (*PF)(unsigned int,int,bool) = (void(*)(unsigned int,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_unsigned_int_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_unsigned_int_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_unsigned_int_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_unsigned_int_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_unsigned_int_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 3,0,1
+class FunctionCaller_void_float_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ void (*PF)(float,int,bool) = (void(*)(float,int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_float_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_float_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_float_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_float_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_float_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 0,1,1
+class FunctionCaller_void_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ void (*PF)(int,bool,bool) = (void(*)(int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_int_bool_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_int_bool_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_int_bool_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_int_bool_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_int_bool_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 1,1,1
+class FunctionCaller_void_bool_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ void (*PF)(bool,bool,bool) = (void(*)(bool,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_bool_bool_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_bool_bool_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_bool_bool_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_bool_bool_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_bool_bool_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 2,1,1
+class FunctionCaller_void_unsigned_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ void (*PF)(unsigned int,bool,bool) = (void(*)(unsigned int,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_unsigned_int_bool_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_unsigned_int_bool_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_unsigned_int_bool_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_unsigned_int_bool_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_unsigned_int_bool_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 3,1,1
+class FunctionCaller_void_float_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ void (*PF)(float,bool,bool) = (void(*)(float,bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_float_bool_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_float_bool_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_float_bool_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_float_bool_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_float_bool_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 0,2,1
+class FunctionCaller_void_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ void (*PF)(int,unsigned int,bool) = (void(*)(int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_int_unsigned_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_int_unsigned_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_int_unsigned_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_int_unsigned_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 1,2,1
+class FunctionCaller_void_bool_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ void (*PF)(bool,unsigned int,bool) = (void(*)(bool,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_bool_unsigned_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_bool_unsigned_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_bool_unsigned_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_bool_unsigned_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_bool_unsigned_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 2,2,1
+class FunctionCaller_void_unsigned_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ void (*PF)(unsigned int,unsigned int,bool) = (void(*)(unsigned int,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_unsigned_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_unsigned_int_unsigned_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_unsigned_int_unsigned_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_unsigned_int_unsigned_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_unsigned_int_unsigned_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 3,2,1
+class FunctionCaller_void_float_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ void (*PF)(float,unsigned int,bool) = (void(*)(float,unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_float_unsigned_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_float_unsigned_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_float_unsigned_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_float_unsigned_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_float_unsigned_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 0,3,1
+class FunctionCaller_void_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ void (*PF)(int,float,bool) = (void(*)(int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_int_float_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_int_float_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_int_float_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_int_float_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_int_float_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 1,3,1
+class FunctionCaller_void_bool_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ void (*PF)(bool,float,bool) = (void(*)(bool,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_bool_float_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_bool_float_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_bool_float_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_bool_float_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_bool_float_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 2,3,1
+class FunctionCaller_void_unsigned_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ void (*PF)(unsigned int,float,bool) = (void(*)(unsigned int,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_unsigned_int_float_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_unsigned_int_float_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_unsigned_int_float_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_unsigned_int_float_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_unsigned_int_float_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 3,3,1
+class FunctionCaller_void_float_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool arg3 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[2] );
+ void (*PF)(float,float,bool) = (void(*)(float,float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_float_float_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_float_float_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_float_float_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_float_float_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_float_float_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 0,0,2
+class FunctionCaller_void_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ void (*PF)(int,int,unsigned int) = (void(*)(int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_int_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_int_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_int_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_int_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 1,0,2
+class FunctionCaller_void_bool_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ void (*PF)(bool,int,unsigned int) = (void(*)(bool,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_bool_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_bool_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_bool_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_bool_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_bool_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 2,0,2
+class FunctionCaller_void_unsigned_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ void (*PF)(unsigned int,int,unsigned int) = (void(*)(unsigned int,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_unsigned_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_unsigned_int_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_unsigned_int_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_unsigned_int_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_unsigned_int_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 3,0,2
+class FunctionCaller_void_float_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ void (*PF)(float,int,unsigned int) = (void(*)(float,int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_float_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_float_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_float_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_float_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_float_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 0,1,2
+class FunctionCaller_void_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ void (*PF)(int,bool,unsigned int) = (void(*)(int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_int_bool_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_int_bool_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_int_bool_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_int_bool_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 1,1,2
+class FunctionCaller_void_bool_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ void (*PF)(bool,bool,unsigned int) = (void(*)(bool,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_bool_bool_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_bool_bool_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_bool_bool_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_bool_bool_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_bool_bool_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 2,1,2
+class FunctionCaller_void_unsigned_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ void (*PF)(unsigned int,bool,unsigned int) = (void(*)(unsigned int,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_unsigned_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_unsigned_int_bool_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_unsigned_int_bool_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_unsigned_int_bool_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_unsigned_int_bool_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 3,1,2
+class FunctionCaller_void_float_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ void (*PF)(float,bool,unsigned int) = (void(*)(float,bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_float_bool_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_float_bool_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_float_bool_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_float_bool_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_float_bool_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 0,2,2
+class FunctionCaller_void_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ void (*PF)(int,unsigned int,unsigned int) = (void(*)(int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_int_unsigned_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_int_unsigned_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_int_unsigned_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_int_unsigned_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 1,2,2
+class FunctionCaller_void_bool_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ void (*PF)(bool,unsigned int,unsigned int) = (void(*)(bool,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_bool_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_bool_unsigned_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_bool_unsigned_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_bool_unsigned_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_bool_unsigned_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 2,2,2
+class FunctionCaller_void_unsigned_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ void (*PF)(unsigned int,unsigned int,unsigned int) = (void(*)(unsigned int,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_unsigned_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_unsigned_int_unsigned_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_unsigned_int_unsigned_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_unsigned_int_unsigned_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_unsigned_int_unsigned_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 3,2,2
+class FunctionCaller_void_float_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ void (*PF)(float,unsigned int,unsigned int) = (void(*)(float,unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_float_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_float_unsigned_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_float_unsigned_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_float_unsigned_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_float_unsigned_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 0,3,2
+class FunctionCaller_void_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ void (*PF)(int,float,unsigned int) = (void(*)(int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_int_float_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_int_float_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_int_float_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_int_float_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 1,3,2
+class FunctionCaller_void_bool_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ void (*PF)(bool,float,unsigned int) = (void(*)(bool,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_bool_float_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_bool_float_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_bool_float_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_bool_float_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_bool_float_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 2,3,2
+class FunctionCaller_void_unsigned_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ void (*PF)(unsigned int,float,unsigned int) = (void(*)(unsigned int,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_unsigned_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_unsigned_int_float_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_unsigned_int_float_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_unsigned_int_float_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_unsigned_int_float_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 3,3,2
+class FunctionCaller_void_float_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int arg3 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[2] );
+ void (*PF)(float,float,unsigned int) = (void(*)(float,float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_float_float_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_float_float_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_float_float_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_float_float_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_float_float_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 0,0,3
+class FunctionCaller_void_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ void (*PF)(int,int,float) = (void(*)(int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_int_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_int_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_int_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_int_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_int_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 1,0,3
+class FunctionCaller_void_bool_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ void (*PF)(bool,int,float) = (void(*)(bool,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_bool_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_bool_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_bool_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_bool_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_bool_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 2,0,3
+class FunctionCaller_void_unsigned_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ void (*PF)(unsigned int,int,float) = (void(*)(unsigned int,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_unsigned_int_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_unsigned_int_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_unsigned_int_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_unsigned_int_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_unsigned_int_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 3,0,3
+class FunctionCaller_void_float_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ void (*PF)(float,int,float) = (void(*)(float,int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_float_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_float_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_float_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_float_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_float_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 0,1,3
+class FunctionCaller_void_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ void (*PF)(int,bool,float) = (void(*)(int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_int_bool_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_int_bool_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_int_bool_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_int_bool_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_int_bool_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 1,1,3
+class FunctionCaller_void_bool_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ void (*PF)(bool,bool,float) = (void(*)(bool,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_bool_bool_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_bool_bool_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_bool_bool_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_bool_bool_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_bool_bool_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 2,1,3
+class FunctionCaller_void_unsigned_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ void (*PF)(unsigned int,bool,float) = (void(*)(unsigned int,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_unsigned_int_bool_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_unsigned_int_bool_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_unsigned_int_bool_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_unsigned_int_bool_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_unsigned_int_bool_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 3,1,3
+class FunctionCaller_void_float_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ void (*PF)(float,bool,float) = (void(*)(float,bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_float_bool_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_float_bool_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_float_bool_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_float_bool_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_float_bool_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 0,2,3
+class FunctionCaller_void_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ void (*PF)(int,unsigned int,float) = (void(*)(int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_int_unsigned_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_int_unsigned_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_int_unsigned_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_int_unsigned_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 1,2,3
+class FunctionCaller_void_bool_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ void (*PF)(bool,unsigned int,float) = (void(*)(bool,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_bool_unsigned_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_bool_unsigned_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_bool_unsigned_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_bool_unsigned_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_bool_unsigned_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 2,2,3
+class FunctionCaller_void_unsigned_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ void (*PF)(unsigned int,unsigned int,float) = (void(*)(unsigned int,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_unsigned_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_unsigned_int_unsigned_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_unsigned_int_unsigned_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_unsigned_int_unsigned_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_unsigned_int_unsigned_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 3,2,3
+class FunctionCaller_void_float_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ void (*PF)(float,unsigned int,float) = (void(*)(float,unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_float_unsigned_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_float_unsigned_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_float_unsigned_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_float_unsigned_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_float_unsigned_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 0,3,3
+class FunctionCaller_void_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ void (*PF)(int,float,float) = (void(*)(int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_int_float_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_int_float_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_int_float_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_int_float_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_int_float_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 1,3,3
+class FunctionCaller_void_bool_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ void (*PF)(bool,float,float) = (void(*)(bool,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_bool_float_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_bool_float_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_bool_float_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_bool_float_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_bool_float_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 2,3,3
+class FunctionCaller_void_unsigned_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ void (*PF)(unsigned int,float,float) = (void(*)(unsigned int,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_unsigned_int_float_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_unsigned_int_float_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_unsigned_int_float_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_unsigned_int_float_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_unsigned_int_float_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 3,3,3
+class FunctionCaller_void_float_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 3);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float arg3 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[2] );
+ void (*PF)(float,float,float) = (void(*)(float,float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2,arg3);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 3 )
+ {
+ return new FunctionCaller_void_float_float_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[3].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_float_float_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_float_float_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_float_float_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_float_float_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
// Number of parameters = 2
-template<typename _TYPE_RETURN_, typename _TYPE_1_, typename _TYPE_2_>
-class FunctionCaller2 : public FunctionCaller {
+// 0 0,0
+class FunctionCaller_int_int_int : public FunctionCaller {
public:
- FunctionCaller2(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ FunctionCaller_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
{
}
virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
{
GTL_ASSERT(function());
GTL_ASSERT(arguments.size() == 2);
- _TYPE_1_ arg1 = GTLCore::PrimitiveTypeTrait<_TYPE_1_>::convert( arguments[0] );
- _TYPE_2_ arg2 = GTLCore::PrimitiveTypeTrait<_TYPE_2_>::convert( arguments[1] );
-
- _TYPE_RETURN_ (*PF)(_TYPE_1_,_TYPE_2_) = (_TYPE_RETURN_(*)(_TYPE_1_,_TYPE_2_)) VirtualMachine::instance()->getPointerToFunction(function());
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int (*PF)(int,int) = (int(*)(int,int)) VirtualMachine::instance()->getPointerToFunction(function());
return GTLCore::Value( PF(arg1,arg2) );
}
public:
static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
{
- if(function->parameters().size() == 2)
+ if( function->parameters().size() == 2 )
{
- return new FunctionCaller2<_TYPE_RETURN_, _TYPE_1_, _TYPE_2_>(llvmFunction, function);
+ return new FunctionCaller_int_int_int(llvmFunction, function);
} else {
- switch( function->parameters()[0].type()->dataType() )
+ switch( function->parameters()[2].type()->dataType() )
{
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_int_int_int::create(llvmFunction, function);
case GTLCore::Type::BOOLEAN:
- return FunctionCaller3<_TYPE_RETURN_, _TYPE_1_, _TYPE_2_, bool>::create(llvmFunction, function);
- break;
+ return FunctionCaller_int_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 1,0
+class FunctionCaller_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int (*PF)(bool,int) = (int(*)(bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_int_bool_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
case GTLCore::Type::INTEGER32:
- return FunctionCaller3<_TYPE_RETURN_, _TYPE_1_, _TYPE_2_, int>::create(llvmFunction, function);
- break;
+ return FunctionCaller_int_bool_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_bool_int_bool::create(llvmFunction, function);
case GTLCore::Type::UNSIGNED_INTEGER32:
- return FunctionCaller3<_TYPE_RETURN_, _TYPE_1_, _TYPE_2_, unsigned int>::create(llvmFunction, function);
- break;
+ return FunctionCaller_int_bool_int_unsigned_int::create(llvmFunction, function);
case GTLCore::Type::HALF:
case GTLCore::Type::FLOAT:
- return FunctionCaller3<_TYPE_RETURN_, _TYPE_1_, _TYPE_2_, float>::create(llvmFunction, function);
- break;
+ return FunctionCaller_int_bool_int_float::create(llvmFunction, function);
default:
- break;
- };
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
}
- return 0;
}
};
-template< typename _TYPE_1_, typename _TYPE_2_>
-class FunctionCaller2<void , _TYPE_1_, _TYPE_2_> : public FunctionCaller {
+// 0 2,0
+class FunctionCaller_int_unsigned_int_int : public FunctionCaller {
public:
- FunctionCaller2(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ FunctionCaller_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
{
}
virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
{
GTL_ASSERT(function());
GTL_ASSERT(arguments.size() == 2);
- _TYPE_1_ arg1 = GTLCore::PrimitiveTypeTrait<_TYPE_1_>::convert( arguments[0] );
- _TYPE_2_ arg2 = GTLCore::PrimitiveTypeTrait<_TYPE_2_>::convert( arguments[1] );
-
- void (*PF)(_TYPE_1_,_TYPE_2_) = (void(*)(_TYPE_1_,_TYPE_2_)) VirtualMachine::instance()->getPointerToFunction(function());
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int (*PF)(unsigned int,int) = (int(*)(unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_unsigned_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_unsigned_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_unsigned_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_unsigned_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 3,0
+class FunctionCaller_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ int (*PF)(float,int) = (int(*)(float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_int_float_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_float_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_float_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_float_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_float_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 0,1
+class FunctionCaller_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int (*PF)(int,bool) = (int(*)(int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_int_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 1,1
+class FunctionCaller_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int (*PF)(bool,bool) = (int(*)(bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_int_bool_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_bool_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_bool_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_bool_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_bool_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 2,1
+class FunctionCaller_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int (*PF)(unsigned int,bool) = (int(*)(unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_unsigned_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_unsigned_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_unsigned_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_unsigned_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 3,1
+class FunctionCaller_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ int (*PF)(float,bool) = (int(*)(float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_int_float_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_float_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_float_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_float_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_float_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 0,2
+class FunctionCaller_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int (*PF)(int,unsigned int) = (int(*)(int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 1,2
+class FunctionCaller_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int (*PF)(bool,unsigned int) = (int(*)(bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_bool_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_bool_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_bool_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_bool_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 2,2
+class FunctionCaller_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int (*PF)(unsigned int,unsigned int) = (int(*)(unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_unsigned_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_unsigned_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_unsigned_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_unsigned_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 3,2
+class FunctionCaller_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ int (*PF)(float,unsigned int) = (int(*)(float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_float_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_float_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_float_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_float_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 0,3
+class FunctionCaller_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int (*PF)(int,float) = (int(*)(int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_int_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 1,3
+class FunctionCaller_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int (*PF)(bool,float) = (int(*)(bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_int_bool_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_bool_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_bool_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_bool_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_bool_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 2,3
+class FunctionCaller_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int (*PF)(unsigned int,float) = (int(*)(unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_unsigned_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_unsigned_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_unsigned_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_unsigned_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 3,3
+class FunctionCaller_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ int (*PF)(float,float) = (int(*)(float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_int_float_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_float_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_float_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_float_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_float_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 0,0
+class FunctionCaller_bool_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool (*PF)(int,int) = (bool(*)(int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_bool_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 1,0
+class FunctionCaller_bool_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool (*PF)(bool,int) = (bool(*)(bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_bool_bool_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_bool_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_bool_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_bool_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_bool_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 2,0
+class FunctionCaller_bool_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool (*PF)(unsigned int,int) = (bool(*)(unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_bool_unsigned_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_unsigned_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_unsigned_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_unsigned_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_unsigned_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 3,0
+class FunctionCaller_bool_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ bool (*PF)(float,int) = (bool(*)(float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_bool_float_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_float_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_float_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_float_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_float_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 0,1
+class FunctionCaller_bool_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool (*PF)(int,bool) = (bool(*)(int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_bool_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 1,1
+class FunctionCaller_bool_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool (*PF)(bool,bool) = (bool(*)(bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_bool_bool_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_bool_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_bool_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_bool_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_bool_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 2,1
+class FunctionCaller_bool_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool (*PF)(unsigned int,bool) = (bool(*)(unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_bool_unsigned_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_unsigned_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_unsigned_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_unsigned_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_unsigned_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 3,1
+class FunctionCaller_bool_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ bool (*PF)(float,bool) = (bool(*)(float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_bool_float_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_float_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_float_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_float_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_float_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 0,2
+class FunctionCaller_bool_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool (*PF)(int,unsigned int) = (bool(*)(int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_bool_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 1,2
+class FunctionCaller_bool_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool (*PF)(bool,unsigned int) = (bool(*)(bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_bool_bool_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_bool_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_bool_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_bool_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_bool_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 2,2
+class FunctionCaller_bool_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool (*PF)(unsigned int,unsigned int) = (bool(*)(unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_bool_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_unsigned_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_unsigned_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_unsigned_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_unsigned_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 3,2
+class FunctionCaller_bool_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ bool (*PF)(float,unsigned int) = (bool(*)(float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_bool_float_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_float_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_float_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_float_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_float_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 0,3
+class FunctionCaller_bool_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool (*PF)(int,float) = (bool(*)(int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_bool_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 1,3
+class FunctionCaller_bool_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool (*PF)(bool,float) = (bool(*)(bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_bool_bool_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_bool_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_bool_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_bool_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_bool_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 2,3
+class FunctionCaller_bool_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool (*PF)(unsigned int,float) = (bool(*)(unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_bool_unsigned_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_unsigned_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_unsigned_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_unsigned_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_unsigned_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 3,3
+class FunctionCaller_bool_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ bool (*PF)(float,float) = (bool(*)(float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_bool_float_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_float_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_float_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_float_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_float_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 0,0
+class FunctionCaller_unsigned_int_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int (*PF)(int,int) = (unsigned int(*)(int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_unsigned_int_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 1,0
+class FunctionCaller_unsigned_int_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int (*PF)(bool,int) = (unsigned int(*)(bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_unsigned_int_bool_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_bool_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_bool_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_bool_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_bool_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 2,0
+class FunctionCaller_unsigned_int_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int (*PF)(unsigned int,int) = (unsigned int(*)(unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_unsigned_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_unsigned_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 3,0
+class FunctionCaller_unsigned_int_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ unsigned int (*PF)(float,int) = (unsigned int(*)(float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_unsigned_int_float_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_float_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_float_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_float_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_float_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 0,1
+class FunctionCaller_unsigned_int_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int (*PF)(int,bool) = (unsigned int(*)(int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_unsigned_int_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 1,1
+class FunctionCaller_unsigned_int_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int (*PF)(bool,bool) = (unsigned int(*)(bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_unsigned_int_bool_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_bool_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_bool_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_bool_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_bool_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 2,1
+class FunctionCaller_unsigned_int_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int (*PF)(unsigned int,bool) = (unsigned int(*)(unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_unsigned_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_unsigned_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 3,1
+class FunctionCaller_unsigned_int_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ unsigned int (*PF)(float,bool) = (unsigned int(*)(float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_unsigned_int_float_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_float_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_float_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_float_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_float_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 0,2
+class FunctionCaller_unsigned_int_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int (*PF)(int,unsigned int) = (unsigned int(*)(int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_unsigned_int_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 1,2
+class FunctionCaller_unsigned_int_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int (*PF)(bool,unsigned int) = (unsigned int(*)(bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_unsigned_int_bool_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_bool_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_bool_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_bool_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_bool_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 2,2
+class FunctionCaller_unsigned_int_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int (*PF)(unsigned int,unsigned int) = (unsigned int(*)(unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_unsigned_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_unsigned_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 3,2
+class FunctionCaller_unsigned_int_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ unsigned int (*PF)(float,unsigned int) = (unsigned int(*)(float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_unsigned_int_float_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_float_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_float_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_float_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_float_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 0,3
+class FunctionCaller_unsigned_int_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int (*PF)(int,float) = (unsigned int(*)(int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_unsigned_int_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 1,3
+class FunctionCaller_unsigned_int_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int (*PF)(bool,float) = (unsigned int(*)(bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_unsigned_int_bool_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_bool_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_bool_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_bool_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_bool_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 2,3
+class FunctionCaller_unsigned_int_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int (*PF)(unsigned int,float) = (unsigned int(*)(unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_unsigned_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_unsigned_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 3,3
+class FunctionCaller_unsigned_int_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ unsigned int (*PF)(float,float) = (unsigned int(*)(float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_unsigned_int_float_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_float_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_float_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_float_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_float_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 0,0
+class FunctionCaller_float_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float (*PF)(int,int) = (float(*)(int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_float_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 1,0
+class FunctionCaller_float_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float (*PF)(bool,int) = (float(*)(bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_float_bool_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_bool_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_bool_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_bool_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_bool_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 2,0
+class FunctionCaller_float_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float (*PF)(unsigned int,int) = (float(*)(unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_float_unsigned_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_unsigned_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_unsigned_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_unsigned_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_unsigned_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 3,0
+class FunctionCaller_float_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ float (*PF)(float,int) = (float(*)(float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_float_float_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_float_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_float_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_float_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_float_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 0,1
+class FunctionCaller_float_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float (*PF)(int,bool) = (float(*)(int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_float_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 1,1
+class FunctionCaller_float_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float (*PF)(bool,bool) = (float(*)(bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_float_bool_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_bool_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_bool_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_bool_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_bool_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 2,1
+class FunctionCaller_float_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float (*PF)(unsigned int,bool) = (float(*)(unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_float_unsigned_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_unsigned_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_unsigned_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_unsigned_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_unsigned_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 3,1
+class FunctionCaller_float_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ float (*PF)(float,bool) = (float(*)(float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_float_float_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_float_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_float_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_float_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_float_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 0,2
+class FunctionCaller_float_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float (*PF)(int,unsigned int) = (float(*)(int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_float_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 1,2
+class FunctionCaller_float_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float (*PF)(bool,unsigned int) = (float(*)(bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_float_bool_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_bool_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_bool_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_bool_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_bool_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 2,2
+class FunctionCaller_float_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float (*PF)(unsigned int,unsigned int) = (float(*)(unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_float_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_unsigned_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_unsigned_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_unsigned_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_unsigned_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 3,2
+class FunctionCaller_float_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ float (*PF)(float,unsigned int) = (float(*)(float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_float_float_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_float_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_float_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_float_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_float_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 0,3
+class FunctionCaller_float_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float (*PF)(int,float) = (float(*)(int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_float_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 1,3
+class FunctionCaller_float_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float (*PF)(bool,float) = (float(*)(bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_float_bool_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_bool_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_bool_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_bool_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_bool_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 2,3
+class FunctionCaller_float_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float (*PF)(unsigned int,float) = (float(*)(unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_float_unsigned_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_unsigned_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_unsigned_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_unsigned_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_unsigned_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 3,3
+class FunctionCaller_float_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ float (*PF)(float,float) = (float(*)(float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1,arg2) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_float_float_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_float_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_float_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_float_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_float_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 0,0
+class FunctionCaller_void_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ void (*PF)(int,int) = (void(*)(int,int)) VirtualMachine::instance()->getPointerToFunction(function());
PF(arg1,arg2);
- return GTLCore::Value( );
+ return GTLCore::Value();
}
public:
static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
{
- if(function->parameters().size() == 2)
+ if( function->parameters().size() == 2 )
{
- return new FunctionCaller2<void, _TYPE_1_, _TYPE_2_>(llvmFunction, function);
+ return new FunctionCaller_void_int_int(llvmFunction, function);
} else {
- switch( function->parameters()[0].type()->dataType() )
+ switch( function->parameters()[2].type()->dataType() )
{
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_int_int_int::create(llvmFunction, function);
case GTLCore::Type::BOOLEAN:
- return FunctionCaller3<void, _TYPE_1_, _TYPE_2_, bool>::create(llvmFunction, function);
- break;
+ return FunctionCaller_void_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 1,0
+class FunctionCaller_void_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ void (*PF)(bool,int) = (void(*)(bool,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_void_bool_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
case GTLCore::Type::INTEGER32:
- return FunctionCaller3<void, _TYPE_1_, _TYPE_2_, int>::create(llvmFunction, function);
- break;
+ return FunctionCaller_void_bool_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_bool_int_bool::create(llvmFunction, function);
case GTLCore::Type::UNSIGNED_INTEGER32:
- return FunctionCaller3<void, _TYPE_1_, _TYPE_2_, unsigned int>::create(llvmFunction, function);
- break;
+ return FunctionCaller_void_bool_int_unsigned_int::create(llvmFunction, function);
case GTLCore::Type::HALF:
case GTLCore::Type::FLOAT:
- return FunctionCaller3<void, _TYPE_1_, _TYPE_2_, float>::create(llvmFunction, function);
- break;
+ return FunctionCaller_void_bool_int_float::create(llvmFunction, function);
default:
- break;
- };
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
}
- return 0;
}
};
+// 4 2,0
+class FunctionCaller_void_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ void (*PF)(unsigned int,int) = (void(*)(unsigned int,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_void_unsigned_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_unsigned_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_unsigned_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_unsigned_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_unsigned_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 3,0
+class FunctionCaller_void_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int arg2 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[1] );
+ void (*PF)(float,int) = (void(*)(float,int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_void_float_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_float_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_float_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_float_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_float_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 0,1
+class FunctionCaller_void_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ void (*PF)(int,bool) = (void(*)(int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_void_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 1,1
+class FunctionCaller_void_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ void (*PF)(bool,bool) = (void(*)(bool,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_void_bool_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_bool_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_bool_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_bool_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_bool_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 2,1
+class FunctionCaller_void_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ void (*PF)(unsigned int,bool) = (void(*)(unsigned int,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_void_unsigned_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_unsigned_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_unsigned_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_unsigned_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_unsigned_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 3,1
+class FunctionCaller_void_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool arg2 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[1] );
+ void (*PF)(float,bool) = (void(*)(float,bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_void_float_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_float_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_float_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_float_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_float_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 0,2
+class FunctionCaller_void_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ void (*PF)(int,unsigned int) = (void(*)(int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_void_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 1,2
+class FunctionCaller_void_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ void (*PF)(bool,unsigned int) = (void(*)(bool,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_void_bool_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_bool_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_bool_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_bool_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_bool_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 2,2
+class FunctionCaller_void_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ void (*PF)(unsigned int,unsigned int) = (void(*)(unsigned int,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_void_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_unsigned_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_unsigned_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_unsigned_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_unsigned_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 3,2
+class FunctionCaller_void_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int arg2 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[1] );
+ void (*PF)(float,unsigned int) = (void(*)(float,unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_void_float_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_float_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_float_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_float_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_float_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 0,3
+class FunctionCaller_void_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ void (*PF)(int,float) = (void(*)(int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_void_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 1,3
+class FunctionCaller_void_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ void (*PF)(bool,float) = (void(*)(bool,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_void_bool_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_bool_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_bool_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_bool_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_bool_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 2,3
+class FunctionCaller_void_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ void (*PF)(unsigned int,float) = (void(*)(unsigned int,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_void_unsigned_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_unsigned_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_unsigned_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_unsigned_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_unsigned_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 3,3
+class FunctionCaller_void_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 2);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float arg2 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[1] );
+ void (*PF)(float,float) = (void(*)(float,float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1,arg2);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 2 )
+ {
+ return new FunctionCaller_void_float_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[2].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_float_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_float_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_float_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_float_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
// Number of parameters = 1
-template<typename _TYPE_RETURN_, typename _TYPE_1_>
-class FunctionCaller1 : public FunctionCaller {
+// 0 0
+class FunctionCaller_int_int : public FunctionCaller {
public:
- FunctionCaller1(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ FunctionCaller_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
{
}
virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
{
GTL_ASSERT(function());
GTL_ASSERT(arguments.size() == 1);
- _TYPE_1_ arg1 = GTLCore::PrimitiveTypeTrait<_TYPE_1_>::convert( arguments[0] );
-
- _TYPE_RETURN_ (*PF)(_TYPE_1_) = (_TYPE_RETURN_(*)(_TYPE_1_)) VirtualMachine::instance()->getPointerToFunction(function());
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ int (*PF)(int) = (int(*)(int)) VirtualMachine::instance()->getPointerToFunction(function());
return GTLCore::Value( PF(arg1) );
}
public:
static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
{
- if(function->parameters().size() == 1)
+ if( function->parameters().size() == 1 )
{
- return new FunctionCaller1<_TYPE_RETURN_, _TYPE_1_>(llvmFunction, function);
+ return new FunctionCaller_int_int(llvmFunction, function);
} else {
- switch( function->parameters()[0].type()->dataType() )
+ switch( function->parameters()[1].type()->dataType() )
{
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_int_int::create(llvmFunction, function);
case GTLCore::Type::BOOLEAN:
- return FunctionCaller2<_TYPE_RETURN_, _TYPE_1_, bool>::create(llvmFunction, function);
- break;
+ return FunctionCaller_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 1
+class FunctionCaller_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 1);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ int (*PF)(bool) = (int(*)(bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 1 )
+ {
+ return new FunctionCaller_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[1].type()->dataType() )
+ {
case GTLCore::Type::INTEGER32:
- return FunctionCaller2<_TYPE_RETURN_, _TYPE_1_, int>::create(llvmFunction, function);
- break;
+ return FunctionCaller_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_bool_bool::create(llvmFunction, function);
case GTLCore::Type::UNSIGNED_INTEGER32:
- return FunctionCaller2<_TYPE_RETURN_, _TYPE_1_, unsigned int>::create(llvmFunction, function);
- break;
+ return FunctionCaller_int_bool_unsigned_int::create(llvmFunction, function);
case GTLCore::Type::HALF:
case GTLCore::Type::FLOAT:
- return FunctionCaller2<_TYPE_RETURN_, _TYPE_1_, float>::create(llvmFunction, function);
- break;
+ return FunctionCaller_int_bool_float::create(llvmFunction, function);
default:
- break;
- };
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
}
- return 0;
}
};
-template< typename _TYPE_1_>
-class FunctionCaller1<void , _TYPE_1_> : public FunctionCaller {
+// 0 2
+class FunctionCaller_int_unsigned_int : public FunctionCaller {
public:
- FunctionCaller1(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ FunctionCaller_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
{
}
virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
{
GTL_ASSERT(function());
GTL_ASSERT(arguments.size() == 1);
- _TYPE_1_ arg1 = GTLCore::PrimitiveTypeTrait<_TYPE_1_>::convert( arguments[0] );
-
- void (*PF)(_TYPE_1_) = (void(*)(_TYPE_1_)) VirtualMachine::instance()->getPointerToFunction(function());
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ int (*PF)(unsigned int) = (int(*)(unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 1 )
+ {
+ return new FunctionCaller_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[1].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 0 3
+class FunctionCaller_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 1);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ int (*PF)(float) = (int(*)(float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 1 )
+ {
+ return new FunctionCaller_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[1].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 0
+class FunctionCaller_bool_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 1);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ bool (*PF)(int) = (bool(*)(int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 1 )
+ {
+ return new FunctionCaller_bool_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[1].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 1
+class FunctionCaller_bool_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 1);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ bool (*PF)(bool) = (bool(*)(bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 1 )
+ {
+ return new FunctionCaller_bool_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[1].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 2
+class FunctionCaller_bool_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_bool_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 1);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ bool (*PF)(unsigned int) = (bool(*)(unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 1 )
+ {
+ return new FunctionCaller_bool_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[1].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1 3
+class FunctionCaller_bool_float : public FunctionCaller {
+ public:
+ FunctionCaller_bool_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 1);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ bool (*PF)(float) = (bool(*)(float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 1 )
+ {
+ return new FunctionCaller_bool_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[1].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_bool_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_bool_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_bool_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 0
+class FunctionCaller_unsigned_int_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 1);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ unsigned int (*PF)(int) = (unsigned int(*)(int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 1 )
+ {
+ return new FunctionCaller_unsigned_int_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[1].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 1
+class FunctionCaller_unsigned_int_bool : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 1);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ unsigned int (*PF)(bool) = (unsigned int(*)(bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 1 )
+ {
+ return new FunctionCaller_unsigned_int_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[1].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 2
+class FunctionCaller_unsigned_int_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 1);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ unsigned int (*PF)(unsigned int) = (unsigned int(*)(unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 1 )
+ {
+ return new FunctionCaller_unsigned_int_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[1].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 2 3
+class FunctionCaller_unsigned_int_float : public FunctionCaller {
+ public:
+ FunctionCaller_unsigned_int_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 1);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ unsigned int (*PF)(float) = (unsigned int(*)(float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 1 )
+ {
+ return new FunctionCaller_unsigned_int_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[1].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 0
+class FunctionCaller_float_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 1);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ float (*PF)(int) = (float(*)(int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 1 )
+ {
+ return new FunctionCaller_float_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[1].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 1
+class FunctionCaller_float_bool : public FunctionCaller {
+ public:
+ FunctionCaller_float_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 1);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ float (*PF)(bool) = (float(*)(bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 1 )
+ {
+ return new FunctionCaller_float_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[1].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_bool_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_bool_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_bool_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 2
+class FunctionCaller_float_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_float_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 1);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ float (*PF)(unsigned int) = (float(*)(unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 1 )
+ {
+ return new FunctionCaller_float_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[1].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3 3
+class FunctionCaller_float_float : public FunctionCaller {
+ public:
+ FunctionCaller_float_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 1);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ float (*PF)(float) = (float(*)(float)) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF(arg1) );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 1 )
+ {
+ return new FunctionCaller_float_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[1].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 0
+class FunctionCaller_void_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 1);
+ int arg1 = GTLCore::PrimitiveTypeTrait<int>::convert( arguments[0] );
+ void (*PF)(int) = (void(*)(int)) VirtualMachine::instance()->getPointerToFunction(function());
PF(arg1);
- return GTLCore::Value( );
+ return GTLCore::Value();
}
public:
static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
{
- if(function->parameters().size() == 1)
+ if( function->parameters().size() == 1 )
{
- return new FunctionCaller1<void, _TYPE_1_>(llvmFunction, function);
+ return new FunctionCaller_void_int(llvmFunction, function);
} else {
- switch( function->parameters()[0].type()->dataType() )
+ switch( function->parameters()[1].type()->dataType() )
{
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_int_int::create(llvmFunction, function);
case GTLCore::Type::BOOLEAN:
- return FunctionCaller2<void, _TYPE_1_, bool>::create(llvmFunction, function);
- break;
+ return FunctionCaller_void_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 1
+class FunctionCaller_void_bool : public FunctionCaller {
+ public:
+ FunctionCaller_void_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 1);
+ bool arg1 = GTLCore::PrimitiveTypeTrait<bool>::convert( arguments[0] );
+ void (*PF)(bool) = (void(*)(bool)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 1 )
+ {
+ return new FunctionCaller_void_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[1].type()->dataType() )
+ {
case GTLCore::Type::INTEGER32:
- return FunctionCaller2<void, _TYPE_1_, int>::create(llvmFunction, function);
- break;
+ return FunctionCaller_void_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_bool_bool::create(llvmFunction, function);
case GTLCore::Type::UNSIGNED_INTEGER32:
- return FunctionCaller2<void, _TYPE_1_, unsigned int>::create(llvmFunction, function);
- break;
+ return FunctionCaller_void_bool_unsigned_int::create(llvmFunction, function);
case GTLCore::Type::HALF:
case GTLCore::Type::FLOAT:
- return FunctionCaller2<void, _TYPE_1_, float>::create(llvmFunction, function);
- break;
+ return FunctionCaller_void_bool_float::create(llvmFunction, function);
default:
- break;
- };
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
}
- return 0;
}
};
+// 4 2
+class FunctionCaller_void_unsigned_int : public FunctionCaller {
+ public:
+ FunctionCaller_void_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 1);
+ unsigned int arg1 = GTLCore::PrimitiveTypeTrait<unsigned int>::convert( arguments[0] );
+ void (*PF)(unsigned int) = (void(*)(unsigned int)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 1 )
+ {
+ return new FunctionCaller_void_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[1].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4 3
+class FunctionCaller_void_float : public FunctionCaller {
+ public:
+ FunctionCaller_void_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 1);
+ float arg1 = GTLCore::PrimitiveTypeTrait<float>::convert( arguments[0] );
+ void (*PF)(float) = (void(*)(float)) VirtualMachine::instance()->getPointerToFunction(function());
+ PF(arg1);
+ return GTLCore::Value();
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 1 )
+ {
+ return new FunctionCaller_void_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[1].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_void_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_void_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_void_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
// Number of parameters = 0
-template<typename _TYPE_RETURN_>
-class FunctionCaller0 : public FunctionCaller {
+// 0
+class FunctionCaller_int : public FunctionCaller {
public:
- FunctionCaller0(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ FunctionCaller_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
{
}
virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
{
GTL_ASSERT(function());
GTL_ASSERT(arguments.size() == 0);
-
- _TYPE_RETURN_ (*PF)() = (_TYPE_RETURN_(*)()) VirtualMachine::instance()->getPointerToFunction(function());
+ int (*PF)() = (int(*)()) VirtualMachine::instance()->getPointerToFunction(function());
return GTLCore::Value( PF() );
}
public:
static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
{
- if(function->parameters().size() == 0)
+ if( function->parameters().size() == 0 )
{
- return new FunctionCaller0<_TYPE_RETURN_>(llvmFunction, function);
+ return new FunctionCaller_int(llvmFunction, function);
} else {
switch( function->parameters()[0].type()->dataType() )
{
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int_int::create(llvmFunction, function);
case GTLCore::Type::BOOLEAN:
- return FunctionCaller1<_TYPE_RETURN_, bool>::create(llvmFunction, function);
- break;
+ return FunctionCaller_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 1
+class FunctionCaller_bool : public FunctionCaller {
+ public:
+ FunctionCaller_bool(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 0);
+ bool (*PF)() = (bool(*)()) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF() );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 0 )
+ {
+ return new FunctionCaller_bool(llvmFunction, function);
+ } else {
+ switch( function->parameters()[0].type()->dataType() )
+ {
case GTLCore::Type::INTEGER32:
- return FunctionCaller1<_TYPE_RETURN_, int>::create(llvmFunction, function);
- break;
+ return FunctionCaller_bool_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool_bool::create(llvmFunction, function);
case GTLCore::Type::UNSIGNED_INTEGER32:
- return FunctionCaller1<_TYPE_RETURN_, unsigned int>::create(llvmFunction, function);
- break;
+ return FunctionCaller_bool_unsigned_int::create(llvmFunction, function);
case GTLCore::Type::HALF:
case GTLCore::Type::FLOAT:
- return FunctionCaller1<_TYPE_RETURN_, float>::create(llvmFunction, function);
- break;
+ return FunctionCaller_bool_float::create(llvmFunction, function);
default:
- break;
- };
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
}
- return 0;
}
};
-template<>
-class FunctionCaller0<void > : public FunctionCaller {
+// 2
+class FunctionCaller_unsigned_int : public FunctionCaller {
public:
- FunctionCaller0(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ FunctionCaller_unsigned_int(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
{
}
virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
{
GTL_ASSERT(function());
GTL_ASSERT(arguments.size() == 0);
-
+ unsigned int (*PF)() = (unsigned int(*)()) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF() );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 0 )
+ {
+ return new FunctionCaller_unsigned_int(llvmFunction, function);
+ } else {
+ switch( function->parameters()[0].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_unsigned_int_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_unsigned_int_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_unsigned_int_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 3
+class FunctionCaller_float : public FunctionCaller {
+ public:
+ FunctionCaller_float(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 0);
+ float (*PF)() = (float(*)()) VirtualMachine::instance()->getPointerToFunction(function());
+ return GTLCore::Value( PF() );
+ }
+ public:
+ static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
+ {
+ if( function->parameters().size() == 0 )
+ {
+ return new FunctionCaller_float(llvmFunction, function);
+ } else {
+ switch( function->parameters()[0].type()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_float_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_float_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_float_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float_float::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ }
+ }
+};
+// 4
+class FunctionCaller_void : public FunctionCaller {
+ public:
+ FunctionCaller_void(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ {
+ }
+ virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
+ {
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == 0);
void (*PF)() = (void(*)()) VirtualMachine::instance()->getPointerToFunction(function());
PF();
- return GTLCore::Value( );
+ return GTLCore::Value();
}
public:
static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
{
- if(function->parameters().size() == 0)
+ if( function->parameters().size() == 0 )
{
- return new FunctionCaller0<void>(llvmFunction, function);
+ return new FunctionCaller_void(llvmFunction, function);
} else {
switch( function->parameters()[0].type()->dataType() )
{
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_void_int::create(llvmFunction, function);
case GTLCore::Type::BOOLEAN:
- return FunctionCaller1<void, bool>::create(llvmFunction, function);
- break;
- case GTLCore::Type::INTEGER32:
- return FunctionCaller1<void, int>::create(llvmFunction, function);
- break;
+ return FunctionCaller_void_bool::create(llvmFunction, function);
case GTLCore::Type::UNSIGNED_INTEGER32:
- return FunctionCaller1<void, unsigned int>::create(llvmFunction, function);
- break;
+ return FunctionCaller_void_unsigned_int::create(llvmFunction, function);
case GTLCore::Type::HALF:
case GTLCore::Type::FLOAT:
- return FunctionCaller1<void, float>::create(llvmFunction, function);
- break;
+ return FunctionCaller_void_float::create(llvmFunction, function);
default:
- break;
- };
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
}
- return 0;
}
};
+FunctionCaller* createFunctionCaller( llvm::Function* llvmFunction, const Function* function)
+{
+ switch( function->returnType()->dataType() )
+ {
+ case GTLCore::Type::INTEGER32:
+ return FunctionCaller_int::create(llvmFunction, function);
+ case GTLCore::Type::BOOLEAN:
+ return FunctionCaller_bool::create(llvmFunction, function);
+ case GTLCore::Type::UNSIGNED_INTEGER32:
+ return FunctionCaller_unsigned_int::create(llvmFunction, function);
+ case GTLCore::Type::HALF:
+ case GTLCore::Type::FLOAT:
+ return FunctionCaller_float::create(llvmFunction, function);
+ case GTLCore::Type::VOID:
+ return FunctionCaller_void::create(llvmFunction, function);
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+}
Modified: trunk/OpenGTL/OpenGTL/GTLCore/FunctionCaller_p.cpp
===================================================================
--- trunk/OpenGTL/OpenGTL/GTLCore/FunctionCaller_p.cpp 2008-06-15 21:10:19 UTC (rev 198)
+++ trunk/OpenGTL/OpenGTL/GTLCore/FunctionCaller_p.cpp 2008-06-16 20:03:15 UTC (rev 199)
@@ -51,29 +51,6 @@
FunctionCaller* FunctionCaller::createCaller(llvm::Function* llvmFunction, const Function* function)
{
- FunctionCaller* fc = 0;
- switch( function->returnType()->dataType() )
- {
- case GTLCore::Type::BOOLEAN:
- fc = FunctionCaller0<bool>::create(llvmFunction, function);
- break;
- case GTLCore::Type::INTEGER32:
- fc = FunctionCaller0<int>::create(llvmFunction, function);
- break;
- case GTLCore::Type::UNSIGNED_INTEGER32:
- fc = FunctionCaller0<unsigned int>::create(llvmFunction, function);
- break;
- case GTLCore::Type::HALF:
- case GTLCore::Type::FLOAT:
- fc = FunctionCaller0<float>::create(llvmFunction, function);
- break;
- case GTLCore::Type::VOID:
- fc = FunctionCaller0<void>::create(llvmFunction, function);
- break;
- default:
- break;
- };
- if(fc) return fc;
- return new FunctionCallerFallBack(llvmFunction, function);
+ return createFunctionCaller( llvmFunction, function );
}
Modified: trunk/OpenGTL/OpenShiva/OpenShiva/CodeGenerator_p.cpp
===================================================================
--- trunk/OpenGTL/OpenShiva/OpenShiva/CodeGenerator_p.cpp 2008-06-15 21:10:19 UTC (rev 198)
+++ trunk/OpenGTL/OpenShiva/OpenShiva/CodeGenerator_p.cpp 2008-06-16 20:03:15 UTC (rev 199)
@@ -40,7 +40,7 @@
llvm::BasicBlock* CodeGenerator::memToPixel( GTLCore::GenerationContext& _gc, llvm::BasicBlock* _currentBlock, llvm::Value* _dataPointer, llvm::Value* _pixel, int _size )
{
// Initialise llvm_memcpy_i32
- // TODO that stuff was copied from a llvmgcc output
+ // TODO that stuff was copied from a llvmgcc output, can't we use memcpy intrinsinc ?
std::vector<const llvm::Type*> memcpyTyArgs;
memcpyTyArgs.push_back(llvm::PointerType::get(llvm::IntegerType::get(8), 0));
memcpyTyArgs.push_back(llvm::PointerType::get(llvm::IntegerType::get(8), 0));
@@ -84,7 +84,10 @@
callMemCpy->setCallingConv(llvm::CallingConv::C);
callMemCpy->setTailCall( false );
-
return _currentBlock;
}
+GTLCore::Function* CodeGenerator::generateEvaluatePixeles( Kernel* )
+{
+ return 0;
+}
Modified: trunk/OpenGTL/OpenShiva/OpenShiva/CodeGenerator_p.h
===================================================================
--- trunk/OpenGTL/OpenShiva/OpenShiva/CodeGenerator_p.h 2008-06-15 21:10:19 UTC (rev 198)
+++ trunk/OpenGTL/OpenShiva/OpenShiva/CodeGenerator_p.h 2008-06-16 20:03:15 UTC (rev 199)
@@ -26,10 +26,12 @@
}
namespace GTLCore {
+ class Function;
class GenerationContext;
}
namespace OpenShiva {
+ class Kernel;
class CodeGenerator {
public:
/**
@@ -37,6 +39,7 @@
* Copy a pixel from memory to the vector.
*/
static llvm::BasicBlock* memToPixel( GTLCore::GenerationContext& _gc, llvm::BasicBlock* _currentBlock, llvm::Value* _dataPointer, llvm::Value* _pixel, int _size );
+ static GTLCore::Function* generateEvaluatePixeles( Kernel* );
};
}
Modified: trunk/OpenGTL/OpenShiva/OpenShiva/Kernel.cpp
===================================================================
--- trunk/OpenGTL/OpenShiva/OpenShiva/Kernel.cpp 2008-06-15 21:10:19 UTC (rev 198)
+++ trunk/OpenGTL/OpenShiva/OpenShiva/Kernel.cpp 2008-06-16 20:03:15 UTC (rev 199)
@@ -34,6 +34,7 @@
#include "GTLCore/VirtualMachine_p.h"
#include "Debug.h"
+#include "CodeGenerator_p.h"
#include "Compiler_p.h"
#include "Types_p.h"
@@ -51,6 +52,7 @@
GTLCore::ModuleData* moduleData;
const GTLCore::PixelDescription pixelDescription;
const GTLCore::Type* referenceDepth;
+ GTLCore::Function* evaluatePixelesFunction;
};
Kernel::Kernel(const GTLCore::String& _name) : d(new Private(GTLCore::PixelDescription( GTLCore::Type::Float, 4 )) )
@@ -73,6 +75,12 @@
init(_name, _referenceDepth );
}
+Kernel::~Kernel()
+{
+ cleanup();
+ delete d;
+}
+
void Kernel::init(const GTLCore::String& _name, const GTLCore::Type* _referenceDepth )
{
d->name = _name;
@@ -81,9 +89,24 @@
d->moduleProvider = 0;
d->moduleData = 0;
d->referenceDepth = _referenceDepth;
+ d->evaluatePixelesFunction = 0;
}
+void Kernel::cleanup()
+{
+ if(d->moduleProvider)
+ {
+ GTLCore::VirtualMachine::instance()->unregisterModule( d->moduleProvider);
+ delete d->moduleProvider;
+ d->moduleProvider = 0;
+ }
+ delete d->moduleData;
+ d->moduleData = 0;
+ delete d->evaluatePixelesFunction;
+ d->evaluatePixelesFunction = 0;
+}
+
const GTLCore::String& Kernel::name() const
{
return d->name;
@@ -117,12 +140,7 @@
void Kernel::compile()
{
if(d->source.empty()) return;
- if(d->moduleProvider)
- {
- GTLCore::VirtualMachine::instance()->unregisterModule( d->moduleProvider);
- delete d->moduleProvider;
- }
- delete d->moduleData;
+ cleanup();
d->moduleData = new GTLCore::ModuleData(new llvm::Module(d->name));
Types::fillTypeManager( d->moduleData->llvmModule(), d->moduleData->typeManager(), d->pixelDescription, d->referenceDepth );
Compiler c;
@@ -133,17 +151,18 @@
d->compiled = true;
d->moduleProvider = new llvm::ExistingModuleProvider( d->moduleData->llvmModule() );
GTLCore::VirtualMachine::instance()->registerModule( d->moduleProvider );
+ d->evaluatePixelesFunction = CodeGenerator::generateEvaluatePixeles( this );
} else {
- delete d->moduleData;
- d->moduleData = 0;
+ cleanup();
d->compilationErrors = c.errorMessages();
}
}
-void Kernel::evaluatePixel( const std::list< AbstractImage* >& _inputImages, AbstractImage* _outputImage) const
+void Kernel::evaluatePixeles( const std::list< AbstractImage* >& _inputImages, AbstractImage* _outputImage) const
{
-
+ GTL_ASSERT( d->evaluatePixelesFunction );
+ // TODO call function
}
int Kernel::runTest() const
Modified: trunk/OpenGTL/OpenShiva/OpenShiva/Kernel.h
===================================================================
--- trunk/OpenGTL/OpenShiva/OpenShiva/Kernel.h 2008-06-15 21:10:19 UTC (rev 198)
+++ trunk/OpenGTL/OpenShiva/OpenShiva/Kernel.h 2008-06-16 20:03:15 UTC (rev 199)
@@ -41,8 +41,10 @@
Kernel(const GTLCore::String& _name, const GTLCore::Type* _referenceDepth, int _channelsNb );
Kernel(const GTLCore::String& _name, const GTLCore::PixelDescription& _pixelDescription );
Kernel(const GTLCore::String& _name, const GTLCore::PixelDescription& _pixelDescription, const GTLCore::Type* _referenceDepth );
+ ~Kernel();
private:
void init(const GTLCore::String& _name, const GTLCore::Type* _referenceDepth );
+ void cleanup();
public:
/**
* @return the name of the module (it's usually the name of the file without the .ctl
@@ -78,7 +80,7 @@
*/
GTLCore::String asmSourceCode() const;
public: // Function call
- void evaluatePixel( const std::list< AbstractImage* >& _inputImages, AbstractImage* _outputImage) const;
+ void evaluatePixeles( const std::list< AbstractImage* >& _inputImages, AbstractImage* _outputImage) const;
/**
* Run the function called "int runTest()" in the Kernel.
*/
Modified: trunk/OpenGTL/OpenShiva/OpenShiva/Types_p.cpp
===================================================================
--- trunk/OpenGTL/OpenShiva/OpenShiva/Types_p.cpp 2008-06-15 21:10:19 UTC (rev 198)
+++ trunk/OpenGTL/OpenShiva/OpenShiva/Types_p.cpp 2008-06-16 20:03:15 UTC (rev 199)
@@ -44,11 +44,9 @@
struct Types::Private
{
static std::vector<GTLCore::Type::StructDataMember> s_imageDataMembers;
- static std::vector<GTLCore::Type::StructDataMember> s_pixelDataMembers;
};
std::vector<GTLCore::Type::StructDataMember> Types::Private::s_imageDataMembers;
-std::vector<GTLCore::Type::StructDataMember> Types::Private::s_pixelDataMembers;
void Types::fillTypeManager( llvm::Module* _module, GTLCore::TypeManager* _typeManager, const GTLCore::PixelDescription& _pixelDescription, const GTLCore::Type* _referenceDepth )
{
@@ -58,18 +56,29 @@
// Create Image type
_typeManager->d->createStructure(
"image" + GTLCore::String::number( i ), Private::s_imageDataMembers );
- _typeManager->d->createStructure(
- "pixel" + GTLCore::String::number( i ), Private::s_pixelDataMembers );
+ createPixelType( _module, _typeManager, i, _referenceDepth );
}
_typeManager->d->createStructure( "image", Private::s_imageDataMembers );
- _typeManager->d->createStructure( "pixel", Private::s_pixelDataMembers );
+ createPixelType( _module, _typeManager, _pixelDescription);
createRegionType( _module, _typeManager );
}
+void Types::createPixelType( llvm::Module* _module, GTLCore::TypeManager* _typeManager, const GTLCore::PixelDescription& _pixelDescription)
+{
+ std::vector<GTLCore::Type::StructDataMember> pixelDataMembers;
+ _typeManager->d->createStructure( "pixel", pixelDataMembers );
+}
+
+void Types::createPixelType( llvm::Module* _module, GTLCore::TypeManager* _typeManager, int _channels, const GTLCore::Type* _referenceDepth )
+{
+ std::vector<GTLCore::Type::StructDataMember> pixelDataMembers;
+ _typeManager->d->createStructure(
+ "pixel" + GTLCore::String::number( _channels ), pixelDataMembers );
+}
+
void Types::createRegionType( llvm::Module* _module, GTLCore::TypeManager* _typeManager )
{
- static std::vector<GTLCore::Type::StructDataMember> regionDataMembers;
- static std::vector<GTLCore::Type::StructFunctionMember> regionFunctionMembers;
+ std::vector<GTLCore::Type::StructDataMember> regionDataMembers;
regionDataMembers.push_back( GTLCore::Type::StructDataMember( "x", GTLCore::Type::Float ) );
regionDataMembers.push_back( GTLCore::Type::StructDataMember( "y", GTLCore::Type::Float) );
regionDataMembers.push_back( GTLCore::Type::StructDataMember( "width", GTLCore::Type::Float ) );
Modified: trunk/OpenGTL/OpenShiva/OpenShiva/Types_p.h
===================================================================
--- trunk/OpenGTL/OpenShiva/OpenShiva/Types_p.h 2008-06-15 21:10:19 UTC (rev 198)
+++ trunk/OpenGTL/OpenShiva/OpenShiva/Types_p.h 2008-06-16 20:03:15 UTC (rev 199)
@@ -51,6 +51,8 @@
struct Private;
private:
static void createRegionType( llvm::Module* _module, GTLCore::TypeManager* _typeManager );
+ static void createPixelType( llvm::Module* _module, GTLCore::TypeManager* _typeManager, int _channels, const GTLCore::Type* _referenceDepth );
+ static void createPixelType( llvm::Module* _module, GTLCore::TypeManager* _typeManager, const GTLCore::PixelDescription& _pixelDescription);
};
}
Modified: trunk/OpenGTL/sdk/generate-function-callers.rb
===================================================================
--- trunk/OpenGTL/sdk/generate-function-callers.rb 2008-06-15 21:10:19 UTC (rev 198)
+++ trunk/OpenGTL/sdk/generate-function-callers.rb 2008-06-16 20:03:15 UTC (rev 199)
@@ -17,32 +17,10 @@
# Boston, MA 02110-1301, USA.
# Generate callers for up to 4 parameters (change this value to get more), but compilation
-# time increase drastically for maxparameters > 4
+# time increase drastically for maxparameters > 4 (not really anymore that there is no
+# templates involved, but 4 generates a 50000 lines file, and 6 a 200000 lines, ...)
maxparameters = 4
-def creator( typeReturn, listoftemplateparameters, parameters)
- return <<ENDOFUNSPECIALIZEDFUNCTION
- switch( function->parameters()[0].type()->dataType() )
- {
- case GTLCore::Type::BOOLEAN:
- return FunctionCaller#{parameters+1}<#{typeReturn}#{listoftemplateparameters}, bool>::create(llvmFunction, function);
- break;
- case GTLCore::Type::INTEGER32:
- return FunctionCaller#{parameters+1}<#{typeReturn}#{listoftemplateparameters}, int>::create(llvmFunction, function);
- break;
- case GTLCore::Type::UNSIGNED_INTEGER32:
- return FunctionCaller#{parameters+1}<#{typeReturn}#{listoftemplateparameters}, unsigned int>::create(llvmFunction, function);
- break;
- case GTLCore::Type::HALF:
- case GTLCore::Type::FLOAT:
- return FunctionCaller#{parameters+1}<#{typeReturn}#{listoftemplateparameters}, float>::create(llvmFunction, function);
- break;
- default:
- break;
- };
-ENDOFUNSPECIALIZEDFUNCTION
-end
-
puts <<ENDOFPUTS
/*
* This file was generated by generate-function-callers.rb. Don't make
@@ -69,101 +47,144 @@
parameters = maxparameters
+TypeArray = [ [ "int", ["INTEGER32"] ], [ "bool", ["BOOLEAN"] ], ["unsigned int", ["UNSIGNED_INTEGER32"] ], [ "float", [ "HALF", "FLOAT" ] ] ]
+
+ReturnTypeArray = TypeArray.clone
+ReturnTypeArray << [ "void", ["VOID"] ]
+
+def typeToString( type )
+ return type.gsub(" ", "_").gsub("*", "p" )
+end
+
+def className( indexRT, index )
+ name = "FunctionCaller"
+ name += "_#{typeToString(ReturnTypeArray[indexRT][0])}"
+ for i in 0...index.size
+ name += "_#{typeToString(TypeArray[index[i]][0])}"
+ end
+ return name
+end
+
+def updateIndex( index, indexIndex )
+ if( indexIndex + 1 > index.size)
+ return false
+ end
+ index[indexIndex] += 1
+ if( index[indexIndex] >= TypeArray.size )
+ index[indexIndex] = 0
+ return updateIndex( index, indexIndex + 1)
+ else
+ return true
+ end
+end
+
while( parameters >= 0 )
puts "// Number of parameters = #{parameters}"
- preparefunctioncaller = <<ENDOFPREPARE
- GTL_ASSERT(function());
- GTL_ASSERT(arguments.size() == #{parameters});
-ENDOFPREPARE
- typelist = ""
- callist = ""
- for i in 1..parameters
- preparefunctioncaller += <<ENDOFPREPARE
- _TYPE_#{i}_ arg#{i} = GTLCore::PrimitiveTypeTrait<_TYPE_#{i}_>::convert( arguments[#{i-1}] );
-ENDOFPREPARE
- if( i != 1)
- typelist += ","
- callist += ","
- end
- typelist += "_TYPE_#{i}_"
- callist += "arg#{i}"
+
+ index = []
+ for i in 0...parameters
+ index[i] = 0
end
-# generate the list of template parameters
- listoftypenamedtemplateparameters = ""
- listoftemplateparameters = ""
- for i in 1..parameters
- listoftypenamedtemplateparameters += ", typename _TYPE_#{i}_"
- listoftemplateparameters += ", _TYPE_#{i}_"
- end
-# The following string is used to create the next level of parameters
-# Output the unspecialized version of the function
- puts <<ENDOFUNSPECIALIZEDFUNCTION
-template<typename _TYPE_RETURN_#{listoftypenamedtemplateparameters}>
-class FunctionCaller#{parameters} : public FunctionCaller {
+
+ for indexRT in 0...ReturnTypeArray.size
+ begin
+ klassName = className( indexRT, index )
+ puts <<ENDOFCLASS
+// #{indexRT} #{index.join(",")}
+class #{klassName} : public FunctionCaller {
public:
- FunctionCaller#{parameters}(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
+ #{klassName}(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
{
}
virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
{
-#{preparefunctioncaller}
- _TYPE_RETURN_ (*PF)(#{typelist}) = (_TYPE_RETURN_(*)(#{typelist})) VirtualMachine::instance()->getPointerToFunction(function());
- return GTLCore::Value( PF(#{callist}) );
+ GTL_ASSERT(function());
+ GTL_ASSERT(arguments.size() == #{parameters});
+ENDOFCLASS
+ # Convert the parameters
+ listType = ""
+ listArgs = ""
+ for i in 0...parameters
+ typeName = TypeArray[index[i]][0]
+ listType += typeName
+ listArgs += "arg#{i+1}"
+ unless( i == parameters - 1)
+ listType += ","
+ listArgs += ","
+ end
+ puts <<ENDOFINITPARAMETERS
+ #{typeName} arg#{i+1} = GTLCore::PrimitiveTypeTrait<#{typeName}>::convert( arguments[#{i}] );
+ENDOFINITPARAMETERS
+ end
+ # Convert the function
+ typeReturn = ReturnTypeArray[indexRT][0]
+ puts <<ENDOFCONVERTFUNCTION
+ #{typeReturn} (*PF)(#{listType}) = (#{typeReturn}(*)(#{listType})) VirtualMachine::instance()->getPointerToFunction(function());
+ENDOFCONVERTFUNCTION
+ if( typeReturn == "void" )
+ puts " PF(#{listArgs});\n return GTLCore::Value();"
+ else
+ puts " return GTLCore::Value( PF(#{listArgs}) );"
+ end
+ puts <<ENDOFCALLBEGINOFCREATEFUNCTION
}
public:
static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
{
- if(function->parameters().size() == #{parameters})
+ if( function->parameters().size() == #{parameters} )
{
- return new FunctionCaller#{parameters}<_TYPE_RETURN_#{listoftemplateparameters}>(llvmFunction, function);
+ return new #{klassName}(llvmFunction, function);
} else {
-ENDOFUNSPECIALIZEDFUNCTION
-# only attempt to add the next parameter if we define the next function
- if( parameters != maxparameters)
- puts creator("_TYPE_RETURN_", listoftemplateparameters, parameters)
- end
- puts <<ENDOFUNSPECIALIZEDFUNCTION
+ENDOFCALLBEGINOFCREATEFUNCTION
+ if( parameters == maxparameters )
+ puts " return new FunctionCallerFallBack(llvmFunction, function);"
+ else
+ puts <<ENDOFCREATESWITCHBEGIN
+ switch( function->parameters()[#{parameters}].type()->dataType() )
+ {
+ENDOFCREATESWITCHBEGIN
+ TypeArray.each() { |x|
+ x[1].each() { |y|
+ puts " case GTLCore::Type::#{y}:"
+ }
+ puts " return #{klassName}_#{typeToString(x[0])}::create(llvmFunction, function);"
+ }
+ puts <<ENDOFCREATESWITCHEND
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+ENDOFCREATESWITCHEND
+ end
+ puts <<ENDOFCLASS
}
- return 0;
}
};
-ENDOFUNSPECIALIZEDFUNCTION
-# function returning void need a specialized version
- listoftypenamedtemplateparametersNoComa = listoftypenamedtemplateparameters[1..listoftypenamedtemplateparameters.size]
-
- puts <<ENDOFSPECIALIZEDFUNCTION
-template<#{listoftypenamedtemplateparametersNoComa}>
-class FunctionCaller#{parameters}<void #{listoftemplateparameters}> : public FunctionCaller {
- public:
- FunctionCaller#{parameters}(llvm::Function* llvmFunction, const Function* function) : FunctionCaller( llvmFunction, function)
- {
- }
- virtual GTLCore::Value call(const std::vector<GTLCore::Value>& arguments )
- {
-#{preparefunctioncaller}
- void (*PF)(#{typelist}) = (void(*)(#{typelist})) VirtualMachine::instance()->getPointerToFunction(function());
- PF(#{callist});
- return GTLCore::Value( );
- }
- public:
- static FunctionCaller* create(llvm::Function* llvmFunction, const Function* function)
- {
- if(function->parameters().size() == #{parameters})
- {
- return new FunctionCaller#{parameters}<void#{listoftemplateparameters}>(llvmFunction, function);
- } else {
-ENDOFSPECIALIZEDFUNCTION
-# only attempt to add the next parameter if we define the next function
- if( parameters != maxparameters)
- puts creator("void", listoftemplateparameters, parameters)
+ENDOFCLASS
+
+ end while( updateIndex( index, 0 ) )
end
- puts <<ENDOFSPECIALIZEDFUNCTION
- }
- return 0;
- }
-};
-ENDOFSPECIALIZEDFUNCTION
-# Decrement the number of parameter
+
parameters -= 1
end
+# Create creator
+
+puts <<CREATOR
+FunctionCaller* createFunctionCaller( llvm::Function* llvmFunction, const Function* function)
+{
+ switch( function->returnType()->dataType() )
+ {
+CREATOR
+ReturnTypeArray.each() { |x|
+ x[1].each() { |y|
+ puts " case GTLCore::Type::#{y}:"
+ }
+ puts " return FunctionCaller_#{typeToString(x[0])}::create(llvmFunction, function);"
+}
+
+puts <<ENDCREATOR
+ default:
+ return new FunctionCallerFallBack(llvmFunction, function);
+ }
+}
+ENDCREATOR