if (!Node)
return;
- for (auto Op : Node->operands())
+ for (auto *Op : Node->operands())
if (Op->getNumOperands())
Printf.push_back(
std::string(cast<MDString>(Op->getOperand(0))->getString()));
return;
auto Printf = HSAMetadataDoc->getArrayNode();
- for (auto Op : Node->operands())
+ for (auto *Op : Node->operands())
if (Op->getNumOperands())
Printf.push_back(Printf.getDocument()->getNode(
cast<MDString>(Op->getOperand(0))->getString(), /*Copy=*/true));
int SchedGroup::link(SUnit &SU, bool MakePred,
std::vector<std::pair<SUnit *, SUnit *>> &AddedEdges) {
int MissedEdges = 0;
- for (auto A : Collection) {
+ for (auto *A : Collection) {
SUnit *B = &SU;
if (A == B || A->getInstr()->getOpcode() == AMDGPU::SCHED_GROUP_BARRIER)
continue;
}
void SchedGroup::link(SUnit &SU, bool MakePred) {
- for (auto A : Collection) {
+ for (auto *A : Collection) {
SUnit *B = &SU;
if (A->getInstr()->getOpcode() == AMDGPU::SCHED_GROUP_BARRIER)
continue;
void SchedGroup::link(SUnit &SU,
function_ref<bool(const SUnit *A, const SUnit *B)> P) {
- for (auto A : Collection) {
+ for (auto *A : Collection) {
SUnit *B = &SU;
if (P(A, B))
std::swap(A, B);
}
void SchedGroup::link(SchedGroup &OtherGroup) {
- for (auto B : OtherGroup.Collection)
+ for (auto *B : OtherGroup.Collection)
link(*B);
}
PHILinearize::PHIInfoElementT *
PHILinearize::findPHIInfoElement(unsigned DestReg) {
- for (auto I : PHIInfo) {
+ for (auto *I : PHIInfo) {
if (phiInfoElementGetDest(I) == DestReg) {
return I;
}
PHILinearize::PHIInfoElementT *
PHILinearize::findPHIInfoElementFromSource(unsigned SourceReg,
MachineBasicBlock *SourceMBB) {
- for (auto I : PHIInfo) {
+ for (auto *I : PHIInfo) {
for (auto SI : phiInfoElementGetSources(I)) {
if (SI.first == SourceReg &&
(SI.second == nullptr || SI.second == SourceMBB)) {
bool PHILinearize::findSourcesFromMBB(MachineBasicBlock *SourceMBB,
SmallVector<unsigned, 4> &Sources) {
bool FoundSource = false;
- for (auto I : PHIInfo) {
+ for (auto *I : PHIInfo) {
for (auto SI : phiInfoElementGetSources(I)) {
if (SI.second == SourceMBB) {
FoundSource = true;
LLVM_DUMP_METHOD void PHILinearize::dump(MachineRegisterInfo *MRI) {
const TargetRegisterInfo *TRI = MRI->getTargetRegisterInfo();
dbgs() << "=PHIInfo Start=\n";
- for (auto PII : this->PHIInfo) {
+ for (auto *PII : this->PHIInfo) {
PHIInfoElementT &Element = *PII;
dbgs() << "Dest: " << printReg(Element.DestReg, TRI)
<< " Sources: {";
delete LRegion;
}
- for (auto CI : Children) {
+ for (auto *CI : Children) {
delete &(*CI);
}
}
dbgs() << "Succ: " << getSucc()->getNumber() << "\n";
else
dbgs() << "Succ: none \n";
- for (auto MRTI : Children) {
+ for (auto *MRTI : Children) {
MRTI->dump(TRI, depth + 1);
}
}
MachineBasicBlock *getSucc() { return Succ; }
bool contains(MachineBasicBlock *MBB) {
- for (auto CI : Children) {
+ for (auto *CI : Children) {
if (CI->isMBB()) {
if (MBB == CI->getMBBMRT()->getMBB()) {
return true;
RegionMap[RegionInfo->getRegionFor(Exit)]->addChild(ExitMRT);
ExitMRT->setBBSelectRegIn(BBSelectRegIn);
- for (auto MBBI : post_order(&(MF.front()))) {
+ for (auto *MBBI : post_order(&(MF.front()))) {
MachineBasicBlock *MBB = &(*MBBI);
// Skip Exit since we already added it
return;
auto Children = Region->getChildren();
- for (auto CI : *Children) {
+ for (auto *CI : *Children) {
if (CI->isMBB()) {
auto MBB = CI->getMBBMRT()->getMBB();
storeMBBLiveOuts(MBB, MRI, TRI, PHIInfo, TopRegion);
LinearizedRegion *SubRegion = CI->getRegionMRT()->getLinearizedRegion();
// We should be limited to only store registers that are live out from the
// linearized region
- for (auto MBBI : SubRegion->MBBs) {
+ for (auto *MBBI : SubRegion->MBBs) {
storeMBBLiveOuts(MBBI, MRI, TRI, PHIInfo, TopRegion);
}
}
void LinearizedRegion::print(raw_ostream &OS, const TargetRegisterInfo *TRI) {
OS << "Linearized Region {";
bool IsFirst = true;
- for (auto MBB : MBBs) {
+ for (auto *MBB : MBBs) {
if (IsFirst) {
IsFirst = false;
} else {
void LinearizedRegion::addMBB(MachineBasicBlock *MBB) { MBBs.insert(MBB); }
void LinearizedRegion::addMBBs(LinearizedRegion *InnerRegion) {
- for (auto MBB : InnerRegion->MBBs) {
+ for (auto *MBB : InnerRegion->MBBs) {
addMBB(MBB);
}
}
const TargetRegisterInfo *TRI = MRI->getTargetRegisterInfo();
(void)TRI; // It's used by LLVM_DEBUG.
- for (auto MBBI : MBBs) {
+ for (auto *MBBI : MBBs) {
MachineBasicBlock *MBB = MBBI;
for (auto &II : *MBB) {
for (auto &RI : II.uses()) {
// linearizing it, because it is already linear
bool regionIsSequence(RegionMRT *Region) {
auto Children = Region->getChildren();
- for (auto CI : *Children) {
+ for (auto *CI : *Children) {
if (!CI->isRegion()) {
if (CI->getMBBMRT()->getMBB()->succ_size() > 1) {
return false;
void fixupRegionExits(RegionMRT *Region) {
auto Children = Region->getChildren();
- for (auto CI : *Children) {
+ for (auto *CI : *Children) {
if (!CI->isRegion()) {
fixMBBTerminator(CI->getMBBMRT()->getMBB());
} else {
}
}
- for (auto PI : PHIs) {
+ for (auto *PI : PHIs) {
PI->eraseFromParent();
}
}
collectPHIs(Exit, PHIs);
- for (auto PHII : PHIs) {
+ for (auto *PHII : PHIs) {
rewriteRegionExitPHI(Region, LastMerge, *PHII, LRegion);
}
}
collectPHIs(Entry, PHIs);
- for (auto PHII : PHIs) {
+ for (auto *PHII : PHIs) {
rewriteRegionEntryPHI(Region, IfMBB, *PHII);
}
}
SmallVector<MachineInstr *, 2> PHIs;
collectPHIs(Entry, PHIs);
- for (auto PHII : PHIs) {
+ for (auto *PHII : PHIs) {
splitLoopPHI(*PHII, Entry, EntrySucc, LRegion);
}
}
bool Changed = false;
auto Children = Region->getChildren();
- for (auto CI : *Children) {
+ for (auto *CI : *Children) {
if (CI->isRegion()) {
Changed |= structurizeRegions(CI->getRegionMRT(), false);
}
/// Collect direct or indirect callers of \p F and save them
/// to \p Callers.
static void collectCallers(Function *F, DenseSet<Function *> &Callers) {
- for (auto U : F->users()) {
+ for (auto *U : F->users()) {
if (auto *CI = dyn_cast<CallInst>(&*U)) {
auto *Caller = CI->getParent()->getParent();
if (Callers.insert(Caller).second)
}
if (!isa<Constant>(U))
return;
- for (auto UU : U->users())
+ for (auto *UU : U->users())
collectFunctionUsers(&*UU, Funcs);
}
/*isExternallyInitialized=*/false);
LLVM_DEBUG(dbgs() << "runtime handle created: " << *GV << '\n');
- for (auto U : F.users()) {
+ for (auto *U : F.users()) {
auto *UU = &*U;
if (!isa<ConstantExpr>(UU))
continue;
}
}
- for (auto F : Callers) {
+ for (auto *F : Callers) {
if (F->getCallingConv() != CallingConv::AMDGPU_KERNEL)
continue;
F->addFnAttr("calls-enqueue-kernel");
// NB: This is important for this string size to be divisible by 4
const char NonLiteralStr[4] = "???";
- for (auto CI : Printfs) {
+ for (auto *CI : Printfs) {
unsigned NumOps = CI->arg_size();
SmallString<16> OpConvSpecifiers;
if (auto LI = dyn_cast<LoadInst>(Op)) {
Op = LI->getPointerOperand();
- for (auto Use : Op->users()) {
+ for (auto *Use : Op->users()) {
if (auto SI = dyn_cast<StoreInst>(Use)) {
Op = SI->getValueOperand();
break;
}
// erase the printf calls
- for (auto CI : Printfs)
+ for (auto *CI : Printfs)
CI->eraseFromParent();
Printfs.clear();
return false;
MDNode *MaxMD = nullptr;
auto MaxVer = 0U;
- for (auto VersionMD : NamedMD->operands()) {
+ for (auto *VersionMD : NamedMD->operands()) {
assert(VersionMD->getNumOperands() == 2);
auto CMajor = mdconst::extract<ConstantInt>(VersionMD->getOperand(0));
auto VersionMajor = CMajor->getZExtValue();
return false;
SmallVector<Metadata *, 4> All;
- for (auto MD : NamedMD->operands())
+ for (auto *MD : NamedMD->operands())
for (const auto &Op : MD->operands())
if (!llvm::is_contained(All, Op.get()))
All.push_back(Op.get());
++NumDPPMovsCombined;
} else {
auto Split = TII->expandMovDPP64(MI);
- for (auto M : { Split.first, Split.second }) {
+ for (auto *M : {Split.first, Split.second}) {
if (M && combineDPPMov(*M))
++NumDPPMovsCombined;
}
<< ", current = " << Occ << '\n');
auto NewOcc = TargetOcc;
- for (auto R : Regions) {
+ for (auto *R : Regions) {
if (R->MaxPressure.getOccupancy(ST) >= NewOcc)
break;
// running first pass with TargetOccupancy = 0 mimics previous scheduling
// approach and is a performance magic
LStrgy.setTargetOccupancy(I == 0 ? 0 : TgtOcc);
- for (auto R : Regions) {
+ for (auto *R : Regions) {
OverrideLegacyStrategy Ovr(*R, LStrgy, *this);
Ovr.schedule();
sortRegionsByPressure(TgtOcc);
auto MaxPressure = Regions.front()->MaxPressure;
- for (auto R : Regions) {
+ for (auto *R : Regions) {
if (!force && R->MaxPressure.less(ST, MaxPressure, TgtOcc))
break;
<< TgtOcc << '\n');
unsigned FinalOccupancy = std::min(Occ, MFI->getOccupancy());
- for (auto R : Regions) {
+ for (auto *R : Regions) {
BuildDAG DAG(*R, *this);
const auto ILPSchedule = makeGCNILPScheduler(DAG.getBottomRoots(), *this);
// Try to schedule SGPR initializations as early as possible in the MBB.
for (auto &Init : Inits) {
auto &Defs = Init.second;
- for (auto MI : Defs) {
+ for (auto *MI : Defs) {
auto MBB = MI->getParent();
MachineInstr &BoundaryMI = *getFirstNonPrologue(MBB, TII);
MachineBasicBlock::reverse_iterator B(BoundaryMI);
for (auto &U : MRI->use_instructions(Reg))
Users.push_back(&U);
}
- for (auto U : Users) {
+ for (auto *U : Users) {
if (TII->isSALU(*U))
Info.SChain.insert(U);
AnalysisWorklist.push_back(U);
SmallVector<MachineOperand *, 4> UsesToProcess;
for (auto &Use : MRI->use_nodbg_operands(Dst.getReg()))
UsesToProcess.push_back(&Use);
- for (auto U : UsesToProcess) {
+ for (auto *U : UsesToProcess) {
MachineInstr *UseMI = U->getParent();
foldOperand(OpToFold, UseMI, UseMI->getOperandNo(U), FoldList,
CopiesToReplace);
MF.insert(MF.end(), EmptyMBBAtEnd);
}
- for (auto MI : EpilogInstrs) {
+ for (auto *MI : EpilogInstrs) {
auto MBB = MI->getParent();
if (MBB == &MF.back() && MI == &MBB->back())
continue;
}
}
assert(Found && "conditional branch is not terminator");
- for (auto BranchMI : ToRemove) {
+ for (auto *BranchMI : ToRemove) {
MachineOperand &Dst = BranchMI->getOperand(0);
assert(Dst.isMBB() && "destination is not basic block");
Parent->removeSuccessor(Dst.getMBB());