LLD: Remove "_hexagon" prefix from some member variables.

[ruiu]

Summary

At least in Mips we don't have a prefix for member variables.
Repeating the architecture is verbose.

[shankarke]

LGTM. Cool!

[Eugene.Zelenko]

Committed in r233746.

lib/ReaderWriter/ELF/Hexagon/HexagonDynamicLibraryWriter.h

protected:
   virtual std::error_code setELFHeader() {
     DynamicLibraryWriter<ELFT>::setELFHeader();
     setHexagonELFHeader(*this->_elfHeader);
     return std::error_code();
   }
 
 private:
   void addDefaultAtoms() {
-    _hexagonRuntimeFile->addAbsoluteAtom("_GLOBAL_OFFSET_TABLE_");
-    _hexagonRuntimeFile->addAbsoluteAtom("_DYNAMIC");
+    _runtimeFile->addAbsoluteAtom("_GLOBAL_OFFSET_TABLE_");
+    _runtimeFile->addAbsoluteAtom("_DYNAMIC");
   }
 
   HexagonLinkingContext &_ctx;
-  HexagonTargetLayout<ELFT> &_hexagonTargetLayout;
-  std::unique_ptr<HexagonRuntimeFile<ELFT>> _hexagonRuntimeFile;
+  HexagonTargetLayout<ELFT> &_targetLayout;
+  std::unique_ptr<HexagonRuntimeFile<ELFT>> _runtimeFile;
 };
 
 template <class ELFT>
 HexagonDynamicLibraryWriter<ELFT>::HexagonDynamicLibraryWriter(
     HexagonLinkingContext &ctx, HexagonTargetLayout<ELFT> &layout)
-    : DynamicLibraryWriter<ELFT>(ctx, layout), _ctx(ctx),
-      _hexagonTargetLayout(layout),
-      _hexagonRuntimeFile(new HexagonRuntimeFile<ELFT>(ctx)) {}
+    : DynamicLibraryWriter<ELFT>(ctx, layout), _ctx(ctx), _targetLayout(layout),
+      _runtimeFile(new HexagonRuntimeFile<ELFT>(ctx)) {}
 
 template <class ELFT>
 bool HexagonDynamicLibraryWriter<ELFT>::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
   DynamicLibraryWriter<ELFT>::createImplicitFiles(result);
   // Add the default atoms as defined for hexagon
   addDefaultAtoms();
-  result.push_back(std::move(_hexagonRuntimeFile));
+  result.push_back(std::move(_runtimeFile));
   return true;
 }
 
 template <class ELFT>
 void HexagonDynamicLibraryWriter<ELFT>::finalizeDefaultAtomValues() {
   // Finalize the atom values that are part of the parent.
   DynamicLibraryWriter<ELFT>::finalizeDefaultAtomValues();
   if (_ctx.isDynamic())
-    finalizeHexagonRuntimeAtomValues(_hexagonTargetLayout);
+    finalizeHexagonRuntimeAtomValues(_targetLayout);
 }
 
 } // namespace elf
 } // namespace lld
 
 #endif // HEXAGON_DYNAMIC_LIBRARY_WRITER_H

lib/ReaderWriter/ELF/Hexagon/HexagonExecutableWriter.h

protected:
   virtual std::error_code setELFHeader() {
     ExecutableWriter<ELFT>::setELFHeader();
     setHexagonELFHeader(*this->_elfHeader);
     return std::error_code();
   }
 
 private:
   void addDefaultAtoms() {
-    _hexagonRuntimeFile->addAbsoluteAtom("_SDA_BASE_");
+    _runtimeFile->addAbsoluteAtom("_SDA_BASE_");
     if (this->_ctx.isDynamic()) {
-      _hexagonRuntimeFile->addAbsoluteAtom("_GLOBAL_OFFSET_TABLE_");
-      _hexagonRuntimeFile->addAbsoluteAtom("_DYNAMIC");
+      _runtimeFile->addAbsoluteAtom("_GLOBAL_OFFSET_TABLE_");
+      _runtimeFile->addAbsoluteAtom("_DYNAMIC");
     }
   }
 
   HexagonLinkingContext &_ctx;
-  HexagonTargetLayout<ELFT> &_hexagonTargetLayout;
-  std::unique_ptr<HexagonRuntimeFile<ELFT>> _hexagonRuntimeFile;
+  HexagonTargetLayout<ELFT> &_targetLayout;
+  std::unique_ptr<HexagonRuntimeFile<ELFT>> _runtimeFile;
 };
 
 template <class ELFT>
 HexagonExecutableWriter<ELFT>::HexagonExecutableWriter(
     HexagonLinkingContext &ctx, HexagonTargetLayout<ELFT> &layout)
-    : ExecutableWriter<ELFT>(ctx, layout), _ctx(ctx),
-      _hexagonTargetLayout(layout),
-      _hexagonRuntimeFile(new HexagonRuntimeFile<ELFT>(ctx)) {}
+    : ExecutableWriter<ELFT>(ctx, layout), _ctx(ctx), _targetLayout(layout),
+      _runtimeFile(new HexagonRuntimeFile<ELFT>(ctx)) {}
 
 template <class ELFT>
 bool HexagonExecutableWriter<ELFT>::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
   ExecutableWriter<ELFT>::createImplicitFiles(result);
   // Add the default atoms as defined for hexagon
   addDefaultAtoms();
-  result.push_back(std::move(_hexagonRuntimeFile));
+  result.push_back(std::move(_runtimeFile));
   return true;
 }
 
 template <class ELFT>
 void HexagonExecutableWriter<ELFT>::finalizeDefaultAtomValues() {
   // Finalize the atom values that are part of the parent.
   ExecutableWriter<ELFT>::finalizeDefaultAtomValues();
-  auto sdabaseAtomIter = _hexagonTargetLayout.findAbsoluteAtom("_SDA_BASE_");
+  auto sdabaseAtomIter = _targetLayout.findAbsoluteAtom("_SDA_BASE_");
   (*sdabaseAtomIter)->_virtualAddr =
-      _hexagonTargetLayout.getSDataSection()->virtualAddr();
+      _targetLayout.getSDataSection()->virtualAddr();
   if (_ctx.isDynamic())
-    finalizeHexagonRuntimeAtomValues(_hexagonTargetLayout);
+    finalizeHexagonRuntimeAtomValues(_targetLayout);
 }
 
 } // namespace elf
 } // namespace lld
 
 #endif // HEXAGON_EXECUTABLE_WRITER_H

lib/ReaderWriter/ELF/Hexagon/HexagonRelocationHandler.h

 namespace lld {
 namespace elf {
 
 class HexagonTargetHandler;
 
 class HexagonTargetRelocationHandler final : public TargetRelocationHandler {
 public:
   HexagonTargetRelocationHandler(HexagonTargetLayout<HexagonELFType> &layout)
-      : _hexagonTargetLayout(layout) {}
+      : _targetLayout(layout) {}
 
   std::error_code applyRelocation(ELFWriter &, llvm::FileOutputBuffer &,
                                   const lld::AtomLayout &,
                                   const Reference &) const override;
 
 private:
-  HexagonTargetLayout<HexagonELFType> &_hexagonTargetLayout;
+  HexagonTargetLayout<HexagonELFType> &_targetLayout;
 };
 } // elf
 } // lld
 #endif

lib/ReaderWriter/ELF/Hexagon/HexagonRelocationHandler.cpp

std::error_code HexagonTargetRelocationHandler::applyRelocation(
   case R_HEX_B9_PCREL_X:
     relocHexBNPCRELX(location, relocVAddress, targetVAddress, ref.addend(), 8);
     break;
   case R_HEX_B7_PCREL_X:
     relocHexBNPCRELX(location, relocVAddress, targetVAddress, ref.addend(), 6);
     break;
   case R_HEX_GPREL16_0:
     relocHexGPRELN(location, relocVAddress, targetVAddress, ref.addend(),
-                   _hexagonTargetLayout.getSDataSection()->virtualAddr(), 0);
+                   _targetLayout.getSDataSection()->virtualAddr(), 0);
     break;
   case R_HEX_GPREL16_1:
     relocHexGPRELN(location, relocVAddress, targetVAddress, ref.addend(),
-                   _hexagonTargetLayout.getSDataSection()->virtualAddr(), 1);
+                   _targetLayout.getSDataSection()->virtualAddr(), 1);
     break;
   case R_HEX_GPREL16_2:
     relocHexGPRELN(location, relocVAddress, targetVAddress, ref.addend(),
-                   _hexagonTargetLayout.getSDataSection()->virtualAddr(), 2);
+                   _targetLayout.getSDataSection()->virtualAddr(), 2);
     break;
   case R_HEX_GPREL16_3:
     relocHexGPRELN(location, relocVAddress, targetVAddress, ref.addend(),
-                   _hexagonTargetLayout.getSDataSection()->virtualAddr(), 3);
+                   _targetLayout.getSDataSection()->virtualAddr(), 3);
     break;
   case R_HEX_16_X:
   case R_HEX_12_X:
   case R_HEX_11_X:
   case R_HEX_10_X:
   case R_HEX_9_X:
   case R_HEX_8_X:
   case R_HEX_7_X:
   case R_HEX_6_X:
     relocHex_N_X(location, relocVAddress, targetVAddress, ref.addend());
     break;
   case R_HEX_6_PCREL_X:
     relocHex6PCRELX(location, relocVAddress, targetVAddress, ref.addend());
     break;
   case R_HEX_JMP_SLOT:
   case R_HEX_GLOB_DAT:
     break;
   case R_HEX_GOTREL_32:
     relocHexGOTREL_32(location, relocVAddress, targetVAddress, ref.addend(),
-                      _hexagonTargetLayout.getGOTSymAddr());
+                      _targetLayout.getGOTSymAddr());
     break;
   case R_HEX_GOTREL_LO16:
     relocHexGOTREL_HILO16(location, relocVAddress, targetVAddress, ref.addend(),
-                          _hexagonTargetLayout.getGOTSymAddr());
+                          _targetLayout.getGOTSymAddr());
     break;
   case R_HEX_GOTREL_HI16:
     relocHexGOTREL_HILO16(location, relocVAddress, targetVAddress, ref.addend(),
-                          _hexagonTargetLayout.getGOTSymAddr(), 16);
+                          _targetLayout.getGOTSymAddr(), 16);
     break;
   case R_HEX_GOT_LO16:
-    relocHexGOTLO16(location, targetVAddress,
-                    _hexagonTargetLayout.getGOTSymAddr());
+    relocHexGOTLO16(location, targetVAddress, _targetLayout.getGOTSymAddr());
     break;
   case R_HEX_GOT_HI16:
-    relocHexGOTHI16(location, targetVAddress,
-                    _hexagonTargetLayout.getGOTSymAddr());
+    relocHexGOTHI16(location, targetVAddress, _targetLayout.getGOTSymAddr());
     break;
   case R_HEX_GOT_32:
-    relocHexGOT32(location, targetVAddress,
-                  _hexagonTargetLayout.getGOTSymAddr());
+    relocHexGOT32(location, targetVAddress, _targetLayout.getGOTSymAddr());
     break;
   case R_HEX_GOT_16:
-    relocHexGOT16(location, targetVAddress,
-                  _hexagonTargetLayout.getGOTSymAddr());
+    relocHexGOT16(location, targetVAddress, _targetLayout.getGOTSymAddr());
     break;
   case R_HEX_GOT_32_6_X:
-    relocHexGOT32_6_X(location, targetVAddress,
-                      _hexagonTargetLayout.getGOTSymAddr());
+    relocHexGOT32_6_X(location, targetVAddress, _targetLayout.getGOTSymAddr());
     break;
   case R_HEX_GOT_16_X:
-    relocHexGOT16_X(location, targetVAddress,
-                    _hexagonTargetLayout.getGOTSymAddr());
+    relocHexGOT16_X(location, targetVAddress, _targetLayout.getGOTSymAddr());
     break;
   case R_HEX_GOT_11_X:
-    relocHexGOT11_X(location, targetVAddress,
-                    _hexagonTargetLayout.getGOTSymAddr());
+    relocHexGOT11_X(location, targetVAddress, _targetLayout.getGOTSymAddr());
     break;
   case R_HEX_GOTREL_32_6_X:
     relocHexGOTRELSigned(location, relocVAddress, targetVAddress, ref.addend(),
-                         _hexagonTargetLayout.getGOTSymAddr(), 6);
+                         _targetLayout.getGOTSymAddr(), 6);
     break;
   case R_HEX_GOTREL_16_X:
   case R_HEX_GOTREL_11_X:
     relocHexGOTRELUnsigned(location, relocVAddress, targetVAddress,
-                           ref.addend(), _hexagonTargetLayout.getGOTSymAddr());
+                           ref.addend(), _targetLayout.getGOTSymAddr());
     break;
 
   default:
     return make_unhandled_reloc_error();
   }
 
   return std::error_code();
 }

lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.h

 class HexagonTargetHandler final :
     public DefaultTargetHandler<HexagonELFType> {
 public:
   HexagonTargetHandler(HexagonLinkingContext &targetInfo);
 
   void registerRelocationNames(Registry &registry) override;
 
   const HexagonTargetRelocationHandler &getRelocationHandler() const override {
-    return *_hexagonRelocationHandler;
+    return *_relocationHandler;
   }
 
   HexagonTargetLayout<HexagonELFType> &getTargetLayout() override {
-    return *_hexagonTargetLayout;
+    return *_targetLayout;
   }
 
   std::unique_ptr<Reader> getObjReader() override {
     return llvm::make_unique<HexagonELFObjectReader>(_ctx);
   }
 
   std::unique_ptr<Reader> getDSOReader() override {
     return llvm::make_unique<HexagonELFDSOReader>(_ctx);
   }
 
   std::unique_ptr<Writer> getWriter() override;
 
 private:
   llvm::BumpPtrAllocator _alloc;
   static const Registry::KindStrings kindStrings[];
   HexagonLinkingContext &_ctx;
-  std::unique_ptr<HexagonRuntimeFile<HexagonELFType> > _hexagonRuntimeFile;
-  std::unique_ptr<HexagonTargetLayout<HexagonELFType>> _hexagonTargetLayout;
-  std::unique_ptr<HexagonTargetRelocationHandler> _hexagonRelocationHandler;
+  std::unique_ptr<HexagonRuntimeFile<HexagonELFType>> _runtimeFile;
+  std::unique_ptr<HexagonTargetLayout<HexagonELFType>> _targetLayout;
+  std::unique_ptr<HexagonTargetRelocationHandler> _relocationHandler;
 };
 
 template <class ELFT>
 void finalizeHexagonRuntimeAtomValues(HexagonTargetLayout<ELFT> &layout) {
   auto gotAtomIter = layout.findAbsoluteAtom("_GLOBAL_OFFSET_TABLE_");
   auto gotpltSection = layout.findOutputSection(".got.plt");
   if (gotpltSection)
     (*gotAtomIter)->_virtualAddr = gotpltSection->virtualAddr();

lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.cpp

 
 using namespace lld;
 using namespace elf;
 using namespace llvm::ELF;
 
 using llvm::makeArrayRef;
 
 HexagonTargetHandler::HexagonTargetHandler(HexagonLinkingContext &ctx)
-    : _ctx(ctx),
-      _hexagonRuntimeFile(new HexagonRuntimeFile<HexagonELFType>(ctx)),
-      _hexagonTargetLayout(new HexagonTargetLayout<HexagonELFType>(ctx)),
-      _hexagonRelocationHandler(
-          new HexagonTargetRelocationHandler(*_hexagonTargetLayout)) {}
+    : _ctx(ctx), _runtimeFile(new HexagonRuntimeFile<HexagonELFType>(ctx)),
+      _targetLayout(new HexagonTargetLayout<HexagonELFType>(ctx)),
+      _relocationHandler(new HexagonTargetRelocationHandler(*_targetLayout)) {}
 
 std::unique_ptr<Writer> HexagonTargetHandler::getWriter() {
   switch (_ctx.getOutputELFType()) {
   case llvm::ELF::ET_EXEC:
     return llvm::make_unique<HexagonExecutableWriter<HexagonELFType>>(
-        _ctx, *_hexagonTargetLayout.get());
+        _ctx, *_targetLayout.get());
   case llvm::ELF::ET_DYN:
     return llvm::make_unique<HexagonDynamicLibraryWriter<HexagonELFType>>(
-        _ctx, *_hexagonTargetLayout.get());
+        _ctx, *_targetLayout.get());
   case llvm::ELF::ET_REL:
     llvm_unreachable("TODO: support -r mode");
   default:
     llvm_unreachable("unsupported output type");
   }
 }
 
 using namespace llvm::ELF;