Remove unneeded use of #undef DEBUG_TYPE. NFC

[sbc100]

Summary

Where is is needed (at the end of headers that define it), be
consistent about its used.

Also fix a few header guards that I found in the process.

llvm/trunk/include/llvm/Analysis/BlockFrequencyInfoImpl.h

std::string getEdgeAttributes(NodeRef Node, EdgeIter EI,
     return Str;
   }
 };
 
 } // end namespace llvm
 
 #undef DEBUG_TYPE
 
-#endif
+#endif // LLVM_ANALYSIS_BLOCKFREQUENCYINFOIMPL_H

llvm/trunk/include/llvm/Analysis/RegionInfoImpl.h

 #include <cassert>
 #include <iterator>
 #include <memory>
 #include <set>
 #include <string>
 #include <type_traits>
 #include <vector>
 
-namespace llvm {
-
 #define DEBUG_TYPE "region"
 
+namespace llvm {
+
 //===----------------------------------------------------------------------===//
 /// RegionBase Implementation
 template <class Tr>
 RegionBase<Tr>::RegionBase(BlockT *Entry, BlockT *Exit,
                            typename Tr::RegionInfoT *RInfo, DomTreeT *dt,
                            RegionT *Parent)
     : RegionNodeBase<Tr>(Parent, Entry, 1), RI(RInfo), DT(dt), exit(Exit) {}
 
void RegionInfoBase<Tr>::calculate(FuncT &F) {
   // This improves performance on linear CFGs.
   BBtoBBMap ShortCut;
 
   scanForRegions(F, &ShortCut);
   BlockT *BB = GraphTraits<FuncPtrT>::getEntryNode(&F);
   buildRegionsTree(DT->getNode(BB), TopLevelRegion);
 }
 
-#undef DEBUG_TYPE
-
 } // end namespace llvm
 
+#undef DEBUG_TYPE
+
 #endif // LLVM_ANALYSIS_REGIONINFOIMPL_H

llvm/trunk/include/llvm/Support/UnicodeCharRanges.h

 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Mutex.h"
 #include "llvm/Support/MutexGuard.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 
+#define DEBUG_TYPE "unicode"
+
 namespace llvm {
 namespace sys {
 
-#define DEBUG_TYPE "unicode"
-
 /// \brief Represents a closed range of Unicode code points [Lower, Upper].
 struct UnicodeCharRange {
   uint32_t Lower;
   uint32_t Upper;
 };
 
 inline bool operator<(uint32_t Value, UnicodeCharRange Range) {
   return Value < Range.Lower;
bool rangesAreValid() const {
     }
 
     return true;
   }
 
   const CharRanges Ranges;
 };
 
-#undef DEBUG_TYPE // "unicode"
-
 } // namespace sys
 } // namespace llvm
 
+#undef DEBUG_TYPE // "unicode"
 
 #endif // LLVM_SUPPORT_UNICODECHARRANGES_H

llvm/trunk/include/llvm/Transforms/Utils/SSAUpdaterImpl.h

 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/ValueHandle.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Debug.h"
 
-namespace llvm {
-
 #define DEBUG_TYPE "ssaupdater"
 
+namespace llvm {
+
 class CastInst;
 class PHINode;
 template<typename T> class SSAUpdaterTraits;
 
 template<typename UpdaterT>
 class SSAUpdaterImpl {
 private:
   UpdaterT *Updater;
for (typename BlockListTy::iterator I = BlockList->begin(),
         BlkT *BB = PHI->getParent();
         ValT PHIVal = Traits::GetPHIValue(PHI);
         (*AvailableVals)[BB] = PHIVal;
         BBMap[BB]->AvailableVal = PHIVal;
       }
   }
 };
 
-#undef DEBUG_TYPE // "ssaupdater"
+} // end llvm namespace
 
-} // End llvm namespace
+#undef DEBUG_TYPE // "ssaupdater"
 
-#endif
+#endif // LLVM_TRANSFORMS_UTILS_SSAUPDATERIMPL_H

llvm/trunk/lib/CodeGen/RegAllocPBQP.cpp

 
 FunctionPass *llvm::createPBQPRegisterAllocator(char *customPassID) {
   return new RegAllocPBQP(customPassID);
 }
 
 FunctionPass* llvm::createDefaultPBQPRegisterAllocator() {
   return createPBQPRegisterAllocator();
 }
-
-#undef DEBUG_TYPE

llvm/trunk/lib/Target/NVPTX/NVPTXISelLowering.cpp

 #include <cassert>
 #include <cstdint>
 #include <iterator>
 #include <sstream>
 #include <string>
 #include <utility>
 #include <vector>
 
-#undef DEBUG_TYPE
 #define DEBUG_TYPE "nvptx-lower"
 
 using namespace llvm;
 
 static unsigned int uniqueCallSite = 0;
 
 static cl::opt<bool> sched4reg(
     "nvptx-sched4reg",

llvm/trunk/lib/Transforms/Instrumentation/CFGMST.h

 //===-- CFGMST.h - Minimum Spanning Tree for CFG ----------------*- C++ -*-===//
 //
 //                      The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a Union-find algorithm to compute Minimum Spanning Tree
 // for a given CFG.
 //
 //===----------------------------------------------------------------------===//
 
+#ifndef LLVM_LIB_TRANSFORMS_INSTRUMENTATION_CFGMST_H
+#define LLVM_LIB_TRANSFORMS_INSTRUMENTATION_CFGMST_H
+
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Analysis/BlockFrequencyInfo.h"
 #include "llvm/Analysis/BranchProbabilityInfo.h"
 #include "llvm/Analysis/CFG.h"
 #include "llvm/Support/BranchProbability.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include <utility>
 #include <vector>
 
-namespace llvm {
-
 #define DEBUG_TYPE "cfgmst"
 
+namespace llvm {
+
 /// \brief An union-find based Minimum Spanning Tree for CFG
 ///
 /// Implements a Union-find algorithm to compute Minimum Spanning Tree
 /// for a given CFG.
 template <class Edge, class BBInfo> class CFGMST {
 public:
   Function &F;
 
CFGMST(Function &Func, BranchProbabilityInfo *BPI_ = nullptr,
          BlockFrequencyInfo *BFI_ = nullptr)
       : F(Func), BPI(BPI_), BFI(BFI_) {
     buildEdges();
     sortEdgesByWeight();
     computeMinimumSpanningTree();
   }
 };
 
-#undef DEBUG_TYPE // "cfgmst"
 } // end namespace llvm
+
+#undef DEBUG_TYPE // "cfgmst"
+
+#endif // LLVM_LIB_TRANSFORMS_INSTRUMENTATION_CFGMST_H

llvm/trunk/lib/Transforms/Instrumentation/MaximumSpanningTree.h

 //===- llvm/Analysis/MaximumSpanningTree.h - Interface ----------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This module provides means for calculating a maximum spanning tree for a
 // given set of weighted edges. The type parameter T is the type of a node.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_ANALYSIS_MAXIMUMSPANNINGTREE_H
-#define LLVM_ANALYSIS_MAXIMUMSPANNINGTREE_H
+#ifndef LLVM_LIB_TRANSFORMS_INSTRUMENTATION_MAXIMUMSPANNINGTREE_H
+#define LLVM_LIB_TRANSFORMS_INSTRUMENTATION_MAXIMUMSPANNINGTREE_H
 
 #include "llvm/ADT/EquivalenceClasses.h"
 #include "llvm/IR/BasicBlock.h"
 #include <algorithm>
 #include <vector>
 
 namespace llvm {
 
public:
 
     typename MaxSpanTree::iterator end() {
       return MST.end();
     }
   };
 
 } // End llvm namespace
 
-#endif
+#endif // LLVM_LIB_TRANSFORMS_INSTRUMENTATION_MAXIMUMSPANNINGTREE_H