diff --git a/src/Reactor/LLVMReactor.cpp b/src/Reactor/LLVMReactor.cpp
index fc9f5e9..9c453b7 100644
--- a/src/Reactor/LLVMReactor.cpp
+++ b/src/Reactor/LLVMReactor.cpp
@@ -3271,6 +3271,28 @@
 
 		return RValue<Long>(V(::builder->CreateCall(rdtsc)));
 	}
+
+	RValue<Pointer<Byte>> ConstantPointer(void const * ptr)
+	{
+		// Note: this should work for 32-bit pointers as well because 'inttoptr'
+		// is defined to truncate (and zero extend) if necessary.
+		auto ptrAsInt = ::llvm::ConstantInt::get(::llvm::Type::getInt64Ty(*::context), reinterpret_cast<uintptr_t>(ptr));
+		return RValue<Pointer<Byte>>(V(::builder->CreateIntToPtr(ptrAsInt, T(Pointer<Byte>::getType()))));
+	}
+
+	Value* Call(RValue<Pointer<Byte>> fptr, Type* retTy, std::initializer_list<Value*> args, std::initializer_list<Type*> argTys)
+	{
+		::llvm::SmallVector<::llvm::Type*, 8> paramTys;
+		for (auto ty : argTys) { paramTys.push_back(T(ty)); }
+		auto funcTy = ::llvm::FunctionType::get(T(retTy), paramTys, false);
+
+		auto funcPtrTy = funcTy->getPointerTo();
+		auto funcPtr = ::builder->CreatePointerCast(V(fptr.value), funcPtrTy);
+
+		::llvm::SmallVector<::llvm::Value*, 8> arguments;
+		for (auto arg : args) { arguments.push_back(V(arg)); }
+		return V(::builder->CreateCall(funcPtr, arguments));
+	}
 }
 
 namespace rr
diff --git a/src/Reactor/Reactor.hpp b/src/Reactor/Reactor.hpp
index e6f3ff2..b7dcaf3 100644
--- a/src/Reactor/Reactor.hpp
+++ b/src/Reactor/Reactor.hpp
@@ -2959,6 +2959,97 @@
 		return ReinterpretCast<T>(val);
 	}
 
+	template <typename T>
+	inline Value* valueOf(RValue<T> v) { return v.value; }
+
+	template <typename T>
+	inline Value* valueOf(LValue<T> v) { return valueOf(RValue<T>(v.loadValue())); }
+
+	template<typename T>
+	struct CToReactor;
+
+	template<> struct CToReactor<void>    { using type = Void; };
+	template<> struct CToReactor<int>     { using type = Int; };
+	template<> struct CToReactor<float>   { using type = Float; };
+	template<> struct CToReactor<int*>     { using type = Pointer<Int>; };
+	template<> struct CToReactor<float*>   { using type = Pointer<Float>; };
+
+	// Pointers to non-reactor types are treated as uint8_t*.
+	template<typename T>
+	struct CToReactor<T*> { using type = Pointer<Byte>; };
+
+	// Returns a reactor pointer to the fixed-address ptr.
+	RValue<Pointer<Byte>> ConstantPointer(void const * ptr);
+
+	// Calls the function pointer fptr with the given arguments, return type
+	// and parameter types. Returns the call's return value if the function has
+	// a non-void return type.
+	Value* Call(RValue<Pointer<Byte>> fptr, Type* retTy, std::initializer_list<Value*> args, std::initializer_list<Type*> paramTys);
+
+	template <typename F>
+	class CallHelper {};
+
+	template<typename Return, typename ... Arguments>
+	class CallHelper<Return(Arguments...)>
+	{
+	public:
+		using RReturn = typename CToReactor<Return>::type;
+
+		static inline RReturn Call(Return(fptr)(Arguments...), typename CToReactor<Arguments>::type... args)
+		{
+			return RValue<RReturn>(rr::Call(
+				ConstantPointer(reinterpret_cast<void*>(fptr)),
+				RReturn::getType(),
+				{ valueOf(args) ... },
+				{ CToReactor<Arguments>::type::getType() ... }));
+		}
+
+		static inline RReturn Call(Pointer<Byte> fptr, typename CToReactor<Arguments>::type... args)
+		{
+			return RValue<RReturn>(rr::Call(
+				fptr,
+				RReturn::getType(),
+				{ valueOf(args) ... },
+				{ CToReactor<Arguments>::type::getType() ... }));
+		}
+	};
+
+	template<typename ... Arguments>
+	class CallHelper<void(Arguments...)>
+	{
+	public:
+		static inline void Call(void(fptr)(Arguments...), typename CToReactor<Arguments>::type... args)
+		{
+			rr::Call(ConstantPointer(reinterpret_cast<void*>(fptr)),
+				Void::getType(),
+				{ valueOf(args) ... },
+				{ CToReactor<Arguments>::type::getType() ... });
+		}
+
+		static inline void Call(Pointer<Byte> fptr, typename CToReactor<Arguments>::type... args)
+		{
+			rr::Call(fptr,
+				Void::getType(),
+				{ valueOf(args) ... },
+				{ CToReactor<Arguments>::type::getType() ... });
+		}
+	};
+
+	// Calls the function pointer fptr with the given arguments args.
+	template<typename Return, typename ... Arguments>
+	inline typename CToReactor<Return>::type Call(Return(fptr)(Arguments...), typename CToReactor<Arguments>::type... args)
+	{
+		return CallHelper<Return(Arguments...)>::Call(fptr, args...);
+	}
+
+	// Calls the function pointer fptr with the signature FUNCTION_SIGNATURE and
+	// arguments.
+	template<typename FUNCTION_SIGNATURE, typename ... Arguments>
+	inline void Call(Pointer<Byte> fptr, Arguments ... args)
+	{
+		CallHelper<FUNCTION_SIGNATURE>::Call(fptr, args...);
+	}
+
 #ifdef ENABLE_RR_PRINT
 	// PrintValue holds the printf format and value(s) for a single argument
 	// to Print(). A single argument can be expanded into multiple printf
diff --git a/src/Reactor/ReactorUnitTests.cpp b/src/Reactor/ReactorUnitTests.cpp
index a5de4f9..b52b722 100644
--- a/src/Reactor/ReactorUnitTests.cpp
+++ b/src/Reactor/ReactorUnitTests.cpp
@@ -1088,6 +1088,57 @@
 	delete routine;
 }
 
+TEST(ReactorUnitTests, Call)
+{
+	if (!rr::Caps.CallSupported)
+	{
+		SUCCEED() << "rr::Call() not supported";
+		return;
+	}
+
+	Routine *routine = nullptr;
+
+	struct Class
+	{
+		static int Callback(uint8_t *p, int i, float f)
+		{
+			auto c = reinterpret_cast<Class*>(p);
+			c->i = i;
+			c->f = f;
+			return i + int(f);
+		}
+
+		int i = 0;
+		float f = 0.0f;
+	};
+
+	{
+		Function<Int(Pointer<Byte>)> function;
+		{
+			Pointer<Byte> c = function.Arg<0>();
+			auto res = Call(Class::Callback, c, 10, 20.0f);
+			Return(res);
+		}
+
+		routine = function("one");
+
+		if(routine)
+		{
+			int(*callable)(void*) = (int(*)(void*))routine->getEntry();
+
+			Class c;
+
+			int res = callable(&c);
+
+			EXPECT_EQ(res, 30);
+			EXPECT_EQ(c.i, 10);
+			EXPECT_EQ(c.f, 20.0f);
+		}
+	}
+
+	delete routine;
+}
+
 // Check that a complex generated function which utilizes all 8 or 16 XMM
 // registers computes the correct result.
 // (Note that due to MSC's lack of support for inline assembly in x64,
diff --git a/src/Reactor/SubzeroReactor.cpp b/src/Reactor/SubzeroReactor.cpp
index c30a419..731e682 100644
--- a/src/Reactor/SubzeroReactor.cpp
+++ b/src/Reactor/SubzeroReactor.cpp
@@ -3381,6 +3381,28 @@
 		return Long(Int(0));
 	}
 
+	RValue<Pointer<Byte>> ConstantPointer(void const * ptr)
+	{
+		return RValue<Pointer<Byte>>(V(::context->getConstantInt64(reinterpret_cast<intptr_t>(ptr))));
+	}
+
+	Value* Call(RValue<Pointer<Byte>> fptr, Type* retTy, std::initializer_list<Value*> args, std::initializer_list<Type*> argTys)
+	{
+		// FIXME: This does not currently work on Windows.
+		Ice::Variable *ret = nullptr;
+		if (retTy != nullptr)
+		{
+			ret = ::function->makeVariable(T(retTy));
+		}
+		auto call = Ice::InstCall::create(::function, args.size(), ret, V(fptr.value), false);
+		for (auto arg : args)
+		{
+			call->addArg(V(arg));
+		}
+		::basicBlock->appendInst(call);
+		return V(ret);
+	}
+
 	// Below are functions currently unimplemented for the Subzero backend.
 	// They are stubbed to satisfy the linker.
 	RValue<Float4> Sin(RValue<Float4> x) { UNIMPLEMENTED("Subzero Sin()"); return Float4(0); }