bool isNull() const { return !I; }
bool isInstruction() const { return I; }
+
+ llvm::Instruction *asInstruction() const { return I; }
+
+private:
bool isLoad() const { return I && llvm::isa<llvm::LoadInst>(I); }
bool isStore() const { return I && llvm::isa<llvm::StoreInst>(I); }
bool isCallInst() const { return I && llvm::isa<llvm::CallInst>(I); }
return I && llvm::isa<llvm::MemTransferInst>(I);
}
- llvm::Instruction *asInstruction() const { return I; }
llvm::LoadInst *asLoad() const { return llvm::cast<llvm::LoadInst>(I); }
llvm::StoreInst *asStore() const { return llvm::cast<llvm::StoreInst>(I); }
llvm::CallInst *asCallInst() const { return llvm::cast<llvm::CallInst>(I); }
return llvm::cast<llvm::MemTransferInst>(I);
}
};
+}
+
+namespace llvm {
+/// @brief Specialize simplify_type for MemAccInst to enable dyn_cast and cast
+/// from a MemAccInst object.
+template <> struct simplify_type<polly::MemAccInst> {
+ typedef Instruction *SimpleType;
+ static SimpleType getSimplifiedValue(polly::MemAccInst &I) {
+ return I.asInstruction();
+ }
+};
+}
+
+namespace polly {
/// @brief Check if the PHINode has any incoming Invoke edge.
///
}
void MemoryAccess::buildMemIntrinsicAccessRelation() {
- auto MAI = MemAccInst(getAccessInstruction());
- (void)MAI;
- assert(MAI.isMemIntrinsic());
+ assert(isa<MemIntrinsic>(getAccessInstruction()));
assert(Subscripts.size() == 2 && Sizes.size() == 0);
auto *SubscriptPWA = Statement->getPwAff(Subscripts[0]);
ScalarEvolution *SE = Statement->getParent()->getSE();
auto MAI = MemAccInst(getAccessInstruction());
- if (MAI.isMemIntrinsic())
+ if (isa<MemIntrinsic>(MAI))
return;
Value *Ptr = MAI.getPointerOperand();
if (!MA->isRead())
HasWriteAccess.insert(MA->getBaseAddr());
MemAccInst Acc(MA->getAccessInstruction());
- if (MA->isRead() && Acc.isMemTransferInst())
- PtrToAcc[Acc.asMemTransferInst()->getSource()] = MA;
+ if (MA->isRead() && isa<MemTransferInst>(Acc))
+ PtrToAcc[cast<MemTransferInst>(Acc)->getSource()] = MA;
else
PtrToAcc[Acc.getPointerOperand()] = MA;
AST.add(Acc);
const SCEVUnknown *BasePointer =
dyn_cast<SCEVUnknown>(SE->getPointerBase(AccessFunction));
enum MemoryAccess::AccessType Type =
- Inst.isLoad() ? MemoryAccess::READ : MemoryAccess::MUST_WRITE;
+ isa<LoadInst>(Inst) ? MemoryAccess::READ : MemoryAccess::MUST_WRITE;
if (auto *BitCast = dyn_cast<BitCastInst>(Address)) {
auto *Src = BitCast->getOperand(0);
Type *ElementType = Val->getType();
unsigned ElementSize = DL->getTypeAllocSize(ElementType);
enum MemoryAccess::AccessType Type =
- Inst.isLoad() ? MemoryAccess::READ : MemoryAccess::MUST_WRITE;
+ isa<LoadInst>(Inst) ? MemoryAccess::READ : MemoryAccess::MUST_WRITE;
const SCEV *AccessFunction = SE->getSCEVAtScope(Address, L);
const SCEVUnknown *BasePointer =
MemAccInst Inst, Loop *L, Region *R,
const ScopDetection::BoxedLoopsSetTy *BoxedLoops,
const InvariantLoadsSetTy &ScopRIL) {
- if (!Inst.isMemIntrinsic())
+ auto *MemIntr = dyn_cast_or_null<MemIntrinsic>(Inst);
+
+ if (MemIntr == nullptr)
return false;
- auto *LengthVal = SE->getSCEVAtScope(Inst.asMemIntrinsic()->getLength(), L);
+ auto *LengthVal = SE->getSCEVAtScope(MemIntr->getLength(), L);
assert(LengthVal);
// Check if the length val is actually affine or if we overapproximate it
if (!LengthIsAffine)
LengthVal = nullptr;
- auto *DestPtrVal = Inst.asMemIntrinsic()->getDest();
+ auto *DestPtrVal = MemIntr->getDest();
assert(DestPtrVal);
auto *DestAccFunc = SE->getSCEVAtScope(DestPtrVal, L);
assert(DestAccFunc);
IntegerType::getInt8Ty(DestPtrVal->getContext()), false,
{DestAccFunc, LengthVal}, {}, Inst.getValueOperand());
- if (!Inst.isMemTransferInst())
+ auto *MemTrans = dyn_cast<MemTransferInst>(MemIntr);
+ if (!MemTrans)
return true;
- auto *SrcPtrVal = Inst.asMemTransferInst()->getSource();
+ auto *SrcPtrVal = MemTrans->getSource();
assert(SrcPtrVal);
auto *SrcAccFunc = SE->getSCEVAtScope(SrcPtrVal, L);
assert(SrcAccFunc);
MemAccInst Inst, Loop *L, Region *R,
const ScopDetection::BoxedLoopsSetTy *BoxedLoops,
const InvariantLoadsSetTy &ScopRIL) {
- if (!Inst.isCallInst())
+ auto *CI = dyn_cast_or_null<CallInst>(Inst);
+
+ if (CI == nullptr)
return false;
- auto &CI = *Inst.asCallInst();
- if (CI.doesNotAccessMemory() || isIgnoredIntrinsic(&CI))
+ if (CI->doesNotAccessMemory() || isIgnoredIntrinsic(CI))
return true;
bool ReadOnly = false;
- auto *AF = SE->getConstant(IntegerType::getInt64Ty(CI.getContext()), 0);
- auto *CalledFunction = CI.getCalledFunction();
+ auto *AF = SE->getConstant(IntegerType::getInt64Ty(CI->getContext()), 0);
+ auto *CalledFunction = CI->getCalledFunction();
switch (AA->getModRefBehavior(CalledFunction)) {
case llvm::FMRB_UnknownModRefBehavior:
llvm_unreachable("Unknown mod ref behaviour cannot be represented.");
case llvm::FMRB_DoesNotAccessMemory:
return true;
case llvm::FMRB_OnlyReadsMemory:
- GlobalReads.push_back(&CI);
+ GlobalReads.push_back(CI);
return true;
case llvm::FMRB_OnlyReadsArgumentPointees:
ReadOnly = true;
// Fall through
case llvm::FMRB_OnlyAccessesArgumentPointees:
auto AccType = ReadOnly ? MemoryAccess::READ : MemoryAccess::MAY_WRITE;
- for (const auto &Arg : CI.arg_operands()) {
+ for (const auto &Arg : CI->arg_operands()) {
if (!Arg->getType()->isPointerTy())
continue;
auto *ArgBasePtr = cast<SCEVUnknown>(SE->getPointerBase(ArgSCEV));
addArrayAccess(Inst, AccType, ArgBasePtr->getValue(),
- ArgBasePtr->getType(), false, {AF}, {}, &CI);
+ ArgBasePtr->getType(), false, {AF}, {}, CI);
}
return true;
}
Value *Val = Inst.getValueOperand();
Type *ElementType = Val->getType();
enum MemoryAccess::AccessType Type =
- Inst.isLoad() ? MemoryAccess::READ : MemoryAccess::MUST_WRITE;
+ isa<LoadInst>(Inst) ? MemoryAccess::READ : MemoryAccess::MUST_WRITE;
const SCEV *AccessFunction = SE->getSCEVAtScope(Address, L);
const SCEVUnknown *BasePointer =