[ARM] Clarify a comment regarding AArch64. NFC.

[compnerd]

llvm/lib/Target/ARM/MCTargetDesc/ARMWinCOFFObjectWriter.cpp

30–31

ARM64 is a different target, but the COFF writer can be shared across the two right? What makes it special? A comment to that effect would be useful. I think that we might want to try to push this upwards to avoid the parameter all together if the two paths cannot be merged.

[mstorsjo]

llvm/lib/Target/ARM/MCTargetDesc/ARMWinCOFFObjectWriter.cpp

30–31

You mean this class? Almost everything in each of them is different between the two, so I don't really see what benefits there would be to stuffing both into one class with conditionals around everything.

[rnk]

llvm/lib/Target/ARM/MCTargetDesc/ARMWinCOFFObjectWriter.cpp

29

I think you can go further and remove the parameter here and in the factory function createARMWinCOFFObjectWriter. We only ever pass false to it. This just appears to be copy-pasta from the MachO version. The ARMELFObjectWriter doesn't have this constructor parameter.

30–31

Even if there is overlap between aarch64 and arm, the shared code would have to live in MC, which means it would have to live in MCWinCOFFObjectWriter anyway. I think we can do this simplification.

[mstorsjo]

Updated to remove the parameter and the related asserts.

[rnk]

lgtm

llvm/lib/Target/ARM/MCTargetDesc/ARMAsmBackendWinCOFF.h

 
 namespace {
 class ARMAsmBackendWinCOFF : public ARMAsmBackend {
 public:
   ARMAsmBackendWinCOFF(const Target &T, const MCSubtargetInfo &STI)
       : ARMAsmBackend(T, STI, support::little) {}
   std::unique_ptr<MCObjectTargetWriter>
   createObjectTargetWriter() const override {
-    return createARMWinCOFFObjectWriter(/*Is64Bit=*/false);
+    return createARMWinCOFFObjectWriter();
   }
 };
 }
 
 #endif

llvm/lib/Target/ARM/MCTargetDesc/ARMMCTargetDesc.h

 
 /// Construct an ARM Mach-O object writer.
 std::unique_ptr<MCObjectTargetWriter>
 createARMMachObjectWriter(bool Is64Bit, uint32_t CPUType,
                           uint32_t CPUSubtype);
 
 /// Construct an ARM PE/COFF object writer.
 std::unique_ptr<MCObjectTargetWriter>
-createARMWinCOFFObjectWriter(bool Is64Bit);
+createARMWinCOFFObjectWriter();
 
 /// Construct ARM Mach-O relocation info.
 MCRelocationInfo *createARMMachORelocationInfo(MCContext &Ctx);
 
 namespace ARM {
 enum OperandType {
   OPERAND_VPRED_R = MCOI::OPERAND_FIRST_TARGET,
   OPERAND_VPRED_N,

llvm/lib/Target/ARM/MCTargetDesc/ARMWinCOFFObjectWriter.cpp

 #include <cassert>
 
 using namespace llvm;
 
 namespace {
 
 class ARMWinCOFFObjectWriter : public MCWinCOFFObjectTargetWriter {
 public:
-  ARMWinCOFFObjectWriter(bool Is64Bit)
+  ARMWinCOFFObjectWriter()
     : MCWinCOFFObjectTargetWriter(COFF::IMAGE_FILE_MACHINE_ARMNT) {
-    assert(!Is64Bit && "AArch64 support not yet implemented");
   }
 
   ~ARMWinCOFFObjectWriter() override = default;
 
   unsigned getRelocType(MCContext &Ctx, const MCValue &Target,
                         const MCFixup &Fixup, bool IsCrossSection,
                         const MCAsmBackend &MAB) const override;
 
   bool recordRelocation(const MCFixup &) const override;
 };
 
 } // end anonymous namespace
 
 unsigned ARMWinCOFFObjectWriter::getRelocType(MCContext &Ctx,
                                               const MCValue &Target,
                                               const MCFixup &Fixup,
                                               bool IsCrossSection,
                                               const MCAsmBackend &MAB) const {
-  assert(getMachine() == COFF::IMAGE_FILE_MACHINE_ARMNT &&
-         "AArch64 support not yet implemented");
-
   MCSymbolRefExpr::VariantKind Modifier =
     Target.isAbsolute() ? MCSymbolRefExpr::VK_None : Target.getSymA()->getKind();
 
   switch (static_cast<unsigned>(Fixup.getKind())) {
   default: {
     const MCFixupKindInfo &Info = MAB.getFixupKindInfo(Fixup.getKind());
     report_fatal_error(Twine("unsupported relocation type: ") + Info.Name);
   }

 
 bool ARMWinCOFFObjectWriter::recordRelocation(const MCFixup &Fixup) const {
   return static_cast<unsigned>(Fixup.getKind()) != ARM::fixup_t2_movt_hi16;
 }
 
 namespace llvm {
 
 std::unique_ptr<MCObjectTargetWriter>
-createARMWinCOFFObjectWriter(bool Is64Bit) {
-  return std::make_unique<ARMWinCOFFObjectWriter>(Is64Bit);
+createARMWinCOFFObjectWriter() {
+  return std::make_unique<ARMWinCOFFObjectWriter>();
 }
 
 } // end namespace llvm