1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
|
//===- lib/ReaderWriter/ELF/X86Reference.cpp ----------------------------===//
//
// The LLVM Linker
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "ReferenceKinds.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/Support/Endian.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/ELF.h"
namespace lld {
namespace elf {
//===----------------------------------------------------------------------===//
// X86KindHandler
// TODO: more to do here
//===----------------------------------------------------------------------===//
X86KindHandler::~X86KindHandler() {
}
/// \brief The following relocation routines are derived from the
/// SYSTEM V APPLICATION BINARY INTERFACE: Intel386 Architecture Processor
/// Supplement (Fourth Edition)
/// Symbols used:
/// P: Place, address of the field being relocated, r_offset
/// S: Value of the symbol whose index resides in the relocation entry.
/// A: Addend used to compute the value, r_addend
namespace x86 {
int relocNone(uint8_t *location, uint64_t P, uint64_t S, uint64_t A) {
return X86KindHandler::NoError;
}
/// \brief R_386_32 - word32: S + A
int reloc32(uint8_t *location, uint64_t P, uint64_t S, uint64_t A) {
int32_t result = (uint32_t)(S + A);
*reinterpret_cast<llvm::support::ulittle32_t *>(location) = result |
(uint32_t)*reinterpret_cast<llvm::support::ulittle32_t *>(location);
return X86KindHandler::NoError;
}
/// \brief R_386_PC32 - word32: S + A - P
int relocPC32(uint8_t *location, uint64_t P, uint64_t S, uint64_t A) {
uint32_t result = (uint32_t)((S + A) - P);
*reinterpret_cast<llvm::support::ulittle32_t *>(location) = result +
(uint32_t)*reinterpret_cast<llvm::support::ulittle32_t *>(location);
return X86KindHandler::NoError;
}
} // namespace x86
X86KindHandler::X86KindHandler(){
_fixupHandler[llvm::ELF::R_386_32] = x86::reloc32;
_fixupHandler[llvm::ELF::R_386_PC32] = x86::relocPC32;
}
Reference::Kind X86KindHandler::stringToKind(StringRef str) {
return llvm::StringSwitch<Reference::Kind>(str)
.Case("none", none)
.Case("R_386_32", llvm::ELF::R_386_32)
.Case("R_386_PC32", llvm::ELF::R_386_PC32)
.Default(invalid);
}
StringRef X86KindHandler::kindToString(Reference::Kind kind) {
switch ((int32_t)kind) {
case llvm::ELF::R_386_32:
return "R_386_32";
case llvm::ELF::R_386_PC32:
return "R_386_PC32";
default:
return "none";
}
}
bool X86KindHandler::isCallSite(Kind kind) {
llvm_unreachable("Unimplemented: X86KindHandler::isCallSite");
return false;
}
bool X86KindHandler::isPointer(Kind kind) {
llvm_unreachable("Unimplemented: X86KindHandler::isPointer");
return false;
}
bool X86KindHandler::isLazyImmediate(Kind kind) {
llvm_unreachable("Unimplemented: X86KindHandler::isLazyImmediate");
return false;
}
bool X86KindHandler::isLazyTarget(Kind kind) {
llvm_unreachable("Unimplemented: X86KindHandler::isLazyTarget");
return false;
}
void X86KindHandler::applyFixup(int32_t reloc, uint64_t addend,
uint8_t *location, uint64_t fixupAddress,
uint64_t targetAddress) {
int error;
if (_fixupHandler[reloc]) {
error = (_fixupHandler[reloc])(location,
fixupAddress, targetAddress, addend);
switch ((RelocationError)error) {
case NoError:
return;
}
}
}
} // namespace elf
} // namespace lld
|
