[lld-macho] Use uint64_t for getSize() instead of size_t

[int3]

Summary

So things work on 32-bit machines. (@vzakhari reported the
breakage starting from D80177).

[vzakhari]

Thank you! The patch does not build, since some CPP definitions are still using size_t.

[vzakhari]

FYI, the tests pass with additional changes in lld/MachO/SyntheticSections.cpp.

[int3]

update

[int3]

Apologies, I don't have a 32-bit machine here to test things out on... hope it works this time, if not feel free to commandeer

[vzakhari]

Should be working now. Thanks!

lld/MachO/InputSection.h

struct Reloc {
   // the destination that this relocation refers to.
   uint64_t addend;
   llvm::PointerUnion<Symbol *, InputSection *> target;
 };
 
 class InputSection {
 public:
   virtual ~InputSection() = default;
-  virtual size_t getSize() const { return data.size(); }
+  virtual uint64_t getSize() const { return data.size(); }
   virtual uint64_t getFileSize() const { return getSize(); }
   uint64_t getFileOffset() const;
   uint64_t getVA() const;
 
   virtual void writeTo(uint8_t *buf);
 
   InputFile *file = nullptr;
   StringRef name;

lld/MachO/MergedOutputSection.h

 class MergedOutputSection : public OutputSection {
 public:
   MergedOutputSection(StringRef name) : OutputSection(MergedKind, name) {}
 
   const InputSection *firstSection() const { return inputs.front(); }
   const InputSection *lastSection() const { return inputs.back(); }
 
   // These accessors will only be valid after finalizing the section
-  size_t getSize() const override { return size; }
+  uint64_t getSize() const override { return size; }
   uint64_t getFileSize() const override { return fileSize; }
 
   void mergeInput(InputSection *input) override;
   void finalize() override;
 
   void writeTo(uint8_t *buf) const override;
 
   std::vector<InputSection *> inputs;

lld/MachO/OutputSection.h

public:
   OutputSection(Kind kind, StringRef name) : name(name), sectionKind(kind) {}
   virtual ~OutputSection() = default;
   Kind kind() const { return sectionKind; }
 
   // These accessors will only be valid after finalizing the section.
   uint64_t getSegmentOffset() const;
 
   // How much space the section occupies in the address space.
-  virtual size_t getSize() const = 0;
+  virtual uint64_t getSize() const = 0;
   // How much space the section occupies in the file. Most sections are copied
   // as-is so their file size is the same as their address space size.
   virtual uint64_t getFileSize() const { return getSize(); }
 
   // Hidden sections omit header content, but body content may still be present.
   virtual bool isHidden() const { return false; }
   // Unneeded sections are omitted entirely (header and body).
   virtual bool isNeeded() const { return true; }

lld/MachO/SyntheticSections.h

 };
 
 // The header of the Mach-O file, which must have a file offset of zero.
 class MachHeaderSection : public SyntheticSection {
 public:
   MachHeaderSection();
   void addLoadCommand(LoadCommand *);
   bool isHidden() const override { return true; }
-  size_t getSize() const override;
+  uint64_t getSize() const override;
   void writeTo(uint8_t *buf) const override;
 
 private:
   std::vector<LoadCommand *> loadCommands;
   uint32_t sizeOfCmds = 0;
 };
 
 // A hidden section that exists solely for the purpose of creating the
 // __PAGEZERO segment, which is used to catch null pointer dereferences.
 class PageZeroSection : public SyntheticSection {
 public:
   PageZeroSection();
   bool isHidden() const override { return true; }
-  size_t getSize() const override { return PageZeroSize; }
+  uint64_t getSize() const override { return PageZeroSize; }
   uint64_t getFileSize() const override { return 0; }
   void writeTo(uint8_t *buf) const override {}
 };
 
 // This section will be populated by dyld with addresses to non-lazily-loaded
 // dylib symbols.
 class GotSection : public SyntheticSection {
 public:
   GotSection();
 
   const llvm::SetVector<const DylibSymbol *> &getEntries() const {
     return entries;
   }
 
   bool isNeeded() const override { return !entries.empty(); }
 
-  size_t getSize() const override { return entries.size() * WordSize; }
+  uint64_t getSize() const override { return entries.size() * WordSize; }
 
   void writeTo(uint8_t *buf) const override {
     // Nothing to write, GOT contains all zeros at link time; it's populated at
     // runtime by dyld.
   }
 
   void addEntry(DylibSymbol &sym);
 
 private:
   llvm::SetVector<const DylibSymbol *> entries;
 };
 
 // Stores bind opcodes for telling dyld which symbols to load non-lazily.
 class BindingSection : public SyntheticSection {
 public:
   BindingSection();
   void finalizeContents();
-  size_t getSize() const override { return contents.size(); }
+  uint64_t getSize() const override { return contents.size(); }
   // Like other sections in __LINKEDIT, the binding section is special: its
   // offsets are recorded in the LC_DYLD_INFO_ONLY load command, instead of in
   // section headers.
   bool isHidden() const override { return true; }
   bool isNeeded() const override;
   void writeTo(uint8_t *buf) const override;
 
   SmallVector<char, 128> contents;

 // the given offset. The bind opcodes will tell the binder to update the address
 // in the LazyPointerSection to point to the symbol, so that subsequent calls
 // don't have to redo the symbol resolution. The binder will then jump to the
 // resolved symbol.
 
 class StubsSection : public SyntheticSection {
 public:
   StubsSection();
-  size_t getSize() const override;
+  uint64_t getSize() const override;
   bool isNeeded() const override { return !entries.empty(); }
   void writeTo(uint8_t *buf) const override;
 
   const llvm::SetVector<DylibSymbol *> &getEntries() const { return entries; }
 
   void addEntry(DylibSymbol &sym);
 
 private:
   llvm::SetVector<DylibSymbol *> entries;
 };
 
 class StubHelperSection : public SyntheticSection {
 public:
   StubHelperSection();
-  size_t getSize() const override;
+  uint64_t getSize() const override;
   bool isNeeded() const override;
   void writeTo(uint8_t *buf) const override;
 
   void setup();
 
   DylibSymbol *stubBinder = nullptr;
 };
 
 // This section contains space for just a single word, and will be used by dyld
 // to cache an address to the image loader it uses. Note that unlike the other
 // synthetic sections, which are OutputSections, the ImageLoaderCacheSection is
 // an InputSection that gets merged into the __data OutputSection.
 class ImageLoaderCacheSection : public InputSection {
 public:
   ImageLoaderCacheSection();
-  size_t getSize() const override { return WordSize; }
+  uint64_t getSize() const override { return WordSize; }
 };
 
 class LazyPointerSection : public SyntheticSection {
 public:
   LazyPointerSection();
-  size_t getSize() const override;
+  uint64_t getSize() const override;
   bool isNeeded() const override;
   void writeTo(uint8_t *buf) const override;
 };
 
 class LazyBindingSection : public SyntheticSection {
 public:
   LazyBindingSection();
   void finalizeContents();
-  size_t getSize() const override { return contents.size(); }
+  uint64_t getSize() const override { return contents.size(); }
   uint32_t encode(const DylibSymbol &);
   // Like other sections in __LINKEDIT, the lazy binding section is special: its
   // offsets are recorded in the LC_DYLD_INFO_ONLY load command, instead of in
   // section headers.
   bool isHidden() const override { return true; }
   bool isNeeded() const override;
   void writeTo(uint8_t *buf) const override;
 
 private:
   SmallVector<char, 128> contents;
   llvm::raw_svector_ostream os{contents};
 };
 
 // Stores a trie that describes the set of exported symbols.
 class ExportSection : public SyntheticSection {
 public:
   ExportSection();
   void finalizeContents();
-  size_t getSize() const override { return size; }
+  uint64_t getSize() const override { return size; }
   // Like other sections in __LINKEDIT, the export section is special: its
   // offsets are recorded in the LC_DYLD_INFO_ONLY load command, instead of in
   // section headers.
   bool isHidden() const override { return true; }
   void writeTo(uint8_t *buf) const override;
 
 private:
   TrieBuilder trieBuilder;
   size_t size = 0;
 };
 
 // Stores the strings referenced by the symbol table.
 class StringTableSection : public SyntheticSection {
 public:
   StringTableSection();
   // Returns the start offset of the added string.
   uint32_t addString(StringRef);
-  size_t getSize() const override { return size; }
+  uint64_t getSize() const override { return size; }
   // Like other sections in __LINKEDIT, the string table section is special: its
   // offsets are recorded in the LC_SYMTAB load command, instead of in section
   // headers.
   bool isHidden() const override { return true; }
   void writeTo(uint8_t *buf) const override;
 
 private:
   // An n_strx value of 0 always indicates the empty string, so we must locate
   // our non-empty string values at positive offsets in the string table.
   // Therefore we insert a dummy value at position zero.
   std::vector<StringRef> strings{"\0"};
   size_t size = 1;
 };
 
 struct SymtabEntry {
   Symbol *sym;
   size_t strx;
 };
 
 class SymtabSection : public SyntheticSection {
 public:
   SymtabSection(StringTableSection &);
   void finalizeContents();
   size_t getNumSymbols() const { return symbols.size(); }
-  size_t getSize() const override;
+  uint64_t getSize() const override;
   // Like other sections in __LINKEDIT, the symtab section is special: its
   // offsets are recorded in the LC_SYMTAB load command, instead of in section
   // headers.
   bool isHidden() const override { return true; }
   void writeTo(uint8_t *buf) const override;
 
 private:
   StringTableSection &stringTableSection;

lld/MachO/SyntheticSections.cpp

 MachHeaderSection::MachHeaderSection()
     : SyntheticSection(segment_names::text, section_names::header) {}
 
 void MachHeaderSection::addLoadCommand(LoadCommand *lc) {
   loadCommands.push_back(lc);
   sizeOfCmds += lc->getSize();
 }
 
-size_t MachHeaderSection::getSize() const {
+uint64_t MachHeaderSection::getSize() const {
   return sizeof(mach_header_64) + sizeOfCmds;
 }
 
 void MachHeaderSection::writeTo(uint8_t *buf) const {
   auto *hdr = reinterpret_cast<mach_header_64 *>(buf);
   hdr->magic = MH_MAGIC_64;
   hdr->cputype = CPU_TYPE_X86_64;
   hdr->cpusubtype = CPU_SUBTYPE_X86_64_ALL | CPU_SUBTYPE_LIB64;

 
 void BindingSection::writeTo(uint8_t *buf) const {
   memcpy(buf, contents.data(), contents.size());
 }
 
 StubsSection::StubsSection()
     : SyntheticSection(segment_names::text, "__stubs") {}
 
-size_t StubsSection::getSize() const {
+uint64_t StubsSection::getSize() const {
   return entries.size() * target->stubSize;
 }
 
 void StubsSection::writeTo(uint8_t *buf) const {
   size_t off = 0;
   for (const DylibSymbol *sym : in.stubs->getEntries()) {
     target->writeStub(buf + off, *sym);
     off += target->stubSize;
   }
 }
 
 void StubsSection::addEntry(DylibSymbol &sym) {
   if (entries.insert(&sym))
     sym.stubsIndex = entries.size() - 1;
 }
 
 StubHelperSection::StubHelperSection()
     : SyntheticSection(segment_names::text, "__stub_helper") {}
 
-size_t StubHelperSection::getSize() const {
+uint64_t StubHelperSection::getSize() const {
   return target->stubHelperHeaderSize +
          in.stubs->getEntries().size() * target->stubHelperEntrySize;
 }
 
 bool StubHelperSection::isNeeded() const {
   return !in.stubs->getEntries().empty();
 }
 

 }
 
 LazyPointerSection::LazyPointerSection()
     : SyntheticSection(segment_names::data, "__la_symbol_ptr") {
   align = 8;
   flags = S_LAZY_SYMBOL_POINTERS;
 }
 
-size_t LazyPointerSection::getSize() const {
+uint64_t LazyPointerSection::getSize() const {
   return in.stubs->getEntries().size() * WordSize;
 }
 
 bool LazyPointerSection::isNeeded() const {
   return !in.stubs->getEntries().empty();
 }
 
 void LazyPointerSection::writeTo(uint8_t *buf) const {

 SymtabSection::SymtabSection(StringTableSection &stringTableSection)
     : SyntheticSection(segment_names::linkEdit, section_names::symbolTable),
       stringTableSection(stringTableSection) {
   // TODO: When we introduce the SyntheticSections superclass, we should make
   // all synthetic sections aligned to WordSize by default.
   align = WordSize;
 }
 
-size_t SymtabSection::getSize() const {
+uint64_t SymtabSection::getSize() const {
   return symbols.size() * sizeof(structs::nlist_64);
 }
 
 void SymtabSection::finalizeContents() {
   // TODO support other symbol types
   for (Symbol *sym : symtab->getSymbols())
     if (isa<Defined>(sym))
       symbols.push_back({sym, stringTableSection.addString(sym->getName())});