[NFCI] Move DEBUG_TYPE definition below #include of headers

[mdchen]

Summary

There're several places in the code base where DEBUG_TYPE definition is defined at the top of the file or around the #includes, which could result in conflicts when you try to define a new DEBUG_TYPE in a related header file.

[ChuanqiXu]

This fix looks good.

which could result in conflicts when you try to define a new DEBUG_TYPE in a related header file.

And I am wondering the reason you want to define DEBUG_TYPE in a header file. It isn't what we used to do.

[mdchen]

In D102594#2762526, @ChuanqiXu wrote:

And I am wondering the reason you want to define DEBUG_TYPE in a header file. It isn't what we used to do.

I don't think it's true. We can find many header files under llvm/include/ have their own DEBUG_TYPE, and it works well if you carefully undefine it at the end of the file.

[ChuanqiXu]

In D102594#2762590, @mdchen wrote:

In D102594#2762526, @ChuanqiXu wrote:

And I am wondering the reason you want to define DEBUG_TYPE in a header file. It isn't what we used to do.

I don't think it's true. We can find many header files under llvm/include/ have their own DEBUG_TYPE, and it works well if you carefully undefine it at the end of the file.

Yeah, the codes shows you are right. I find definitions for DEBUG_TYPE in some headers.

[mdchen]

Did a fully scan and modified more files that have the same issue.

[tejohnson]

lgtm. this seems fine to me, but presumably we would have a compile error if there was ever a conflict in practice with one of these files?

[mdchen]

In D102594#2766167, @tejohnson wrote:

lgtm. this seems fine to me, but presumably we would have a compile error if there was ever a conflict in practice with one of these files?

In practice it conflicts with macros defined in header files; if a conflict header file defines one but doesn't undefined it(which is unusual), the compiler throws a redefinition warning; in a general case, there'll be a compile error instead. Thanks for the review!

llvm/lib/Analysis/AssumeBundleQueries.cpp

 //===- AssumeBundleQueries.cpp - tool to query assume bundles ---*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-#define DEBUG_TYPE "assume-queries"
-
 #include "llvm/Analysis/AssumeBundleQueries.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/AssumptionCache.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/InstIterator.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/PatternMatch.h"
 #include "llvm/Support/DebugCounter.h"
 
+#define DEBUG_TYPE "assume-queries"
+
 using namespace llvm;
 using namespace llvm::PatternMatch;
 
 STATISTIC(NumAssumeQueries, "Number of Queries into an assume assume bundles");
 STATISTIC(
     NumUsefullAssumeQueries,
     "Number of Queries into an assume assume bundles that were satisfied");
 

llvm/lib/Target/AArch64/AArch64PBQPRegAlloc.cpp

 //===-- AArch64PBQPRegAlloc.cpp - AArch64 specific PBQP constraints -------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 // This file contains the AArch64 / Cortex-A57 specific register allocation
 // constraints for use by the PBQP register allocator.
 //
 // It is essentially a transcription of what is contained in
 // AArch64A57FPLoadBalancing, which tries to use a balanced
 // mix of odd and even D-registers when performing a critical sequence of
 // independent, non-quadword FP/ASIMD floating-point multiply-accumulates.
 //===----------------------------------------------------------------------===//
 
-#define DEBUG_TYPE "aarch64-pbqp"
-
 #include "AArch64PBQPRegAlloc.h"
 #include "AArch64.h"
 #include "AArch64RegisterInfo.h"
 #include "llvm/CodeGen/LiveIntervals.h"
 #include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/RegAllocPBQP.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 
+#define DEBUG_TYPE "aarch64-pbqp"
+
 using namespace llvm;
 
 namespace {
 
 #ifndef NDEBUG
 bool isFPReg(unsigned reg) {
   return AArch64::FPR32RegClass.contains(reg) ||
          AArch64::FPR64RegClass.contains(reg) ||

llvm/lib/Transforms/Scalar/AlignmentFromAssumptions.cpp

 // expressions of assume intrinsics. The primary motivation is to handle
 // complex alignment assumptions that apply to vector loads and stores that
 // appear after vectorization and unrolling.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/Instructions.h"
 #include "llvm/InitializePasses.h"
-#define AA_NAME "alignment-from-assumptions"
-#define DEBUG_TYPE AA_NAME
 #include "llvm/Transforms/Scalar/AlignmentFromAssumptions.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/AssumptionCache.h"
 #include "llvm/Analysis/GlobalsModRef.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/ScalarEvolutionExpressions.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/Scalar.h"
+
+#define AA_NAME "alignment-from-assumptions"
+#define DEBUG_TYPE AA_NAME
 using namespace llvm;
 
 STATISTIC(NumLoadAlignChanged,
   "Number of loads changed by alignment assumptions");
 STATISTIC(NumStoreAlignChanged,
   "Number of stores changed by alignment assumptions");
 STATISTIC(NumMemIntAlignChanged,
   "Number of memory intrinsics changed by alignment assumptions");

llvm/lib/Transforms/Scalar/Float2Int.cpp

 //===- Float2Int.cpp - Demote floating point ops to work on integers ------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the Float2Int pass, which aims to demote floating
 // point operations to work on integers, where that is losslessly possible.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/InitializePasses.h"
 #include "llvm/Support/CommandLine.h"
-#define DEBUG_TYPE "float2int"
-
 #include "llvm/Transforms/Scalar/Float2Int.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Analysis/GlobalsModRef.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/InstIterator.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/Scalar.h"
 #include <deque>
 #include <functional> // For std::function
+
+#define DEBUG_TYPE "float2int"
 using namespace llvm;
 
 // The algorithm is simple. Start at instructions that convert from the
 // float to the int domain: fptoui, fptosi and fcmp. Walk up the def-use
 // graph, using an equivalence datastructure to unify graphs that interfere.
 //
 // Mappable instructions are those with an integer corrollary that, given
 // integer domain inputs, produce an integer output; fadd, for example.

llvm/utils/TableGen/DFAEmitter.cpp

 //
 // The generated code can run the DFA and produce an accepted / not accepted
 // state and also produce, given a sequence of transitions that results in an
 // accepted state, the sequence of intermediate states. This is useful if the
 // initial automaton was nondeterministic - it allows mapping back from the DFA
 // to the NFA.
 //
 //===----------------------------------------------------------------------===//
-#define DEBUG_TYPE "dfa-emitter"
 
 #include "DFAEmitter.h"
 #include "CodeGenTarget.h"
 #include "SequenceToOffsetTable.h"
 #include "TableGenBackends.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/UniqueVector.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/TableGen/Record.h"
 #include "llvm/TableGen/TableGenBackend.h"
 #include <cassert>
 #include <cstdint>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
+#define DEBUG_TYPE "dfa-emitter"
+
 using namespace llvm;
 
 //===----------------------------------------------------------------------===//
 // DfaEmitter implementation. This is independent of the GenAutomaton backend.
 //===----------------------------------------------------------------------===//
 
 void DfaEmitter::addTransition(state_type From, state_type To, action_type A) {
   Actions.insert(A);

llvm/utils/TableGen/DFAPacketizerEmitter.cpp

 //===- DFAPacketizerEmitter.cpp - Packetization DFA for a VLIW machine ----===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This class parses the Schedule.td file and produces an API that can be used
 // to reason about whether an instruction can be added to a packet on a VLIW
 // architecture. The class internally generates a deterministic finite
 // automaton (DFA) that models all possible mappings of machine instructions
 // to functional units as instructions are added to a packet.
 //
 //===----------------------------------------------------------------------===//
 
-#define DEBUG_TYPE "dfa-emitter"
-
 #include "CodeGenSchedule.h"
 #include "CodeGenTarget.h"
 #include "DFAEmitter.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/TableGen/Record.h"
 #include "llvm/TableGen/TableGenBackend.h"
 #include <cassert>
 #include <cstdint>
 #include <map>
 #include <set>
 #include <string>
 #include <unordered_map>
 #include <vector>
 
+#define DEBUG_TYPE "dfa-emitter"
+
 using namespace llvm;
 
 // We use a uint64_t to represent a resource bitmask.
 #define DFA_MAX_RESOURCES 64
 
 namespace {
 using ResourceVector = SmallVector<uint64_t, 4>;