Rename InstIntrinsicCall to InstIntrinsic
It is no longer derived from InstCall, and doesn't take a Target
parameter which could be a symbol to a function which implements
the intrinsic.
Note one can still emit actual Call instructions if a function call
is needed. Since the previous change which removed the Target parameter
we can no longer decide between implementing an intrinsic as inline
instructions or a function call at the Subzero level, but we can still
do that at the Reactor level which has its own concept of intrinsics.
This change also removes mentions of intrinsics representing function
calls. It also removes code related to PNaCl-specific LLVM intrinsics,
including the ability to look up intrinsics by name. The addArg(),
getArg(), and getNumArgs() methods, adopted from InstCall (but no longer
inherited from it), are kept for now due to risk of replacing the ones
for InstCall objects, while the confusion caused by keeping the
function-related "arg" term is deemed low.
Bug: b/179497998
Change-Id: I293f039853abff6f5bebda1b714774205bdec846
Reviewed-on: https://swiftshader-review.googlesource.com/c/SwiftShader/+/52608
Presubmit-Ready: Nicolas Capens <nicolascapens@google.com>
Tested-by: Nicolas Capens <nicolascapens@google.com>
Kokoro-Result: kokoro <noreply+kokoro@google.com>
Reviewed-by: Antonio Maiorano <amaiorano@google.com>
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);
