[GOFF] Write out relocations in the GOFF writer

Add support for writing relocations. Since the symbol numbering is only
available after the symbols are written, the relocations are collected
in a vector. At write time, the relocations are converted using the
symbols ids, compressed and written out. A relocation data record is
limited to 32K-1 bytes, which requires making sure that larger relocation
data is written into multiple records.

Author: redstar

llvm/include/llvm/BinaryFormat/GOFF.h

@@ -157,6 +157,32 @@ enum ESDAlignment : uint8_t {
   ESD_ALIGN_4Kpage = 12,
 };
 
+enum RLDReferenceType : uint8_t {
+  RLD_RT_RAddress = 0,
+  RLD_RT_ROffset = 1,
+  RLD_RT_RLength = 2,
+  RLD_RT_RRelativeImmediate = 6,
+  RLD_RT_RTypeConstant = 7,
+  RLD_RT_RLongDisplacement = 9,
+};
+
+enum RLDReferentType : uint8_t {
+  RLD_RO_Label = 0,
+  RLD_RO_Element = 1,
+  RLD_RO_Class = 2,
+  RLD_RO_Part = 3,
+};
+
+enum RLDAction : uint8_t {
+  RLD_ACT_Add = 0,
+  RLD_ACT_Subtract = 1,
+};
+
+enum RLDFetchStore : uint8_t {
+  RLD_FS_Fetch = 0,
+  RLD_FS_Store = 1
+};
+
 enum ENDEntryPointRequest : uint8_t {
   END_EPR_None = 0,
   END_EPR_EsdidOffset = 1,

llvm/include/llvm/MC/MCGOFFObjectWriter.h

@@ -11,40 +11,75 @@
 
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCValue.h"
+#include <memory>
+#include <vector>
 
 namespace llvm {
 class MCObjectWriter;
+class MCSectionGOFF;
+class MCSymbolGOFF;
 class raw_pwrite_stream;
 
 class MCGOFFObjectTargetWriter : public MCObjectTargetWriter {
 protected:
   MCGOFFObjectTargetWriter() = default;
 
 public:
+  enum RLDRelocationType {
+    Reloc_Type_ACon = 0x1,   // General address.
+    Reloc_Type_RelImm = 0x2, // Relative-immediate address.
+    Reloc_Type_QCon = 0x3,   // Offset of symbol in class.
+    Reloc_Type_VCon = 0x4,   // Address of external symbol.
+    Reloc_Type_RCon = 0x5,   // PSECT of symbol.
+  };
+
   ~MCGOFFObjectTargetWriter() override = default;
 
+  virtual unsigned getRelocType(const MCValue &Target, const MCFixup &Fixup,
+                                bool IsPCRel) const = 0;
+
   Triple::ObjectFormatType getFormat() const override { return Triple::GOFF; }
 
   static bool classof(const MCObjectTargetWriter *W) {
     return W->getFormat() == Triple::GOFF;
   }
 };
 
+struct GOFFSavedRelocationEntry {
+  const MCSectionGOFF *Section;
+  const MCSymbolGOFF *SymA;
+  const MCSymbolGOFF *SymB;
+  unsigned RelocType;
+  uint64_t FixupOffset;
+  uint32_t Length;
+  uint64_t FixedValue; // Info only.
+
+  GOFFSavedRelocationEntry(const MCSectionGOFF *Section,
+                           const MCSymbolGOFF *SymA, const MCSymbolGOFF *SymB,
+                           unsigned RelocType, uint64_t FixupOffset,
+                           uint32_t Length, uint64_t FixedValue)
+      : Section(Section), SymA(SymA), SymB(SymB), RelocType(RelocType),
+        FixupOffset(FixupOffset), Length(Length), FixedValue(FixedValue) {}
+};
+
 class GOFFObjectWriter : public MCObjectWriter {
   // The target specific GOFF writer instance.
   std::unique_ptr<MCGOFFObjectTargetWriter> TargetObjectWriter;
 
   // The stream used to write the GOFF records.
   raw_pwrite_stream &OS;
 
+  // Saved relocation data.
+  std::vector<GOFFSavedRelocationEntry> SavedRelocs;
+
 public:
   GOFFObjectWriter(std::unique_ptr<MCGOFFObjectTargetWriter> MOTW,
                    raw_pwrite_stream &OS);
   ~GOFFObjectWriter() override;
 
   // Implementation of the MCObjectWriter interface.
   void recordRelocation(const MCFragment &F, const MCFixup &Fixup,
-                        MCValue Target, uint64_t &FixedValue) override {}
+                        MCValue Target, uint64_t &FixedValue) override;
 
   uint64_t writeObject() override;
 };