[lld] r316841 - Pass symbol attributes instead of ElfSym to Shared symbol ctor.

Rafael EspĂ­ndola via llvm-commits llvm-commits at lists.llvm.org
Fri Nov 3 12:47:20 PDT 2017


This also caused a performance regression.

r316848 helped bring some of the performance back, but not to parity.

316879  and 316880 got us back the previous perf on scylla, but they
seem to be an independent improvement, so we probably still have this
regression.

The area has been further changed, so it is really hard to revert this
now. Can you try to semantically revert it (and benchmark it)?

*Please*, in the future do not commit such a big series of patches in
quick sequence. We are now stuck with regressions that are hard to
fix.

Cheers,
Rafael



On 28 October 2017 at 13:15, Rui Ueyama via llvm-commits
<llvm-commits at lists.llvm.org> wrote:
> Author: ruiu
> Date: Sat Oct 28 13:15:56 2017
> New Revision: 316841
>
> URL: http://llvm.org/viewvc/llvm-project?rev=316841&view=rev
> Log:
> Pass symbol attributes instead of ElfSym to Shared symbol ctor.
>
> This change allows us to use less templates for Shared symbol and
> the functions that deals with shared symbols.
>
> Modified:
>     lld/trunk/ELF/InputFiles.cpp
>     lld/trunk/ELF/InputFiles.h
>     lld/trunk/ELF/MapFile.cpp
>     lld/trunk/ELF/MapFile.h
>     lld/trunk/ELF/Relocations.cpp
>     lld/trunk/ELF/SymbolTable.cpp
>     lld/trunk/ELF/SymbolTable.h
>     lld/trunk/ELF/Symbols.cpp
>     lld/trunk/ELF/Symbols.h
>     lld/trunk/ELF/SyntheticSections.cpp
>     lld/trunk/ELF/Writer.cpp
>
> Modified: lld/trunk/ELF/InputFiles.cpp
> URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/InputFiles.cpp?rev=316841&r1=316840&r2=316841&view=diff
> ==============================================================================
> --- lld/trunk/ELF/InputFiles.cpp (original)
> +++ lld/trunk/ELF/InputFiles.cpp Sat Oct 28 13:15:56 2017
> @@ -514,11 +514,9 @@ template <class ELFT> void ObjFile<ELFT>
>  }
>
>  template <class ELFT>
> -InputSectionBase *ObjFile<ELFT>::getSection(const Elf_Sym &Sym) const {
> -  uint32_t Index = this->getSectionIndex(Sym);
> +InputSectionBase *ObjFile<ELFT>::getSection(uint32_t Index) const {
>    if (Index == 0)
>      return nullptr;
> -
>    if (Index >= this->Sections.size())
>      fatal(toString(this) + ": invalid section index: " + Twine(Index));
>
> @@ -533,7 +531,7 @@ InputSectionBase *ObjFile<ELFT>::getSect
>  template <class ELFT>
>  SymbolBody *ObjFile<ELFT>::createSymbolBody(const Elf_Sym *Sym) {
>    int Binding = Sym->getBinding();
> -  InputSectionBase *Sec = getSection(*Sym);
> +  InputSectionBase *Sec = getSection(this->getSectionIndex(*Sym));
>
>    uint8_t StOther = Sym->st_other;
>    uint8_t Type = Sym->getType();
> @@ -629,14 +627,6 @@ SharedFile<ELFT>::SharedFile(MemoryBuffe
>      : ELFFileBase<ELFT>(Base::SharedKind, M), SoName(DefaultSoName),
>        AsNeeded(Config->AsNeeded) {}
>
> -template <class ELFT>
> -const typename ELFT::Shdr *
> -SharedFile<ELFT>::getSection(const Elf_Sym &Sym) const {
> -  return check(
> -      this->getObj().getSection(&Sym, this->ELFSyms, this->SymtabSHNDX),
> -      toString(this));
> -}
> -
>  // Partially parse the shared object file so that we can call
>  // getSoName on this object.
>  template <class ELFT> void SharedFile<ELFT>::parseSoName() {
> @@ -735,6 +725,10 @@ template <class ELFT> void SharedFile<EL
>    const Elf_Versym *Versym = nullptr;
>    std::vector<const Elf_Verdef *> Verdefs = parseVerdefs(Versym);
>
> +  ArrayRef<Elf_Shdr> Sections =
> +      check(this->getObj().sections(), toString(this));
> +
> +  // Add symbols to the symbol table.
>    Elf_Sym_Range Syms = this->getGlobalELFSyms();
>    for (const Elf_Sym &Sym : Syms) {
>      unsigned VersymIndex = 0;
> @@ -765,15 +759,25 @@ template <class ELFT> void SharedFile<EL
>        V = Verdefs[VersymIndex];
>      }
>
> +    // We do not usually care about alignments of data in shared object
> +    // files because the loader takes care of it. However, if we promote a
> +    // DSO symbol to point to .bss due to copy relocation, we need to keep
> +    // the original alignment requirements. We infer it here.
> +    uint32_t Alignment = 1 << countTrailingZeros((uint64_t)Sym.st_value);
> +    if (0 < Sym.st_shndx && Sym.st_shndx < Sections.size()) {
> +      uint32_t SecAlign = Sections[Sym.st_shndx].sh_addralign;
> +      Alignment = std::min(Alignment, SecAlign);
> +    }
> +
>      if (!Hidden)
> -      Symtab->addShared(Name, this, Sym, V);
> +      Symtab->addShared(Name, this, Sym, Alignment, V);
>
>      // Also add the symbol with the versioned name to handle undefined symbols
>      // with explicit versions.
>      if (V) {
>        StringRef VerName = this->StringTable.data() + V->getAux()->vda_name;
>        Name = Saver.save(Name + "@" + VerName);
> -      Symtab->addShared(Name, this, Sym, V);
> +      Symtab->addShared(Name, this, Sym, Alignment, V);
>      }
>    }
>  }
>
> Modified: lld/trunk/ELF/InputFiles.h
> URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/InputFiles.h?rev=316841&r1=316840&r2=316841&view=diff
> ==============================================================================
> --- lld/trunk/ELF/InputFiles.h (original)
> +++ lld/trunk/ELF/InputFiles.h Sat Oct 28 13:15:56 2017
> @@ -167,7 +167,7 @@ public:
>    ObjFile(MemoryBufferRef M, StringRef ArchiveName);
>    void parse(llvm::DenseSet<llvm::CachedHashStringRef> &ComdatGroups);
>
> -  InputSectionBase *getSection(const Elf_Sym &Sym) const;
> +  InputSectionBase *getSection(uint32_t Index) const;
>
>    SymbolBody &getSymbolBody(uint32_t SymbolIndex) const {
>      if (SymbolIndex >= this->Symbols.size())
> @@ -294,7 +294,6 @@ template <class ELFT> class SharedFile :
>  public:
>    std::string SoName;
>
> -  const Elf_Shdr *getSection(const Elf_Sym &Sym) const;
>    llvm::ArrayRef<StringRef> getUndefinedSymbols() { return Undefs; }
>
>    static bool classof(const InputFile *F) {
>
> Modified: lld/trunk/ELF/MapFile.cpp
> URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/MapFile.cpp?rev=316841&r1=316840&r2=316841&view=diff
> ==============================================================================
> --- lld/trunk/ELF/MapFile.cpp (original)
> +++ lld/trunk/ELF/MapFile.cpp Sat Oct 28 13:15:56 2017
> @@ -49,7 +49,7 @@ static void writeHeader(raw_ostream &OS,
>  static std::string indent(int Depth) { return std::string(Depth * 8, ' '); }
>
>  // Returns a list of all symbols that we want to print out.
> -template <class ELFT> static std::vector<Defined *> getSymbols() {
> +static std::vector<Defined *> getSymbols() {
>    std::vector<Defined *> V;
>    for (InputFile *File : ObjectFiles) {
>      for (SymbolBody *B : File->getSymbols()) {
> @@ -90,13 +90,12 @@ static SymbolMapTy getSectionSyms(ArrayR
>  // Construct a map from symbols to their stringified representations.
>  // Demangling symbols (which is what toString() does) is slow, so
>  // we do that in batch using parallel-for.
> -template <class ELFT>
>  static DenseMap<Defined *, std::string>
>  getSymbolStrings(ArrayRef<Defined *> Syms) {
>    std::vector<std::string> Str(Syms.size());
>    parallelForEachN(0, Syms.size(), [&](size_t I) {
>      raw_string_ostream OS(Str[I]);
> -    writeHeader(OS, Syms[I]->getVA(), Syms[I]->template getSize<ELFT>(), 0);
> +    writeHeader(OS, Syms[I]->getVA(), Syms[I]->getSize(), 0);
>      OS << indent(2) << toString(*Syms[I]);
>    });
>
> @@ -106,7 +105,7 @@ getSymbolStrings(ArrayRef<Defined *> Sym
>    return Ret;
>  }
>
> -template <class ELFT> void elf::writeMapFile() {
> +void elf::writeMapFile() {
>    if (Config->MapFile.empty())
>      return;
>
> @@ -119,12 +118,12 @@ template <class ELFT> void elf::writeMap
>    }
>
>    // Collect symbol info that we want to print out.
> -  std::vector<Defined *> Syms = getSymbols<ELFT>();
> +  std::vector<Defined *> Syms = getSymbols();
>    SymbolMapTy SectionSyms = getSectionSyms(Syms);
> -  DenseMap<Defined *, std::string> SymStr = getSymbolStrings<ELFT>(Syms);
> +  DenseMap<Defined *, std::string> SymStr = getSymbolStrings(Syms);
>
>    // Print out the header line.
> -  int W = ELFT::Is64Bits ? 16 : 8;
> +  int W = Config->Is64 ? 16 : 8;
>    OS << left_justify("Address", W) << ' ' << left_justify("Size", W)
>       << " Align Out     In      Symbol\n";
>
> @@ -148,8 +147,3 @@ template <class ELFT> void elf::writeMap
>      }
>    }
>  }
> -
> -template void elf::writeMapFile<ELF32LE>();
> -template void elf::writeMapFile<ELF32BE>();
> -template void elf::writeMapFile<ELF64LE>();
> -template void elf::writeMapFile<ELF64BE>();
>
> Modified: lld/trunk/ELF/MapFile.h
> URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/MapFile.h?rev=316841&r1=316840&r2=316841&view=diff
> ==============================================================================
> --- lld/trunk/ELF/MapFile.h (original)
> +++ lld/trunk/ELF/MapFile.h Sat Oct 28 13:15:56 2017
> @@ -10,12 +10,9 @@
>  #ifndef LLD_ELF_MAPFILE_H
>  #define LLD_ELF_MAPFILE_H
>
> -#include <llvm/ADT/ArrayRef.h>
> -
>  namespace lld {
>  namespace elf {
> -class OutputSection;
> -template <class ELFT> void writeMapFile();
> +void writeMapFile();
>  } // namespace elf
>  } // namespace lld
>
>
> Modified: lld/trunk/ELF/Relocations.cpp
> URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/Relocations.cpp?rev=316841&r1=316840&r2=316841&view=diff
> ==============================================================================
> --- lld/trunk/ELF/Relocations.cpp (original)
> +++ lld/trunk/ELF/Relocations.cpp Sat Oct 28 13:15:56 2017
> @@ -445,14 +445,13 @@ static RelExpr fromPlt(RelExpr Expr) {
>  // Returns true if a given shared symbol is in a read-only segment in a DSO.
>  template <class ELFT> static bool isReadOnly(SharedSymbol *SS) {
>    typedef typename ELFT::Phdr Elf_Phdr;
> -  uint64_t Value = SS->getValue<ELFT>();
>
>    // Determine if the symbol is read-only by scanning the DSO's program headers.
>    const SharedFile<ELFT> *File = SS->getFile<ELFT>();
>    for (const Elf_Phdr &Phdr : check(File->getObj().program_headers()))
>      if ((Phdr.p_type == ELF::PT_LOAD || Phdr.p_type == ELF::PT_GNU_RELRO) &&
> -        !(Phdr.p_flags & ELF::PF_W) && Value >= Phdr.p_vaddr &&
> -        Value < Phdr.p_vaddr + Phdr.p_memsz)
> +        !(Phdr.p_flags & ELF::PF_W) && SS->Value >= Phdr.p_vaddr &&
> +        SS->Value < Phdr.p_vaddr + Phdr.p_memsz)
>        return true;
>    return false;
>  }
> @@ -467,12 +466,10 @@ static std::vector<SharedSymbol *> getSy
>    typedef typename ELFT::Sym Elf_Sym;
>
>    SharedFile<ELFT> *File = SS->getFile<ELFT>();
> -  uint64_t Shndx = SS->getShndx<ELFT>();
> -  uint64_t Value = SS->getValue<ELFT>();
>
>    std::vector<SharedSymbol *> Ret;
>    for (const Elf_Sym &S : File->getGlobalELFSyms()) {
> -    if (S.st_shndx != Shndx || S.st_value != Value)
> +    if (S.st_shndx != SS->Shndx || S.st_value != SS->Value)
>        continue;
>      StringRef Name = check(S.getName(File->getStringTable()));
>      SymbolBody *Sym = Symtab->find(Name);
> @@ -526,7 +523,7 @@ static std::vector<SharedSymbol *> getSy
>  // define an accessor getV().
>  template <class ELFT> static void addCopyRelSymbol(SharedSymbol *SS) {
>    // Copy relocation against zero-sized symbol doesn't make sense.
> -  uint64_t SymSize = SS->template getSize<ELFT>();
> +  uint64_t SymSize = SS->getSize();
>    if (SymSize == 0)
>      fatal("cannot create a copy relocation for symbol " + toString(*SS));
>
> @@ -534,7 +531,7 @@ template <class ELFT> static void addCop
>    // memory protection by reserving space in the .bss.rel.ro section.
>    bool IsReadOnly = isReadOnly<ELFT>(SS);
>    BssSection *Sec = make<BssSection>(IsReadOnly ? ".bss.rel.ro" : ".bss",
> -                                     SymSize, SS->getAlignment<ELFT>());
> +                                     SymSize, SS->Alignment);
>    if (IsReadOnly)
>      InX::BssRelRo->getParent()->addSection(Sec);
>    else
> @@ -1014,7 +1011,7 @@ static void scanRelocs(InputSectionBase
>
>      // The size is not going to change, so we fold it in here.
>      if (Expr == R_SIZE)
> -      Addend += Body.getSize<ELFT>();
> +      Addend += Body.getSize();
>
>      // If the produced value is a constant, we just remember to write it
>      // when outputting this section. We also have to do it if the format
>
> Modified: lld/trunk/ELF/SymbolTable.cpp
> URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/SymbolTable.cpp?rev=316841&r1=316840&r2=316841&view=diff
> ==============================================================================
> --- lld/trunk/ELF/SymbolTable.cpp (original)
> +++ lld/trunk/ELF/SymbolTable.cpp Sat Oct 28 13:15:56 2017
> @@ -498,7 +498,7 @@ Symbol *SymbolTable::addRegular(StringRe
>
>  template <typename ELFT>
>  void SymbolTable::addShared(StringRef Name, SharedFile<ELFT> *File,
> -                            const typename ELFT::Sym &Sym,
> +                            const typename ELFT::Sym &Sym, uint32_t Alignment,
>                              const typename ELFT::Verdef *Verdef) {
>    // DSO symbols do not affect visibility in the output, so we pass STV_DEFAULT
>    // as the visibility, which will leave the visibility in the symbol table
> @@ -516,8 +516,9 @@ void SymbolTable::addShared(StringRef Na
>    // in the same DSO.
>    if (WasInserted || ((Body->isUndefined() || Body->isLazy()) &&
>                        Body->getVisibility() == STV_DEFAULT)) {
> -    replaceBody<SharedSymbol>(S, File, Name, Sym.st_other, Sym.getType(), &Sym,
> -                              Verdef);
> +    replaceBody<SharedSymbol>(S, File, Name, Sym.st_other, Sym.getType(),
> +                              Sym.st_value, Sym.st_size, Alignment,
> +                              Sym.st_shndx, Verdef);
>      if (!S->isWeak())
>        File->IsUsed = true;
>    }
> @@ -881,15 +882,19 @@ template void SymbolTable::addLazyObject
>
>  template void SymbolTable::addShared<ELF32LE>(StringRef, SharedFile<ELF32LE> *,
>                                                const typename ELF32LE::Sym &,
> +                                              uint32_t Alignment,
>                                                const typename ELF32LE::Verdef *);
>  template void SymbolTable::addShared<ELF32BE>(StringRef, SharedFile<ELF32BE> *,
>                                                const typename ELF32BE::Sym &,
> +                                              uint32_t Alignment,
>                                                const typename ELF32BE::Verdef *);
>  template void SymbolTable::addShared<ELF64LE>(StringRef, SharedFile<ELF64LE> *,
>                                                const typename ELF64LE::Sym &,
> +                                              uint32_t Alignment,
>                                                const typename ELF64LE::Verdef *);
>  template void SymbolTable::addShared<ELF64BE>(StringRef, SharedFile<ELF64BE> *,
>                                                const typename ELF64BE::Sym &,
> +                                              uint32_t Alignment,
>                                                const typename ELF64BE::Verdef *);
>
>  template void SymbolTable::fetchIfLazy<ELF32LE>(StringRef);
>
> Modified: lld/trunk/ELF/SymbolTable.h
> URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/SymbolTable.h?rev=316841&r1=316840&r2=316841&view=diff
> ==============================================================================
> --- lld/trunk/ELF/SymbolTable.h (original)
> +++ lld/trunk/ELF/SymbolTable.h Sat Oct 28 13:15:56 2017
> @@ -60,7 +60,7 @@ public:
>
>    template <class ELFT>
>    void addShared(StringRef Name, SharedFile<ELFT> *F,
> -                 const typename ELFT::Sym &Sym,
> +                 const typename ELFT::Sym &Sym, uint32_t Alignment,
>                   const typename ELFT::Verdef *Verdef);
>
>    template <class ELFT>
>
> Modified: lld/trunk/ELF/Symbols.cpp
> URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/Symbols.cpp?rev=316841&r1=316840&r2=316841&view=diff
> ==============================================================================
> --- lld/trunk/ELF/Symbols.cpp (original)
> +++ lld/trunk/ELF/Symbols.cpp Sat Oct 28 13:15:56 2017
> @@ -174,13 +174,13 @@ uint64_t SymbolBody::getPltVA() const {
>           PltIndex * Target->PltEntrySize;
>  }
>
> -template <class ELFT> typename ELFT::uint SymbolBody::getSize() const {
> +uint64_t SymbolBody::getSize() const {
>    if (const auto *C = dyn_cast<DefinedCommon>(this))
>      return C->Size;
>    if (const auto *DR = dyn_cast<DefinedRegular>(this))
>      return DR->Size;
>    if (const auto *S = dyn_cast<SharedSymbol>(this))
> -    return S->getSize<ELFT>();
> +    return S->Size;
>    return 0;
>  }
>
> @@ -261,17 +261,6 @@ template <class ELFT> bool DefinedRegula
>           (Hdr->e_flags & EF_MIPS_PIC);
>  }
>
> -// If a shared symbol is referred via a copy relocation, its alignment
> -// becomes part of the ABI. This function returns a symbol alignment.
> -// Because symbols don't have alignment attributes, we need to infer that.
> -template <class ELFT> uint32_t SharedSymbol::getAlignment() const {
> -  SharedFile<ELFT> *File = getFile<ELFT>();
> -  uint32_t SecAlign = File->getSection(getSym<ELFT>())->sh_addralign;
> -  uint64_t SymValue = getSym<ELFT>().st_value;
> -  uint32_t SymAlign = uint32_t(1) << countTrailingZeros(SymValue);
> -  return std::min(SecAlign, SymAlign);
> -}
> -
>  InputFile *Lazy::fetch() {
>    if (auto *S = dyn_cast<LazyArchive>(this))
>      return S->fetch();
> @@ -346,17 +335,7 @@ std::string lld::toString(const SymbolBo
>    return B.getName();
>  }
>
> -template uint32_t SymbolBody::template getSize<ELF32LE>() const;
> -template uint32_t SymbolBody::template getSize<ELF32BE>() const;
> -template uint64_t SymbolBody::template getSize<ELF64LE>() const;
> -template uint64_t SymbolBody::template getSize<ELF64BE>() const;
> -
>  template bool DefinedRegular::template isMipsPIC<ELF32LE>() const;
>  template bool DefinedRegular::template isMipsPIC<ELF32BE>() const;
>  template bool DefinedRegular::template isMipsPIC<ELF64LE>() const;
>  template bool DefinedRegular::template isMipsPIC<ELF64BE>() const;
> -
> -template uint32_t SharedSymbol::template getAlignment<ELF32LE>() const;
> -template uint32_t SharedSymbol::template getAlignment<ELF32BE>() const;
> -template uint32_t SharedSymbol::template getAlignment<ELF64LE>() const;
> -template uint32_t SharedSymbol::template getAlignment<ELF64BE>() const;
>
> Modified: lld/trunk/ELF/Symbols.h
> URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/Symbols.h?rev=316841&r1=316840&r2=316841&view=diff
> ==============================================================================
> --- lld/trunk/ELF/Symbols.h (original)
> +++ lld/trunk/ELF/Symbols.h Sat Oct 28 13:15:56 2017
> @@ -93,7 +93,7 @@ public:
>    uint64_t getGotPltOffset() const;
>    uint64_t getGotPltVA() const;
>    uint64_t getPltVA() const;
> -  template <class ELFT> typename ELFT::uint getSize() const;
> +  uint64_t getSize() const;
>    OutputSection *getOutputSection() const;
>
>    uint32_t DynsymIndex = 0;
> @@ -218,10 +218,12 @@ class SharedSymbol : public Defined {
>  public:
>    static bool classof(const SymbolBody *S) { return S->kind() == SharedKind; }
>
> -  SharedSymbol(StringRef Name, uint8_t StOther, uint8_t Type,
> -               const void *ElfSym, const void *Verdef)
> +  SharedSymbol(StringRef Name, uint8_t StOther, uint8_t Type, uint64_t Value,
> +               uint64_t Size, uint32_t Alignment, uint64_t Shndx,
> +               const void *Verdef)
>        : Defined(SharedKind, Name, /*IsLocal=*/false, StOther, Type),
> -        Verdef(Verdef), ElfSym(ElfSym) {
> +        Verdef(Verdef), Value(Value), Size(Size), Shndx(Shndx),
> +        Alignment(Alignment) {
>      // GNU ifunc is a mechanism to allow user-supplied functions to
>      // resolve PLT slot values at load-time. This is contrary to the
>      // regualr symbol resolution scheme in which symbols are resolved just
> @@ -246,18 +248,6 @@ public:
>      return cast<SharedFile<ELFT>>(SymbolBody::getFile());
>    }
>
> -  template <class ELFT> uint64_t getShndx() const {
> -    return getSym<ELFT>().st_shndx;
> -  }
> -
> -  template <class ELFT> uint64_t getValue() const {
> -    return getSym<ELFT>().st_value;
> -  }
> -
> -  template <class ELFT> uint64_t getSize() const {
> -    return getSym<ELFT>().st_size;
> -  }
> -
>    template <class ELFT> uint32_t getAlignment() const;
>
>    // This field is a pointer to the symbol's version definition.
> @@ -266,12 +256,10 @@ public:
>    // If not null, there is a copy relocation to this section.
>    InputSection *CopyRelSec = nullptr;
>
> -private:
> -  template <class ELFT> const typename ELFT::Sym &getSym() const {
> -    return *(const typename ELFT::Sym *)ElfSym;
> -  }
> -
> -  const void *ElfSym;
> +  uint64_t Value; // st_value
> +  uint64_t Size;  // st_size
> +  uint64_t Shndx; // st_shndx
> +  uint32_t Alignment;
>  };
>
>  // This represents a symbol that is not yet in the link, but we know where to
>
> Modified: lld/trunk/ELF/SyntheticSections.cpp
> URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/SyntheticSections.cpp?rev=316841&r1=316840&r2=316841&view=diff
> ==============================================================================
> --- lld/trunk/ELF/SyntheticSections.cpp (original)
> +++ lld/trunk/ELF/SyntheticSections.cpp Sat Oct 28 13:15:56 2017
> @@ -82,7 +82,7 @@ template <class ELFT> void elf::createCo
>      // don't have to care about DefinedCommon symbols beyond this point.
>      replaceBody<DefinedRegular>(S, Sym->getFile(), Sym->getName(),
>                                  static_cast<bool>(Sym->isLocal()), Sym->StOther,
> -                                Sym->Type, 0, Sym->getSize<ELFT>(), Section);
> +                                Sym->Type, 0, Sym->getSize(), Section);
>    }
>  }
>
> @@ -1615,7 +1615,7 @@ template <class ELFT> void SymbolTableSe
>      if (ESym->st_shndx == SHN_UNDEF)
>        ESym->st_size = 0;
>      else
> -      ESym->st_size = Body->getSize<ELFT>();
> +      ESym->st_size = Body->getSize();
>
>      // st_value is usually an address of a symbol, but that has a
>      // special meaining for uninstantiated common symbols (this can
>
> Modified: lld/trunk/ELF/Writer.cpp
> URL: http://llvm.org/viewvc/llvm-project/lld/trunk/ELF/Writer.cpp?rev=316841&r1=316840&r2=316841&view=diff
> ==============================================================================
> --- lld/trunk/ELF/Writer.cpp (original)
> +++ lld/trunk/ELF/Writer.cpp Sat Oct 28 13:15:56 2017
> @@ -248,7 +248,7 @@ template <class ELFT> void Writer<ELFT>:
>      return;
>
>    // Handle -Map option.
> -  writeMapFile<ELFT>();
> +  writeMapFile();
>    if (errorCount())
>      return;
>
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at lists.llvm.org
> http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits
-------------- next part --------------
A non-text attachment was scrubbed...
Name: Screen Shot 2017-11-03 at 12.34.20 PM.png
Type: image/png
Size: 594775 bytes
Desc: not available
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20171103/8527378f/attachment-0001.png>


More information about the llvm-commits mailing list