diff --git a/src/Reactor/Optimizer.cpp b/src/Reactor/Optimizer.cpp
index 558f64e..768760f 100644
--- a/src/Reactor/Optimizer.cpp
+++ b/src/Reactor/Optimizer.cpp
@@ -37,8 +37,8 @@
 	void deleteInstruction(Ice::Inst *instruction);
 	bool isDead(Ice::Inst *instruction);
 
-	static const Ice::InstIntrinsicCall *asLoadSubVector(const Ice::Inst *instruction);
-	static const Ice::InstIntrinsicCall *asStoreSubVector(const Ice::Inst *instruction);
+	static const Ice::InstIntrinsic *asLoadSubVector(const Ice::Inst *instruction);
+	static const Ice::InstIntrinsic *asStoreSubVector(const Ice::Inst *instruction);
 	static bool isLoad(const Ice::Inst &instruction);
 	static bool isStore(const Ice::Inst &instruction);
 	static Ice::Operand *storeAddress(const Ice::Inst *instruction);
@@ -578,9 +578,9 @@
 	return false;
 }
 
-const Ice::InstIntrinsicCall *Optimizer::asLoadSubVector(const Ice::Inst *instruction)
+const Ice::InstIntrinsic *Optimizer::asLoadSubVector(const Ice::Inst *instruction)
 {
-	if(auto *instrinsic = llvm::dyn_cast<Ice::InstIntrinsicCall>(instruction))
+	if(auto *instrinsic = llvm::dyn_cast<Ice::InstIntrinsic>(instruction))
 	{
 		if(instrinsic->getIntrinsicInfo().ID == Ice::Intrinsics::LoadSubVector)
 		{
@@ -591,9 +591,9 @@
 	return nullptr;
 }
 
-const Ice::InstIntrinsicCall *Optimizer::asStoreSubVector(const Ice::Inst *instruction)
+const Ice::InstIntrinsic *Optimizer::asStoreSubVector(const Ice::Inst *instruction)
 {
-	if(auto *instrinsic = llvm::dyn_cast<Ice::InstIntrinsicCall>(instruction))
+	if(auto *instrinsic = llvm::dyn_cast<Ice::InstIntrinsic>(instruction))
 	{
 		if(instrinsic->getIntrinsicInfo().ID == Ice::Intrinsics::StoreSubVector)
 		{
diff --git a/src/Reactor/SubzeroReactor.cpp b/src/Reactor/SubzeroReactor.cpp
index ee80697..15d15e3 100644
--- a/src/Reactor/SubzeroReactor.cpp
+++ b/src/Reactor/SubzeroReactor.cpp
@@ -1445,7 +1445,7 @@
 		{
 			const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::LoadSubVector, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
 			result = ::function->makeVariable(T(type));
-			auto load = Ice::InstIntrinsicCall::create(::function, 2, result, intrinsic);
+			auto load = Ice::InstIntrinsic::create(::function, 2, result, intrinsic);
 			load->addArg(ptr);
 			load->addArg(::context->getConstantInt32(typeSize(type)));
 			::basicBlock->appendInst(load);
@@ -1515,7 +1515,7 @@
 		else
 		{
 			const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::StoreSubVector, Ice::Intrinsics::SideEffects_T, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_T };
-			auto store = Ice::InstIntrinsicCall::create(::function, 3, nullptr, intrinsic);
+			auto store = Ice::InstIntrinsic::create(::function, 3, nullptr, intrinsic);
 			store->addArg(value);
 			store->addArg(ptr);
 			store->addArg(::context->getConstantInt32(typeSize(type)));
@@ -1575,7 +1575,7 @@
 	Ice::Variable *result = ::function->makeVariable(value->getType());
 
 	const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::AtomicRMW, Ice::Intrinsics::SideEffects_T, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_T };
-	auto inst = Ice::InstIntrinsicCall::create(::function, 0, result, intrinsic);
+	auto inst = Ice::InstIntrinsic::create(::function, 0, result, intrinsic);
 	auto op = ::context->getConstantInt32(rmwOp);
 	auto order = ::context->getConstantInt32(stdToIceMemoryOrder(memoryOrder));
 	inst->addArg(op);
@@ -1629,7 +1629,7 @@
 	Ice::Variable *result = ::function->makeVariable(value->getType());
 
 	const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::AtomicCmpxchg, Ice::Intrinsics::SideEffects_T, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_T };
-	auto inst = Ice::InstIntrinsicCall::create(::function, 0, result, intrinsic);
+	auto inst = Ice::InstIntrinsic::create(::function, 0, result, intrinsic);
 	auto orderEq = ::context->getConstantInt32(stdToIceMemoryOrder(memoryOrderEqual));
 	auto orderNeq = ::context->getConstantInt32(stdToIceMemoryOrder(memoryOrderUnequal));
 	inst->addArg(ptr);
@@ -2287,7 +2287,7 @@
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v16i8);
 		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::AddSaturateUnsigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
-		auto paddusb = Ice::InstIntrinsicCall::create(::function, 2, result, intrinsic);
+		auto paddusb = Ice::InstIntrinsic::create(::function, 2, result, intrinsic);
 		paddusb->addArg(x.value());
 		paddusb->addArg(y.value());
 		::basicBlock->appendInst(paddusb);
@@ -2317,7 +2317,7 @@
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v16i8);
 		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::SubtractSaturateUnsigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
-		auto psubusw = Ice::InstIntrinsicCall::create(::function, 2, result, intrinsic);
+		auto psubusw = Ice::InstIntrinsic::create(::function, 2, result, intrinsic);
 		psubusw->addArg(x.value());
 		psubusw->addArg(y.value());
 		::basicBlock->appendInst(psubusw);
@@ -2381,7 +2381,7 @@
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_i32);
 		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::SignMask, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
-		auto movmsk = Ice::InstIntrinsicCall::create(::function, 1, result, intrinsic);
+		auto movmsk = Ice::InstIntrinsic::create(::function, 1, result, intrinsic);
 		movmsk->addArg(x.value());
 		::basicBlock->appendInst(movmsk);
 
@@ -2442,7 +2442,7 @@
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v16i8);
 		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::AddSaturateSigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
-		auto paddsb = Ice::InstIntrinsicCall::create(::function, 2, result, intrinsic);
+		auto paddsb = Ice::InstIntrinsic::create(::function, 2, result, intrinsic);
 		paddsb->addArg(x.value());
 		paddsb->addArg(y.value());
 		::basicBlock->appendInst(paddsb);
@@ -2472,7 +2472,7 @@
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v16i8);
 		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::SubtractSaturateSigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
-		auto psubsb = Ice::InstIntrinsicCall::create(::function, 2, result, intrinsic);
+		auto psubsb = Ice::InstIntrinsic::create(::function, 2, result, intrinsic);
 		psubsb->addArg(x.value());
 		psubsb->addArg(y.value());
 		::basicBlock->appendInst(psubsb);
@@ -2493,7 +2493,7 @@
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_i32);
 		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::SignMask, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
-		auto movmsk = Ice::InstIntrinsicCall::create(::function, 1, result, intrinsic);
+		auto movmsk = Ice::InstIntrinsic::create(::function, 1, result, intrinsic);
 		movmsk->addArg(x.value());
 		::basicBlock->appendInst(movmsk);
 
@@ -2651,7 +2651,7 @@
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v8i16);
 		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::AddSaturateSigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
-		auto paddsw = Ice::InstIntrinsicCall::create(::function, 2, result, intrinsic);
+		auto paddsw = Ice::InstIntrinsic::create(::function, 2, result, intrinsic);
 		paddsw->addArg(x.value());
 		paddsw->addArg(y.value());
 		::basicBlock->appendInst(paddsw);
@@ -2677,7 +2677,7 @@
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v8i16);
 		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::SubtractSaturateSigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
-		auto psubsw = Ice::InstIntrinsicCall::create(::function, 2, result, intrinsic);
+		auto psubsw = Ice::InstIntrinsic::create(::function, 2, result, intrinsic);
 		psubsw->addArg(x.value());
 		psubsw->addArg(y.value());
 		::basicBlock->appendInst(psubsw);
@@ -2703,7 +2703,7 @@
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v8i16);
 		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::MultiplyHighSigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
-		auto pmulhw = Ice::InstIntrinsicCall::create(::function, 2, result, intrinsic);
+		auto pmulhw = Ice::InstIntrinsic::create(::function, 2, result, intrinsic);
 		pmulhw->addArg(x.value());
 		pmulhw->addArg(y.value());
 		::basicBlock->appendInst(pmulhw);
@@ -2727,7 +2727,7 @@
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v8i16);
 		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::MultiplyAddPairs, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
-		auto pmaddwd = Ice::InstIntrinsicCall::create(::function, 2, result, intrinsic);
+		auto pmaddwd = Ice::InstIntrinsic::create(::function, 2, result, intrinsic);
 		pmaddwd->addArg(x.value());
 		pmaddwd->addArg(y.value());
 		::basicBlock->appendInst(pmaddwd);
@@ -2757,7 +2757,7 @@
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v16i8);
 		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::VectorPackSigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
-		auto pack = Ice::InstIntrinsicCall::create(::function, 2, result, intrinsic);
+		auto pack = Ice::InstIntrinsic::create(::function, 2, result, intrinsic);
 		pack->addArg(x.value());
 		pack->addArg(y.value());
 		::basicBlock->appendInst(pack);
@@ -2787,7 +2787,7 @@
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v16i8);
 		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::VectorPackUnsigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
-		auto pack = Ice::InstIntrinsicCall::create(::function, 2, result, intrinsic);
+		auto pack = Ice::InstIntrinsic::create(::function, 2, result, intrinsic);
 		pack->addArg(x.value());
 		pack->addArg(y.value());
 		::basicBlock->appendInst(pack);
@@ -2940,7 +2940,7 @@
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v8i16);
 		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::AddSaturateUnsigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
-		auto paddusw = Ice::InstIntrinsicCall::create(::function, 2, result, intrinsic);
+		auto paddusw = Ice::InstIntrinsic::create(::function, 2, result, intrinsic);
 		paddusw->addArg(x.value());
 		paddusw->addArg(y.value());
 		::basicBlock->appendInst(paddusw);
@@ -2966,7 +2966,7 @@
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v8i16);
 		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::SubtractSaturateUnsigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
-		auto psubusw = Ice::InstIntrinsicCall::create(::function, 2, result, intrinsic);
+		auto psubusw = Ice::InstIntrinsic::create(::function, 2, result, intrinsic);
 		psubusw->addArg(x.value());
 		psubusw->addArg(y.value());
 		::basicBlock->appendInst(psubusw);
@@ -2992,7 +2992,7 @@
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v8i16);
 		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::MultiplyHighUnsigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
-		auto pmulhuw = Ice::InstIntrinsicCall::create(::function, 2, result, intrinsic);
+		auto pmulhuw = Ice::InstIntrinsic::create(::function, 2, result, intrinsic);
 		pmulhuw->addArg(x.value());
 		pmulhuw->addArg(y.value());
 		::basicBlock->appendInst(pmulhuw);
@@ -3250,7 +3250,7 @@
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_i32);
 		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::Nearbyint, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
-		auto nearbyint = Ice::InstIntrinsicCall::create(::function, 1, result, intrinsic);
+		auto nearbyint = Ice::InstIntrinsic::create(::function, 1, result, intrinsic);
 		nearbyint->addArg(cast.value());
 		::basicBlock->appendInst(nearbyint);
 
@@ -3602,7 +3602,7 @@
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v4i32);
 		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::Nearbyint, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
-		auto nearbyint = Ice::InstIntrinsicCall::create(::function, 1, result, intrinsic);
+		auto nearbyint = Ice::InstIntrinsic::create(::function, 1, result, intrinsic);
 		nearbyint->addArg(cast.value());
 		::basicBlock->appendInst(nearbyint);
 
@@ -3628,7 +3628,7 @@
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v4i32);
 		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::Nearbyint, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
-		auto nearbyint = Ice::InstIntrinsicCall::create(::function, 1, result, intrinsic);
+		auto nearbyint = Ice::InstIntrinsic::create(::function, 1, result, intrinsic);
 		nearbyint->addArg(clamped.value());
 		::basicBlock->appendInst(nearbyint);
 
@@ -3657,7 +3657,7 @@
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v8i16);
 		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::VectorPackSigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
-		auto pack = Ice::InstIntrinsicCall::create(::function, 2, result, intrinsic);
+		auto pack = Ice::InstIntrinsic::create(::function, 2, result, intrinsic);
 		pack->addArg(x.value());
 		pack->addArg(y.value());
 		::basicBlock->appendInst(pack);
@@ -3683,7 +3683,7 @@
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v8i16);
 		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::VectorPackUnsigned, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
-		auto pack = Ice::InstIntrinsicCall::create(::function, 2, result, intrinsic);
+		auto pack = Ice::InstIntrinsic::create(::function, 2, result, intrinsic);
 		pack->addArg(x.value());
 		pack->addArg(y.value());
 		::basicBlock->appendInst(pack);
@@ -3704,7 +3704,7 @@
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_i32);
 		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::SignMask, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
-		auto movmsk = Ice::InstIntrinsicCall::create(::function, 1, result, intrinsic);
+		auto movmsk = Ice::InstIntrinsic::create(::function, 1, result, intrinsic);
 		movmsk->addArg(x.value());
 		::basicBlock->appendInst(movmsk);
 
@@ -3876,7 +3876,7 @@
 	RR_DEBUG_INFO_UPDATE_LOC();
 	Ice::Variable *result = ::function->makeVariable(Ice::IceType_f32);
 	const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::Sqrt, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
-	auto sqrt = Ice::InstIntrinsicCall::create(::function, 1, result, intrinsic);
+	auto sqrt = Ice::InstIntrinsic::create(::function, 1, result, intrinsic);
 	sqrt->addArg(x.value());
 	::basicBlock->appendInst(sqrt);
 
@@ -4031,7 +4031,7 @@
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v4f32);
 		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::Sqrt, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
-		auto sqrt = Ice::InstIntrinsicCall::create(::function, 1, result, intrinsic);
+		auto sqrt = Ice::InstIntrinsic::create(::function, 1, result, intrinsic);
 		sqrt->addArg(x.value());
 		::basicBlock->appendInst(sqrt);
 
@@ -4051,7 +4051,7 @@
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_i32);
 		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::SignMask, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
-		auto movmsk = Ice::InstIntrinsicCall::create(::function, 1, result, intrinsic);
+		auto movmsk = Ice::InstIntrinsic::create(::function, 1, result, intrinsic);
 		movmsk->addArg(x.value());
 		::basicBlock->appendInst(movmsk);
 
@@ -4143,7 +4143,7 @@
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v4f32);
 		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::Round, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
-		auto round = Ice::InstIntrinsicCall::create(::function, 2, result, intrinsic);
+		auto round = Ice::InstIntrinsic::create(::function, 2, result, intrinsic);
 		round->addArg(x.value());
 		round->addArg(::context->getConstantInt32(0));
 		::basicBlock->appendInst(round);
@@ -4163,7 +4163,7 @@
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v4f32);
 		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::Round, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
-		auto round = Ice::InstIntrinsicCall::create(::function, 2, result, intrinsic);
+		auto round = Ice::InstIntrinsic::create(::function, 2, result, intrinsic);
 		round->addArg(x.value());
 		round->addArg(::context->getConstantInt32(3));
 		::basicBlock->appendInst(round);
@@ -4204,7 +4204,7 @@
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v4f32);
 		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::Round, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
-		auto round = Ice::InstIntrinsicCall::create(::function, 2, result, intrinsic);
+		auto round = Ice::InstIntrinsic::create(::function, 2, result, intrinsic);
 		round->addArg(x.value());
 		round->addArg(::context->getConstantInt32(1));
 		::basicBlock->appendInst(round);
@@ -4224,7 +4224,7 @@
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_v4f32);
 		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::Round, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
-		auto round = Ice::InstIntrinsicCall::create(::function, 2, result, intrinsic);
+		auto round = Ice::InstIntrinsic::create(::function, 2, result, intrinsic);
 		round->addArg(x.value());
 		round->addArg(::context->getConstantInt32(2));
 		::basicBlock->appendInst(round);
@@ -4271,7 +4271,7 @@
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
 	const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::Trap, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
-	auto trap = Ice::InstIntrinsicCall::create(::function, 0, nullptr, intrinsic);
+	auto trap = Ice::InstIntrinsic::create(::function, 0, nullptr, intrinsic);
 	::basicBlock->appendInst(trap);
 }
 
@@ -4279,7 +4279,7 @@
 {
 	RR_DEBUG_INFO_UPDATE_LOC();
 	const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::AtomicFence, Ice::Intrinsics::SideEffects_T, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
-	auto inst = Ice::InstIntrinsicCall::create(::function, 0, nullptr, intrinsic);
+	auto inst = Ice::InstIntrinsic::create(::function, 0, nullptr, intrinsic);
 	auto order = ::context->getConstantInt32(stdToIceMemoryOrder(memoryOrder));
 	inst->addArg(order);
 	::basicBlock->appendInst(inst);
@@ -4459,7 +4459,7 @@
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_i32);
 		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::Ctlz, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
-		auto ctlz = Ice::InstIntrinsicCall::create(::function, 1, result, intrinsic);
+		auto ctlz = Ice::InstIntrinsic::create(::function, 1, result, intrinsic);
 		ctlz->addArg(x.value());
 		::basicBlock->appendInst(ctlz);
 
@@ -4499,7 +4499,7 @@
 	{
 		Ice::Variable *result = ::function->makeVariable(Ice::IceType_i32);
 		const Ice::Intrinsics::IntrinsicInfo intrinsic = { Ice::Intrinsics::Cttz, Ice::Intrinsics::SideEffects_F, Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F };
-		auto ctlz = Ice::InstIntrinsicCall::create(::function, 1, result, intrinsic);
+		auto ctlz = Ice::InstIntrinsic::create(::function, 1, result, intrinsic);
 		ctlz->addArg(x.value());
 		::basicBlock->appendInst(ctlz);
 
diff --git a/third_party/subzero/docs/DESIGN.rst b/third_party/subzero/docs/DESIGN.rst
index 115d645..d9a3d4c 100644
--- a/third_party/subzero/docs/DESIGN.rst
+++ b/third_party/subzero/docs/DESIGN.rst
@@ -276,7 +276,7 @@
 
 - Icmp: integer comparison
 
-- IntrinsicCall: call a known intrinsic
+- Intrinsic: invoke a known intrinsic
 
 - InsertElement: insert a scalar element into a vector-type value
 
diff --git a/third_party/subzero/src/IceCfg.cpp b/third_party/subzero/src/IceCfg.cpp
index 7725bb4..98956ef 100644
--- a/third_party/subzero/src/IceCfg.cpp
+++ b/third_party/subzero/src/IceCfg.cpp
@@ -676,7 +676,7 @@
         case Inst::InstKind::Ret:
         case Inst::InstKind::Phi:
         case Inst::InstKind::Call:
-        case Inst::InstKind::IntrinsicCall:
+        case Inst::InstKind::Intrinsic:
         case Inst::InstKind::Load:
         case Inst::InstKind::Store:
         case Inst::InstKind::Switch:
diff --git a/third_party/subzero/src/IceConverter.cpp b/third_party/subzero/src/IceConverter.cpp
index bb113c8..65d0261 100644
--- a/third_party/subzero/src/IceConverter.cpp
+++ b/third_party/subzero/src/IceConverter.cpp
@@ -554,36 +554,38 @@
     Ice::Variable *Dest = mapValueToIceVar(Instr);
     Ice::Operand *CallTarget = convertValue(Instr->getCalledValue());
     unsigned NumArgs = Instr->getNumArgOperands();
-    // Note: Subzero doesn't (yet) do anything special with the Tail flag in
-    // the bitcode, i.e. CallInst::isTailCall().
-    Ice::InstCall *NewInst = nullptr;
-    const Ice::Intrinsics::FullIntrinsicInfo *Info = nullptr;
 
     if (const auto Target = dyn_cast<Ice::ConstantRelocatable>(CallTarget)) {
       // Check if this direct call is to an Intrinsic (starts with "llvm.")
       bool BadIntrinsic;
-      Info = Ctx->getIntrinsicsInfo().find(Target->getName(), BadIntrinsic);
+      const Ice::Intrinsics::FullIntrinsicInfo *Info =
+          Ctx->getIntrinsicsInfo().find(Target->getName(), BadIntrinsic);
       if (BadIntrinsic) {
         report_fatal_error(std::string("Invalid PNaCl intrinsic call: ") +
                            LLVMObjectAsString(Instr));
       }
-      if (Info)
-        NewInst = Ice::InstIntrinsicCall::create(Func.get(), NumArgs, Dest,
-                                                 CallTarget, Info->Info);
+      if (Info) {
+        Ice::InstIntrinsic *Intrinsic = Ice::InstIntrinsic::create(
+            Func.get(), NumArgs, Dest, CallTarget, Info->Info);
+        for (unsigned i = 0; i < NumArgs; ++i) {
+          Intrinsic->addArg(convertOperand(Instr, i));
+        }
+        validateIntrinsic(Intrinsic, Info);
+
+        return Intrinsic;
+      }
     }
 
-    // Not an intrinsic call.
-    if (NewInst == nullptr) {
-      NewInst = Ice::InstCall::create(Func.get(), NumArgs, Dest, CallTarget,
-                                      Instr->isTailCall());
-    }
+    // Not an intrinsic.
+    // Note: Subzero doesn't (yet) do anything special with the Tail flag in
+    // the bitcode, i.e. CallInst::isTailCall().
+    Ice::InstCall *Call = Ice::InstCall::create(
+        Func.get(), NumArgs, Dest, CallTarget, Instr->isTailCall());
     for (unsigned i = 0; i < NumArgs; ++i) {
-      NewInst->addArg(convertOperand(Instr, i));
+      Intrinsic->addArg(convertOperand(Instr, i));
     }
-    if (Info) {
-      validateIntrinsicCall(NewInst, Info);
-    }
-    return NewInst;
+
+    return Call;
   }
 
   Ice::Inst *convertAllocaInstruction(const AllocaInst *Instr) {
@@ -608,17 +610,17 @@
     return Node;
   }
 
-  void validateIntrinsicCall(const Ice::InstCall *Call,
-                             const Ice::Intrinsics::FullIntrinsicInfo *I) {
+  void validateIntrinsic(const Ice::InstIntrinsic *Intrinsic,
+                         const Ice::Intrinsics::FullIntrinsicInfo *I) {
     Ice::SizeT ArgIndex = 0;
-    switch (I->validateCall(Call, ArgIndex)) {
+    switch (I->validateCall(Intrinsic, ArgIndex)) {
     case Ice::Intrinsics::IsValidCall:
       break;
     case Ice::Intrinsics::BadReturnType: {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Intrinsic call expects return type " << I->getReturnType()
-             << ". Found: " << Call->getReturnType();
+             << ". Found: " << Intrinsic->getReturnType();
       report_fatal_error(StrBuf.str());
       break;
     }
@@ -626,7 +628,7 @@
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Intrinsic call expects " << I->getNumArgs()
-             << ". Found: " << Call->getNumArgs();
+             << ". Found: " << Intrinsic->getNumArgs();
       report_fatal_error(StrBuf.str());
       break;
     }
@@ -635,7 +637,7 @@
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Intrinsic call argument " << ArgIndex << " expects type "
              << I->getArgType(ArgIndex)
-             << ". Found: " << Call->getArg(ArgIndex)->getType();
+             << ". Found: " << Intrinsic->getArg(ArgIndex)->getType();
       report_fatal_error(StrBuf.str());
       break;
     }
diff --git a/third_party/subzero/src/IceELFObjectWriter.cpp b/third_party/subzero/src/IceELFObjectWriter.cpp
index 6517f39..1f375c6 100644
--- a/third_party/subzero/src/IceELFObjectWriter.cpp
+++ b/third_party/subzero/src/IceELFObjectWriter.cpp
@@ -629,14 +629,6 @@
     const auto *Sym = llvm::cast<ConstantRelocatable>(S);
     GlobalString Name = Sym->getName();
     assert(Name.hasStdString());
-    bool BadIntrinsic;
-    const Intrinsics::FullIntrinsicInfo *Info =
-        Ctx.getIntrinsicsInfo().find(Name, BadIntrinsic);
-    if (Info)
-      continue;
-    // Ignore BadIntrinsic, which is set if the name begins with "llvm." but
-    // doesn't match a known intrinsic.  If we want this to turn into an error,
-    // we should catch it early on.
     assert(Sym->getOffset() == 0);
     SymTab->noteUndefinedSym(Name, NullSection);
     StrTab->add(Name);
diff --git a/third_party/subzero/src/IceGlobalContext.cpp b/third_party/subzero/src/IceGlobalContext.cpp
index 392ccbf..f7cf65f 100644
--- a/third_party/subzero/src/IceGlobalContext.cpp
+++ b/third_party/subzero/src/IceGlobalContext.cpp
@@ -300,8 +300,7 @@
 GlobalContext::GlobalContext(Ostream *OsDump, Ostream *OsEmit, Ostream *OsError,
                              ELFStreamer *ELFStr)
     : Strings(new StringPool()), ConstPool(new ConstantPool()), ErrorStatus(),
-      StrDump(OsDump), StrEmit(OsEmit), StrError(OsError), IntrinsicsInfo(this),
-      ObjectWriter(),
+      StrDump(OsDump), StrEmit(OsEmit), StrError(OsError), ObjectWriter(),
       OptQWakeupSize(std::max(DefaultOptQWakeupSize,
                               size_t(getFlags().getNumTranslationThreads()))),
       OptQ(/*Sequential=*/getFlags().isSequential(),
diff --git a/third_party/subzero/src/IceGlobalContext.h b/third_party/subzero/src/IceGlobalContext.h
index b901d52..4c15905 100644
--- a/third_party/subzero/src/IceGlobalContext.h
+++ b/third_party/subzero/src/IceGlobalContext.h
@@ -292,8 +292,6 @@
     return Ret;
   }
 
-  const Intrinsics &getIntrinsicsInfo() const { return IntrinsicsInfo; }
-
   ELFObjectWriter *getObjectWriter() const { return ObjectWriter.get(); }
 
   /// Reset stats at the beginning of a function.
@@ -486,7 +484,6 @@
 
   ICE_CACHELINE_BOUNDARY;
 
-  Intrinsics IntrinsicsInfo;
   // TODO(jpp): move to EmitterContext.
   std::unique_ptr<ELFObjectWriter> ObjectWriter;
   // Value defining when to wake up the main parse thread.
diff --git a/third_party/subzero/src/IceGlobalInits.cpp b/third_party/subzero/src/IceGlobalInits.cpp
index a21980b..d90e7f7 100644
--- a/third_party/subzero/src/IceGlobalInits.cpp
+++ b/third_party/subzero/src/IceGlobalInits.cpp
@@ -60,20 +60,7 @@
 
 namespace Ice {
 
-const Intrinsics::FullIntrinsicInfo *
-FunctionDeclaration::getIntrinsicInfo(const GlobalContext *Ctx,
-                                      bool *IsIntrinsic) const {
-  *IsIntrinsic = false;
-  if (!hasName())
-    return nullptr;
-  bool BadIntrinsic;
-  const Intrinsics::FullIntrinsicInfo *Info =
-      Ctx->getIntrinsicsInfo().find(getName(), BadIntrinsic);
-  *IsIntrinsic = Info || BadIntrinsic;
-  return Info;
-}
-
-bool FunctionDeclaration::validateRegularTypeSignature() const {
+bool FunctionDeclaration::validateTypeSignature() const {
   for (SizeT i = 0; i < Signature.getNumArgs(); ++i) {
     if (!isCallParameterType(Signature.getArgType(i)))
       return false;
@@ -81,32 +68,11 @@
   return isCallReturnType(Signature.getReturnType());
 }
 
-bool FunctionDeclaration::validateIntrinsicTypeSignature(
-    const Intrinsics::FullIntrinsicInfo *Info) const {
-  if (Signature.getNumArgs() != Info->getNumArgs())
-    return false;
-  for (SizeT i = 0; i < Signature.getNumArgs(); ++i) {
-    if (Signature.getArgType(i) != Info->getArgType(i))
-      return false;
-  }
-  return Signature.getReturnType() == Info->getReturnType();
-}
-
 std::string
 FunctionDeclaration::getTypeSignatureError(const GlobalContext *Ctx) {
   std::string Buffer;
   llvm::raw_string_ostream StrBuf(Buffer);
-  StrBuf << "Invalid";
-  bool IsIntrinsic;
-  const Intrinsics::FullIntrinsicInfo *Info =
-      getIntrinsicInfo(Ctx, &IsIntrinsic);
-  if (IsIntrinsic && Info == nullptr) {
-    StrBuf << " intrinsic name: " << getName();
-    return StrBuf.str();
-  }
-  StrBuf << " type signature for";
-  if (IsIntrinsic)
-    StrBuf << " intrinsic";
+  StrBuf << "Invalid type signature for";
   StrBuf << " " << getName() << ": " << getSignature();
   return StrBuf.str();
 }
diff --git a/third_party/subzero/src/IceGlobalInits.h b/third_party/subzero/src/IceGlobalInits.h
index e951734..3c4c2fc 100644
--- a/third_party/subzero/src/IceGlobalInits.h
+++ b/third_party/subzero/src/IceGlobalInits.h
@@ -98,10 +98,6 @@
     return isInternal() ? "internal" : "external";
   }
 
-  /// Returns true if the name of this GlobalDeclaration indicates that it
-  /// should have ExternalLinkage (as a special case).
-  virtual bool isPNaClABIExternalName(const std::string &Name) const = 0;
-
 protected:
   GlobalDeclaration(GlobalDeclarationKind Kind,
                     llvm::GlobalValue::LinkageTypes Linkage)
@@ -154,41 +150,17 @@
 
   /// Returns true if linkage is correct for the function declaration.
   bool verifyLinkageCorrect(const GlobalContext *Ctx) const {
-    if (getName().hasStdString()) {
-      if (isPNaClABIExternalName(getName().toString()) ||
-          isIntrinsicName(Ctx)) {
-        return Linkage == llvm::GlobalValue::ExternalLinkage;
-      }
-    }
     return verifyLinkageDefault();
   }
 
   /// Validates that the type signature of the function is correct. Returns true
   /// if valid.
-  bool validateTypeSignature(const GlobalContext *Ctx) const {
-    bool IsIntrinsic;
-    if (const Intrinsics::FullIntrinsicInfo *Info =
-            getIntrinsicInfo(Ctx, &IsIntrinsic))
-      return validateIntrinsicTypeSignature(Info);
-    return !IsIntrinsic && validateRegularTypeSignature();
-  }
+  bool validateTypeSignature() const;
 
   /// Generates an error message describing why validateTypeSignature returns
   /// false.
   std::string getTypeSignatureError(const GlobalContext *Ctx);
 
-  /// Returns corresponding PNaCl intrisic information.
-  const Intrinsics::FullIntrinsicInfo *
-  getIntrinsicInfo(const GlobalContext *Ctx) const {
-    bool BadIntrinsic;
-    return getIntrinsicInfo(Ctx, &BadIntrinsic);
-  }
-
-  /// Same as above, except IsIntrinsic is true if the function is intrinsic
-  /// (even if not a PNaCl intrinsic).
-  const Intrinsics::FullIntrinsicInfo *
-  getIntrinsicInfo(const GlobalContext *Ctx, bool *IsIntrinsic) const;
-
 private:
   const Ice::FuncSigType Signature;
   llvm::CallingConv::ID CallingConv;
@@ -199,21 +171,6 @@
                       llvm::GlobalValue::LinkageTypes Linkage, bool IsProto)
       : GlobalDeclaration(FunctionDeclarationKind, Linkage),
         Signature(Signature), CallingConv(CallingConv), IsProto(IsProto) {}
-
-  bool isPNaClABIExternalName(const std::string &Name) const override {
-    return Name == "_start";
-  }
-
-  bool isIntrinsicName(const GlobalContext *Ctx) const {
-    bool IsIntrinsic;
-    getIntrinsicInfo(Ctx, &IsIntrinsic);
-    return IsIntrinsic;
-  }
-
-  bool validateRegularTypeSignature() const;
-
-  bool validateIntrinsicTypeSignature(
-      const Intrinsics::FullIntrinsicInfo *Info) const;
 };
 
 /// Models a global variable declaration, and its initializers.
@@ -461,14 +418,7 @@
   virtual void dump(Ostream &Stream) const override;
 
   /// Returns true if linkage is correct for the variable declaration.
-  bool verifyLinkageCorrect() const {
-    if (getName().hasStdString()) {
-      if (isPNaClABIExternalName(getName().toString())) {
-        return Linkage == llvm::GlobalValue::ExternalLinkage;
-      }
-    }
-    return verifyLinkageDefault();
-  }
+  bool verifyLinkageCorrect() const { return verifyLinkageDefault(); }
 
   static bool classof(const GlobalDeclaration *Addr) {
     return Addr->getKind() == VariableDeclarationKind;
@@ -482,10 +432,6 @@
 
   void discardInitializers() { Initializers.clear(); }
 
-  bool isPNaClABIExternalName(const std::string &Name) const override {
-    return Name == "__pnacl_pso_root";
-  }
-
 private:
   /// List of initializers for the declared variable.
   InitializerListType Initializers;
diff --git a/third_party/subzero/src/IceInst.cpp b/third_party/subzero/src/IceInst.cpp
index 7cf0a34..5c9a5a3 100644
--- a/third_party/subzero/src/IceInst.cpp
+++ b/third_party/subzero/src/IceInst.cpp
@@ -91,7 +91,7 @@
     X(ExtractElement, "extractelement");
     X(Fcmp, "fcmp");
     X(Icmp, "icmp");
-    X(IntrinsicCall, "intrinsiccall");
+    X(Intrinsic, "intrinsic");
     X(InsertElement, "insertelement");
     X(Load, "load");
     X(Phi, "phi");
diff --git a/third_party/subzero/src/IceInst.h b/third_party/subzero/src/IceInst.h
index d602abf..bd38dd9 100644
--- a/third_party/subzero/src/IceInst.h
+++ b/third_party/subzero/src/IceInst.h
@@ -54,7 +54,7 @@
     ExtractElement,
     Fcmp,
     Icmp,
-    IntrinsicCall,
+    Intrinsic,
     InsertElement,
     Load,
     Phi,
@@ -429,8 +429,7 @@
                           bool IsTargetHelperCall = false,
                           bool IsVariadic = false) {
     /// Set HasSideEffects to true so that the call instruction can't be
-    /// dead-code eliminated. IntrinsicCalls can override this if the particular
-    /// intrinsic is deletable and has no side-effects.
+    /// dead-code eliminated.
     constexpr bool HasSideEffects = true;
     constexpr InstKind Kind = Inst::Call;
     return new (Func->allocate<InstCall>())
@@ -610,23 +609,24 @@
                     Operand *Source2, Operand *Source3);
 };
 
-/// Call to an intrinsic function.
-class InstIntrinsicCall : public InstHighLevel {
-  InstIntrinsicCall() = delete;
-  InstIntrinsicCall(const InstIntrinsicCall &) = delete;
-  InstIntrinsicCall &operator=(const InstIntrinsicCall &) = delete;
+/// An intrinsic operation, representing either a sequence of instructions,
+/// or a single instruction. Availability of intrinsics is target-specific.
+class InstIntrinsic : public InstHighLevel {
+  InstIntrinsic() = delete;
+  InstIntrinsic(const InstIntrinsic &) = delete;
+  InstIntrinsic &operator=(const InstIntrinsic &) = delete;
 
 public:
-  static InstIntrinsicCall *create(Cfg *Func, SizeT NumArgs, Variable *Dest,
-                                   const Intrinsics::IntrinsicInfo &Info) {
-    return new (Func->allocate<InstIntrinsicCall>())
-        InstIntrinsicCall(Func, NumArgs, Dest, Info);
+  static InstIntrinsic *create(Cfg *Func, SizeT NumArgs, Variable *Dest,
+                               const Intrinsics::IntrinsicInfo &Info) {
+    return new (Func->allocate<InstIntrinsic>())
+        InstIntrinsic(Func, NumArgs, Dest, Info);
   }
   void addArg(Operand *Arg) { addSource(Arg); }
   Operand *getArg(SizeT I) const { return getSrc(I); }
   SizeT getNumArgs() const { return getSrcSize(); }
   static bool classof(const Inst *Instr) {
-    return Instr->getKind() == IntrinsicCall;
+    return Instr->getKind() == Intrinsic;
   }
 
   Intrinsics::IntrinsicInfo getIntrinsicInfo() const { return Info; }
@@ -635,9 +635,9 @@
   }
 
 private:
-  InstIntrinsicCall(Cfg *Func, SizeT NumArgs, Variable *Dest,
-                    const Intrinsics::IntrinsicInfo &Info)
-      : InstHighLevel(Func, Inst::IntrinsicCall, NumArgs, Dest), Info(Info) {}
+  InstIntrinsic(Cfg *Func, SizeT NumArgs, Variable *Dest,
+                const Intrinsics::IntrinsicInfo &Info)
+      : InstHighLevel(Func, Inst::Intrinsic, NumArgs, Dest), Info(Info) {}
 
   const Intrinsics::IntrinsicInfo Info;
 };
diff --git a/third_party/subzero/src/IceInstrumentation.cpp b/third_party/subzero/src/IceInstrumentation.cpp
index 0709bfc..b62bc9d 100644
--- a/third_party/subzero/src/IceInstrumentation.cpp
+++ b/third_party/subzero/src/IceInstrumentation.cpp
@@ -87,8 +87,8 @@
   case Inst::InsertElement:
     instrumentInsertElement(Context, llvm::cast<InstInsertElement>(Instr));
     break;
-  case Inst::IntrinsicCall:
-    instrumentIntrinsicCall(Context, llvm::cast<InstIntrinsicCall>(Instr));
+  case Inst::Intrinsic:
+    instrumentIntrinsic(Context, llvm::cast<InstIntrinsic>(Instr));
     break;
   case Inst::Load:
     instrumentLoad(Context, llvm::cast<InstLoad>(Instr));
diff --git a/third_party/subzero/src/IceInstrumentation.h b/third_party/subzero/src/IceInstrumentation.h
index 2392f96..3177ce1 100644
--- a/third_party/subzero/src/IceInstrumentation.h
+++ b/third_party/subzero/src/IceInstrumentation.h
@@ -67,8 +67,7 @@
   virtual void instrumentIcmp(LoweringContext &, class InstIcmp *) {}
   virtual void instrumentInsertElement(LoweringContext &,
                                        class InstInsertElement *) {}
-  virtual void instrumentIntrinsicCall(LoweringContext &,
-                                       class InstIntrinsicCall *) {}
+  virtual void instrumentIntrinsic(LoweringContext &, class InstIntrinsic *) {}
   virtual void instrumentLoad(LoweringContext &, class InstLoad *) {}
   virtual void instrumentPhi(LoweringContext &, class InstPhi *) {}
   virtual void instrumentRet(LoweringContext &, class InstRet *) {}
diff --git a/third_party/subzero/src/IceIntrinsics.cpp b/third_party/subzero/src/IceIntrinsics.cpp
index cbf0726..fe3c679 100644
--- a/third_party/subzero/src/IceIntrinsics.cpp
+++ b/third_party/subzero/src/IceIntrinsics.cpp
@@ -29,248 +29,8 @@
 static_assert(sizeof(Intrinsics::IntrinsicInfo) == 4,
               "Unexpected sizeof(IntrinsicInfo)");
 
-namespace {
-
-#define INTRIN(ID, SE, RT, MW)                                                 \
-  { Intrinsics::ID, Intrinsics::SE, Intrinsics::RT, Intrinsics::MW }
-
-// Build list of intrinsics with their attributes and expected prototypes. List
-// is sorted alphabetically.
-const struct IceIntrinsicsEntry_ {
-  Intrinsics::FullIntrinsicInfo Info;
-  const char *IntrinsicName;
-} IceIntrinsicsTable[] = {
-
-#define AtomicCmpxchgInit(Overload, NameSuffix)                                \
-  {                                                                            \
-    {INTRIN(AtomicCmpxchg, SideEffects_T, ReturnsTwice_F, MemoryWrite_T),      \
-     {Overload, IceType_i32, Overload, Overload, IceType_i32, IceType_i32},    \
-     6},                                                                       \
-        "llvm.nacl.atomic.cmpxchg." NameSuffix                                 \
-  }
-    AtomicCmpxchgInit(IceType_i8, "i8"),
-    AtomicCmpxchgInit(IceType_i16, "i16"),
-    AtomicCmpxchgInit(IceType_i32, "i32"),
-    AtomicCmpxchgInit(IceType_i64, "i64"),
-#undef AtomicCmpxchgInit
-
-    {{INTRIN(AtomicFence, SideEffects_T, ReturnsTwice_F, MemoryWrite_T),
-      {IceType_void, IceType_i32},
-      2},
-     "llvm.nacl.atomic.fence"},
-    {{INTRIN(AtomicFenceAll, SideEffects_T, ReturnsTwice_F, MemoryWrite_T),
-      {IceType_void},
-      1},
-     "llvm.nacl.atomic.fence.all"},
-    {{INTRIN(AtomicIsLockFree, SideEffects_F, ReturnsTwice_F, MemoryWrite_F),
-      {IceType_i1, IceType_i32, IceType_i32},
-      3},
-     "llvm.nacl.atomic.is.lock.free"},
-
-#define AtomicLoadInit(Overload, NameSuffix)                                   \
-  {                                                                            \
-    {INTRIN(AtomicLoad, SideEffects_T, ReturnsTwice_F, MemoryWrite_T),         \
-     {Overload, IceType_i32, IceType_i32},                                     \
-     3},                                                                       \
-        "llvm.nacl.atomic.load." NameSuffix                                    \
-  }
-    AtomicLoadInit(IceType_i8, "i8"),
-    AtomicLoadInit(IceType_i16, "i16"),
-    AtomicLoadInit(IceType_i32, "i32"),
-    AtomicLoadInit(IceType_i64, "i64"),
-#undef AtomicLoadInit
-
-#define AtomicRMWInit(Overload, NameSuffix)                                    \
-  {                                                                            \
-    {INTRIN(AtomicRMW, SideEffects_T, ReturnsTwice_F, MemoryWrite_T),          \
-     {Overload, IceType_i32, IceType_i32, Overload, IceType_i32},              \
-     5},                                                                       \
-        "llvm.nacl.atomic.rmw." NameSuffix                                     \
-  }
-    AtomicRMWInit(IceType_i8, "i8"),
-    AtomicRMWInit(IceType_i16, "i16"),
-    AtomicRMWInit(IceType_i32, "i32"),
-    AtomicRMWInit(IceType_i64, "i64"),
-#undef AtomicRMWInit
-
-#define AtomicStoreInit(Overload, NameSuffix)                                  \
-  {                                                                            \
-    {INTRIN(AtomicStore, SideEffects_T, ReturnsTwice_F, MemoryWrite_T),        \
-     {IceType_void, Overload, IceType_i32, IceType_i32},                       \
-     4},                                                                       \
-        "llvm.nacl.atomic.store." NameSuffix                                   \
-  }
-    AtomicStoreInit(IceType_i8, "i8"),
-    AtomicStoreInit(IceType_i16, "i16"),
-    AtomicStoreInit(IceType_i32, "i32"),
-    AtomicStoreInit(IceType_i64, "i64"),
-#undef AtomicStoreInit
-
-#define BswapInit(Overload, NameSuffix)                                        \
-  {                                                                            \
-    {INTRIN(Bswap, SideEffects_F, ReturnsTwice_F, MemoryWrite_F),              \
-     {Overload, Overload},                                                     \
-     2},                                                                       \
-        "llvm.bswap." NameSuffix                                               \
-  }
-    BswapInit(IceType_i16, "i16"),
-    BswapInit(IceType_i32, "i32"),
-    BswapInit(IceType_i64, "i64"),
-#undef BswapInit
-
-#define CtlzInit(Overload, NameSuffix)                                         \
-  {                                                                            \
-    {INTRIN(Ctlz, SideEffects_F, ReturnsTwice_F, MemoryWrite_F),               \
-     {Overload, Overload, IceType_i1},                                         \
-     3},                                                                       \
-        "llvm.ctlz." NameSuffix                                                \
-  }
-    CtlzInit(IceType_i32, "i32"),
-    CtlzInit(IceType_i64, "i64"),
-#undef CtlzInit
-
-#define CtpopInit(Overload, NameSuffix)                                        \
-  {                                                                            \
-    {INTRIN(Ctpop, SideEffects_F, ReturnsTwice_F, MemoryWrite_F),              \
-     {Overload, Overload},                                                     \
-     2},                                                                       \
-        "llvm.ctpop." NameSuffix                                               \
-  }
-    CtpopInit(IceType_i32, "i32"),
-    CtpopInit(IceType_i64, "i64"),
-#undef CtpopInit
-
-#define CttzInit(Overload, NameSuffix)                                         \
-  {                                                                            \
-    {INTRIN(Cttz, SideEffects_F, ReturnsTwice_F, MemoryWrite_F),               \
-     {Overload, Overload, IceType_i1},                                         \
-     3},                                                                       \
-        "llvm.cttz." NameSuffix                                                \
-  }
-    CttzInit(IceType_i32, "i32"),
-    CttzInit(IceType_i64, "i64"),
-#undef CttzInit
-
-#define FabsInit(Overload, NameSuffix)                                         \
-  {                                                                            \
-    {INTRIN(Fabs, SideEffects_F, ReturnsTwice_F, MemoryWrite_F),               \
-     {Overload, Overload},                                                     \
-     2},                                                                       \
-        "llvm.fabs." NameSuffix                                                \
-  }
-    FabsInit(IceType_f32, "f32"),
-    FabsInit(IceType_f64, "f64"),
-    FabsInit(IceType_v4f32, "v4f32"),
-#undef FabsInit
-
-    {{INTRIN(Longjmp, SideEffects_T, ReturnsTwice_F, MemoryWrite_F),
-      {IceType_void, IceType_i32, IceType_i32},
-      3},
-     "llvm.nacl.longjmp"},
-    {{INTRIN(Memcpy, SideEffects_T, ReturnsTwice_F, MemoryWrite_T),
-      {IceType_void, IceType_i32, IceType_i32, IceType_i32, IceType_i32,
-       IceType_i1},
-      6},
-     "llvm.memcpy.p0i8.p0i8.i32"},
-    {{INTRIN(Memmove, SideEffects_T, ReturnsTwice_F, MemoryWrite_T),
-      {IceType_void, IceType_i32, IceType_i32, IceType_i32, IceType_i32,
-       IceType_i1},
-      6},
-     "llvm.memmove.p0i8.p0i8.i32"},
-    {{INTRIN(Memset, SideEffects_T, ReturnsTwice_F, MemoryWrite_T),
-      {IceType_void, IceType_i32, IceType_i8, IceType_i32, IceType_i32,
-       IceType_i1},
-      6},
-     "llvm.memset.p0i8.i32"},
-    {{INTRIN(NaClReadTP, SideEffects_F, ReturnsTwice_F, MemoryWrite_F),
-      {IceType_i32},
-      1},
-     "llvm.nacl.read.tp"},
-    {{INTRIN(Setjmp, SideEffects_T, ReturnsTwice_T, MemoryWrite_T),
-      {IceType_i32, IceType_i32},
-      2},
-     "llvm.nacl.setjmp"},
-
-#define SqrtInit(Overload, NameSuffix)                                         \
-  {                                                                            \
-    {INTRIN(Sqrt, SideEffects_F, ReturnsTwice_F, MemoryWrite_F),               \
-     {Overload, Overload},                                                     \
-     2},                                                                       \
-        "llvm.sqrt." NameSuffix                                                \
-  }
-    SqrtInit(IceType_f32, "f32"),
-    SqrtInit(IceType_f64, "f64"),
-#undef SqrtInit
-
-    {{INTRIN(Stacksave, SideEffects_T, ReturnsTwice_F, MemoryWrite_F),
-      {IceType_i32},
-      1},
-     "llvm.stacksave"},
-    {{INTRIN(Stackrestore, SideEffects_T, ReturnsTwice_F, MemoryWrite_F),
-      {IceType_void, IceType_i32},
-      2},
-     "llvm.stackrestore"},
-    {{INTRIN(Trap, SideEffects_T, ReturnsTwice_F, MemoryWrite_F),
-      {IceType_void},
-      1},
-     "llvm.trap"}};
-const size_t IceIntrinsicsTableSize = llvm::array_lengthof(IceIntrinsicsTable);
-
-#undef INTRIN
-
-} // end of anonymous namespace
-
-Intrinsics::Intrinsics(GlobalContext *Ctx) {
-  for (size_t I = 0; I < IceIntrinsicsTableSize; ++I) {
-    const struct IceIntrinsicsEntry_ &Entry = IceIntrinsicsTable[I];
-    assert(Entry.Info.NumTypes <= kMaxIntrinsicParameters);
-    Map.insert(
-        std::make_pair(Ctx->getGlobalString(Entry.IntrinsicName), Entry.Info));
-  }
-}
-
-const Intrinsics::FullIntrinsicInfo *Intrinsics::find(GlobalString Name,
-                                                      bool &Error) const {
-  static constexpr char LLVMPrefix[] = "llvm.";
-  constexpr size_t LLVMPrefixLen = llvm::array_lengthof(LLVMPrefix) - 1;
-  Error = false;
-  if (Name.toString().substr(0, LLVMPrefixLen) != LLVMPrefix)
-    return nullptr;
-  auto Iter = Map.find(Name);
-  if (Iter == Map.end()) {
-    Error = true;
-    return nullptr;
-  }
-  return &Iter->second;
-}
-
-namespace {
-
-// Returns whether PNaCl allows the given memory ordering in general.
-bool isMemoryOrderValidPNaCl(uint64_t Order) {
-  if (::Ice::getFlags().getApplicationBinaryInterface() != ::Ice::ABI_PNaCl)
-    return true;
-
-  switch (Order) {
-  case Intrinsics::MemoryOrderAcquire:
-  case Intrinsics::MemoryOrderRelease:
-  case Intrinsics::MemoryOrderAcquireRelease:
-  case Intrinsics::MemoryOrderSequentiallyConsistent:
-    return true;
-  default:
-    return false;
-  }
-}
-
-} // end of anonymous namespace
-
 bool Intrinsics::isMemoryOrderValid(IntrinsicID ID, uint64_t Order,
                                     uint64_t OrderOther) {
-  // Reject orderings not allowed in PNaCl.
-  if (!isMemoryOrderValidPNaCl(Order))
-    return false;
-  if (ID == AtomicCmpxchg && !isMemoryOrderValidPNaCl(OrderOther))
-    return false;
   // Reject orderings not allowed by C++11.
   switch (ID) {
   default:
@@ -316,27 +76,27 @@
   }
 }
 
-Intrinsics::ValidateCallValue
-Intrinsics::FullIntrinsicInfo::validateCall(const InstCall *Call,
-                                            SizeT &ArgIndex) const {
+Intrinsics::ValidateIntrinsicValue
+Intrinsics::FullIntrinsicInfo::validateIntrinsic(const InstIntrinsic *Intrinsic,
+                                                 SizeT &ArgIndex) const {
   assert(NumTypes >= 1);
-  Variable *Result = Call->getDest();
+  Variable *Result = Intrinsic->getDest();
   if (Result == nullptr) {
     if (getReturnType() != IceType_void)
       return Intrinsics::BadReturnType;
   } else if (getReturnType() != Result->getType()) {
     return Intrinsics::BadReturnType;
   }
-  if (Call->getNumArgs() != getNumArgs()) {
+  if (Intrinsic->getNumArgs() != getNumArgs()) {
     return Intrinsics::WrongNumOfArgs;
   }
   for (size_t i = 1; i < NumTypes; ++i) {
-    if (Call->getArg(i - 1)->getType() != Signature[i]) {
+    if (Intrinsic->getArg(i - 1)->getType() != Signature[i]) {
       ArgIndex = i - 1;
-      return Intrinsics::WrongCallArgType;
+      return Intrinsics::WrongArgType;
     }
   }
-  return Intrinsics::IsValidCall;
+  return Intrinsics::IsValidIntrinsic;
 }
 
 Type Intrinsics::FullIntrinsicInfo::getArgType(SizeT Index) const {
diff --git a/third_party/subzero/src/IceIntrinsics.h b/third_party/subzero/src/IceIntrinsics.h
index 54a0243..447ac4d 100644
--- a/third_party/subzero/src/IceIntrinsics.h
+++ b/third_party/subzero/src/IceIntrinsics.h
@@ -21,173 +21,151 @@
 
 namespace Ice {
 
-class InstCall;
+class InstIntrinsic;
 
 static constexpr size_t kMaxIntrinsicParameters = 6;
 
-class Intrinsics {
-  Intrinsics(const Intrinsics &) = delete;
-  Intrinsics &operator=(const Intrinsics &) = delete;
+namespace Intrinsics {
 
-public:
-  explicit Intrinsics(GlobalContext *Ctx);
-  ~Intrinsics() = default;
-
-  /// Some intrinsics allow overloading by type. This enum collapses all
-  /// overloads into a single ID, but the type can still be recovered by the
-  /// type of the intrinsic function call's return value and parameters.
-  enum IntrinsicID {
-    UnknownIntrinsic = 0,
-    // Arbitrary (alphabetical) order.
-    AtomicCmpxchg,
-    AtomicFence,
-    AtomicFenceAll,
-    AtomicIsLockFree,
-    AtomicLoad,
-    AtomicRMW,
-    AtomicStore,
-    Bswap,
-    Ctlz,
-    Ctpop,
-    Cttz,
-    Fabs,
-    Longjmp,
-    Memcpy,
-    Memmove,
-    Memset,
-    NaClReadTP,
-    Setjmp,
-    Sqrt,
-    Stacksave,
-    Stackrestore,
-    Trap,
-    // The intrinsics below are not part of the PNaCl specification.
-    AddSaturateSigned,
-    AddSaturateUnsigned,
-    LoadSubVector,
-    MultiplyAddPairs,
-    MultiplyHighSigned,
-    MultiplyHighUnsigned,
-    Nearbyint,
-    Round,
-    SignMask,
-    StoreSubVector,
-    SubtractSaturateSigned,
-    SubtractSaturateUnsigned,
-    VectorPackSigned,
-    VectorPackUnsigned
-  };
-
-  /// Operations that can be represented by the AtomicRMW intrinsic.
-  ///
-  /// Do not reorder these values: their order offers forward compatibility of
-  /// bitcode targeted to PNaCl.
-  enum AtomicRMWOperation {
-    AtomicInvalid = 0, // Invalid, keep first.
-    AtomicAdd,
-    AtomicSub,
-    AtomicOr,
-    AtomicAnd,
-    AtomicXor,
-    AtomicExchange,
-    AtomicNum // Invalid, keep last.
-  };
-
-  /// Memory orderings supported by PNaCl IR.
-  ///
-  /// Do not reorder these values: their order offers forward compatibility of
-  /// bitcode targeted to PNaCl.
-  enum MemoryOrder {
-    MemoryOrderInvalid = 0, // Invalid, keep first.
-    MemoryOrderRelaxed,
-    MemoryOrderConsume,
-    MemoryOrderAcquire,
-    MemoryOrderRelease,
-    MemoryOrderAcquireRelease,
-    MemoryOrderSequentiallyConsistent,
-    MemoryOrderNum // Invalid, keep last.
-  };
-
-  /// Verify memory ordering rules for atomic intrinsics. For AtomicCmpxchg,
-  /// Order is the "success" ordering and OrderOther is the "failure" ordering.
-  /// Returns true if valid, false if invalid.
-  // TODO(stichnot,kschimpf): Perform memory order validation in the bitcode
-  // reader/parser, allowing LLVM and Subzero to share. See
-  // https://code.google.com/p/nativeclient/issues/detail?id=4126 .
-  static bool isMemoryOrderValid(IntrinsicID ID, uint64_t Order,
-                                 uint64_t OrderOther = MemoryOrderInvalid);
-
-  enum SideEffects { SideEffects_F = 0, SideEffects_T = 1 };
-
-  enum ReturnsTwice { ReturnsTwice_F = 0, ReturnsTwice_T = 1 };
-
-  enum MemoryWrite { MemoryWrite_F = 0, MemoryWrite_T = 1 };
-
-  /// Basic attributes related to each intrinsic, that are relevant to code
-  /// generation. Perhaps the attributes representation can be shared with
-  /// general function calls, but PNaCl currently strips all attributes from
-  /// functions.
-  struct IntrinsicInfo {
-    enum IntrinsicID ID : 29;
-    enum SideEffects HasSideEffects : 1;
-    enum ReturnsTwice ReturnsTwice : 1;
-    enum MemoryWrite IsMemoryWrite : 1;
-  };
-  static_assert(sizeof(IntrinsicInfo) == 4, "IntrinsicInfo should be 32 bits");
-
-  /// The types of validation values for FullIntrinsicInfo.validateCall.
-  enum ValidateCallValue {
-    IsValidCall,      /// Valid use of instrinsic call.
-    BadReturnType,    /// Return type invalid for intrinsic.
-    WrongNumOfArgs,   /// Wrong number of arguments for intrinsic.
-    WrongCallArgType, /// Argument of wrong type.
-  };
-
-  /// The complete set of information about an intrinsic.
-  struct FullIntrinsicInfo {
-    struct IntrinsicInfo Info; /// Information that CodeGen would care about.
-
-    // Sanity check during parsing.
-    Type Signature[kMaxIntrinsicParameters];
-    uint8_t NumTypes;
-
-    /// Validates that type signature of call matches intrinsic. If
-    /// WrongArgumentType is returned, ArgIndex is set to corresponding argument
-    /// index.
-    ValidateCallValue validateCall(const Ice::InstCall *Call,
-                                   SizeT &ArgIndex) const;
-
-    /// Returns the return type of the intrinsic.
-    Type getReturnType() const {
-      assert(NumTypes > 0);
-      return Signature[0];
-    }
-
-    /// Returns number of arguments expected.
-    SizeT getNumArgs() const {
-      assert(NumTypes > 0);
-      return NumTypes - 1;
-    }
-
-    /// Returns type of Index-th argument.
-    Type getArgType(SizeT Index) const;
-  };
-
-  /// Find the information about a given intrinsic, based on function name. If
-  /// the function name does not have the common "llvm." prefix, nullptr is
-  /// returned and Error is set to false. Otherwise, tries to find a reference
-  /// to a FullIntrinsicInfo entry (valid for the lifetime of the map). If
-  /// found, sets Error to false and returns the reference. If not found, sets
-  /// Error to true and returns nullptr (indicating an unknown "llvm.foo"
-  /// intrinsic).
-  const FullIntrinsicInfo *find(GlobalString Name, bool &Error) const;
-
-private:
-  // TODO(jvoung): May want to switch to something like LLVM's StringMap.
-  using IntrinsicMap = std::unordered_map<GlobalString, FullIntrinsicInfo>;
-  IntrinsicMap Map;
+/// Some intrinsics allow overloading by type. This enum collapses all
+/// overloads into a single ID, but the type can still be recovered by the
+/// type of the intrinsic's return value and parameters.
+enum IntrinsicID {
+  UnknownIntrinsic = 0,
+  // Arbitrary (alphabetical) order.
+  AtomicCmpxchg,
+  AtomicFence,
+  AtomicFenceAll,
+  AtomicIsLockFree,
+  AtomicLoad,
+  AtomicRMW,
+  AtomicStore,
+  Bswap,
+  Ctlz,
+  Ctpop,
+  Cttz,
+  Fabs,
+  Longjmp,
+  Memcpy,
+  Memmove,
+  Memset,
+  NaClReadTP,
+  Setjmp,
+  Sqrt,
+  Stacksave,
+  Stackrestore,
+  Trap,
+  // The intrinsics below are not part of the PNaCl specification.
+  AddSaturateSigned,
+  AddSaturateUnsigned,
+  LoadSubVector,
+  MultiplyAddPairs,
+  MultiplyHighSigned,
+  MultiplyHighUnsigned,
+  Nearbyint,
+  Round,
+  SignMask,
+  StoreSubVector,
+  SubtractSaturateSigned,
+  SubtractSaturateUnsigned,
+  VectorPackSigned,
+  VectorPackUnsigned
 };
 
+/// Operations that can be represented by the AtomicRMW intrinsic.
+///
+/// Do not reorder these values: their order offers forward compatibility of
+/// bitcode targeted to PNaCl.
+enum AtomicRMWOperation {
+  AtomicInvalid = 0, // Invalid, keep first.
+  AtomicAdd,
+  AtomicSub,
+  AtomicOr,
+  AtomicAnd,
+  AtomicXor,
+  AtomicExchange,
+  AtomicNum // Invalid, keep last.
+};
+
+/// Memory orderings supported by PNaCl IR.
+///
+/// Do not reorder these values: their order offers forward compatibility of
+/// bitcode targeted to PNaCl.
+enum MemoryOrder {
+  MemoryOrderInvalid = 0, // Invalid, keep first.
+  MemoryOrderRelaxed,
+  MemoryOrderConsume,
+  MemoryOrderAcquire,
+  MemoryOrderRelease,
+  MemoryOrderAcquireRelease,
+  MemoryOrderSequentiallyConsistent,
+  MemoryOrderNum // Invalid, keep last.
+};
+
+/// Verify memory ordering rules for atomic intrinsics. For AtomicCmpxchg,
+/// Order is the "success" ordering and OrderOther is the "failure" ordering.
+/// Returns true if valid, false if invalid.
+// TODO(stichnot,kschimpf): Perform memory order validation in the bitcode
+// reader/parser, allowing LLVM and Subzero to share. See
+// https://code.google.com/p/nativeclient/issues/detail?id=4126 .
+bool isMemoryOrderValid(IntrinsicID ID, uint64_t Order,
+                        uint64_t OrderOther = MemoryOrderInvalid);
+
+enum SideEffects { SideEffects_F = 0, SideEffects_T = 1 };
+
+enum ReturnsTwice { ReturnsTwice_F = 0, ReturnsTwice_T = 1 };
+
+enum MemoryWrite { MemoryWrite_F = 0, MemoryWrite_T = 1 };
+
+/// Basic attributes related to each intrinsic, that are relevant to code
+/// generation.
+struct IntrinsicInfo {
+  enum IntrinsicID ID : 29;
+  enum SideEffects HasSideEffects : 1;
+  enum ReturnsTwice ReturnsTwice : 1;
+  enum MemoryWrite IsMemoryWrite : 1;
+};
+static_assert(sizeof(IntrinsicInfo) == 4, "IntrinsicInfo should be 32 bits");
+
+/// The types of validation values for FullIntrinsicInfo.validateIntrinsic.
+enum ValidateIntrinsicValue {
+  IsValidIntrinsic, /// Valid use of instrinsic.
+  BadReturnType,    /// Return type invalid for intrinsic.
+  WrongNumOfArgs,   /// Wrong number of arguments for intrinsic.
+  WrongArgType,     /// Argument of wrong type.
+};
+
+/// The complete set of information about an intrinsic.
+struct FullIntrinsicInfo {
+  struct IntrinsicInfo Info; /// Information that CodeGen would care about.
+
+  // Sanity check during parsing.
+  Type Signature[kMaxIntrinsicParameters];
+  uint8_t NumTypes;
+
+  /// Validates that type signature matches intrinsic. If WrongArgumentType is
+  /// returned, ArgIndex is set to corresponding argument index.
+  ValidateIntrinsicValue validateIntrinsic(const Ice::InstIntrinsic *Intrinsic,
+                                           SizeT &ArgIndex) const;
+
+  /// Returns the return type of the intrinsic.
+  Type getReturnType() const {
+    assert(NumTypes > 0);
+    return Signature[0];
+  }
+
+  /// Returns number of arguments expected.
+  SizeT getNumArgs() const {
+    assert(NumTypes > 0);
+    return NumTypes - 1;
+  }
+
+  /// Returns type of Index-th argument.
+  Type getArgType(SizeT Index) const;
+};
+
+} // namespace Intrinsics
+
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINTRINSICS_H
diff --git a/third_party/subzero/src/IceTargetLowering.cpp b/third_party/subzero/src/IceTargetLowering.cpp
index 7cb476b..179d760 100644
--- a/third_party/subzero/src/IceTargetLowering.cpp
+++ b/third_party/subzero/src/IceTargetLowering.cpp
@@ -365,7 +365,7 @@
   else if (llvm::isa<InstStore>(*Context.getCur()))
     doAddressOptStore();
   else if (auto *Intrinsic =
-               llvm::dyn_cast<InstIntrinsicCall>(&*Context.getCur())) {
+               llvm::dyn_cast<InstIntrinsic>(&*Context.getCur())) {
     if (Intrinsic->getIntrinsicInfo().ID == Intrinsics::LoadSubVector)
       doAddressOptLoadSubVector();
     else if (Intrinsic->getIntrinsicInfo().ID == Intrinsics::StoreSubVector)
@@ -444,11 +444,11 @@
     case Inst::InsertElement:
       lowerInsertElement(llvm::cast<InstInsertElement>(Instr));
       break;
-    case Inst::IntrinsicCall: {
-      auto *Call = llvm::cast<InstIntrinsicCall>(Instr);
-      if (Call->getIntrinsicInfo().ReturnsTwice)
+    case Inst::Intrinsic: {
+      auto *Intrinsic = llvm::cast<InstIntrinsic>(Instr);
+      if (Intrinsic->getIntrinsicInfo().ReturnsTwice)
         setCallsReturnsTwice(true);
-      lowerIntrinsicCall(Call);
+      lowerIntrinsic(Intrinsic);
       break;
     }
     case Inst::Load:
diff --git a/third_party/subzero/src/IceTargetLowering.h b/third_party/subzero/src/IceTargetLowering.h
index c92a929..ef81514 100644
--- a/third_party/subzero/src/IceTargetLowering.h
+++ b/third_party/subzero/src/IceTargetLowering.h
@@ -408,7 +408,7 @@
   virtual void lowerExtractElement(const InstExtractElement *Instr) = 0;
   virtual void lowerIcmp(const InstIcmp *Instr) = 0;
   virtual void lowerInsertElement(const InstInsertElement *Instr) = 0;
-  virtual void lowerIntrinsicCall(const InstIntrinsicCall *Instr) = 0;
+  virtual void lowerIntrinsic(const InstIntrinsic *Instr) = 0;
   virtual void lowerLoad(const InstLoad *Instr) = 0;
   virtual void lowerPhi(const InstPhi *Instr) = 0;
   virtual void lowerRet(const InstRet *Instr) = 0;
diff --git a/third_party/subzero/src/IceTargetLoweringARM32.cpp b/third_party/subzero/src/IceTargetLoweringARM32.cpp
index d290e15..8d71e2e 100644
--- a/third_party/subzero/src/IceTargetLoweringARM32.cpp
+++ b/third_party/subzero/src/IceTargetLoweringARM32.cpp
@@ -720,15 +720,15 @@
     }
     llvm::report_fatal_error("Control flow should never have reached here.");
   }
-  case Inst::IntrinsicCall: {
+  case Inst::Intrinsic: {
     Variable *Dest = Instr->getDest();
-    auto *IntrinsicCall = llvm::cast<InstIntrinsicCall>(Instr);
-    Intrinsics::IntrinsicID ID = IntrinsicCall->getIntrinsicInfo().ID;
+    auto *Intrinsic = llvm::cast<InstIntrinsic>(Instr);
+    Intrinsics::IntrinsicID ID = Intrinsic->getIntrinsicInfo().ID;
     switch (ID) {
     default:
       return;
     case Intrinsics::Ctpop: {
-      Operand *Src0 = IntrinsicCall->getArg(0);
+      Operand *Src0 = Intrinsic->getArg(0);
       Operand *TargetHelper =
           Ctx->getRuntimeHelperFunc(isInt32Asserting32Or64(Src0->getType())
                                         ? RuntimeHelper::H_call_ctpop_i32
@@ -750,8 +750,8 @@
           Ctx->getRuntimeHelperFunc(RuntimeHelper::H_call_longjmp);
       auto *Call = Context.insert<InstCall>(MaxArgs, NoDest, TargetHelper,
                                             NoTailCall, IsTargetHelperCall);
-      Call->addArg(IntrinsicCall->getArg(0));
-      Call->addArg(IntrinsicCall->getArg(1));
+      Call->addArg(Intrinsic->getArg(0));
+      Call->addArg(Intrinsic->getArg(1));
       Instr->setDeleted();
       return;
     }
@@ -764,9 +764,9 @@
           Ctx->getRuntimeHelperFunc(RuntimeHelper::H_call_memcpy);
       auto *Call = Context.insert<InstCall>(MaxArgs, NoDest, TargetHelper,
                                             NoTailCall, IsTargetHelperCall);
-      Call->addArg(IntrinsicCall->getArg(0));
-      Call->addArg(IntrinsicCall->getArg(1));
-      Call->addArg(IntrinsicCall->getArg(2));
+      Call->addArg(Intrinsic->getArg(0));
+      Call->addArg(Intrinsic->getArg(1));
+      Call->addArg(Intrinsic->getArg(2));
       Instr->setDeleted();
       return;
     }
@@ -777,16 +777,16 @@
           Ctx->getRuntimeHelperFunc(RuntimeHelper::H_call_memmove);
       auto *Call = Context.insert<InstCall>(MaxArgs, NoDest, TargetHelper,
                                             NoTailCall, IsTargetHelperCall);
-      Call->addArg(IntrinsicCall->getArg(0));
-      Call->addArg(IntrinsicCall->getArg(1));
-      Call->addArg(IntrinsicCall->getArg(2));
+      Call->addArg(Intrinsic->getArg(0));
+      Call->addArg(Intrinsic->getArg(1));
+      Call->addArg(Intrinsic->getArg(2));
       Instr->setDeleted();
       return;
     }
     case Intrinsics::Memset: {
       // The value operand needs to be extended to a stack slot size because the
       // PNaCl ABI requires arguments to be at least 32 bits wide.
-      Operand *ValOp = IntrinsicCall->getArg(1);
+      Operand *ValOp = Intrinsic->getArg(1);
       assert(ValOp->getType() == IceType_i8);
       Variable *ValExt = Func->makeVariable(stackSlotType());
       Context.insert<InstCast>(InstCast::Zext, ValExt, ValOp);
@@ -800,9 +800,9 @@
           Ctx->getRuntimeHelperFunc(RuntimeHelper::H_call_memset);
       auto *Call = Context.insert<InstCall>(MaxArgs, NoDest, TargetHelper,
                                             NoTailCall, IsTargetHelperCall);
-      Call->addArg(IntrinsicCall->getArg(0));
+      Call->addArg(Intrinsic->getArg(0));
       Call->addArg(ValExt);
-      Call->addArg(IntrinsicCall->getArg(2));
+      Call->addArg(Intrinsic->getArg(2));
       Instr->setDeleted();
       return;
     }
@@ -827,7 +827,7 @@
           Ctx->getRuntimeHelperFunc(RuntimeHelper::H_call_setjmp);
       auto *Call = Context.insert<InstCall>(MaxArgs, Dest, TargetHelper,
                                             NoTailCall, IsTargetHelperCall);
-      Call->addArg(IntrinsicCall->getArg(0));
+      Call->addArg(Intrinsic->getArg(0));
       Instr->setDeleted();
       return;
     }
@@ -5013,7 +5013,7 @@
   _mov(DestHi, T);
 }
 
-void TargetARM32::lowerIntrinsicCall(const InstIntrinsicCall *Instr) {
+void TargetARM32::lowerIntrinsic(const InstIntrinsic *Instr) {
   Variable *Dest = Instr->getDest();
   Type DestTy = (Dest != nullptr) ? Dest->getType() : IceType_void;
   Intrinsics::IntrinsicID ID = Instr->getIntrinsicInfo().ID;
diff --git a/third_party/subzero/src/IceTargetLoweringARM32.h b/third_party/subzero/src/IceTargetLoweringARM32.h
index a629627..51cb63e 100644
--- a/third_party/subzero/src/IceTargetLoweringARM32.h
+++ b/third_party/subzero/src/IceTargetLoweringARM32.h
@@ -281,7 +281,7 @@
   void lowerAtomicRMW(Variable *Dest, uint32_t Operation, Operand *Ptr,
                       Operand *Val);
   void lowerBreakpoint(const InstBreakpoint *Instr) override;
-  void lowerIntrinsicCall(const InstIntrinsicCall *Instr) override;
+  void lowerIntrinsic(const InstIntrinsic *Instr) override;
   void lowerInsertElement(const InstInsertElement *Instr) override;
   void lowerLoad(const InstLoad *Instr) override;
   void lowerPhi(const InstPhi *Instr) override;
diff --git a/third_party/subzero/src/IceTargetLoweringMIPS32.cpp b/third_party/subzero/src/IceTargetLoweringMIPS32.cpp
index cd082cd..bc8fc87 100644
--- a/third_party/subzero/src/IceTargetLoweringMIPS32.cpp
+++ b/third_party/subzero/src/IceTargetLoweringMIPS32.cpp
@@ -580,11 +580,11 @@
     }
     llvm::report_fatal_error("Control flow should never have reached here.");
   }
-  case Inst::IntrinsicCall: {
-    auto *IntrinsicCall = llvm::cast<InstIntrinsicCall>(Instr);
-    Intrinsics::IntrinsicID ID = IntrinsicCall->getIntrinsicInfo().ID;
+  case Inst::Intrinsic: {
+    auto *Intrinsic = llvm::cast<InstIntrinsic>(Instr);
+    Intrinsics::IntrinsicID ID = Intrinsic->getIntrinsicInfo().ID;
     if (isVectorType(DestTy) && ID == Intrinsics::Fabs) {
-      Operand *Src0 = IntrinsicCall->getArg(0);
+      Operand *Src0 = Intrinsic->getArg(0);
       GlobalString FabsFloat = Ctx->getGlobalString("llvm.fabs.f32");
       Operand *CallTarget = Ctx->getConstantExternSym(FabsFloat);
       GlobalString FabsVec = Ctx->getGlobalString("llvm.fabs.v4f32");
@@ -605,9 +605,8 @@
         Context.insert<InstExtractElement>(Op, Src0, Index);
         auto *Res = Func->makeVariable(IceType_f32);
         Variable *DestT = Func->makeVariable(IceType_v4f32);
-        auto *Call =
-            Context.insert<InstIntrinsicCall>(1, Res, CallTarget, Info);
-        Call->addArg(Op);
+        auto *Intrinsic = Context.insert<InstIntrinsic>(1, Res, CallTarget, Info);
+        Intrinsic->addArg(Op);
         Context.insert<InstInsertElement>(DestT, T, Res, Index);
         T = DestT;
       }
@@ -624,11 +623,11 @@
       if (DestTy != IceType_i64)
         return;
       if (!Intrinsics::isMemoryOrderValid(
-              ID, getConstantMemoryOrder(IntrinsicCall->getArg(1)))) {
+              ID, getConstantMemoryOrder(Intrinsic->getArg(1)))) {
         Func->setError("Unexpected memory ordering for AtomicLoad");
         return;
       }
-      Operand *Addr = IntrinsicCall->getArg(0);
+      Operand *Addr = Intrinsic->getArg(0);
       Operand *TargetHelper = Ctx->getConstantExternSym(
           Ctx->getGlobalString("__sync_val_compare_and_swap_8"));
       static constexpr SizeT MaxArgs = 3;
@@ -643,15 +642,15 @@
       return;
     }
     case Intrinsics::AtomicStore: {
-      Operand *Val = IntrinsicCall->getArg(0);
+      Operand *Val = Intrinsic->getArg(0);
       if (Val->getType() != IceType_i64)
         return;
       if (!Intrinsics::isMemoryOrderValid(
-              ID, getConstantMemoryOrder(IntrinsicCall->getArg(2)))) {
+              ID, getConstantMemoryOrder(Intrinsic->getArg(2)))) {
         Func->setError("Unexpected memory ordering for AtomicStore");
         return;
       }
-      Operand *Addr = IntrinsicCall->getArg(1);
+      Operand *Addr = Intrinsic->getArg(1);
       Variable *NoDest = nullptr;
       Operand *TargetHelper = Ctx->getConstantExternSym(
           Ctx->getGlobalString("__sync_lock_test_and_set_8"));
@@ -669,14 +668,14 @@
       if (DestTy != IceType_i64)
         return;
       if (!Intrinsics::isMemoryOrderValid(
-              ID, getConstantMemoryOrder(IntrinsicCall->getArg(3)),
-              getConstantMemoryOrder(IntrinsicCall->getArg(4)))) {
+              ID, getConstantMemoryOrder(Intrinsic->getArg(3)),
+              getConstantMemoryOrder(Intrinsic->getArg(4)))) {
         Func->setError("Unexpected memory ordering for AtomicCmpxchg");
         return;
       }
-      Operand *Addr = IntrinsicCall->getArg(0);
-      Operand *Oldval = IntrinsicCall->getArg(1);
-      Operand *Newval = IntrinsicCall->getArg(2);
+      Operand *Addr = Intrinsic->getArg(0);
+      Operand *Oldval = Intrinsic->getArg(1);
+      Operand *Newval = Intrinsic->getArg(2);
       Operand *TargetHelper = Ctx->getConstantExternSym(
           Ctx->getGlobalString("__sync_val_compare_and_swap_8"));
       Context.insert<InstMIPS32Sync>();
@@ -694,14 +693,14 @@
       if (DestTy != IceType_i64)
         return;
       if (!Intrinsics::isMemoryOrderValid(
-              ID, getConstantMemoryOrder(IntrinsicCall->getArg(3)))) {
+              ID, getConstantMemoryOrder(Intrinsic->getArg(3)))) {
         Func->setError("Unexpected memory ordering for AtomicRMW");
         return;
       }
       auto Operation = static_cast<Intrinsics::AtomicRMWOperation>(
-          llvm::cast<ConstantInteger32>(IntrinsicCall->getArg(0))->getValue());
-      auto *Addr = IntrinsicCall->getArg(1);
-      auto *Newval = IntrinsicCall->getArg(2);
+          llvm::cast<ConstantInteger32>(Intrinsic->getArg(0))->getValue());
+      auto *Addr = Intrinsic->getArg(1);
+      auto *Newval = Intrinsic->getArg(2);
       Operand *TargetHelper;
       switch (Operation) {
       case Intrinsics::AtomicAdd:
@@ -743,7 +742,7 @@
       return;
     }
     case Intrinsics::Ctpop: {
-      Operand *Src0 = IntrinsicCall->getArg(0);
+      Operand *Src0 = Intrinsic->getArg(0);
       Operand *TargetHelper =
           Ctx->getRuntimeHelperFunc(isInt32Asserting32Or64(Src0->getType())
                                         ? RuntimeHelper::H_call_ctpop_i32
@@ -762,8 +761,8 @@
           Ctx->getRuntimeHelperFunc(RuntimeHelper::H_call_longjmp);
       auto *Call = Context.insert<InstCall>(MaxArgs, NoDest, TargetHelper,
                                             NoTailCall, IsTargetHelperCall);
-      Call->addArg(IntrinsicCall->getArg(0));
-      Call->addArg(IntrinsicCall->getArg(1));
+      Call->addArg(Intrinsic->getArg(0));
+      Call->addArg(Intrinsic->getArg(1));
       Instr->setDeleted();
       return;
     }
@@ -774,9 +773,9 @@
           Ctx->getRuntimeHelperFunc(RuntimeHelper::H_call_memcpy);
       auto *Call = Context.insert<InstCall>(MaxArgs, NoDest, TargetHelper,
                                             NoTailCall, IsTargetHelperCall);
-      Call->addArg(IntrinsicCall->getArg(0));
-      Call->addArg(IntrinsicCall->getArg(1));
-      Call->addArg(IntrinsicCall->getArg(2));
+      Call->addArg(Intrinsic->getArg(0));
+      Call->addArg(Intrinsic->getArg(1));
+      Call->addArg(Intrinsic->getArg(2));
       Instr->setDeleted();
       return;
     }
@@ -787,14 +786,14 @@
           Ctx->getRuntimeHelperFunc(RuntimeHelper::H_call_memmove);
       auto *Call = Context.insert<InstCall>(MaxArgs, NoDest, TargetHelper,
                                             NoTailCall, IsTargetHelperCall);
-      Call->addArg(IntrinsicCall->getArg(0));
-      Call->addArg(IntrinsicCall->getArg(1));
-      Call->addArg(IntrinsicCall->getArg(2));
+      Call->addArg(Intrinsic->getArg(0));
+      Call->addArg(Intrinsic->getArg(1));
+      Call->addArg(Intrinsic->getArg(2));
       Instr->setDeleted();
       return;
     }
     case Intrinsics::Memset: {
-      Operand *ValOp = IntrinsicCall->getArg(1);
+      Operand *ValOp = Intrinsic->getArg(1);
       assert(ValOp->getType() == IceType_i8);
       Variable *ValExt = Func->makeVariable(stackSlotType());
       Context.insert<InstCast>(InstCast::Zext, ValExt, ValOp);
@@ -805,9 +804,9 @@
           Ctx->getRuntimeHelperFunc(RuntimeHelper::H_call_memset);
       auto *Call = Context.insert<InstCall>(MaxArgs, NoDest, TargetHelper,
                                             NoTailCall, IsTargetHelperCall);
-      Call->addArg(IntrinsicCall->getArg(0));
+      Call->addArg(Intrinsic->getArg(0));
       Call->addArg(ValExt);
-      Call->addArg(IntrinsicCall->getArg(2));
+      Call->addArg(Intrinsic->getArg(2));
       Instr->setDeleted();
       return;
     }
@@ -830,7 +829,7 @@
           Ctx->getRuntimeHelperFunc(RuntimeHelper::H_call_setjmp);
       auto *Call = Context.insert<InstCall>(MaxArgs, Dest, TargetHelper,
                                             NoTailCall, IsTargetHelperCall);
-      Call->addArg(IntrinsicCall->getArg(0));
+      Call->addArg(Intrinsic->getArg(0));
       Instr->setDeleted();
       return;
     }
@@ -4563,7 +4562,7 @@
   }
 }
 
-void TargetMIPS32::lowerIntrinsicCall(const InstIntrinsicCall *Instr) {
+void TargetMIPS32::lowerIntrinsic(const InstIntrinsic *Instr) {
   Variable *Dest = Instr->getDest();
   Type DestTy = (Dest == nullptr) ? IceType_void : Dest->getType();
 
diff --git a/third_party/subzero/src/IceTargetLoweringMIPS32.h b/third_party/subzero/src/IceTargetLoweringMIPS32.h
index 710e8e7..988de6e 100644
--- a/third_party/subzero/src/IceTargetLoweringMIPS32.h
+++ b/third_party/subzero/src/IceTargetLoweringMIPS32.h
@@ -777,7 +777,7 @@
   void lower64Icmp(const InstIcmp *Instr);
   void createArithInst(Intrinsics::AtomicRMWOperation Operation, Variable *Dest,
                        Variable *Src0, Variable *Src1);
-  void lowerIntrinsicCall(const InstIntrinsicCall *Instr) override;
+  void lowerIntrinsic(const InstIntrinsic *Instr) override;
   void lowerInsertElement(const InstInsertElement *Instr) override;
   void lowerLoad(const InstLoad *Instr) override;
   void lowerPhi(const InstPhi *Instr) override;
diff --git a/third_party/subzero/src/IceTargetLoweringX86Base.h b/third_party/subzero/src/IceTargetLoweringX86Base.h
index 376d7b2..4fffd43 100644
--- a/third_party/subzero/src/IceTargetLoweringX86Base.h
+++ b/third_party/subzero/src/IceTargetLoweringX86Base.h
@@ -274,7 +274,7 @@
   void lowerFcmp(const InstFcmp *Instr) override;
   void lowerIcmp(const InstIcmp *Instr) override;
 
-  void lowerIntrinsicCall(const InstIntrinsicCall *Instr) override;
+  void lowerIntrinsic(const InstIntrinsic *Instr) override;
   void lowerInsertElement(const InstInsertElement *Instr) override;
   void lowerLoad(const InstLoad *Instr) override;
   void lowerPhi(const InstPhi *Instr) override;
diff --git a/third_party/subzero/src/IceTargetLoweringX86BaseImpl.h b/third_party/subzero/src/IceTargetLoweringX86BaseImpl.h
index 397a19b..b9570e7 100644
--- a/third_party/subzero/src/IceTargetLoweringX86BaseImpl.h
+++ b/third_party/subzero/src/IceTargetLoweringX86BaseImpl.h
@@ -845,7 +845,7 @@
         constexpr bool DoLegalize = false;
         LoadSrc = formMemoryOperand(Load->getSourceAddress(),
                                     LoadDest->getType(), DoLegalize);
-      } else if (auto *Intrin = llvm::dyn_cast<InstIntrinsicCall>(CurInst)) {
+      } else if (auto *Intrin = llvm::dyn_cast<InstIntrinsic>(CurInst)) {
         // An AtomicLoad intrinsic qualifies as long as it has a valid memory
         // ordering, and can be implemented in a single instruction (i.e., not
         // i64 on x86-32).
@@ -4125,8 +4125,7 @@
 }
 
 template <typename TraitsType>
-void TargetX86Base<TraitsType>::lowerIntrinsicCall(
-    const InstIntrinsicCall *Instr) {
+void TargetX86Base<TraitsType>::lowerIntrinsic(const InstIntrinsic *Instr) {
   switch (Intrinsics::IntrinsicID ID = Instr->getIntrinsicInfo().ID) {
   case Intrinsics::AtomicCmpxchg: {
     if (!Intrinsics::isMemoryOrderValid(
@@ -4804,10 +4803,10 @@
   // [%y_phi = ...] // list of phi stores
   // br eq, %l1, %l2
   InstList::iterator I = Context.getCur();
-  // I is currently the InstIntrinsicCall. Peek past that.
+  // I is currently the InstIntrinsic. Peek past that.
   // This assumes that the atomic cmpxchg has not been lowered yet,
   // so that the instructions seen in the scan from "Cur" is simple.
-  assert(llvm::isa<InstIntrinsicCall>(*I));
+  assert(llvm::isa<InstIntrinsic>(*I));
   Inst *NextInst = Context.getNextInst(I);
   if (!NextInst)
     return false;
@@ -6118,7 +6117,7 @@
 
 template <typename TraitsType>
 void TargetX86Base<TraitsType>::doAddressOptLoadSubVector() {
-  auto *Intrinsic = llvm::cast<InstIntrinsicCall>(Context.getCur());
+  auto *Intrinsic = llvm::cast<InstIntrinsic>(Context.getCur());
   Operand *Addr = Intrinsic->getArg(0);
   Variable *Dest = Intrinsic->getDest();
   if (auto *OptAddr = computeAddressOpt(Intrinsic, Dest->getType(), Addr)) {
@@ -6126,7 +6125,7 @@
     const Ice::Intrinsics::IntrinsicInfo Info = {
         Ice::Intrinsics::LoadSubVector, Ice::Intrinsics::SideEffects_F,
         Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_F};
-    auto *NewLoad = Context.insert<InstIntrinsicCall>(2, Dest, Info);
+    auto *NewLoad = Context.insert<InstIntrinsic>(2, Dest, Info);
     NewLoad->addArg(OptAddr);
     NewLoad->addArg(Intrinsic->getArg(1));
   }
@@ -6993,7 +6992,7 @@
 
 template <typename TraitsType>
 void TargetX86Base<TraitsType>::doAddressOptStoreSubVector() {
-  auto *Intrinsic = llvm::cast<InstIntrinsicCall>(Context.getCur());
+  auto *Intrinsic = llvm::cast<InstIntrinsic>(Context.getCur());
   Operand *Addr = Intrinsic->getArg(1);
   Operand *Data = Intrinsic->getArg(0);
   if (auto *OptAddr = computeAddressOpt(Intrinsic, Data->getType(), Addr)) {
@@ -7001,7 +7000,7 @@
     const Ice::Intrinsics::IntrinsicInfo Info = {
         Ice::Intrinsics::StoreSubVector, Ice::Intrinsics::SideEffects_T,
         Ice::Intrinsics::ReturnsTwice_F, Ice::Intrinsics::MemoryWrite_T};
-    auto *NewStore = Context.insert<InstIntrinsicCall>(3, nullptr, Info);
+    auto *NewStore = Context.insert<InstIntrinsic>(3, nullptr, Info);
     NewStore->addArg(Data);
     NewStore->addArg(OptAddr);
     NewStore->addArg(Intrinsic->getArg(2));
@@ -7609,7 +7608,7 @@
     if (CallDest->getType() != Dest->getType())
       Context.insert<InstCast>(InstCast::Trunc, Dest, CallDest);
     Cast->setDeleted();
-  } else if (auto *Intrinsic = llvm::dyn_cast<InstIntrinsicCall>(Instr)) {
+  } else if (auto *Intrinsic = llvm::dyn_cast<InstIntrinsic>(Instr)) {
     CfgVector<Type> ArgTypes;
     Type ReturnType = IceType_void;
     switch (Intrinsics::IntrinsicID ID = Intrinsic->getIntrinsicInfo().ID) {
diff --git a/third_party/subzero/src/PNaClTranslator.cpp b/third_party/subzero/src/PNaClTranslator.cpp
index 95619a0..4646065 100644
--- a/third_party/subzero/src/PNaClTranslator.cpp
+++ b/third_party/subzero/src/PNaClTranslator.cpp
@@ -2758,8 +2758,8 @@
                               : getNextInstVar(ReturnType);
     std::unique_ptr<Ice::InstCall> Instr;
     if (IntrinsicInfo) {
-      Instr.reset(Ice::InstIntrinsicCall::create(
-          Func.get(), Params.size(), Dest, Callee, IntrinsicInfo->Info));
+      Instr.reset(Ice::InstIntrinsic::create(Func.get(), Params.size(), Dest,
+                                             Callee, IntrinsicInfo->Info));
     } else {
       Instr.reset(Ice::InstCall::create(Func.get(), Params.size(), Dest, Callee,
                                         IsTailCall));
diff --git a/third_party/subzero/src/WasmTranslator.cpp b/third_party/subzero/src/WasmTranslator.cpp
index 960a940..ab93eb3 100644
--- a/third_party/subzero/src/WasmTranslator.cpp
+++ b/third_party/subzero/src/WasmTranslator.cpp
@@ -741,7 +741,7 @@
       assert(!BadInstrinsic);
       assert(Info);
 
-      auto *Call = InstIntrinsicCall::create(
+      auto *Call = InstIntrinsic::create(
           Func, 1, Dest, Ctx->getConstantExternSym(FnName), Info->Info);
       Call->addArg(Input);
       Control()->appendInst(Call);
@@ -767,7 +767,7 @@
       assert(!BadInstrinsic);
       assert(Info);
 
-      auto *Call = InstIntrinsicCall::create(
+      auto *Call = InstIntrinsic::create(
           Func, 1, Dest, Ctx->getConstantExternSym(FnName), Info->Info);
       Call->addArg(Input);
       Control()->appendInst(Call);
@@ -781,7 +781,7 @@
       assert(!BadInstrinsic);
       assert(Info);
 
-      auto *Call = InstIntrinsicCall::create(
+      auto *Call = InstIntrinsic::create(
           Func, 1, Dest, Ctx->getConstantExternSym(FnName), Info->Info);
       Call->addArg(Input);
       Control()->appendInst(Call);
@@ -817,7 +817,7 @@
       assert(!BadInstrinsic);
       assert(Info);
 
-      auto *Call = InstIntrinsicCall::create(
+      auto *Call = InstIntrinsic::create(
           Func, 1, Dest, Ctx->getConstantExternSym(FnName), Info->Info);
       Call->addArg(Input);
       Control()->appendInst(Call);
@@ -831,7 +831,7 @@
       assert(!BadInstrinsic);
       assert(Info);
 
-      auto *Call = InstIntrinsicCall::create(
+      auto *Call = InstIntrinsic::create(
           Func, 1, Dest, Ctx->getConstantExternSym(FnName), Info->Info);
       Call->addArg(Input);
       Control()->appendInst(Call);