maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/lld/ELF/Target.h

132 lines
4.9 KiB
C
Raw Normal View History

Start adding target abstractions. This is just enough to get PLT working on 32 bit x86. The idea behind using a virtual interface is that it should be easy to convert any of the functions to template parameters if any turns out to be performance critical. llvm-svn: 248308
2015-09-23 02:19:46 +08:00
//===- Target.h -------------------------------------------------*- C++ -*-===//
//
// The LLVM Linker
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLD_ELF_TARGET_H
#define LLD_ELF_TARGET_H
[ELF2] Add initial MIPS support Besides a trivial MIPS support the patch introduces new TargetInfo class member getDefaultEntry() to override default name of the entry symbol. MIPS uses __start for that. Differential Revision: http://reviews.llvm.org/D13227 llvm-svn: 248779
2015-09-29 13:34:03 +08:00
#include "llvm/ADT/StringRef.h"
Start adding target abstractions. This is just enough to get PLT working on 32 bit x86. The idea behind using a virtual interface is that it should be easy to convert any of the functions to template parameters if any turns out to be performance critical. llvm-svn: 248308
2015-09-23 02:19:46 +08:00
#include <memory>
namespace lld {
namespace elf2 {
class SymbolBody;
class TargetInfo {
public:
[ELF2] Make the system page size a target-dependent property The required page alignment is different on different targets. On PowerPC, for example, we need 64K pages (the loader won't set different permissions on a finer granularity than that). I've set the existing targets to what I believe to be the correct values, and have updated the regression tests accordingly. llvm-svn: 249760
2015-10-09 06:23:54 +08:00
unsigned getPageSize() const { return PageSize; }
Revert: r249728 - Roll back r249726 and r249723 because they broke buildbots. Reapply r249726 (and r249723), hopefully with the correct test fixups this time. Original commit message: Address a FIXME in ELF/Writer.cpp: Make VAStart a target-dependent property. I've set the values for the existing targets to what I believe to be the correct values, and updated the regression tests accordingly. llvm-svn: 249752
2015-10-09 05:25:04 +08:00
uint64_t getVAStart() const { return VAStart; }
Start adding target abstractions. This is just enough to get PLT working on 32 bit x86. The idea behind using a virtual interface is that it should be easy to convert any of the functions to template parameters if any turns out to be performance critical. llvm-svn: 248308
2015-09-23 02:19:46 +08:00
unsigned getPCRelReloc() const { return PCRelReloc; }
Move the last remaining hard coded relocations to Target. Unfortunately the i386 and x86_64 relocation have the same numerical value and it is a probably a bit much to add got support for another architecture just to test this. llvm-svn: 248326
2015-09-23 05:35:51 +08:00
unsigned getGotReloc() const { return GotReloc; }
Create R_X86_64_RELATIVE when needed. The dynamic relocation code needs refactoring, but it is probably better to do it with this test passing. llvm-svn: 249340
2015-10-06 03:30:12 +08:00
unsigned getGotRefReloc() const { return GotRefReloc; }
unsigned getRelativeReloc() const { return RelativeReloc; }
[ELF2] Make the .plt entry size target dependent The size of a .plt entry is different on different targets (it is, specifically, much larger than 8 on all PPC ABIs). There is no functional change here (later patches to create .plt entries for PPC64 will depend on this change). llvm-svn: 249756
2015-10-09 05:51:31 +08:00
unsigned getPltEntrySize() const { return PltEntrySize; }
Start adding target abstractions. This is just enough to get PLT working on 32 bit x86. The idea behind using a virtual interface is that it should be easy to convert any of the functions to template parameters if any turns out to be performance critical. llvm-svn: 248308
2015-09-23 02:19:46 +08:00
virtual void writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
uint64_t PltEntryAddr) const = 0;
Create R_X86_64_RELATIVE when needed. The dynamic relocation code needs refactoring, but it is probably better to do it with this test passing. llvm-svn: 249340
2015-10-06 03:30:12 +08:00
virtual bool isRelRelative(uint32_t Type) const;
Start adding support for static programs using dynamic libraries. This is just enough for a hello world using a dynamic glibc. llvm-svn: 248854
2015-09-30 07:22:16 +08:00
virtual bool relocNeedsGot(uint32_t Type, const SymbolBody &S) const = 0;
Add R_386_GOTPC support. llvm-svn: 248793
2015-09-29 21:36:32 +08:00
virtual bool relocPointsToGot(uint32_t Type) const;
Start adding support for static programs using dynamic libraries. This is just enough for a hello world using a dynamic glibc. llvm-svn: 248854
2015-09-30 07:22:16 +08:00
virtual bool relocNeedsPlt(uint32_t Type, const SymbolBody &S) const = 0;
[ELF2] Allow PPC64 to add the TOC-restore after .plt-based relocations Under the PPC64 ELF ABI, functions that might call into other modules (and, thus, need to load a different TOC base value into %r2), need to restore the old value after the call. The old value is saved by the .plt code, and the caller only needs to include a nop instruction after the call, which the linker will transform into a TOC restore if necessary. In order to do this the relocation handler needs two things: 1. It needs to know whether the call instruction it is modifying is targeting a .plt stub that will load a new TOC base value (necessitating a restore after the call). 2. It needs to know where the buffer ends, so that it does not accidentally run off the end of the buffer when looking for the 'nop' instruction after the call. Given these two pieces of information, we can insert the restore instruction in place of the following nop when necessary. llvm-svn: 250110
2015-10-13 05:19:18 +08:00
virtual void relocateOne(uint8_t *Buf, uint8_t *BufEnd, const void *RelP,
uint32_t Type, uint64_t BaseAddr,
uint64_t SymVA) const = 0;
Move relocation processing to Target. I will add a couple of ppc64 relocs in the next patches. llvm-svn: 248319
2015-09-23 04:54:08 +08:00
Start adding target abstractions. This is just enough to get PLT working on 32 bit x86. The idea behind using a virtual interface is that it should be easy to convert any of the functions to template parameters if any turns out to be performance critical. llvm-svn: 248308
2015-09-23 02:19:46 +08:00
virtual ~TargetInfo();
protected:
[ELF2] Make the system page size a target-dependent property The required page alignment is different on different targets. On PowerPC, for example, we need 64K pages (the loader won't set different permissions on a finer granularity than that). I've set the existing targets to what I believe to be the correct values, and have updated the regression tests accordingly. llvm-svn: 249760
2015-10-09 06:23:54 +08:00
unsigned PageSize = 4096;
Revert: r249728 - Roll back r249726 and r249723 because they broke buildbots. Reapply r249726 (and r249723), hopefully with the correct test fixups this time. Original commit message: Address a FIXME in ELF/Writer.cpp: Make VAStart a target-dependent property. I've set the values for the existing targets to what I believe to be the correct values, and updated the regression tests accordingly. llvm-svn: 249752
2015-10-09 05:25:04 +08:00
uint64_t VAStart;
Start adding target abstractions. This is just enough to get PLT working on 32 bit x86. The idea behind using a virtual interface is that it should be easy to convert any of the functions to template parameters if any turns out to be performance critical. llvm-svn: 248308
2015-09-23 02:19:46 +08:00
unsigned PCRelReloc;
Add support for R_386_GOT32. llvm-svn: 248799
2015-09-29 22:42:37 +08:00
unsigned GotRefReloc;
Move the last remaining hard coded relocations to Target. Unfortunately the i386 and x86_64 relocation have the same numerical value and it is a probably a bit much to add got support for another architecture just to test this. llvm-svn: 248326
2015-09-23 05:35:51 +08:00
unsigned GotReloc;
Create R_X86_64_RELATIVE when needed. The dynamic relocation code needs refactoring, but it is probably better to do it with this test passing. llvm-svn: 249340
2015-10-06 03:30:12 +08:00
unsigned RelativeReloc;
[ELF2] Make the .plt entry size target dependent The size of a .plt entry is different on different targets (it is, specifically, much larger than 8 on all PPC ABIs). There is no functional change here (later patches to create .plt entries for PPC64 will depend on this change). llvm-svn: 249756
2015-10-09 05:51:31 +08:00
unsigned PltEntrySize = 8;
Start adding target abstractions. This is just enough to get PLT working on 32 bit x86. The idea behind using a virtual interface is that it should be easy to convert any of the functions to template parameters if any turns out to be performance critical. llvm-svn: 248308
2015-09-23 02:19:46 +08:00
};
class X86TargetInfo final : public TargetInfo {
public:
X86TargetInfo();
void writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
uint64_t PltEntryAddr) const override;
Start adding support for static programs using dynamic libraries. This is just enough for a hello world using a dynamic glibc. llvm-svn: 248854
2015-09-30 07:22:16 +08:00
bool relocNeedsGot(uint32_t Type, const SymbolBody &S) const override;
Add R_386_GOTPC support. llvm-svn: 248793
2015-09-29 21:36:32 +08:00
bool relocPointsToGot(uint32_t Type) const override;
Start adding support for static programs using dynamic libraries. This is just enough for a hello world using a dynamic glibc. llvm-svn: 248854
2015-09-30 07:22:16 +08:00
bool relocNeedsPlt(uint32_t Type, const SymbolBody &S) const override;
[ELF2] Allow PPC64 to add the TOC-restore after .plt-based relocations Under the PPC64 ELF ABI, functions that might call into other modules (and, thus, need to load a different TOC base value into %r2), need to restore the old value after the call. The old value is saved by the .plt code, and the caller only needs to include a nop instruction after the call, which the linker will transform into a TOC restore if necessary. In order to do this the relocation handler needs two things: 1. It needs to know whether the call instruction it is modifying is targeting a .plt stub that will load a new TOC base value (necessitating a restore after the call). 2. It needs to know where the buffer ends, so that it does not accidentally run off the end of the buffer when looking for the 'nop' instruction after the call. Given these two pieces of information, we can insert the restore instruction in place of the following nop when necessary. llvm-svn: 250110
2015-10-13 05:19:18 +08:00
void relocateOne(uint8_t *Buf, uint8_t *BufEnd, const void *RelP,
uint32_t Type, uint64_t BaseAddr,
uint64_t SymVA) const override;
Start adding target abstractions. This is just enough to get PLT working on 32 bit x86. The idea behind using a virtual interface is that it should be easy to convert any of the functions to template parameters if any turns out to be performance critical. llvm-svn: 248308
2015-09-23 02:19:46 +08:00
};
class X86_64TargetInfo final : public TargetInfo {
public:
X86_64TargetInfo();
void writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
uint64_t PltEntryAddr) const override;
Start adding support for static programs using dynamic libraries. This is just enough for a hello world using a dynamic glibc. llvm-svn: 248854
2015-09-30 07:22:16 +08:00
bool relocNeedsGot(uint32_t Type, const SymbolBody &S) const override;
bool relocNeedsPlt(uint32_t Type, const SymbolBody &S) const override;
[ELF2] Allow PPC64 to add the TOC-restore after .plt-based relocations Under the PPC64 ELF ABI, functions that might call into other modules (and, thus, need to load a different TOC base value into %r2), need to restore the old value after the call. The old value is saved by the .plt code, and the caller only needs to include a nop instruction after the call, which the linker will transform into a TOC restore if necessary. In order to do this the relocation handler needs two things: 1. It needs to know whether the call instruction it is modifying is targeting a .plt stub that will load a new TOC base value (necessitating a restore after the call). 2. It needs to know where the buffer ends, so that it does not accidentally run off the end of the buffer when looking for the 'nop' instruction after the call. Given these two pieces of information, we can insert the restore instruction in place of the following nop when necessary. llvm-svn: 250110
2015-10-13 05:19:18 +08:00
void relocateOne(uint8_t *Buf, uint8_t *BufEnd, const void *RelP,
uint32_t Type, uint64_t BaseAddr,
uint64_t SymVA) const override;
Create R_X86_64_RELATIVE when needed. The dynamic relocation code needs refactoring, but it is probably better to do it with this test passing. llvm-svn: 249340
2015-10-06 03:30:12 +08:00
bool isRelRelative(uint32_t Type) const override;
Move relocation processing to Target. I will add a couple of ppc64 relocs in the next patches. llvm-svn: 248319
2015-09-23 04:54:08 +08:00
};
class PPC64TargetInfo final : public TargetInfo {
public:
PPC64TargetInfo();
void writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
uint64_t PltEntryAddr) const override;
Start adding support for static programs using dynamic libraries. This is just enough for a hello world using a dynamic glibc. llvm-svn: 248854
2015-09-30 07:22:16 +08:00
bool relocNeedsGot(uint32_t Type, const SymbolBody &S) const override;
bool relocNeedsPlt(uint32_t Type, const SymbolBody &S) const override;
[ELF2] Allow PPC64 to add the TOC-restore after .plt-based relocations Under the PPC64 ELF ABI, functions that might call into other modules (and, thus, need to load a different TOC base value into %r2), need to restore the old value after the call. The old value is saved by the .plt code, and the caller only needs to include a nop instruction after the call, which the linker will transform into a TOC restore if necessary. In order to do this the relocation handler needs two things: 1. It needs to know whether the call instruction it is modifying is targeting a .plt stub that will load a new TOC base value (necessitating a restore after the call). 2. It needs to know where the buffer ends, so that it does not accidentally run off the end of the buffer when looking for the 'nop' instruction after the call. Given these two pieces of information, we can insert the restore instruction in place of the following nop when necessary. llvm-svn: 250110
2015-10-13 05:19:18 +08:00
void relocateOne(uint8_t *Buf, uint8_t *BufEnd, const void *RelP,
uint32_t Type, uint64_t BaseAddr,
uint64_t SymVA) const override;
[ELF2] Implement PPC64TargetInfo::isRelRelative This is essentially pattern-matching against the x86 target, and generates the analogous PPC64 relocation. llvm-svn: 250102
2015-10-13 04:58:52 +08:00
bool isRelRelative(uint32_t Type) const override;
Start adding target abstractions. This is just enough to get PLT working on 32 bit x86. The idea behind using a virtual interface is that it should be easy to convert any of the functions to template parameters if any turns out to be performance critical. llvm-svn: 248308
2015-09-23 02:19:46 +08:00
};
Stub out ARM and PPC targets so that we can use a switch to create them. llvm-svn: 248324
2015-09-23 05:24:52 +08:00
class PPCTargetInfo final : public TargetInfo {
public:
PPCTargetInfo();
void writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
uint64_t PltEntryAddr) const override;
Start adding support for static programs using dynamic libraries. This is just enough for a hello world using a dynamic glibc. llvm-svn: 248854
2015-09-30 07:22:16 +08:00
bool relocNeedsGot(uint32_t Type, const SymbolBody &S) const override;
bool relocNeedsPlt(uint32_t Type, const SymbolBody &S) const override;
[ELF2] Allow PPC64 to add the TOC-restore after .plt-based relocations Under the PPC64 ELF ABI, functions that might call into other modules (and, thus, need to load a different TOC base value into %r2), need to restore the old value after the call. The old value is saved by the .plt code, and the caller only needs to include a nop instruction after the call, which the linker will transform into a TOC restore if necessary. In order to do this the relocation handler needs two things: 1. It needs to know whether the call instruction it is modifying is targeting a .plt stub that will load a new TOC base value (necessitating a restore after the call). 2. It needs to know where the buffer ends, so that it does not accidentally run off the end of the buffer when looking for the 'nop' instruction after the call. Given these two pieces of information, we can insert the restore instruction in place of the following nop when necessary. llvm-svn: 250110
2015-10-13 05:19:18 +08:00
void relocateOne(uint8_t *Buf, uint8_t *BufEnd, const void *RelP,
uint32_t Type, uint64_t BaseAddr,
uint64_t SymVA) const override;
Stub out ARM and PPC targets so that we can use a switch to create them. llvm-svn: 248324
2015-09-23 05:24:52 +08:00
};
[ELF2] Add initial AArch64 support. Differential Revision: http://reviews.llvm.org/D13167 llvm-svn: 248641
2015-09-26 08:32:04 +08:00
class AArch64TargetInfo final : public TargetInfo {
public:
AArch64TargetInfo();
void writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
uint64_t PltEntryAddr) const override;
Start adding support for static programs using dynamic libraries. This is just enough for a hello world using a dynamic glibc. llvm-svn: 248854
2015-09-30 07:22:16 +08:00
bool relocNeedsGot(uint32_t Type, const SymbolBody &S) const override;
bool relocNeedsPlt(uint32_t Type, const SymbolBody &S) const override;
[ELF2] Allow PPC64 to add the TOC-restore after .plt-based relocations Under the PPC64 ELF ABI, functions that might call into other modules (and, thus, need to load a different TOC base value into %r2), need to restore the old value after the call. The old value is saved by the .plt code, and the caller only needs to include a nop instruction after the call, which the linker will transform into a TOC restore if necessary. In order to do this the relocation handler needs two things: 1. It needs to know whether the call instruction it is modifying is targeting a .plt stub that will load a new TOC base value (necessitating a restore after the call). 2. It needs to know where the buffer ends, so that it does not accidentally run off the end of the buffer when looking for the 'nop' instruction after the call. Given these two pieces of information, we can insert the restore instruction in place of the following nop when necessary. llvm-svn: 250110
2015-10-13 05:19:18 +08:00
void relocateOne(uint8_t *Buf, uint8_t *BufEnd, const void *RelP,
uint32_t Type, uint64_t BaseAddr,
uint64_t SymVA) const override;
[ELF2] Add initial AArch64 support. Differential Revision: http://reviews.llvm.org/D13167 llvm-svn: 248641
2015-09-26 08:32:04 +08:00
};
[ELF2] Add initial MIPS support Besides a trivial MIPS support the patch introduces new TargetInfo class member getDefaultEntry() to override default name of the entry symbol. MIPS uses __start for that. Differential Revision: http://reviews.llvm.org/D13227 llvm-svn: 248779
2015-09-29 13:34:03 +08:00
class MipsTargetInfo final : public TargetInfo {
public:
MipsTargetInfo();
void writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
uint64_t PltEntryAddr) const override;
Start adding support for static programs using dynamic libraries. This is just enough for a hello world using a dynamic glibc. llvm-svn: 248854
2015-09-30 07:22:16 +08:00
bool relocNeedsGot(uint32_t Type, const SymbolBody &S) const override;
bool relocNeedsPlt(uint32_t Type, const SymbolBody &S) const override;
[ELF2] Allow PPC64 to add the TOC-restore after .plt-based relocations Under the PPC64 ELF ABI, functions that might call into other modules (and, thus, need to load a different TOC base value into %r2), need to restore the old value after the call. The old value is saved by the .plt code, and the caller only needs to include a nop instruction after the call, which the linker will transform into a TOC restore if necessary. In order to do this the relocation handler needs two things: 1. It needs to know whether the call instruction it is modifying is targeting a .plt stub that will load a new TOC base value (necessitating a restore after the call). 2. It needs to know where the buffer ends, so that it does not accidentally run off the end of the buffer when looking for the 'nop' instruction after the call. Given these two pieces of information, we can insert the restore instruction in place of the following nop when necessary. llvm-svn: 250110
2015-10-13 05:19:18 +08:00
void relocateOne(uint8_t *Buf, uint8_t *BufEnd, const void *RelP,
uint32_t Type, uint64_t BaseAddr,
uint64_t SymVA) const override;
[ELF2] Add initial MIPS support Besides a trivial MIPS support the patch introduces new TargetInfo class member getDefaultEntry() to override default name of the entry symbol. MIPS uses __start for that. Differential Revision: http://reviews.llvm.org/D13227 llvm-svn: 248779
2015-09-29 13:34:03 +08:00
};
Start adding target abstractions. This is just enough to get PLT working on 32 bit x86. The idea behind using a virtual interface is that it should be easy to convert any of the functions to template parameters if any turns out to be performance critical. llvm-svn: 248308
2015-09-23 02:19:46 +08:00
extern std::unique_ptr<TargetInfo> Target;
}
}
#endif