[LLD] COFF: Make DefinedCOFF one pointer smaller

[ruiu]

Summary

COFFSymbolRef is a container type for coff_symbol16 and coff_symbol32.
The difference between 16 and 32 matters only for SectionNumber, Type,
StorageClass and NumberOfAuxSymbols. Name and Value fields are at
the same offsets. So we don't need to distinguish them.

[majnemer]

I think it would be safer to create a coff_symbol_generic which only contains the fields that coff_symbol16 and coff_symbol32 have in common. This way, we wouldn't accidentally assume we could use the other fields.

[ruiu]

Updated to use http://reviews.llvm.org/D10819

[chandlerc]

Deferring to David here, he's more familiar with the libObject side of things.

[majnemer]

Thanks! LGTM.

[Eugene.Zelenko]

Committed in r241025.

COFF/Symbols.h

 #include <vector>
 
 namespace lld {
 namespace coff {
 
 using llvm::object::Archive;
 using llvm::object::COFFSymbolRef;
 using llvm::object::coff_import_header;
+using llvm::object::coff_symbol_generic;
 
 class ArchiveFile;
 class InputFile;
 class ObjectFile;
 class SymbolBody;
 
 // A real symbol object, SymbolBody, is usually accessed indirectly
 // through a Symbol. There's always one Symbol for each symbol name.
public:
   uint64_t getFileOff();
 };
 
 // Symbols defined via a COFF object file.
 class DefinedCOFF : public Defined {
   friend SymbolBody;
 public:
   DefinedCOFF(Kind K, ObjectFile *F, COFFSymbolRef S)
-      : Defined(K), File(F), Sym(S) {}
+      : Defined(K), File(F), Sym(S.getGeneric()) {}
 
   static bool classof(const SymbolBody *S) {
     return S->kind() <= LastDefinedCOFFKind;
   }
 
 protected:
   ObjectFile *File;
-  COFFSymbolRef Sym;
+  const coff_symbol_generic *Sym;
 };
 
 // Regular defined symbols read from object file symbol tables.
 class DefinedRegular : public DefinedCOFF {
 public:
   DefinedRegular(ObjectFile *F, COFFSymbolRef S, SectionChunk *C)
       : DefinedCOFF(DefinedRegularKind, F, S), Data(&C->Ptr) {
-    IsExternal = Sym.isExternal();
+    IsExternal = S.isExternal();
     IsCOMDAT = C->isCOMDAT();
   }
 
   static bool classof(const SymbolBody *S) {
     return S->kind() == DefinedRegularKind;
   }
 
   uint64_t getFileOff() {
-    return (*Data)->getFileOff() + Sym.getValue();
+    return (*Data)->getFileOff() + Sym->Value;
   }
 
-  uint64_t getRVA() { return (*Data)->getRVA() + Sym.getValue(); }
+  uint64_t getRVA() { return (*Data)->getRVA() + Sym->Value; }
   bool isCOMDAT() { return IsCOMDAT; }
   bool isLive() const { return (*Data)->isLive(); }
   void markLive() { (*Data)->markLive(); }
   SectionChunk *getChunk() { return *Data; }
-  uint64_t getValue() { return Sym.getValue(); }
+  uint32_t getValue() { return Sym->Value; }
 
 private:
   SectionChunk **Data;
 };
 
 class DefinedCommon : public DefinedCOFF {
 public:
   DefinedCommon(ObjectFile *F, COFFSymbolRef S, CommonChunk *C)
       : DefinedCOFF(DefinedCommonKind, F, S), Data(C) {
-    IsExternal = Sym.isExternal();
+    IsExternal = S.isExternal();
   }
 
   static bool classof(const SymbolBody *S) {
     return S->kind() == DefinedCommonKind;
   }
 
   uint64_t getRVA() { return Data->getRVA(); }
   uint64_t getFileOff() { return Data->getFileOff(); }
 
 private:
   friend SymbolBody;
 
-  uint64_t getSize() { return Sym.getValue(); }
+  uint64_t getSize() { return Sym->Value; }
 
   CommonChunk *Data;
 };
 
 // Absolute symbols.
 class DefinedAbsolute : public Defined {
 public:
   DefinedAbsolute(StringRef N, COFFSymbolRef S)