[NFC][COFF] clang-format WinCOFFObjectWriter and MCWinCOFFObjectWriter

[skan]

LGTM

llvm/include/llvm/MC/MCWinCOFFObjectWriter.h

 namespace llvm {
 
 class MCAsmBackend;
 class MCContext;
 class MCFixup;
 class MCValue;
 class raw_pwrite_stream;
 
-  class MCWinCOFFObjectTargetWriter : public MCObjectTargetWriter {
-    virtual void anchor();
 
-    const unsigned Machine;
 
-  protected:
-    MCWinCOFFObjectTargetWriter(unsigned Machine_);
 
-  public:
-    virtual ~MCWinCOFFObjectTargetWriter() = default;
 
-    Triple::ObjectFormatType getFormat() const override { return Triple::COFF; }
-    static bool classof(const MCObjectTargetWriter *W) {
-      return W->getFormat() == Triple::COFF;
-    }
 
-    unsigned getMachine() const { return Machine; }
-    virtual unsigned getRelocType(MCContext &Ctx, const MCValue &Target,
-                                  const MCFixup &Fixup, bool IsCrossSection,
-                                  const MCAsmBackend &MAB) const = 0;
-    virtual bool recordRelocation(const MCFixup &) const { return true; }
-  };
 
-  /// Construct a new Win COFF writer instance.
-  ///
-  /// \param MOTW - The target specific WinCOFF writer subclass.
-  /// \param OS - The stream to write to.
-  /// \returns The constructed object writer.
-  std::unique_ptr<MCObjectWriter>
-  createWinCOFFObjectWriter(std::unique_ptr<MCWinCOFFObjectTargetWriter> MOTW,
-                            raw_pwrite_stream &OS);
 } // end namespace llvm
 
 #endif // LLVM_MC_MCWINCOFFOBJECTWRITER_H

llvm/lib/MC/WinCOFFObjectWriter.cpp

 #define DEBUG_TYPE "WinCOFFObjectWriter"
 
 namespace {
 
 constexpr int OffsetLabelIntervalBits = 20;
 
 using name = SmallString<COFF::NameSize>;
 
-enum AuxiliaryType {
-  ATWeakExternal,
-  ATFile,
-  ATSectionDefinition
-};
+enum AuxiliaryType { ATWeakExternal, ATFile, ATSectionDefinition };
 
 struct AuxSymbol {
   AuxiliaryType AuxType;
   COFF::Auxiliary Aux;
 };
 
 class COFFSection;
 
if (Local) {
     Local->Data.Value = getSymbolValue(MCSym, Layout);
 
     const MCSymbolCOFF &SymbolCOFF = cast<MCSymbolCOFF>(MCSym);
     Local->Data.Type = SymbolCOFF.getType();
     Local->Data.StorageClass = SymbolCOFF.getClass();
 
     // If no storage class was specified in the streamer, define it here.
     if (Local->Data.StorageClass == COFF::IMAGE_SYM_CLASS_NULL) {
-      bool IsExternal = MCSym.isExternal() ||
-                        (!MCSym.getFragment() && !MCSym.isVariable());
+      bool IsExternal =
+          MCSym.isExternal() || (!MCSym.getFragment() && !MCSym.isVariable());
 
       Local->Data.StorageClass = IsExternal ? COFF::IMAGE_SYM_CLASS_EXTERNAL
                                             : COFF::IMAGE_SYM_CLASS_STATIC;
     }
   }
 
   Sym->MC = &MCSym;
 }
case ATWeakExternal:
       W.write<uint32_t>(i.Aux.WeakExternal.TagIndex);
       W.write<uint32_t>(i.Aux.WeakExternal.Characteristics);
       W.OS.write_zeros(sizeof(i.Aux.WeakExternal.unused));
       if (UseBigObj)
         W.OS.write_zeros(COFF::Symbol32Size - COFF::Symbol16Size);
       break;
     case ATFile:
       W.OS.write(reinterpret_cast<const char *>(&i.Aux),
-                        UseBigObj ? COFF::Symbol32Size : COFF::Symbol16Size);
       break;
     case ATSectionDefinition:
       W.write<uint32_t>(i.Aux.SectionDefinition.Length);
       W.write<uint16_t>(i.Aux.SectionDefinition.NumberOfRelocations);
       W.write<uint16_t>(i.Aux.SectionDefinition.NumberOfLinenumbers);
       W.write<uint32_t>(i.Aux.SectionDefinition.CheckSum);
       W.write<uint16_t>(static_cast<int16_t>(i.Aux.SectionDefinition.Number));
       W.OS << char(i.Aux.SectionDefinition.Selection);
       W.OS.write_zeros(sizeof(i.Aux.SectionDefinition.unused));
-      W.write<uint16_t>(static_cast<int16_t>(i.Aux.SectionDefinition.Number >> 16));
+      W.write<uint16_t>(
+          static_cast<int16_t>(i.Aux.SectionDefinition.Number >> 16));
       if (UseBigObj)
         W.OS.write_zeros(COFF::Symbol32Size - COFF::Symbol16Size);
       break;
     }
   }
 }
 
 // Write the section header.
void WinCOFFObjectWriter::recordRelocation(MCAssembler &Asm,
                                            const MCAsmLayout &Layout,
                                            const MCFragment *Fragment,
                                            const MCFixup &Fixup, MCValue Target,
                                            uint64_t &FixedValue) {
   assert(Target.getSymA() && "Relocation must reference a symbol!");
 
   const MCSymbol &A = Target.getSymA()->getSymbol();
   if (!A.isRegistered()) {
-    Asm.getContext().reportError(Fixup.getLoc(),
-                                      Twine("symbol '") + A.getName() +
+    Asm.getContext().reportError(Fixup.getLoc(), Twine("symbol '") +
+                                                     A.getName() +
                                                      "' can not be undefined");
     return;
   }
   if (A.isTemporary() && A.isUndefined()) {
-    Asm.getContext().reportError(Fixup.getLoc(),
-                                      Twine("assembler label '") + A.getName() +
+    Asm.getContext().reportError(Fixup.getLoc(), Twine("assembler label '") +
+                                                     A.getName() +
                                                      "' can not be undefined");
     return;
   }
 
   MCSection *MCSec = Fragment->getParent();
 
   // Mark this symbol as requiring an entry in the symbol table.
   assert(SectionMap.contains(MCSec) &&
          "Section must already have been defined in executePostLayoutBinding!");