[lld] r234913 - ELF: Remove ELFT template argument when referring the base class.

Rui Ueyama ruiu at google.com
Tue Apr 14 10:32:14 PDT 2015


Author: ruiu
Date: Tue Apr 14 12:32:13 2015
New Revision: 234913

URL: http://llvm.org/viewvc/llvm-project?rev=234913&view=rev
Log:
ELF: Remove ELFT template argument when referring the base class.

We don't need to repeat the template argument. They are not
ambiguous. MIPS is parameterized for ELFT, so we can't do this
for MIPS, though.

Modified:
    lld/trunk/lib/ReaderWriter/ELF/AArch64/AArch64DynamicLibraryWriter.h
    lld/trunk/lib/ReaderWriter/ELF/AArch64/AArch64ExecutableWriter.h
    lld/trunk/lib/ReaderWriter/ELF/ARM/ARMELFFile.h
    lld/trunk/lib/ReaderWriter/ELF/ARM/ARMExecutableWriter.h
    lld/trunk/lib/ReaderWriter/ELF/ARM/ARMSymbolTable.h
    lld/trunk/lib/ReaderWriter/ELF/ARM/ARMTargetHandler.h
    lld/trunk/lib/ReaderWriter/ELF/Hexagon/HexagonDynamicLibraryWriter.h
    lld/trunk/lib/ReaderWriter/ELF/Hexagon/HexagonELFFile.h
    lld/trunk/lib/ReaderWriter/ELF/Hexagon/HexagonExecutableWriter.h
    lld/trunk/lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.cpp
    lld/trunk/lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.h
    lld/trunk/lib/ReaderWriter/ELF/X86/X86DynamicLibraryWriter.h
    lld/trunk/lib/ReaderWriter/ELF/X86/X86ExecutableWriter.h

Modified: lld/trunk/lib/ReaderWriter/ELF/AArch64/AArch64DynamicLibraryWriter.h
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/lib/ReaderWriter/ELF/AArch64/AArch64DynamicLibraryWriter.h?rev=234913&r1=234912&r2=234913&view=diff
==============================================================================
--- lld/trunk/lib/ReaderWriter/ELF/AArch64/AArch64DynamicLibraryWriter.h (original)
+++ lld/trunk/lib/ReaderWriter/ELF/AArch64/AArch64DynamicLibraryWriter.h Tue Apr 14 12:32:13 2015
@@ -28,11 +28,11 @@ protected:
 
 AArch64DynamicLibraryWriter::AArch64DynamicLibraryWriter(
     AArch64LinkingContext &ctx, TargetLayout<ELF64LE> &layout)
-    : DynamicLibraryWriter<ELF64LE>(ctx, layout) {}
+    : DynamicLibraryWriter(ctx, layout) {}
 
 void AArch64DynamicLibraryWriter::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
-  DynamicLibraryWriter<ELF64LE>::createImplicitFiles(result);
+  DynamicLibraryWriter::createImplicitFiles(result);
   auto gotFile = llvm::make_unique<SimpleFile>("GOTFile");
   gotFile->addAtom(*new (gotFile->allocator()) GlobalOffsetTableAtom(*gotFile));
   gotFile->addAtom(*new (gotFile->allocator()) DynamicAtom(*gotFile));

Modified: lld/trunk/lib/ReaderWriter/ELF/AArch64/AArch64ExecutableWriter.h
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/lib/ReaderWriter/ELF/AArch64/AArch64ExecutableWriter.h?rev=234913&r1=234912&r2=234913&view=diff
==============================================================================
--- lld/trunk/lib/ReaderWriter/ELF/AArch64/AArch64ExecutableWriter.h (original)
+++ lld/trunk/lib/ReaderWriter/ELF/AArch64/AArch64ExecutableWriter.h Tue Apr 14 12:32:13 2015
@@ -27,11 +27,11 @@ protected:
 
 AArch64ExecutableWriter::AArch64ExecutableWriter(AArch64LinkingContext &ctx,
                                                  TargetLayout<ELF64LE> &layout)
-    : ExecutableWriter<ELF64LE>(ctx, layout) {}
+    : ExecutableWriter(ctx, layout) {}
 
 void AArch64ExecutableWriter::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
-  ExecutableWriter<ELF64LE>::createImplicitFiles(result);
+  ExecutableWriter::createImplicitFiles(result);
   auto gotFile = llvm::make_unique<SimpleFile>("GOTFile");
   gotFile->addAtom(*new (gotFile->allocator()) GlobalOffsetTableAtom(*gotFile));
   if (this->_ctx.isDynamic())

Modified: lld/trunk/lib/ReaderWriter/ELF/ARM/ARMELFFile.h
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/lib/ReaderWriter/ELF/ARM/ARMELFFile.h?rev=234913&r1=234912&r2=234913&view=diff
==============================================================================
--- lld/trunk/lib/ReaderWriter/ELF/ARM/ARMELFFile.h (original)
+++ lld/trunk/lib/ReaderWriter/ELF/ARM/ARMELFFile.h Tue Apr 14 12:32:13 2015
@@ -58,7 +58,7 @@ class ARMELFFile : public ELFFile<ELF32L
 
 public:
   ARMELFFile(std::unique_ptr<MemoryBuffer> mb, ELFLinkingContext &ctx)
-      : ELFFile<ELF32LE>(std::move(mb), ctx) {}
+      : ELFFile(std::move(mb), ctx) {}
 
 protected:
   /// Returns initial addend; for ARM it is 0, because it is read

Modified: lld/trunk/lib/ReaderWriter/ELF/ARM/ARMExecutableWriter.h
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/lib/ReaderWriter/ELF/ARM/ARMExecutableWriter.h?rev=234913&r1=234912&r2=234913&view=diff
==============================================================================
--- lld/trunk/lib/ReaderWriter/ELF/ARM/ARMExecutableWriter.h (original)
+++ lld/trunk/lib/ReaderWriter/ELF/ARM/ARMExecutableWriter.h Tue Apr 14 12:32:13 2015
@@ -48,16 +48,16 @@ private:
 
 ARMExecutableWriter::ARMExecutableWriter(ARMLinkingContext &ctx,
                                          ARMTargetLayout &layout)
-    : ExecutableWriter<ELF32LE>(ctx, layout), _ctx(ctx), _armLayout(layout) {}
+    : ExecutableWriter(ctx, layout), _ctx(ctx), _armLayout(layout) {}
 
 void ARMExecutableWriter::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
-  ExecutableWriter<ELF32LE>::createImplicitFiles(result);
+  ExecutableWriter::createImplicitFiles(result);
 }
 
 void ARMExecutableWriter::finalizeDefaultAtomValues() {
   // Finalize the atom values that are part of the parent.
-  ExecutableWriter<ELF32LE>::finalizeDefaultAtomValues();
+  ExecutableWriter::finalizeDefaultAtomValues();
   AtomLayout *gotAtom = _armLayout.findAbsoluteAtom(gotSymbol);
   if (gotAtom) {
     if (auto gotpltSection = _armLayout.findOutputSection(".got.plt"))
@@ -86,7 +86,7 @@ void ARMExecutableWriter::processUndefin
 }
 
 std::error_code ARMExecutableWriter::setELFHeader() {
-  if (std::error_code ec = ExecutableWriter<ELF32LE>::setELFHeader())
+  if (std::error_code ec = ExecutableWriter::setELFHeader())
     return ec;
 
   // Set ARM-specific flags.

Modified: lld/trunk/lib/ReaderWriter/ELF/ARM/ARMSymbolTable.h
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/lib/ReaderWriter/ELF/ARM/ARMSymbolTable.h?rev=234913&r1=234912&r2=234913&view=diff
==============================================================================
--- lld/trunk/lib/ReaderWriter/ELF/ARM/ARMSymbolTable.h (original)
+++ lld/trunk/lib/ReaderWriter/ELF/ARM/ARMSymbolTable.h Tue Apr 14 12:32:13 2015
@@ -25,12 +25,11 @@ public:
 };
 
 ARMSymbolTable::ARMSymbolTable(const ELFLinkingContext &ctx)
-    : SymbolTable<ELF32LE>(ctx, ".symtab",
-                           TargetLayout<ELF32LE>::ORDER_SYMBOL_TABLE) {}
+    : SymbolTable(ctx, ".symtab", TargetLayout<ELF32LE>::ORDER_SYMBOL_TABLE) {}
 
 void ARMSymbolTable::addDefinedAtom(Elf_Sym &sym, const DefinedAtom *da,
                                     int64_t addr) {
-  SymbolTable<ELF32LE>::addDefinedAtom(sym, da, addr);
+  SymbolTable::addDefinedAtom(sym, da, addr);
 
   // Set zero bit to distinguish real symbols addressing Thumb instructions.
   // Don't care about mapping symbols like $t and others.

Modified: lld/trunk/lib/ReaderWriter/ELF/ARM/ARMTargetHandler.h
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/lib/ReaderWriter/ELF/ARM/ARMTargetHandler.h?rev=234913&r1=234912&r2=234913&view=diff
==============================================================================
--- lld/trunk/lib/ReaderWriter/ELF/ARM/ARMTargetHandler.h (original)
+++ lld/trunk/lib/ReaderWriter/ELF/ARM/ARMTargetHandler.h Tue Apr 14 12:32:13 2015
@@ -22,7 +22,7 @@ namespace elf {
 
 class ARMTargetLayout : public TargetLayout<ELF32LE> {
 public:
-  ARMTargetLayout(ELFLinkingContext &ctx) : TargetLayout<ELF32LE>(ctx) {}
+  ARMTargetLayout(ELFLinkingContext &ctx) : TargetLayout(ctx) {}
 
   uint64_t getGOTSymAddr() {
     std::call_once(_gotSymOnce, [this]() {

Modified: lld/trunk/lib/ReaderWriter/ELF/Hexagon/HexagonDynamicLibraryWriter.h
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/lib/ReaderWriter/ELF/Hexagon/HexagonDynamicLibraryWriter.h?rev=234913&r1=234912&r2=234913&view=diff
==============================================================================
--- lld/trunk/lib/ReaderWriter/ELF/Hexagon/HexagonDynamicLibraryWriter.h (original)
+++ lld/trunk/lib/ReaderWriter/ELF/Hexagon/HexagonDynamicLibraryWriter.h Tue Apr 14 12:32:13 2015
@@ -29,7 +29,7 @@ protected:
   void finalizeDefaultAtomValues() override;
 
   std::error_code setELFHeader() override {
-    DynamicLibraryWriter<ELF32LE>::setELFHeader();
+    DynamicLibraryWriter::setELFHeader();
     setHexagonELFHeader(*_elfHeader);
     return std::error_code();
   }
@@ -41,12 +41,11 @@ private:
 
 HexagonDynamicLibraryWriter::HexagonDynamicLibraryWriter(
     HexagonLinkingContext &ctx, HexagonTargetLayout &layout)
-    : DynamicLibraryWriter<ELF32LE>(ctx, layout), _ctx(ctx),
-      _targetLayout(layout) {}
+    : DynamicLibraryWriter(ctx, layout), _ctx(ctx), _targetLayout(layout) {}
 
 void HexagonDynamicLibraryWriter::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
-  DynamicLibraryWriter<ELF32LE>::createImplicitFiles(result);
+  DynamicLibraryWriter::createImplicitFiles(result);
   // Add the default atoms as defined for hexagon
   auto file =
       llvm::make_unique<RuntimeFile<ELF32LE>>(_ctx, "Hexagon runtime file");
@@ -57,7 +56,7 @@ void HexagonDynamicLibraryWriter::create
 
 void HexagonDynamicLibraryWriter::finalizeDefaultAtomValues() {
   // Finalize the atom values that are part of the parent.
-  DynamicLibraryWriter<ELF32LE>::finalizeDefaultAtomValues();
+  DynamicLibraryWriter::finalizeDefaultAtomValues();
   if (_ctx.isDynamic())
     finalizeHexagonRuntimeAtomValues(_targetLayout);
 }

Modified: lld/trunk/lib/ReaderWriter/ELF/Hexagon/HexagonELFFile.h
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/lib/ReaderWriter/ELF/Hexagon/HexagonELFFile.h?rev=234913&r1=234912&r2=234913&view=diff
==============================================================================
--- lld/trunk/lib/ReaderWriter/ELF/Hexagon/HexagonELFFile.h (original)
+++ lld/trunk/lib/ReaderWriter/ELF/Hexagon/HexagonELFFile.h Tue Apr 14 12:32:13 2015
@@ -25,7 +25,7 @@ class HexagonELFDefinedAtom : public ELF
 public:
   template <typename... T>
   HexagonELFDefinedAtom(T &&... args)
-      : ELFDefinedAtom<ELF32LE>(std::forward<T>(args)...) {}
+      : ELFDefinedAtom(std::forward<T>(args)...) {}
 
   DefinedAtom::ContentType contentType() const override {
     if (_contentType != DefinedAtom::typeUnknown)
@@ -35,13 +35,13 @@ public:
         return (_contentType = DefinedAtom::typeZeroFillFast);
       return (_contentType = DefinedAtom::typeDataFast);
     }
-    return ELFDefinedAtom<ELF32LE>::contentType();
+    return ELFDefinedAtom::contentType();
   }
 
   DefinedAtom::ContentPermissions permissions() const override {
     if (_section->sh_flags & llvm::ELF::SHF_HEX_GPREL)
       return DefinedAtom::permRW_;
-    return ELFDefinedAtom<ELF32LE>::permissions();
+    return ELFDefinedAtom::permissions();
   }
 };
 
@@ -52,7 +52,7 @@ class HexagonELFCommonAtom : public ELFC
 public:
   HexagonELFCommonAtom(const ELFFile<ELF32LE> &file, StringRef symbolName,
                        const Elf_Sym *symbol)
-      : ELFCommonAtom<ELF32LE>(file, symbolName, symbol) {}
+      : ELFCommonAtom(file, symbolName, symbol) {}
 
   virtual bool isSmallCommonSymbol() const {
     switch (_symbol->st_shndx) {
@@ -72,7 +72,7 @@ public:
   uint64_t size() const override {
     if (isSmallCommonSymbol())
       return _symbol->st_size;
-    return ELFCommonAtom<ELF32LE>::size();
+    return ELFCommonAtom::size();
   }
 
   DefinedAtom::Merge merge() const override {
@@ -80,13 +80,13 @@ public:
       return DefinedAtom::mergeAsWeak;
     if (isSmallCommonSymbol())
       return DefinedAtom::mergeAsTentative;
-    return ELFCommonAtom<ELF32LE>::merge();
+    return ELFCommonAtom::merge();
   }
 
   DefinedAtom::ContentType contentType() const override {
     if (isSmallCommonSymbol())
       return DefinedAtom::typeZeroFillFast;
-    return ELFCommonAtom<ELF32LE>::contentType();
+    return ELFCommonAtom::contentType();
   }
 
   DefinedAtom::Alignment alignment() const override {
@@ -98,7 +98,7 @@ public:
   DefinedAtom::ContentPermissions permissions() const override {
     if (isSmallCommonSymbol())
       return DefinedAtom::permRW_;
-    return ELFCommonAtom<ELF32LE>::permissions();
+    return ELFCommonAtom::permissions();
   }
 };
 
@@ -108,7 +108,7 @@ class HexagonELFFile : public ELFFile<EL
 
 public:
   HexagonELFFile(std::unique_ptr<MemoryBuffer> mb, ELFLinkingContext &ctx)
-      : ELFFile<ELF32LE>(std::move(mb), ctx) {}
+      : ELFFile(std::move(mb), ctx) {}
 
   bool isCommonSymbol(const Elf_Sym *symbol) const override {
     switch (symbol->st_shndx) {
@@ -122,7 +122,7 @@ public:
     default:
       break;
     }
-    return ELFFile<ELF32LE>::isCommonSymbol(symbol);
+    return ELFFile::isCommonSymbol(symbol);
   }
 
   /// Process the Defined symbol and create an atom for it.

Modified: lld/trunk/lib/ReaderWriter/ELF/Hexagon/HexagonExecutableWriter.h
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/lib/ReaderWriter/ELF/Hexagon/HexagonExecutableWriter.h?rev=234913&r1=234912&r2=234913&view=diff
==============================================================================
--- lld/trunk/lib/ReaderWriter/ELF/Hexagon/HexagonExecutableWriter.h (original)
+++ lld/trunk/lib/ReaderWriter/ELF/Hexagon/HexagonExecutableWriter.h Tue Apr 14 12:32:13 2015
@@ -30,7 +30,7 @@ protected:
   void finalizeDefaultAtomValues() override;
 
   std::error_code setELFHeader() override {
-    ExecutableWriter<ELF32LE>::setELFHeader();
+    ExecutableWriter::setELFHeader();
     setHexagonELFHeader(*_elfHeader);
     return std::error_code();
   }
@@ -42,12 +42,11 @@ private:
 
 HexagonExecutableWriter::HexagonExecutableWriter(HexagonLinkingContext &ctx,
                                                  HexagonTargetLayout &layout)
-    : ExecutableWriter<ELF32LE>(ctx, layout), _ctx(ctx), _targetLayout(layout) {
-}
+    : ExecutableWriter(ctx, layout), _ctx(ctx), _targetLayout(layout) {}
 
 void HexagonExecutableWriter::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
-  ExecutableWriter<ELF32LE>::createImplicitFiles(result);
+  ExecutableWriter::createImplicitFiles(result);
   // Add the default atoms as defined for hexagon
   auto file =
       llvm::make_unique<RuntimeFile<ELF32LE>>(_ctx, "Hexagon runtime file");
@@ -61,7 +60,7 @@ void HexagonExecutableWriter::createImpl
 
 void HexagonExecutableWriter::finalizeDefaultAtomValues() {
   // Finalize the atom values that are part of the parent.
-  ExecutableWriter<ELF32LE>::finalizeDefaultAtomValues();
+  ExecutableWriter::finalizeDefaultAtomValues();
   AtomLayout *sdabaseAtom = _targetLayout.findAbsoluteAtom("_SDA_BASE_");
   sdabaseAtom->_virtualAddr = _targetLayout.getSDataSection()->virtualAddr();
   if (_ctx.isDynamic())

Modified: lld/trunk/lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.cpp
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.cpp?rev=234913&r1=234912&r2=234913&view=diff
==============================================================================
--- lld/trunk/lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.cpp (original)
+++ lld/trunk/lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.cpp Tue Apr 14 12:32:13 2015
@@ -342,8 +342,8 @@ void SDataSection::doPreFlight() {
 } // finalize
 
 SDataSection::SDataSection(const HexagonLinkingContext &ctx)
-    : AtomSection<ELF32LE>(ctx, ".sdata", DefinedAtom::typeDataFast, 0,
-                           HexagonTargetLayout::ORDER_SDATA) {
+    : AtomSection(ctx, ".sdata", DefinedAtom::typeDataFast, 0,
+                  HexagonTargetLayout::ORDER_SDATA) {
   _type = SHT_PROGBITS;
   _flags = SHF_ALLOC | SHF_WRITE;
   _alignment = 4096;

Modified: lld/trunk/lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.h
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.h?rev=234913&r1=234912&r2=234913&view=diff
==============================================================================
--- lld/trunk/lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.h (original)
+++ lld/trunk/lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.h Tue Apr 14 12:32:13 2015
@@ -41,17 +41,16 @@ public:
   };
 
   HexagonTargetLayout(HexagonLinkingContext &ctx)
-      : TargetLayout<ELF32LE>(ctx), _sdataSection(ctx) {}
+      : TargetLayout(ctx), _sdataSection(ctx) {}
 
   /// \brief Return the section order for a input section
-  TargetLayout<ELF32LE>::SectionOrder
+  TargetLayout::SectionOrder
   getSectionOrder(StringRef name, int32_t contentType,
                   int32_t contentPermissions) override {
     if (contentType == DefinedAtom::typeDataFast ||
         contentType == DefinedAtom::typeZeroFillFast)
       return ORDER_SDATA;
-    return TargetLayout<ELF32LE>::getSectionOrder(name, contentType,
-                                                  contentPermissions);
+    return TargetLayout::getSectionOrder(name, contentType, contentPermissions);
   }
 
   /// \brief Return the appropriate input section name.
@@ -63,27 +62,27 @@ public:
     default:
       break;
     }
-    return TargetLayout<ELF32LE>::getInputSectionName(da);
+    return TargetLayout::getInputSectionName(da);
   }
 
   /// \brief Gets or creates a section.
   AtomSection<ELF32LE> *
   createSection(StringRef name, int32_t contentType,
                 DefinedAtom::ContentPermissions contentPermissions,
-                TargetLayout<ELF32LE>::SectionOrder sectionOrder) override {
+                TargetLayout::SectionOrder sectionOrder) override {
     if (contentType == DefinedAtom::typeDataFast ||
         contentType == DefinedAtom::typeZeroFillFast)
       return &_sdataSection;
-    return TargetLayout<ELF32LE>::createSection(
-        name, contentType, contentPermissions, sectionOrder);
+    return TargetLayout::createSection(name, contentType, contentPermissions,
+                                       sectionOrder);
   }
 
   /// \brief get the segment type for the section thats defined by the target
-  TargetLayout<ELF32LE>::SegmentType
+  TargetLayout::SegmentType
   getSegmentType(Section<ELF32LE> *section) const override {
     if (section->order() == ORDER_SDATA)
       return PT_LOAD;
-    return TargetLayout<ELF32LE>::getSegmentType(section);
+    return TargetLayout::getSegmentType(section);
   }
 
   Section<ELF32LE> *getSDataSection() { return &_sdataSection; }

Modified: lld/trunk/lib/ReaderWriter/ELF/X86/X86DynamicLibraryWriter.h
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/lib/ReaderWriter/ELF/X86/X86DynamicLibraryWriter.h?rev=234913&r1=234912&r2=234913&view=diff
==============================================================================
--- lld/trunk/lib/ReaderWriter/ELF/X86/X86DynamicLibraryWriter.h (original)
+++ lld/trunk/lib/ReaderWriter/ELF/X86/X86DynamicLibraryWriter.h Tue Apr 14 12:32:13 2015
@@ -27,11 +27,11 @@ protected:
 
 X86DynamicLibraryWriter::X86DynamicLibraryWriter(X86LinkingContext &ctx,
                                                  TargetLayout<ELF32LE> &layout)
-    : DynamicLibraryWriter<ELF32LE>(ctx, layout) {}
+    : DynamicLibraryWriter(ctx, layout) {}
 
 void X86DynamicLibraryWriter::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
-  DynamicLibraryWriter<ELF32LE>::createImplicitFiles(result);
+  DynamicLibraryWriter::createImplicitFiles(result);
   auto gotFile = llvm::make_unique<SimpleFile>("GOTFile");
   gotFile->addAtom(*new (gotFile->allocator()) GlobalOffsetTableAtom(*gotFile));
   gotFile->addAtom(*new (gotFile->allocator()) DynamicAtom(*gotFile));

Modified: lld/trunk/lib/ReaderWriter/ELF/X86/X86ExecutableWriter.h
URL: http://llvm.org/viewvc/llvm-project/lld/trunk/lib/ReaderWriter/ELF/X86/X86ExecutableWriter.h?rev=234913&r1=234912&r2=234913&view=diff
==============================================================================
--- lld/trunk/lib/ReaderWriter/ELF/X86/X86ExecutableWriter.h (original)
+++ lld/trunk/lib/ReaderWriter/ELF/X86/X86ExecutableWriter.h Tue Apr 14 12:32:13 2015
@@ -26,11 +26,11 @@ protected:
 
 X86ExecutableWriter::X86ExecutableWriter(X86LinkingContext &ctx,
                                          TargetLayout<ELF32LE> &layout)
-    : ExecutableWriter<ELF32LE>(ctx, layout) {}
+    : ExecutableWriter(ctx, layout) {}
 
 void X86ExecutableWriter::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
-  ExecutableWriter<ELF32LE>::createImplicitFiles(result);
+  ExecutableWriter::createImplicitFiles(result);
 }
 
 } // namespace elf





More information about the llvm-commits mailing list