diff --git a/CMakeLists.txt b/CMakeLists.txt
index aaf2be0..4451f44 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -543,9 +543,8 @@
     endif()
 endif()
 
-if((${REACTOR_BACKEND} STREQUAL "Subzero") AND (REACTOR_ENABLE_PRINT OR REACTOR_EMIT_PRINT_LOCATION OR REACTOR_EMIT_DEBUG_INFO))
+if((${REACTOR_BACKEND} STREQUAL "Subzero") AND (REACTOR_EMIT_PRINT_LOCATION OR REACTOR_EMIT_DEBUG_INFO))
     message(WARNING "REACTOR_ENABLE_PRINT, REACTOR_EMIT_PRINT_LOCATION, and REACTOR_EMIT_DEBUG_INFO are not supported by Subzero, disabling.")
-    set(REACTOR_ENABLE_PRINT "Off")
     set(REACTOR_EMIT_PRINT_LOCATION "Off")
     set(REACTOR_EMIT_DEBUG_INFO "Off")
 endif()
diff --git a/src/Reactor/LLVMReactor.cpp b/src/Reactor/LLVMReactor.cpp
index c14012d..7f780a6 100644
--- a/src/Reactor/LLVMReactor.cpp
+++ b/src/Reactor/LLVMReactor.cpp
@@ -77,19 +77,6 @@
 	return config;
 }
 
-#ifdef ENABLE_RR_PRINT
-std::string replace(std::string str, const std::string &substr, const std::string &replacement)
-{
-	size_t pos = 0;
-	while((pos = str.find(substr, pos)) != std::string::npos)
-	{
-		str.replace(pos, substr.length(), replacement);
-		pos += replacement.length();
-	}
-	return str;
-}
-#endif  // ENABLE_RR_PRINT
-
 llvm::Value *lowerPAVG(llvm::Value *x, llvm::Value *y)
 {
 	llvm::VectorType *ty = llvm::cast<llvm::VectorType>(x->getType());
@@ -1567,11 +1554,42 @@
 	jit->builder->CreateUnreachable();
 }
 
+Type *Nucleus::getType(Value *value)
+{
+	return T(V(value)->getType());
+}
+
+Type *Nucleus::getContainedType(Type *vectorType)
+{
+	return T(T(vectorType)->getContainedType(0));
+}
+
 Type *Nucleus::getPointerType(Type *ElementType)
 {
 	return T(llvm::PointerType::get(T(ElementType), 0));
 }
 
+static ::llvm::Type *getNaturalIntType()
+{
+	return ::llvm::Type::getIntNTy(jit->context, sizeof(int) * 8);
+}
+
+Type *Nucleus::getPrintfStorageType(Type *valueType)
+{
+	llvm::Type *valueTy = T(valueType);
+	if(valueTy->isIntegerTy())
+	{
+		return T(getNaturalIntType());
+	}
+	if(valueTy->isFloatTy())
+	{
+		return T(llvm::Type::getDoubleTy(jit->context));
+	}
+
+	UNIMPLEMENTED_NO_BUG("getPrintfStorageType: add more cases as needed");
+	return {};
+}
+
 Value *Nucleus::createNullValue(Type *Ty)
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
@@ -1670,6 +1688,12 @@
 	return V(llvm::ConstantVector::get(llvm::ArrayRef<llvm::Constant *>(constantVector, numElements)));
 }
 
+Value *Nucleus::createConstantString(const char *v)
+{
+	auto ptr = jit->builder->CreateGlobalStringPtr(v);
+	return V(ptr);
+}
+
 Type *Void::getType()
 {
 	return T(llvm::Type::getVoidTy(jit->context));
@@ -3827,189 +3851,13 @@
 #endif  // defined(__i386__) || defined(__x86_64__)
 
 #ifdef ENABLE_RR_PRINT
-// extractAll returns a vector containing the extracted n scalar value of
-// the vector vec.
-static std::vector<Value *> extractAll(Value *vec, int n)
+void VPrintf(const std::vector<Value *> &vals)
 {
-	std::vector<Value *> elements;
-	elements.reserve(n);
-	for(int i = 0; i < n; i++)
-	{
-		auto el = V(jit->builder->CreateExtractElement(V(vec), i));
-		elements.push_back(el);
-	}
-	return elements;
-}
-
-// toInt returns all the integer values in vals extended to a native width
-// integer.
-static std::vector<Value *> toInt(const std::vector<Value *> &vals, bool isSigned)
-{
-	auto intTy = ::llvm::Type::getIntNTy(jit->context, sizeof(int) * 8);  // Natural integer width.
-	std::vector<Value *> elements;
-	elements.reserve(vals.size());
-	for(auto v : vals)
-	{
-		if(isSigned)
-		{
-			elements.push_back(V(jit->builder->CreateSExt(V(v), intTy)));
-		}
-		else
-		{
-			elements.push_back(V(jit->builder->CreateZExt(V(v), intTy)));
-		}
-	}
-	return elements;
-}
-
-// toDouble returns all the float values in vals extended to doubles.
-static std::vector<Value *> toDouble(const std::vector<Value *> &vals)
-{
-	auto doubleTy = ::llvm::Type::getDoubleTy(jit->context);
-	std::vector<Value *> elements;
-	elements.reserve(vals.size());
-	for(auto v : vals)
-	{
-		elements.push_back(V(jit->builder->CreateFPExt(V(v), doubleTy)));
-	}
-	return elements;
-}
-
-std::vector<Value *> PrintValue::Ty<Bool>::val(const RValue<Bool> &v)
-{
-	auto t = jit->builder->CreateGlobalStringPtr("true");
-	auto f = jit->builder->CreateGlobalStringPtr("false");
-	return { V(jit->builder->CreateSelect(V(v.value), t, f)) };
-}
-
-std::vector<Value *> PrintValue::Ty<Byte>::val(const RValue<Byte> &v)
-{
-	return toInt({ v.value }, false);
-}
-
-std::vector<Value *> PrintValue::Ty<Byte4>::val(const RValue<Byte4> &v)
-{
-	return toInt(extractAll(v.value, 4), false);
-}
-
-std::vector<Value *> PrintValue::Ty<Int>::val(const RValue<Int> &v)
-{
-	return toInt({ v.value }, true);
-}
-
-std::vector<Value *> PrintValue::Ty<Int2>::val(const RValue<Int2> &v)
-{
-	return toInt(extractAll(v.value, 2), true);
-}
-
-std::vector<Value *> PrintValue::Ty<Int4>::val(const RValue<Int4> &v)
-{
-	return toInt(extractAll(v.value, 4), true);
-}
-
-std::vector<Value *> PrintValue::Ty<UInt>::val(const RValue<UInt> &v)
-{
-	return toInt({ v.value }, false);
-}
-
-std::vector<Value *> PrintValue::Ty<UInt2>::val(const RValue<UInt2> &v)
-{
-	return toInt(extractAll(v.value, 2), false);
-}
-
-std::vector<Value *> PrintValue::Ty<UInt4>::val(const RValue<UInt4> &v)
-{
-	return toInt(extractAll(v.value, 4), false);
-}
-
-std::vector<Value *> PrintValue::Ty<Short>::val(const RValue<Short> &v)
-{
-	return toInt({ v.value }, true);
-}
-
-std::vector<Value *> PrintValue::Ty<Short4>::val(const RValue<Short4> &v)
-{
-	return toInt(extractAll(v.value, 4), true);
-}
-
-std::vector<Value *> PrintValue::Ty<UShort>::val(const RValue<UShort> &v)
-{
-	return toInt({ v.value }, false);
-}
-
-std::vector<Value *> PrintValue::Ty<UShort4>::val(const RValue<UShort4> &v)
-{
-	return toInt(extractAll(v.value, 4), false);
-}
-
-std::vector<Value *> PrintValue::Ty<Float>::val(const RValue<Float> &v)
-{
-	return toDouble({ v.value });
-}
-
-std::vector<Value *> PrintValue::Ty<Float4>::val(const RValue<Float4> &v)
-{
-	return toDouble(extractAll(v.value, 4));
-}
-
-std::vector<Value *> PrintValue::Ty<const char *>::val(const char *v)
-{
-	return { V(jit->builder->CreateGlobalStringPtr(v)) };
-}
-
-void Printv(const char *function, const char *file, int line, const char *fmt, std::initializer_list<PrintValue> args)
-{
-	// LLVM types used below.
 	auto i32Ty = ::llvm::Type::getInt32Ty(jit->context);
-	auto intTy = ::llvm::Type::getIntNTy(jit->context, sizeof(int) * 8);  // Natural integer width.
 	auto i8PtrTy = ::llvm::Type::getInt8PtrTy(jit->context);
 	auto funcTy = ::llvm::FunctionType::get(i32Ty, { i8PtrTy }, true);
-
 	auto func = jit->module->getOrInsertFunction("printf", funcTy);
-
-	// Build the printf format message string.
-	std::string str;
-	if(file != nullptr) { str += (line > 0) ? "%s:%d " : "%s "; }
-	if(function != nullptr) { str += "%s "; }
-	str += fmt;
-
-	// Perform substitution on all '{n}' bracketed indices in the format
-	// message.
-	int i = 0;
-	for(const PrintValue &arg : args)
-	{
-		str = replace(str, "{" + std::to_string(i++) + "}", arg.format);
-	}
-
-	::llvm::SmallVector<::llvm::Value *, 8> vals;
-
-	// The format message is always the first argument.
-	vals.push_back(jit->builder->CreateGlobalStringPtr(str));
-
-	// Add optional file, line and function info if provided.
-	if(file != nullptr)
-	{
-		vals.push_back(jit->builder->CreateGlobalStringPtr(file));
-		if(line > 0)
-		{
-			vals.push_back(::llvm::ConstantInt::get(intTy, line));
-		}
-	}
-	if(function != nullptr)
-	{
-		vals.push_back(jit->builder->CreateGlobalStringPtr(function));
-	}
-
-	// Add all format arguments.
-	for(const PrintValue &arg : args)
-	{
-		for(auto val : arg.values)
-		{
-			vals.push_back(V(val));
-		}
-	}
-
-	jit->builder->CreateCall(func, vals);
+	jit->builder->CreateCall(func, V(vals));
 }
 #endif  // ENABLE_RR_PRINT
 
diff --git a/src/Reactor/LLVMReactor.hpp b/src/Reactor/LLVMReactor.hpp
index db7df10..fc3f1a2 100644
--- a/src/Reactor/LLVMReactor.hpp
+++ b/src/Reactor/LLVMReactor.hpp
@@ -65,6 +65,17 @@
 	return reinterpret_cast<Value *>(t);
 }
 
+inline std::vector<llvm::Value *> V(const std::vector<Value *> &values)
+{
+	std::vector<llvm::Value *> result;
+	result.reserve(values.size());
+	for(auto &v : values)
+	{
+		result.push_back(V(v));
+	}
+	return result;
+}
+
 // Emits a no-op instruction that will not be optimized away.
 // Useful for emitting something that can have a source location without
 // effect.
diff --git a/src/Reactor/Nucleus.hpp b/src/Reactor/Nucleus.hpp
index 513f4fb..4c08ddd 100644
--- a/src/Reactor/Nucleus.hpp
+++ b/src/Reactor/Nucleus.hpp
@@ -21,6 +21,7 @@
 #include <cstdint>
 #include <functional>
 #include <memory>
+#include <string>
 #include <vector>
 
 #ifdef None
@@ -326,8 +327,13 @@
 	static Value *createNullPointer(Type *type);
 	static Value *createConstantVector(const int64_t *constants, Type *type);
 	static Value *createConstantVector(const double *constants, Type *type);
+	static Value *createConstantString(const char *v);
+	static Value *createConstantString(const std::string &v) { return createConstantString(v.c_str()); }
 
+	static Type *getType(Value *value);
+	static Type *getContainedType(Type *vectorType);
 	static Type *getPointerType(Type *elementType);
+	static Type *getPrintfStorageType(Type *valueType);
 };
 
 }  // namespace rr
diff --git a/src/Reactor/Print.hpp b/src/Reactor/Print.hpp
index a5bde3e..ca70465 100644
--- a/src/Reactor/Print.hpp
+++ b/src/Reactor/Print.hpp
@@ -337,6 +337,10 @@
 	static std::vector<Value *> val(const RValue<T> &v) { return PrintValue::Ty<T>::val(v); }
 };
 
+// VPrintf emits a call to printf() using vals[0] as the format string,
+// and vals[1..n] as the args.
+void VPrintf(const std::vector<Value *> &vals);
+
 // Printv emits a call to printf() using the function, file and line,
 // message and optional values.
 // See Printv below.
diff --git a/src/Reactor/Reactor.cpp b/src/Reactor/Reactor.cpp
index 8801f2a..abe4882 100644
--- a/src/Reactor/Reactor.cpp
+++ b/src/Reactor/Reactor.cpp
@@ -14,6 +14,7 @@
 
 #include "Reactor.hpp"
 #include "Debug.hpp"
+#include "Print.hpp"
 
 #include <cmath>
 
@@ -4596,4 +4597,197 @@
 // TODO: Long has no constructor that takes a uint64_t
 // Long          CToReactor<uint64_t>::cast(uint64_t v)       { return type(v); }
 
+#ifdef ENABLE_RR_PRINT
+static std::string replaceAll(std::string str, const std::string &substr, const std::string &replacement)
+{
+	size_t pos = 0;
+	while((pos = str.find(substr, pos)) != std::string::npos)
+	{
+		str.replace(pos, substr.length(), replacement);
+		pos += replacement.length();
+	}
+	return str;
+}
+
+// extractAll returns a vector containing the extracted n scalar value of
+// the vector vec.
+// TODO: Move to Reactor.cpp (LLVMReactor can use this too)
+static std::vector<Value *> extractAll(Value *vec, int n)
+{
+	Type *elemTy = Nucleus::getContainedType(Nucleus::getType(vec));
+	std::vector<Value *> elements;
+	elements.reserve(n);
+	for(int i = 0; i < n; i++)
+	{
+		auto el = Nucleus::createExtractElement(vec, elemTy, i);
+		elements.push_back(el);
+	}
+	return elements;
+}
+
+// toInt returns all the integer values in vals extended to a printf-required storage value
+static std::vector<Value *> toInt(const std::vector<Value *> &vals, bool isSigned)
+{
+	auto storageTy = Nucleus::getPrintfStorageType(Int::getType());
+	std::vector<Value *> elements;
+	elements.reserve(vals.size());
+	for(auto v : vals)
+	{
+		if(isSigned)
+		{
+			elements.push_back(Nucleus::createSExt(v, storageTy));
+		}
+		else
+		{
+			elements.push_back(Nucleus::createZExt(v, storageTy));
+		}
+	}
+	return elements;
+}
+
+// toFloat returns all the float values in vals extended to extended to a printf-required storage value
+static std::vector<Value *> toFloat(const std::vector<Value *> &vals)
+{
+	auto storageTy = Nucleus::getPrintfStorageType(Float::getType());
+	std::vector<Value *> elements;
+	elements.reserve(vals.size());
+	for(auto v : vals)
+	{
+		elements.push_back(Nucleus::createFPExt(v, storageTy));
+	}
+	return elements;
+}
+
+std::vector<Value *> PrintValue::Ty<Bool>::val(const RValue<Bool> &v)
+{
+	auto t = Nucleus::createConstantString("true");
+	auto f = Nucleus::createConstantString("false");
+	return { Nucleus::createSelect(v.value, t, f) };
+}
+
+std::vector<Value *> PrintValue::Ty<Byte>::val(const RValue<Byte> &v)
+{
+	return toInt({ v.value }, false);
+}
+
+std::vector<Value *> PrintValue::Ty<Byte4>::val(const RValue<Byte4> &v)
+{
+	return toInt(extractAll(v.value, 4), false);
+}
+
+std::vector<Value *> PrintValue::Ty<Int>::val(const RValue<Int> &v)
+{
+	return toInt({ v.value }, true);
+}
+
+std::vector<Value *> PrintValue::Ty<Int2>::val(const RValue<Int2> &v)
+{
+	return toInt(extractAll(v.value, 2), true);
+}
+
+std::vector<Value *> PrintValue::Ty<Int4>::val(const RValue<Int4> &v)
+{
+	return toInt(extractAll(v.value, 4), true);
+}
+
+std::vector<Value *> PrintValue::Ty<UInt>::val(const RValue<UInt> &v)
+{
+	return toInt({ v.value }, false);
+}
+
+std::vector<Value *> PrintValue::Ty<UInt2>::val(const RValue<UInt2> &v)
+{
+	return toInt(extractAll(v.value, 2), false);
+}
+
+std::vector<Value *> PrintValue::Ty<UInt4>::val(const RValue<UInt4> &v)
+{
+	return toInt(extractAll(v.value, 4), false);
+}
+
+std::vector<Value *> PrintValue::Ty<Short>::val(const RValue<Short> &v)
+{
+	return toInt({ v.value }, true);
+}
+
+std::vector<Value *> PrintValue::Ty<Short4>::val(const RValue<Short4> &v)
+{
+	return toInt(extractAll(v.value, 4), true);
+}
+
+std::vector<Value *> PrintValue::Ty<UShort>::val(const RValue<UShort> &v)
+{
+	return toInt({ v.value }, false);
+}
+
+std::vector<Value *> PrintValue::Ty<UShort4>::val(const RValue<UShort4> &v)
+{
+	return toInt(extractAll(v.value, 4), false);
+}
+
+std::vector<Value *> PrintValue::Ty<Float>::val(const RValue<Float> &v)
+{
+	return toFloat({ v.value });
+}
+
+std::vector<Value *> PrintValue::Ty<Float4>::val(const RValue<Float4> &v)
+{
+	return toFloat(extractAll(v.value, 4));
+}
+
+std::vector<Value *> PrintValue::Ty<const char *>::val(const char *v)
+{
+	return { Nucleus::createConstantString(v) };
+}
+
+void Printv(const char *function, const char *file, int line, const char *fmt, std::initializer_list<PrintValue> args)
+{
+	// Build the printf format message string.
+	std::string str;
+	if(file != nullptr) { str += (line > 0) ? "%s:%d " : "%s "; }
+	if(function != nullptr) { str += "%s "; }
+	str += fmt;
+
+	// Perform substitution on all '{n}' bracketed indices in the format
+	// message.
+	int i = 0;
+	for(const PrintValue &arg : args)
+	{
+		str = replaceAll(str, "{" + std::to_string(i++) + "}", arg.format);
+	}
+
+	std::vector<Value *> vals;
+	vals.reserve(8);
+
+	// The format message is always the first argument.
+	vals.push_back(Nucleus::createConstantString(str));
+
+	// Add optional file, line and function info if provided.
+	if(file != nullptr)
+	{
+		vals.push_back(Nucleus::createConstantString(file));
+		if(line > 0)
+		{
+			vals.push_back(Nucleus::createConstantInt(line));
+		}
+	}
+	if(function != nullptr)
+	{
+		vals.push_back(Nucleus::createConstantString(function));
+	}
+
+	// Add all format arguments.
+	for(const PrintValue &arg : args)
+	{
+		for(auto val : arg.values)
+		{
+			vals.push_back(val);
+		}
+	}
+
+	// This call is implemented by each backend
+	VPrintf(vals);
+}
+#endif  // ENABLE_RR_PRINT
+
 }  // namespace rr
diff --git a/src/Reactor/SubzeroReactor.cpp b/src/Reactor/SubzeroReactor.cpp
index f2dbdef..29aa1c8 100644
--- a/src/Reactor/SubzeroReactor.cpp
+++ b/src/Reactor/SubzeroReactor.cpp
@@ -14,6 +14,7 @@
 
 #include "Debug.hpp"
 #include "EmulatedReactor.hpp"
+#include "Print.hpp"
 #include "Reactor.hpp"
 
 #include "ExecutableMemory.hpp"
@@ -143,11 +144,8 @@
 }
 
 // Wrapper for calls on C functions with Ice types
-template<typename Return, typename... CArgs, typename... RArgs>
-Ice::Variable *Call(Ice::Cfg *function, Ice::CfgNode *basicBlock, Return(fptr)(CArgs...), RArgs &&... args)
+Ice::Variable *Call(Ice::Cfg *function, Ice::CfgNode *basicBlock, Ice::Type retTy, void const *fptr, const std::vector<Ice::Operand *> &iceArgs)
 {
-	Ice::Type retTy = T(rr::CToReactorT<Return>::getType());
-
 	// Subzero doesn't support boolean return values. Replace with an i32.
 	if(retTy == Ice::IceType_i1)
 	{
@@ -160,9 +158,7 @@
 		ret = function->makeVariable(retTy);
 	}
 
-	std::array<Ice::Variable *, sizeof...(args)> iceArgs{ { std::forward<RArgs>(args)... } };
-
-	auto call = Ice::InstCall::create(function, iceArgs.size(), ret, getConstantPointer(function->getContext(), reinterpret_cast<void const *>(fptr)), false);
+	auto call = Ice::InstCall::create(function, iceArgs.size(), ret, getConstantPointer(function->getContext(), fptr), false);
 	for(auto arg : iceArgs)
 	{
 		call->addArg(arg);
@@ -172,6 +168,15 @@
 	return ret;
 }
 
+// Wrapper for calls on C functions with Ice types
+template<typename Return, typename... CArgs, typename... RArgs>
+Ice::Variable *Call(Ice::Cfg *function, Ice::CfgNode *basicBlock, Return(fptr)(CArgs...), RArgs &&... args)
+{
+	Ice::Type retTy = T(rr::CToReactorT<Return>::getType());
+	std::vector<Ice::Operand *> iceArgs{ std::forward<RArgs>(args)... };
+	return Call(function, basicBlock, retTy, reinterpret_cast<void const *>(fptr), iceArgs);
+}
+
 // Returns a non-const variable copy of const v
 Ice::Variable *createUnconstCast(Ice::Cfg *function, Ice::CfgNode *basicBlock, Ice::Constant *v)
 {
@@ -414,6 +419,17 @@
 	return reinterpret_cast<Ice::Operand *>(v);
 }
 
+std::vector<Ice::Operand *> V(const std::vector<Value *> &values)
+{
+	std::vector<Ice::Operand *> result;
+	result.reserve(values.size());
+	for(auto &v : values)
+	{
+		result.push_back(V(v));
+	}
+	return result;
+}
+
 BasicBlock *B(Ice::CfgNode *b)
 {
 	return reinterpret_cast<BasicBlock *>(b);
@@ -798,6 +814,13 @@
 	std::vector<std::unique_ptr<uint8_t[]>> constantData;
 };
 
+#ifdef ENABLE_RR_PRINT
+void VPrintf(const std::vector<Value *> &vals)
+{
+	sz::Call(::function, ::basicBlock, Ice::IceType_i32, reinterpret_cast<const void *>(::printf), V(vals));
+}
+#endif  // ENABLE_RR_PRINT
+
 Nucleus::Nucleus()
 {
 	::codegenMutex.lock();  // Reactor is currently not thread safe
@@ -1701,7 +1724,7 @@
 Value *Nucleus::createExtractElement(Value *vector, Type *type, int index)
 {
 	auto result = ::function->makeVariable(T(type));
-	auto extract = Ice::InstExtractElement::create(::function, result, vector, ::context->getConstantInt32(index));
+	auto extract = Ice::InstExtractElement::create(::function, result, V(vector), ::context->getConstantInt32(index));
 	::basicBlock->appendInst(extract);
 
 	return V(result);
@@ -1764,11 +1787,58 @@
 	::basicBlock->appendInst(unreachable);
 }
 
+Type *Nucleus::getType(Value *value)
+{
+	return T(V(value)->getType());
+}
+
+Type *Nucleus::getContainedType(Type *vectorType)
+{
+	Ice::Type vecTy = T(vectorType);
+	switch(vecTy)
+	{
+		case Ice::IceType_v4i1: return T(Ice::IceType_i1);
+		case Ice::IceType_v8i1: return T(Ice::IceType_i1);
+		case Ice::IceType_v16i1: return T(Ice::IceType_i1);
+		case Ice::IceType_v16i8: return T(Ice::IceType_i8);
+		case Ice::IceType_v8i16: return T(Ice::IceType_i16);
+		case Ice::IceType_v4i32: return T(Ice::IceType_i32);
+		case Ice::IceType_v4f32: return T(Ice::IceType_f32);
+		default:
+			ASSERT_MSG(false, "getContainedType: input type is not a vector type");
+			return {};
+	}
+}
+
 Type *Nucleus::getPointerType(Type *ElementType)
 {
 	return T(sz::getPointerType(T(ElementType)));
 }
 
+static constexpr Ice::Type getNaturalIntType()
+{
+	constexpr size_t intSize = sizeof(int);
+	static_assert(intSize == 4 || intSize == 8, "");
+	return intSize == 4 ? Ice::IceType_i32 : Ice::IceType_i64;
+}
+
+Type *Nucleus::getPrintfStorageType(Type *valueType)
+{
+	Ice::Type valueTy = T(valueType);
+	switch(valueTy)
+	{
+		case Ice::IceType_i32:
+			return T(getNaturalIntType());
+
+		case Ice::IceType_f32:
+			return T(Ice::IceType_f64);
+
+		default:
+			UNIMPLEMENTED_NO_BUG("getPrintfStorageType: add more cases as needed");
+			return {};
+	}
+}
+
 Value *Nucleus::createNullValue(Type *Ty)
 {
 	if(Ice::isVectorType(T(Ty)))
@@ -1933,6 +2003,11 @@
 	return createConstantVector((const int64_t *)constants, type);
 }
 
+Value *Nucleus::createConstantString(const char *v)
+{
+	return V(IceConstantData(v, strlen(v) + 1));
+}
+
 Type *Void::getType()
 {
 	return T(Ice::IceType_void);