LLD: Use DEBUG_TYPE

[ruiu]

Summary

Use DEBUG_TYPE and DEBUG instead of DEBUG_WITH_TYPE.

[denis-protivensky]

LGTM

[Eugene.Zelenko]

Committed in r233710.

lib/ReaderWriter/ELF/AArch64/AArch64RelocationHandler.cpp

 //===- lib/ReaderWriter/ELF/AArch64/AArch64RelocationHandler.cpp ----------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "AArch64TargetHandler.h"
 #include "AArch64LinkingContext.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/MathExtras.h"
 
+#define DEBUG_TYPE "AArch64"
+
 using namespace lld;
 using namespace lld::elf;
 using namespace llvm::support::endian;
 
 #define PAGE(X) ((X) & ~0x0FFFL)
 
 /// \brief Check X is in the interval (-2^(bits-1), 2^bits]
 static bool withinSignedUnsignedRange(int64_t X, int bits) {
   return isIntN(bits - 1, X) || isUIntN(bits, X);
 }
 
 /// \brief R_AARCH64_ABS64 - word64: S + A
 static void relocR_AARCH64_ABS64(uint8_t *location, uint64_t P, uint64_t S,
                                  int64_t A) {
   int64_t result = (int64_t)S + A;
-  DEBUG_WITH_TYPE(
-      "AArch64", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: 0x" << Twine::utohexstr(S);
         llvm::dbgs() << " A: 0x" << Twine::utohexstr(A);
         llvm::dbgs() << " P: 0x" << Twine::utohexstr(P);
         llvm::dbgs() << " result: 0x" << Twine::utohexstr(result) << "\n");
   write64le(location, result | read64le(location));
 }
 
 /// \brief R_AARCH64_PREL32 - word32: S + A - P
 static void relocR_AARCH64_PREL32(uint8_t *location, uint64_t P, uint64_t S,
                                   int64_t A) {
   int32_t result = (int32_t)((S + A) - P);
   write32le(location, result + (int32_t)read32le(location));
 }
 
 /// \brief R_AARCH64_ABS32 - word32:  S + A
 static std::error_code relocR_AARCH64_ABS32(uint8_t *location, uint64_t P,
                                             uint64_t S, int64_t A) {
   int64_t result = S + A;
   if (!withinSignedUnsignedRange(result, 32))
     return make_out_of_range_reloc_error();
-  DEBUG_WITH_TYPE(
-      "AArch64", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: 0x" << Twine::utohexstr(S);
         llvm::dbgs() << " A: 0x" << Twine::utohexstr(A);
         llvm::dbgs() << " P: 0x" << Twine::utohexstr(P);
         llvm::dbgs() << " result: 0x" << Twine::utohexstr(result) << "\n");
   write32le(location, result | read32le(location));
   return std::error_code();
 }
 
 /// \brief R_AARCH64_ADR_PREL_PG_HI21 - Page(S+A) - Page(P)
 static void relocR_AARCH64_ADR_PREL_PG_HI21(uint8_t *location, uint64_t P,
                                             uint64_t S, int64_t A) {
   uint64_t result = (PAGE(S + A) - PAGE(P));
   result = result >> 12;
   uint32_t immlo = result & 0x3;
   uint32_t immhi = result & 0x1FFFFC;
   immlo = immlo << 29;
   immhi = immhi << 3;
-  DEBUG_WITH_TYPE(
-      "AArch64", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: " << Twine::utohexstr(S);
         llvm::dbgs() << " A: " << Twine::utohexstr(A);
         llvm::dbgs() << " P: " << Twine::utohexstr(P);
         llvm::dbgs() << " immhi: " << Twine::utohexstr(immhi);
         llvm::dbgs() << " immlo: " << Twine::utohexstr(immlo);
         llvm::dbgs() << " result: " << Twine::utohexstr(result) << "\n");
   write32le(location, immlo | immhi | read32le(location));
   // TODO: Make sure this is correct!
 }
 
 /// \brief R_AARCH64_ADR_PREL_LO21 - S + A - P
 static void relocR_AARCH64_ADR_PREL_LO21(uint8_t *location, uint64_t P,
                                          uint64_t S, int64_t A) {
   uint64_t result = (S + A) - P;
   uint32_t immlo = result & 0x3;
   uint32_t immhi = result & 0x1FFFFC;
   immlo = immlo << 29;
   immhi = immhi << 3;
-  DEBUG_WITH_TYPE(
-      "AArch64", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: " << Twine::utohexstr(S);
         llvm::dbgs() << " A: " << Twine::utohexstr(A);
         llvm::dbgs() << " P: " << Twine::utohexstr(P);
         llvm::dbgs() << " immhi: " << Twine::utohexstr(immhi);
         llvm::dbgs() << " immlo: " << Twine::utohexstr(immlo);
         llvm::dbgs() << " result: " << Twine::utohexstr(result) << "\n");
   write32le(location, immlo | immhi | read32le(location));
   // TODO: Make sure this is correct!
 }
 
 /// \brief R_AARCH64_ADD_ABS_LO12_NC
 static void relocR_AARCH64_ADD_ABS_LO12_NC(uint8_t *location, uint64_t P,
                                            uint64_t S, int64_t A) {
   int32_t result = (int32_t)((S + A) & 0xFFF);
   result <<= 10;
-  DEBUG_WITH_TYPE(
-      "AArch64", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: " << Twine::utohexstr(S);
         llvm::dbgs() << " A: " << Twine::utohexstr(A);
         llvm::dbgs() << " P: " << Twine::utohexstr(P);
         llvm::dbgs() << " result: " << Twine::utohexstr(result) << "\n");
   write32le(location, result | read32le(location));
 }
 
 static void relocJump26(uint8_t *location, uint64_t P, uint64_t S, int64_t A) {
   int32_t result = (int32_t)((S + A) - P);
   result &= 0x0FFFFFFC;
   result >>= 2;
-  DEBUG_WITH_TYPE(
-      "AArch64", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: " << Twine::utohexstr(S);
         llvm::dbgs() << " A: " << Twine::utohexstr(A);
         llvm::dbgs() << " P: " << Twine::utohexstr(P);
         llvm::dbgs() << " result: " << Twine::utohexstr(result) << "\n");
   write32le(location, result | read32le(location));
 }
 
 /// \brief R_AARCH64_CONDBR19
 static void relocR_AARCH64_CONDBR19(uint8_t *location, uint64_t P, uint64_t S,
                                     int64_t A) {
   int32_t result = (int32_t)((S + A) - P);
   result &= 0x01FFFFC;
   result <<= 3;
-  DEBUG_WITH_TYPE(
-      "AArch64", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: " << Twine::utohexstr(S);
         llvm::dbgs() << " A: " << Twine::utohexstr(A);
         llvm::dbgs() << " P: " << Twine::utohexstr(P);
         llvm::dbgs() << " result: " << Twine::utohexstr(result) << "\n");
   write32le(location, result | read32le(location));
 }
 
 /// \brief R_AARCH64_LDST8_ABS_LO12_NC - S + A
 static void relocR_AARCH64_LDST8_ABS_LO12_NC(uint8_t *location, uint64_t P,
                                              uint64_t S, int64_t A) {
   int32_t result = (int32_t)((S + A) & 0xFFF);
   result <<= 10;
-  DEBUG_WITH_TYPE(
-      "AArch64", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: " << Twine::utohexstr(S);
         llvm::dbgs() << " A: " << Twine::utohexstr(A);
         llvm::dbgs() << " P: " << Twine::utohexstr(P);
         llvm::dbgs() << " result: " << Twine::utohexstr(result) << "\n");
   write32le(location, result | read32le(location));
 }
 
 /// \brief R_AARCH64_LDST16_ABS_LO12_NC
 static void relocR_AARCH64_LDST16_ABS_LO12_NC(uint8_t *location, uint64_t P,
                                               uint64_t S, int64_t A) {
   int32_t result = (int32_t)(S + A);
   result &= 0x0FFC;
   result <<= 9;
-  DEBUG_WITH_TYPE(
-      "AArch64", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: " << Twine::utohexstr(S);
         llvm::dbgs() << " A: " << Twine::utohexstr(A);
         llvm::dbgs() << " P: " << Twine::utohexstr(P);
         llvm::dbgs() << " result: " << Twine::utohexstr(result) << "\n");
   write32le(location, result | read32le(location));
 }
 
 /// \brief R_AARCH64_LDST32_ABS_LO12_NC
 static void relocR_AARCH64_LDST32_ABS_LO12_NC(uint8_t *location, uint64_t P,
                                               uint64_t S, int64_t A) {
   int32_t result = (int32_t)(S + A);
   result &= 0x0FFC;
   result <<= 8;
-  DEBUG_WITH_TYPE(
-      "AArch64", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: " << Twine::utohexstr(S);
         llvm::dbgs() << " A: " << Twine::utohexstr(A);
         llvm::dbgs() << " P: " << Twine::utohexstr(P);
         llvm::dbgs() << " result: " << Twine::utohexstr(result) << "\n");
   write32le(location, result | read32le(location));
 }
 
 /// \brief R_AARCH64_LDST64_ABS_LO12_NC
 static void relocR_AARCH64_LDST64_ABS_LO12_NC(uint8_t *location, uint64_t P,
                                               uint64_t S, int64_t A) {
   int32_t result = (int32_t)(S + A);
   result &= 0x0FF8;
   result <<= 7;
-  DEBUG_WITH_TYPE(
-      "AArch64", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: " << Twine::utohexstr(S);
         llvm::dbgs() << " A: " << Twine::utohexstr(A);
         llvm::dbgs() << " P: " << Twine::utohexstr(P);
         llvm::dbgs() << " result: " << Twine::utohexstr(result) << "\n");
   write32le(location, result | read32le(location));
 }
 
 /// \brief R_AARCH64_LDST128_ABS_LO12_NC
 static void relocR_AARCH64_LDST128_ABS_LO12_NC(uint8_t *location, uint64_t P,
                                                uint64_t S, int64_t A) {
   int32_t result = (int32_t)(S + A);
   result &= 0x0FF8;
   result <<= 6;
-  DEBUG_WITH_TYPE(
-      "AArch64", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: " << Twine::utohexstr(S);
         llvm::dbgs() << " A: " << Twine::utohexstr(A);
         llvm::dbgs() << " P: " << Twine::utohexstr(P);
         llvm::dbgs() << " result: " << Twine::utohexstr(result) << "\n");
   write32le(location, result | read32le(location));
 }
 
 static void relocR_AARCH64_ADR_GOT_PAGE(uint8_t *location, uint64_t P,
                                         uint64_t S, int64_t A) {
   uint64_t result = PAGE(S + A) - PAGE(P);
   result >>= 12;
   uint32_t immlo = result & 0x3;
   uint32_t immhi = result & 0x1FFFFC;
   immlo = immlo << 29;
   immhi = immhi << 3;
-  DEBUG_WITH_TYPE(
-      "AArch64", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: " << Twine::utohexstr(S);
         llvm::dbgs() << " A: " << Twine::utohexstr(A);
         llvm::dbgs() << " P: " << Twine::utohexstr(P);
         llvm::dbgs() << " immhi: " << Twine::utohexstr(immhi);
         llvm::dbgs() << " immlo: " << Twine::utohexstr(immlo);
         llvm::dbgs() << " result: " << Twine::utohexstr(result) << "\n");
   write32le(location, result | read32le(location));
 }
 
 // R_AARCH64_LD64_GOT_LO12_NC
 static void relocR_AARCH64_LD64_GOT_LO12_NC(uint8_t *location, uint64_t P,
                                             uint64_t S, int64_t A) {
   int32_t result = S + A;
-  DEBUG_WITH_TYPE(
-      "AArch64", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: " << Twine::utohexstr(S);
         llvm::dbgs() << " A: " << Twine::utohexstr(A);
         llvm::dbgs() << " P: " << Twine::utohexstr(P);
         llvm::dbgs() << " result: " << Twine::utohexstr(result) << "\n");
   result &= 0xFF8;
   result <<= 7;
   write32le(location, result | read32le(location));
 }
 
 // ADD_AARCH64_GOTRELINDEX
 static void relocADD_AARCH64_GOTRELINDEX(uint8_t *location, uint64_t P,
                                          uint64_t S, int64_t A) {
   int32_t result = S + A;
-  DEBUG_WITH_TYPE(
-      "AArch64", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: " << Twine::utohexstr(S);
         llvm::dbgs() << " A: " << Twine::utohexstr(A);
         llvm::dbgs() << " P: " << Twine::utohexstr(P);
         llvm::dbgs() << " result: " << Twine::utohexstr(result) << "\n");
   result &= 0xFFF;
   result <<= 10;
   write32le(location, result | read32le(location));
 }
 
 // R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21
 static void relocR_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21(uint8_t *location,
                                                      uint64_t P, uint64_t S,
                                                      int64_t A) {
   int64_t result = PAGE(S + A) - PAGE(P);
   result >>= 12;
   uint32_t immlo = result & 0x3;
   uint32_t immhi = result & 0x1FFFFC;
   immlo = immlo << 29;
   immhi = immhi << 3;
-  DEBUG_WITH_TYPE(
-      "AArch64", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: " << Twine::utohexstr(S);
         llvm::dbgs() << " A: " << Twine::utohexstr(A);
         llvm::dbgs() << " P: " << Twine::utohexstr(P);
         llvm::dbgs() << " immhi: " << Twine::utohexstr(immhi);
         llvm::dbgs() << " immlo: " << Twine::utohexstr(immlo);
         llvm::dbgs() << " result: " << Twine::utohexstr(result) << "\n");
   write32le(location, immlo | immhi | read32le(location));
 }
 
 // R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC
 static void relocR_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC(uint8_t *location,
                                                        uint64_t P, uint64_t S,
                                                        int64_t A) {
   int32_t result = S + A;
   result &= 0xFF8;
   result <<= 7;
-  DEBUG_WITH_TYPE(
-      "AArch64", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: " << Twine::utohexstr(S);
         llvm::dbgs() << " A: " << Twine::utohexstr(A);
         llvm::dbgs() << " P: " << Twine::utohexstr(P);
         llvm::dbgs() << " result: " << Twine::utohexstr(result) << "\n");
   write32le(location, result | read32le(location));
 }
 
 /// \brief R_AARCH64_TLSLE_ADD_TPREL_HI12
 static void relocR_AARCH64_TLSLE_ADD_TPREL_HI12(uint8_t *location, uint64_t P,
                                                 uint64_t S, int64_t A) {
   int32_t result = S + A;
   result &= 0x0FFF000;
   result >>= 2;
-  DEBUG_WITH_TYPE(
-      "AArch64", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: " << Twine::utohexstr(S);
         llvm::dbgs() << " A: " << Twine::utohexstr(A);
         llvm::dbgs() << " P: " << Twine::utohexstr(P);
         llvm::dbgs() << " result: " << Twine::utohexstr(result) << "\n");
   write32le(location, result | read32le(location));
 }
 
 /// \brief R_AARCH64_TLSLE_ADD_TPREL_LO12_NC
 static void relocR_AARCH64_TLSLE_ADD_TPREL_LO12_NC(uint8_t *location,
                                                    uint64_t P, uint64_t S,
                                                    int64_t A) {
   int32_t result = S + A;
   result &= 0x0FFF;
   result <<= 10;
-  DEBUG_WITH_TYPE(
-      "AArch64", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: " << Twine::utohexstr(S);
         llvm::dbgs() << " A: " << Twine::utohexstr(A);
         llvm::dbgs() << " P: " << Twine::utohexstr(P);
         llvm::dbgs() << " result: " << Twine::utohexstr(result) << "\n");
   write32le(location, result | read32le(location));
 }
 
 std::error_code AArch64TargetRelocationHandler::applyRelocation(
     ELFWriter &writer, llvm::FileOutputBuffer &buf, const lld::AtomLayout &atom,
     const Reference &ref) const {
   uint8_t *atomContent = buf.getBufferStart() + atom._fileOffset;
   uint8_t *location = atomContent + ref.offsetInAtom();

lib/ReaderWriter/ELF/ARM/ARMRelocationHandler.cpp

 //===--------- lib/ReaderWriter/ELF/ARM/ARMRelocationHandler.cpp ----------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ARMTargetHandler.h"
 #include "ARMLinkingContext.h"
 
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/MathExtras.h"
 
+#define DEBUG_TYPE "ARM"
+
 using namespace lld;
 using namespace lld::elf;
 using namespace llvm::support::endian;
 
 static Reference::Addend readAddend_THM_MOV(const uint8_t *location) {
   const uint16_t halfHi = read16le(location);
   const uint16_t halfLo = read16le(location + 2);
 

 }
 
 /// \brief R_ARM_ABS32 - (S + A) | T
 static void relocR_ARM_ABS32(uint8_t *location, uint64_t P, uint64_t S,
                              int64_t A, bool addressesThumb) {
   uint64_t T = addressesThumb;
   uint32_t result = (uint32_t)((S + A) | T);
 
-  DEBUG_WITH_TYPE(
-      "ARM", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: 0x" << Twine::utohexstr(S);
         llvm::dbgs() << " A: 0x" << Twine::utohexstr(A);
         llvm::dbgs() << " P: 0x" << Twine::utohexstr(P);
         llvm::dbgs() << " T: 0x" << Twine::utohexstr(T);
         llvm::dbgs() << " result: 0x" << Twine::utohexstr(result) << "\n");
   applyArmReloc(location, result);
 }
 
 /// \brief R_ARM_REL32 - ((S + A) | T) - P
 static void relocR_ARM_REL32(uint8_t *location, uint64_t P, uint64_t S,
                              int64_t A, bool addressesThumb) {
   uint64_t T = addressesThumb;
   uint32_t result = (uint32_t)(((S + A) | T) - P);
 
-  DEBUG_WITH_TYPE(
-      "ARM", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: 0x" << Twine::utohexstr(S);
         llvm::dbgs() << " A: 0x" << Twine::utohexstr(A);
         llvm::dbgs() << " P: 0x" << Twine::utohexstr(P);
         llvm::dbgs() << " T: 0x" << Twine::utohexstr(T);
         llvm::dbgs() << " result: 0x" << Twine::utohexstr(result) << "\n");
   applyArmReloc(location, result);
 }
 
 /// \brief R_ARM_PREL31 - ((S + A) | T) - P
 static void relocR_ARM_PREL31(uint8_t *location, uint64_t P, uint64_t S,
                                   int64_t A, bool addressesThumb) {
   uint64_t T = addressesThumb;
   uint32_t result = (uint32_t)(((S + A) | T) - P);
   const uint32_t mask = 0x7FFFFFFF;
   uint32_t rel31 = result & mask;
 
-  DEBUG_WITH_TYPE(
-      "ARM", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: 0x" << Twine::utohexstr(S);
         llvm::dbgs() << " A: 0x" << Twine::utohexstr(A);
         llvm::dbgs() << " P: 0x" << Twine::utohexstr(P);
         llvm::dbgs() << " T: 0x" << Twine::utohexstr(T);
         llvm::dbgs() << " result: 0x" << Twine::utohexstr(result);
         llvm::dbgs() << " rel31: 0x" << Twine::utohexstr(rel31) << "\n");
 
   applyArmReloc(location, rel31, mask);
 }
 
 /// \brief Relocate B/BL instructions. useJs defines whether J1 & J2 are used
 static void relocR_ARM_THM_B_L(uint8_t *location, uint32_t result, bool useJs) {
   result = (result & 0x01FFFFFE) >> 1;
 
static void relocR_ARM_THM_CALL(uint8_t *location, uint64_t P, uint64_t S,
   const bool switchMode = !addressesThumb;
 
   if (switchMode) {
     P &= ~0x3; // Align(P, 4) by rounding down
   }
 
   uint32_t result = (uint32_t)(((S + A) | T) - P);
 
-  DEBUG_WITH_TYPE(
-      "ARM", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: 0x" << Twine::utohexstr(S);
         llvm::dbgs() << " A: 0x" << Twine::utohexstr(A);
         llvm::dbgs() << " P: 0x" << Twine::utohexstr(P);
         llvm::dbgs() << " T: 0x" << Twine::utohexstr(T);
         llvm::dbgs() << " result: 0x" << Twine::utohexstr(result) << "\n");
   relocR_ARM_THM_B_L(location, result, useJs);
 
   if (switchMode) {
     applyThmReloc(location, 0, 0, 0, 0x1001);
   }
 }
 
 /// \brief R_ARM_THM_JUMP24 - ((S + A) | T) - P
 static void relocR_ARM_THM_JUMP24(uint8_t *location, uint64_t P, uint64_t S,
                                   int64_t A, bool addressesThumb) {
   uint64_t T = addressesThumb;
   uint32_t result = (uint32_t)(((S + A) | T) - P);
 
-  DEBUG_WITH_TYPE(
-      "ARM", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: 0x" << Twine::utohexstr(S);
         llvm::dbgs() << " A: 0x" << Twine::utohexstr(A);
         llvm::dbgs() << " P: 0x" << Twine::utohexstr(P);
         llvm::dbgs() << " T: 0x" << Twine::utohexstr(T);
         llvm::dbgs() << " result: 0x" << Twine::utohexstr(result) << "\n");
   relocR_ARM_THM_B_L(location, result, true);
 }
 
 /// \brief R_ARM_THM_JUMP11 - S + A - P
 static void relocR_ARM_THM_JUMP11(uint8_t *location, uint64_t P, uint64_t S,
                                   int64_t A) {
   uint32_t result = (uint32_t)(S + A - P);
 
-  DEBUG_WITH_TYPE(
-      "ARM", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: 0x" << Twine::utohexstr(S);
         llvm::dbgs() << " A: 0x" << Twine::utohexstr(A);
         llvm::dbgs() << " P: 0x" << Twine::utohexstr(P);
         llvm::dbgs() << " result: 0x" << Twine::utohexstr(result) << "\n");
 
   //we cut off first bit because it is always 1 according to p. 4.5.3
   result = (result & 0x0FFE) >> 1;
 
   applyThumb16Reloc(location, result, 0x7FF);
 }
 
 /// \brief R_ARM_BASE_PREL - B(S) + A - P => S + A - P
 static void relocR_ARM_BASE_PREL(uint8_t *location, uint64_t P, uint64_t S,
                                  int64_t A) {
   uint32_t result = (uint32_t)(S + A - P);
-  DEBUG_WITH_TYPE(
-      "ARM", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: 0x" << Twine::utohexstr(S);
         llvm::dbgs() << " A: 0x" << Twine::utohexstr(A);
         llvm::dbgs() << " P: 0x" << Twine::utohexstr(P);
         llvm::dbgs() << " result: 0x" << Twine::utohexstr(result) << "\n");
   applyArmReloc(location, result);
 }
 
 /// \brief R_ARM_GOT_BREL - GOT(S) + A - GOT_ORG => S + A - GOT_ORG
 static void relocR_ARM_GOT_BREL(uint8_t *location, uint64_t P, uint64_t S,
                                 int64_t A, uint64_t GOT_ORG) {
   uint32_t result = (uint32_t)(S + A - GOT_ORG);
-  DEBUG_WITH_TYPE(
-      "ARM", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: 0x" << Twine::utohexstr(S);
         llvm::dbgs() << " A: 0x" << Twine::utohexstr(A);
         llvm::dbgs() << " P: 0x" << Twine::utohexstr(P);
         llvm::dbgs() << " result: 0x" << Twine::utohexstr(result) << "\n");
   applyArmReloc(location, result);
 }
 
 /// \brief R_ARM_CALL - ((S + A) | T) - P
 static void relocR_ARM_CALL(uint8_t *location, uint64_t P, uint64_t S,
                             int64_t A, bool addressesThumb) {
   uint64_t T = addressesThumb;
   const bool switchMode = addressesThumb;
 
   uint32_t result = (uint32_t)(((S + A) | T) - P);
   const uint32_t imm24 = (result & 0x03FFFFFC) >> 2;
 
-  DEBUG_WITH_TYPE(
-      "ARM", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: 0x" << Twine::utohexstr(S);
         llvm::dbgs() << " A: 0x" << Twine::utohexstr(A);
         llvm::dbgs() << " P: 0x" << Twine::utohexstr(P);
         llvm::dbgs() << " T: 0x" << Twine::utohexstr(T);
         llvm::dbgs() << " result: 0x" << Twine::utohexstr(result) << "\n");
   applyArmReloc(location, imm24, 0xFFFFFF);
 
   if (switchMode) {
     const uint32_t bitH = (result & 0x2) >> 1;
     applyArmReloc(location, (0xFA | bitH) << 24, 0xFF000000);
   }
 }
 
 /// \brief R_ARM_JUMP24 - ((S + A) | T) - P
 static void relocR_ARM_JUMP24(uint8_t *location, uint64_t P, uint64_t S,
                               int64_t A, bool addressesThumb) {
   uint64_t T = addressesThumb;
   uint32_t result = (uint32_t)(((S + A) | T) - P);
   const uint32_t imm24 = (result & 0x03FFFFFC) >> 2;
 
-  DEBUG_WITH_TYPE(
-      "ARM", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: 0x" << Twine::utohexstr(S);
         llvm::dbgs() << " A: 0x" << Twine::utohexstr(A);
         llvm::dbgs() << " P: 0x" << Twine::utohexstr(P);
         llvm::dbgs() << " T: 0x" << Twine::utohexstr(T);
         llvm::dbgs() << " result: 0x" << Twine::utohexstr(result) << "\n");
   applyArmReloc(location, imm24, 0xFFFFFF);
 }
 
 /// \brief Relocate ARM MOVW/MOVT instructions
 static void relocR_ARM_MOV(uint8_t *location, uint32_t result) {
   const uint32_t imm12 = result & 0xFFF;
   const uint32_t imm4 = (result >> 12) & 0xF;
 
   applyArmReloc(location, (imm4 << 16) | imm12, 0xF0FFF);
 }
 
 /// \brief R_ARM_MOVW_ABS_NC - (S + A) | T
 static void relocR_ARM_MOVW_ABS_NC(uint8_t *location, uint64_t P, uint64_t S,
                                    int64_t A, bool addressesThumb) {
   uint64_t T = addressesThumb;
   uint32_t result = (uint32_t)((S + A) | T);
   const uint32_t arg = result & 0x0000FFFF;
 
-  DEBUG_WITH_TYPE(
-      "ARM", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: 0x" << Twine::utohexstr(S);
         llvm::dbgs() << " A: 0x" << Twine::utohexstr(A);
         llvm::dbgs() << " P: 0x" << Twine::utohexstr(P);
         llvm::dbgs() << " T: 0x" << Twine::utohexstr(T);
         llvm::dbgs() << " result: 0x" << Twine::utohexstr(result) << "\n");
   return relocR_ARM_MOV(location, arg);
 }
 
 /// \brief R_ARM_MOVT_ABS - S + A
 static void relocR_ARM_MOVT_ABS(uint8_t *location, uint64_t P, uint64_t S,
                                 int64_t A) {
   uint32_t result = (uint32_t)(S + A);
   const uint32_t arg = (result & 0xFFFF0000) >> 16;
 
-  DEBUG_WITH_TYPE(
-      "ARM", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: 0x" << Twine::utohexstr(S);
         llvm::dbgs() << " A: 0x" << Twine::utohexstr(A);
         llvm::dbgs() << " P: 0x" << Twine::utohexstr(P);
         llvm::dbgs() << " result: 0x" << Twine::utohexstr(result) << "\n");
   return relocR_ARM_MOV(location, arg);
 }
 
 /// \brief Relocate Thumb MOVW/MOVT instructions
 static void relocR_ARM_THM_MOV(uint8_t *location, uint32_t result) {
   const uint16_t imm8 = result & 0xFF;
   const uint16_t imm3 = (result >> 8) & 0x7;
   const uint16_t resLo = (imm3 << 12) | imm8;
 
   const uint16_t imm4 = (result >> 12) & 0xF;
   const uint16_t bitI = (result >> 11) & 0x1;
   const uint16_t resHi = (bitI << 10) | imm4;
 
   applyThmReloc(location, resHi, resLo, 0x40F, 0x70FF);
 }
 
 /// \brief R_ARM_THM_MOVW_ABS_NC - (S + A) | T
 static void relocR_ARM_THM_MOVW_ABS_NC(uint8_t *location, uint64_t P,
                                        uint64_t S, int64_t A,
                                        bool addressesThumb) {
   uint64_t T = addressesThumb;
   uint32_t result = (uint32_t)((S + A) | T);
   const uint32_t arg = result & 0x0000FFFF;
 
-  DEBUG_WITH_TYPE(
-      "ARM", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: 0x" << Twine::utohexstr(S);
         llvm::dbgs() << " A: 0x" << Twine::utohexstr(A);
         llvm::dbgs() << " P: 0x" << Twine::utohexstr(P);
         llvm::dbgs() << " T: 0x" << Twine::utohexstr(T);
         llvm::dbgs() << " result: 0x" << Twine::utohexstr(result) << "\n");
   return relocR_ARM_THM_MOV(location, arg);
 }
 
 /// \brief R_ARM_THM_MOVT_ABS - S + A
 static void relocR_ARM_THM_MOVT_ABS(uint8_t *location, uint64_t P, uint64_t S,
                                     int64_t A) {
   uint32_t result = (uint32_t)(S + A);
   const uint32_t arg = (result & 0xFFFF0000) >> 16;
 
-  DEBUG_WITH_TYPE(
-      "ARM", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: 0x" << Twine::utohexstr(S);
         llvm::dbgs() << " A: 0x" << Twine::utohexstr(A);
         llvm::dbgs() << " P: 0x" << Twine::utohexstr(P);
         llvm::dbgs() << " result: 0x" << Twine::utohexstr(result) << "\n");
   return relocR_ARM_THM_MOV(location, arg);
 }
 
 /// \brief R_ARM_TLS_IE32 - GOT(S) + A - P => S + A - P
 static void relocR_ARM_TLS_IE32(uint8_t *location, uint64_t P, uint64_t S,
                                 int64_t A) {
   uint32_t result = (uint32_t)(S + A - P);
 
-  DEBUG_WITH_TYPE(
-      "ARM", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: 0x" << Twine::utohexstr(S);
         llvm::dbgs() << " A: 0x" << Twine::utohexstr(A);
         llvm::dbgs() << " P: 0x" << Twine::utohexstr(P);
         llvm::dbgs() << " result: 0x" << Twine::utohexstr(result) << "\n");
   applyArmReloc(location, result);
 }
 
 /// \brief R_ARM_TLS_LE32 - S + A - tp => S + A + tpoff
 static void relocR_ARM_TLS_LE32(uint8_t *location, uint64_t P, uint64_t S,
                                 int64_t A, uint64_t tpoff) {
   uint32_t result = (uint32_t)(S + A + tpoff);
 
-  DEBUG_WITH_TYPE(
-      "ARM", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: 0x" << Twine::utohexstr(S);
         llvm::dbgs() << " A: 0x" << Twine::utohexstr(A);
         llvm::dbgs() << " P: 0x" << Twine::utohexstr(P);
         llvm::dbgs() << " result: 0x" << Twine::utohexstr(result) << "\n");
   applyArmReloc(location, result);
 }
 
 template <uint32_t lshift>
 static void relocR_ARM_ALU_PC_GN_NC(uint8_t *location, uint32_t result) {
   static_assert(lshift < 32 && lshift % 2 == 0,
                 "lshift must be even and less than word size");
 
   const uint32_t rshift = 32 - lshift;
   result = ((result >> lshift) & 0xFF) | ((rshift / 2) << 8);
 
   applyArmReloc(location, result, 0xFFF);
 }
 
 /// \brief R_ARM_ALU_PC_G0_NC - ((S + A) | T) - P => S + A - P
 static void relocR_ARM_ALU_PC_G0_NC(uint8_t *location, uint64_t P, uint64_t S,
                                     int64_t A) {
   int32_t result = (int32_t)((S + A) - P);
 
   if (result < 0)
     llvm_unreachable(
         "Negative offsets for group relocations has not been implemented");
 
-  DEBUG_WITH_TYPE(
-      "ARM", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: 0x" << Twine::utohexstr(S);
         llvm::dbgs() << " A: 0x" << Twine::utohexstr(A);
         llvm::dbgs() << " P: 0x" << Twine::utohexstr(P);
-      llvm::dbgs() << " result: 0x" << Twine::utohexstr((uint32_t)result) << "\n");
+        llvm::dbgs() << " result: 0x" << Twine::utohexstr((uint32_t)result)
+                     << "\n");
 
   relocR_ARM_ALU_PC_GN_NC<20>(location, (uint32_t)result);
 }
 
 /// \brief R_ARM_ALU_PC_G1_NC - ((S + A) | T) - P => S + A - P
 static void relocR_ARM_ALU_PC_G1_NC(uint8_t *location, uint64_t P, uint64_t S,
                                     int64_t A) {
   int32_t result = (int32_t)((S + A) - P);
 
   if (result < 0)
     llvm_unreachable(
         "Negative offsets for group relocations has not been implemented");
 
-  DEBUG_WITH_TYPE(
-      "ARM", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: 0x" << Twine::utohexstr(S);
         llvm::dbgs() << " A: 0x" << Twine::utohexstr(A);
         llvm::dbgs() << " P: 0x" << Twine::utohexstr(P);
-      llvm::dbgs() << " result: 0x" << Twine::utohexstr((uint32_t)result) << "\n");
+        llvm::dbgs() << " result: 0x" << Twine::utohexstr((uint32_t)result)
+                     << "\n");
 
   relocR_ARM_ALU_PC_GN_NC<12>(location, (uint32_t)result);
 }
 
 /// \brief R_ARM_LDR_PC_G2 - S + A - P
 static void relocR_ARM_LDR_PC_G2(uint8_t *location, uint64_t P, uint64_t S,
                                  int64_t A) {
   int32_t result = (int32_t)((S + A) - P);
 
   if (result < 0)
     llvm_unreachable(
         "Negative offsets for group relocations has not been implemented");
 
-  DEBUG_WITH_TYPE(
-      "ARM", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+  DEBUG(llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
         llvm::dbgs() << " S: 0x" << Twine::utohexstr(S);
         llvm::dbgs() << " A: 0x" << Twine::utohexstr(A);
         llvm::dbgs() << " P: 0x" << Twine::utohexstr(P);
-      llvm::dbgs() << " result: 0x" << Twine::utohexstr((uint32_t)result) << "\n");
+        llvm::dbgs() << " result: 0x" << Twine::utohexstr((uint32_t)result)
+                     << "\n");
 
   const uint32_t mask = 0xFFF;
   applyArmReloc(location, (uint32_t)result & mask, mask);
 }
 
 std::error_code ARMTargetRelocationHandler::applyRelocation(
     ELFWriter &writer, llvm::FileOutputBuffer &buf, const lld::AtomLayout &atom,
     const Reference &ref) const {