[AMDGPU] Use depth first iterator instead of recursive DFS. NFCI.

[foad]

Summary

The reason for this is to avoid deep recursion in DFS() which can cause
stack overflow on large CFGs, especially on Windows.

[dstuttard]

LGTM

llvm/lib/Target/AMDGPU/AMDGPUAnnotateUniformValues.cpp

 //===-- AMDGPUAnnotateUniformValues.cpp - ---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 /// \file
 /// This pass adds amdgpu.uniform metadata to IR values so this information
 /// can be used during instruction selection.
 //
 //===----------------------------------------------------------------------===//
 
 #include "AMDGPU.h"
 #include "Utils/AMDGPUBaseInfo.h"
+#include "llvm/ADT/DepthFirstIterator.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/Analysis/LegacyDivergenceAnalysis.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/MemoryDependenceAnalysis.h"
 #include "llvm/IR/InstVisitor.h"
 #include "llvm/InitializePasses.h"
 
 #define DEBUG_TYPE "amdgpu-annotate-uniform"

 
 static void setUniformMetadata(Instruction *I) {
   I->setMetadata("amdgpu.uniform", MDNode::get(I->getContext(), {}));
 }
 static void setNoClobberMetadata(Instruction *I) {
   I->setMetadata("amdgpu.noclobber", MDNode::get(I->getContext(), {}));
 }
 
-static void DFS(BasicBlock *Root, SetVector<BasicBlock*> & Set) {
-  for (auto I : predecessors(Root))
-    if (Set.insert(I))
-      DFS(I, Set);
-}
-
 bool AMDGPUAnnotateUniformValues::isClobberedInFunction(LoadInst * Load) {
   // 1. get Loop for the Load->getparent();
   // 2. if it exists, collect all the BBs from the most outer
   // loop and check for the writes. If NOT - start DFS over all preds.
   // 3. Start DFS over all preds from the most outer loop header.
   SetVector<BasicBlock *> Checklist;
   BasicBlock *Start = Load->getParent();
   Checklist.insert(Start);
   const Value *Ptr = Load->getPointerOperand();
   const Loop *L = LI->getLoopFor(Start);
   if (L) {
     const Loop *P = L;
     do {
       L = P;
       P = P->getParentLoop();
     } while (P);
     Checklist.insert(L->block_begin(), L->block_end());
     Start = L->getHeader();
   }
 
-  DFS(Start, Checklist);
+  Checklist.insert(idf_begin(Start), idf_end(Start));
   for (auto &BB : Checklist) {
     BasicBlock::iterator StartIt = (!L && (BB == Load->getParent())) ?
       BasicBlock::iterator(Load) : BB->end();
     auto Q = MDR->getPointerDependencyFrom(
         MemoryLocation::getBeforeOrAfter(Ptr), true, StartIt, BB, Load);
     if (Q.isClobber() || Q.isUnknown() ||
         // Store defines the load and thus clobbers it.
         (Q.isDef() && Q.getInst()->mayWriteToMemory()))