lib/ReaderWriter/ELF/Mips/MipsSectionChunks.cpp - lld - Git at Google

 //===- lib/ReaderWriter/ELF/Mips/MipsSectionChunks.cpp --------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

 #include "MipsLinkingContext.h"
 #include "MipsSectionChunks.h"
 #include "MipsTargetLayout.h"

 namespace lld {
 namespace elf {

 template <class ELFT>
 MipsReginfoSection<ELFT>::MipsReginfoSection(
     const ELFLinkingContext &ctx, MipsTargetLayout<ELFT> &targetLayout,
     const Elf_Mips_RegInfo &reginfo)
     : Section<ELFT>(ctx, ".reginfo", "MipsReginfo"), _reginfo(reginfo),
       _targetLayout(targetLayout) {
   this->setOrder(MipsTargetLayout<ELFT>::ORDER_MIPS_REGINFO);
   this->_entSize = sizeof(Elf_Mips_RegInfo);
   this->_fsize = sizeof(Elf_Mips_RegInfo);
   this->_msize = sizeof(Elf_Mips_RegInfo);
   this->_alignment = 4;
   this->_type = SHT_MIPS_REGINFO;
   this->_flags = SHF_ALLOC;
 }

 template <class ELFT>
 void MipsReginfoSection<ELFT>::write(ELFWriter *writer,
                                      TargetLayout<ELFT> &layout,
                                      llvm::FileOutputBuffer &buffer) {
   uint8_t *dest = buffer.getBufferStart() + this->fileOffset();
   std::memcpy(dest, &_reginfo, this->_fsize);
 }

 template <class ELFT> void MipsReginfoSection<ELFT>::finalize() {
   _reginfo.ri_gp_value = _targetLayout.getGPAddr();

   if (this->_outputSection)
     this->_outputSection->setType(this->_type);
 }

 template class MipsReginfoSection<ELF32BE>;
 template class MipsReginfoSection<ELF32LE>;
 template class MipsReginfoSection<ELF64BE>;
 template class MipsReginfoSection<ELF64LE>;

 template <class ELFT>
 MipsOptionsSection<ELFT>::MipsOptionsSection(
     const ELFLinkingContext &ctx, MipsTargetLayout<ELFT> &targetLayout,
     const Elf_Mips_RegInfo &reginfo)
     : Section<ELFT>(ctx, ".MIPS.options", "MipsOptions"), _reginfo(reginfo),
       _targetLayout(targetLayout) {
   this->setOrder(MipsTargetLayout<ELFT>::ORDER_MIPS_OPTIONS);
   this->_entSize = 1;
   this->_alignment = 8;
   this->_fsize = llvm::RoundUpToAlignment(
       sizeof(Elf_Mips_Options) + sizeof(Elf_Mips_RegInfo), this->_alignment);
   this->_msize = this->_fsize;
   this->_type = SHT_MIPS_OPTIONS;
   this->_flags = SHF_ALLOC | SHF_MIPS_NOSTRIP;

   _header.kind = ODK_REGINFO;
   _header.size = this->_fsize;
   _header.section = 0;
   _header.info = 0;
 }

 template <class ELFT>
 void MipsOptionsSection<ELFT>::write(ELFWriter *writer,
                                      TargetLayout<ELFT> &layout,
                                      llvm::FileOutputBuffer &buffer) {
   uint8_t *dest = buffer.getBufferStart() + this->fileOffset();
   std::memset(dest, 0, this->_fsize);
   std::memcpy(dest, &_header, sizeof(_header));
   std::memcpy(dest + sizeof(_header), &_reginfo, sizeof(_reginfo));
 }

 template <class ELFT> void MipsOptionsSection<ELFT>::finalize() {
   _reginfo.ri_gp_value = _targetLayout.getGPAddr();

   if (this->_outputSection)
     this->_outputSection->setType(this->_type);
 }

 template class MipsOptionsSection<ELF32BE>;
 template class MipsOptionsSection<ELF32LE>;
 template class MipsOptionsSection<ELF64BE>;
 template class MipsOptionsSection<ELF64LE>;

 template <class ELFT>
 MipsAbiFlagsSection<ELFT>::MipsAbiFlagsSection(
     const ELFLinkingContext &ctx, MipsTargetLayout<ELFT> &targetLayout,
     const Elf_Mips_ABIFlags &abiFlags)
     : Section<ELFT>(ctx, ".MIPS.abiflags", "MipsAbiFlags"), _abiFlags(abiFlags),
       _targetLayout(targetLayout) {
   this->setOrder(MipsTargetLayout<ELFT>::ORDER_MIPS_ABI_FLAGS);
   this->_alignment = 8;
   this->_fsize = llvm::RoundUpToAlignment(sizeof(_abiFlags), this->_alignment);
   this->_msize = this->_fsize;
   this->_entSize = this->_fsize;
   this->_type = SHT_MIPS_ABIFLAGS;
   this->_flags = SHF_ALLOC;
 }

 template <class ELFT>
 void MipsAbiFlagsSection<ELFT>::write(ELFWriter *writer,
                                       TargetLayout<ELFT> &layout,
                                       llvm::FileOutputBuffer &buffer) {
   uint8_t *dest = buffer.getBufferStart() + this->fileOffset();
   std::memcpy(dest, &_abiFlags, this->_fsize);
 }

 template <class ELFT> void MipsAbiFlagsSection<ELFT>::finalize() {
   if (this->_outputSection)
     this->_outputSection->setType(this->_type);
 }

 template class MipsAbiFlagsSection<ELF32BE>;
 template class MipsAbiFlagsSection<ELF32LE>;
 template class MipsAbiFlagsSection<ELF64BE>;
 template class MipsAbiFlagsSection<ELF64LE>;

 template <class ELFT>
 MipsGOTSection<ELFT>::MipsGOTSection(const MipsLinkingContext &ctx)
     : AtomSection<ELFT>(ctx, ".got", DefinedAtom::typeGOT, DefinedAtom::permRW_,
                         MipsTargetLayout<ELFT>::ORDER_GOT),
       _hasNonLocal(false), _localCount(0) {
   this->_flags |= SHF_MIPS_GPREL;
   this->_alignment = 4;
 }

 template <class ELFT>
 bool MipsGOTSection<ELFT>::compare(const Atom *a, const Atom *b) const {
   auto ia = _posMap.find(a);
   auto ib = _posMap.find(b);

   if (ia != _posMap.end() && ib != _posMap.end())
     return ia->second < ib->second;

   return ia == _posMap.end() && ib != _posMap.end();
 }

 template <class ELFT>
 const AtomLayout *MipsGOTSection<ELFT>::appendAtom(const Atom *atom) {
   const DefinedAtom *da = dyn_cast<DefinedAtom>(atom);

   if (atom->name() == "_GLOBAL_OFFSET_TABLE_")
     return AtomSection<ELFT>::appendAtom(atom);

   for (const auto &r : *da) {
     if (r->kindNamespace() != Reference::KindNamespace::ELF)
       continue;
     assert(r->kindArch() == Reference::KindArch::Mips);
     switch (r->kindValue()) {
     case LLD_R_MIPS_GLOBAL_GOT:
       _hasNonLocal = true;
       _posMap[r->target()] = _posMap.size();
       return AtomSection<ELFT>::appendAtom(atom);
     case R_MIPS_TLS_TPREL32:
     case R_MIPS_TLS_DTPREL32:
     case R_MIPS_TLS_TPREL64:
     case R_MIPS_TLS_DTPREL64:
       _hasNonLocal = true;
       _tlsMap[r->target()] = _tlsMap.size();
       return AtomSection<ELFT>::appendAtom(atom);
     case R_MIPS_TLS_DTPMOD32:
     case R_MIPS_TLS_DTPMOD64:
       _hasNonLocal = true;
       break;
     }
   }

   if (!_hasNonLocal)
     ++_localCount;

   return AtomSection<ELFT>::appendAtom(atom);
 }

 template class MipsGOTSection<ELF32BE>;
 template class MipsGOTSection<ELF32LE>;
 template class MipsGOTSection<ELF64BE>;
 template class MipsGOTSection<ELF64LE>;

 template <class ELFT>
 MipsPLTSection<ELFT>::MipsPLTSection(const MipsLinkingContext &ctx)
     : AtomSection<ELFT>(ctx, ".plt", DefinedAtom::typeGOT, DefinedAtom::permR_X,
                         MipsTargetLayout<ELFT>::ORDER_PLT) {}

 template <class ELFT>
 const AtomLayout *MipsPLTSection<ELFT>::findPLTLayout(const Atom *plt) const {
   auto it = _pltLayoutMap.find(plt);
   return it != _pltLayoutMap.end() ? it->second : nullptr;
 }

 template <class ELFT>
 const AtomLayout *MipsPLTSection<ELFT>::appendAtom(const Atom *atom) {
   const auto *layout = AtomSection<ELFT>::appendAtom(atom);

   const DefinedAtom *da = cast<DefinedAtom>(atom);

   for (const auto &r : *da) {
     if (r->kindNamespace() != Reference::KindNamespace::ELF)
       continue;
     assert(r->kindArch() == Reference::KindArch::Mips);
     if (r->kindValue() == LLD_R_MIPS_STO_PLT) {
       _pltLayoutMap[r->target()] = layout;
       break;
     }
   }

   return layout;
 }

 template class MipsPLTSection<ELF32BE>;
 template class MipsPLTSection<ELF32LE>;
 template class MipsPLTSection<ELF64BE>;
 template class MipsPLTSection<ELF64LE>;

 template <class ELFT> static bool isMips64EL() {
   return ELFT::Is64Bits && ELFT::TargetEndianness == llvm::support::little;
 }

 template <class ELFT>
 MipsRelocationTable<ELFT>::MipsRelocationTable(const ELFLinkingContext &ctx,
                                                StringRef str, int32_t order)
     : RelocationTable<ELFT>(ctx, str, order) {}

 template <class ELFT>
 void MipsRelocationTable<ELFT>::writeRela(ELFWriter *writer, Elf_Rela &r,
                                           const DefinedAtom &atom,
                                           const Reference &ref) {
   uint32_t rType = ref.kindValue() | (ref.tag() << 8);
   r.setSymbolAndType(this->getSymbolIndex(ref.target()), rType,
                      isMips64EL<ELFT>());
   r.r_offset = writer->addressOfAtom(&atom) + ref.offsetInAtom();
   // The addend is used only by relative relocations
   if (this->_ctx.isRelativeReloc(ref))
     r.r_addend = writer->addressOfAtom(ref.target()) + ref.addend();
   else
     r.r_addend = 0;
 }

 template <class ELFT>
 void MipsRelocationTable<ELFT>::writeRel(ELFWriter *writer, Elf_Rel &r,
                                          const DefinedAtom &atom,
                                          const Reference &ref) {
   uint32_t rType = ref.kindValue() | (ref.tag() << 8);
   r.setSymbolAndType(this->getSymbolIndex(ref.target()), rType,
                      isMips64EL<ELFT>());
   r.r_offset = writer->addressOfAtom(&atom) + ref.offsetInAtom();
 }

 template class MipsRelocationTable<ELF32BE>;
 template class MipsRelocationTable<ELF32LE>;
 template class MipsRelocationTable<ELF64BE>;
 template class MipsRelocationTable<ELF64LE>;

 } // elf
 } // lld
	//===- lib/ReaderWriter/ELF/Mips/MipsSectionChunks.cpp --------------------===//
	//
	// The LLVM Linker
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	#include "MipsLinkingContext.h"
	#include "MipsSectionChunks.h"
	#include "MipsTargetLayout.h"

	namespace lld {
	namespace elf {

	template <class ELFT>
	MipsReginfoSection<ELFT>::MipsReginfoSection(
	const ELFLinkingContext &ctx, MipsTargetLayout<ELFT> &targetLayout,
	const Elf_Mips_RegInfo &reginfo)
	: Section<ELFT>(ctx, ".reginfo", "MipsReginfo"), _reginfo(reginfo),
	_targetLayout(targetLayout) {
	this->setOrder(MipsTargetLayout<ELFT>::ORDER_MIPS_REGINFO);
	this->_entSize = sizeof(Elf_Mips_RegInfo);
	this->_fsize = sizeof(Elf_Mips_RegInfo);
	this->_msize = sizeof(Elf_Mips_RegInfo);
	this->_alignment = 4;
	this->_type = SHT_MIPS_REGINFO;
	this->_flags = SHF_ALLOC;
	}

	template <class ELFT>
	void MipsReginfoSection<ELFT>::write(ELFWriter *writer,
	TargetLayout<ELFT> &layout,
	llvm::FileOutputBuffer &buffer) {
	uint8_t *dest = buffer.getBufferStart() + this->fileOffset();
	std::memcpy(dest, &_reginfo, this->_fsize);
	}

	template <class ELFT> void MipsReginfoSection<ELFT>::finalize() {
	_reginfo.ri_gp_value = _targetLayout.getGPAddr();

	if (this->_outputSection)
	this->_outputSection->setType(this->_type);
	}

	template class MipsReginfoSection<ELF32BE>;
	template class MipsReginfoSection<ELF32LE>;
	template class MipsReginfoSection<ELF64BE>;
	template class MipsReginfoSection<ELF64LE>;

	template <class ELFT>
	MipsOptionsSection<ELFT>::MipsOptionsSection(
	const ELFLinkingContext &ctx, MipsTargetLayout<ELFT> &targetLayout,
	const Elf_Mips_RegInfo &reginfo)
	: Section<ELFT>(ctx, ".MIPS.options", "MipsOptions"), _reginfo(reginfo),
	_targetLayout(targetLayout) {
	this->setOrder(MipsTargetLayout<ELFT>::ORDER_MIPS_OPTIONS);
	this->_entSize = 1;
	this->_alignment = 8;
	this->_fsize = llvm::RoundUpToAlignment(
	sizeof(Elf_Mips_Options) + sizeof(Elf_Mips_RegInfo), this->_alignment);
	this->_msize = this->_fsize;
	this->_type = SHT_MIPS_OPTIONS;
	this->_flags = SHF_ALLOC \| SHF_MIPS_NOSTRIP;

	_header.kind = ODK_REGINFO;
	_header.size = this->_fsize;
	_header.section = 0;
	_header.info = 0;
	}

	template <class ELFT>
	void MipsOptionsSection<ELFT>::write(ELFWriter *writer,
	TargetLayout<ELFT> &layout,
	llvm::FileOutputBuffer &buffer) {
	uint8_t *dest = buffer.getBufferStart() + this->fileOffset();
	std::memset(dest, 0, this->_fsize);
	std::memcpy(dest, &_header, sizeof(_header));
	std::memcpy(dest + sizeof(_header), &_reginfo, sizeof(_reginfo));
	}

	template <class ELFT> void MipsOptionsSection<ELFT>::finalize() {
	_reginfo.ri_gp_value = _targetLayout.getGPAddr();

	if (this->_outputSection)
	this->_outputSection->setType(this->_type);
	}

	template class MipsOptionsSection<ELF32BE>;
	template class MipsOptionsSection<ELF32LE>;
	template class MipsOptionsSection<ELF64BE>;
	template class MipsOptionsSection<ELF64LE>;

	template <class ELFT>
	MipsAbiFlagsSection<ELFT>::MipsAbiFlagsSection(
	const ELFLinkingContext &ctx, MipsTargetLayout<ELFT> &targetLayout,
	const Elf_Mips_ABIFlags &abiFlags)
	: Section<ELFT>(ctx, ".MIPS.abiflags", "MipsAbiFlags"), _abiFlags(abiFlags),
	_targetLayout(targetLayout) {
	this->setOrder(MipsTargetLayout<ELFT>::ORDER_MIPS_ABI_FLAGS);
	this->_alignment = 8;
	this->_fsize = llvm::RoundUpToAlignment(sizeof(_abiFlags), this->_alignment);
	this->_msize = this->_fsize;
	this->_entSize = this->_fsize;
	this->_type = SHT_MIPS_ABIFLAGS;
	this->_flags = SHF_ALLOC;
	}

	template <class ELFT>
	void MipsAbiFlagsSection<ELFT>::write(ELFWriter *writer,
	TargetLayout<ELFT> &layout,
	llvm::FileOutputBuffer &buffer) {
	uint8_t *dest = buffer.getBufferStart() + this->fileOffset();
	std::memcpy(dest, &_abiFlags, this->_fsize);
	}

	template <class ELFT> void MipsAbiFlagsSection<ELFT>::finalize() {
	if (this->_outputSection)
	this->_outputSection->setType(this->_type);
	}

	template class MipsAbiFlagsSection<ELF32BE>;
	template class MipsAbiFlagsSection<ELF32LE>;
	template class MipsAbiFlagsSection<ELF64BE>;
	template class MipsAbiFlagsSection<ELF64LE>;

	template <class ELFT>
	MipsGOTSection<ELFT>::MipsGOTSection(const MipsLinkingContext &ctx)
	: AtomSection<ELFT>(ctx, ".got", DefinedAtom::typeGOT, DefinedAtom::permRW_,
	MipsTargetLayout<ELFT>::ORDER_GOT),
	_hasNonLocal(false), _localCount(0) {
	this->_flags \|= SHF_MIPS_GPREL;
	this->_alignment = 4;
	}

	template <class ELFT>
	bool MipsGOTSection<ELFT>::compare(const Atom a, const Atom b) const {
	auto ia = _posMap.find(a);
	auto ib = _posMap.find(b);

	if (ia != _posMap.end() && ib != _posMap.end())
	return ia->second < ib->second;

	return ia == _posMap.end() && ib != _posMap.end();
	}

	template <class ELFT>
	const AtomLayout MipsGOTSection<ELFT>::appendAtom(const Atom atom) {
	const DefinedAtom *da = dyn_cast<DefinedAtom>(atom);

	if (atom->name() == "_GLOBAL_OFFSET_TABLE_")
	return AtomSection<ELFT>::appendAtom(atom);

	for (const auto &r : *da) {
	if (r->kindNamespace() != Reference::KindNamespace::ELF)
	continue;
	assert(r->kindArch() == Reference::KindArch::Mips);
	switch (r->kindValue()) {
	case LLD_R_MIPS_GLOBAL_GOT:
	_hasNonLocal = true;
	_posMap[r->target()] = _posMap.size();
	return AtomSection<ELFT>::appendAtom(atom);
	case R_MIPS_TLS_TPREL32:
	case R_MIPS_TLS_DTPREL32:
	case R_MIPS_TLS_TPREL64:
	case R_MIPS_TLS_DTPREL64:
	_hasNonLocal = true;
	_tlsMap[r->target()] = _tlsMap.size();
	return AtomSection<ELFT>::appendAtom(atom);
	case R_MIPS_TLS_DTPMOD32:
	case R_MIPS_TLS_DTPMOD64:
	_hasNonLocal = true;
	break;
	}
	}

	if (!_hasNonLocal)
	++_localCount;

	return AtomSection<ELFT>::appendAtom(atom);
	}

	template class MipsGOTSection<ELF32BE>;
	template class MipsGOTSection<ELF32LE>;
	template class MipsGOTSection<ELF64BE>;
	template class MipsGOTSection<ELF64LE>;

	template <class ELFT>
	MipsPLTSection<ELFT>::MipsPLTSection(const MipsLinkingContext &ctx)
	: AtomSection<ELFT>(ctx, ".plt", DefinedAtom::typeGOT, DefinedAtom::permR_X,
	MipsTargetLayout<ELFT>::ORDER_PLT) {}

	template <class ELFT>
	const AtomLayout MipsPLTSection<ELFT>::findPLTLayout(const Atom plt) const {
	auto it = _pltLayoutMap.find(plt);
	return it != _pltLayoutMap.end() ? it->second : nullptr;
	}

	template <class ELFT>
	const AtomLayout MipsPLTSection<ELFT>::appendAtom(const Atom atom) {
	const auto *layout = AtomSection<ELFT>::appendAtom(atom);

	const DefinedAtom *da = cast<DefinedAtom>(atom);

	for (const auto &r : *da) {
	if (r->kindNamespace() != Reference::KindNamespace::ELF)
	continue;
	assert(r->kindArch() == Reference::KindArch::Mips);
	if (r->kindValue() == LLD_R_MIPS_STO_PLT) {
	_pltLayoutMap[r->target()] = layout;
	break;
	}
	}

	return layout;
	}

	template class MipsPLTSection<ELF32BE>;
	template class MipsPLTSection<ELF32LE>;
	template class MipsPLTSection<ELF64BE>;
	template class MipsPLTSection<ELF64LE>;

	template <class ELFT> static bool isMips64EL() {
	return ELFT::Is64Bits && ELFT::TargetEndianness == llvm::support::little;
	}

	template <class ELFT>
	MipsRelocationTable<ELFT>::MipsRelocationTable(const ELFLinkingContext &ctx,
	StringRef str, int32_t order)
	: RelocationTable<ELFT>(ctx, str, order) {}

	template <class ELFT>
	void MipsRelocationTable<ELFT>::writeRela(ELFWriter *writer, Elf_Rela &r,
	const DefinedAtom &atom,
	const Reference &ref) {
	uint32_t rType = ref.kindValue() \| (ref.tag() << 8);
	r.setSymbolAndType(this->getSymbolIndex(ref.target()), rType,
	isMips64EL<ELFT>());
	r.r_offset = writer->addressOfAtom(&atom) + ref.offsetInAtom();
	// The addend is used only by relative relocations
	if (this->_ctx.isRelativeReloc(ref))
	r.r_addend = writer->addressOfAtom(ref.target()) + ref.addend();
	else
	r.r_addend = 0;
	}

	template <class ELFT>
	void MipsRelocationTable<ELFT>::writeRel(ELFWriter *writer, Elf_Rel &r,
	const DefinedAtom &atom,
	const Reference &ref) {
	uint32_t rType = ref.kindValue() \| (ref.tag() << 8);
	r.setSymbolAndType(this->getSymbolIndex(ref.target()), rType,
	isMips64EL<ELFT>());
	r.r_offset = writer->addressOfAtom(&atom) + ref.offsetInAtom();
	}

	template class MipsRelocationTable<ELF32BE>;
	template class MipsRelocationTable<ELF32LE>;
	template class MipsRelocationTable<ELF64BE>;
	template class MipsRelocationTable<ELF64LE>;

	} // elf
	} // lld