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
122
123
124
125
|
//===- lib/ReaderWriter/ELF/X86_64Reference.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/ELF.h"
#include "llvm/Support/Endian.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm::ELF;
namespace {
/// \brief R_X86_64_64 - word64: S + A
int reloc64(uint8_t *location, uint64_t P, uint64_t S, uint64_t A) {
uint64_t result = S + A;
*reinterpret_cast<llvm::support::ulittle64_t *>(location) = result |
(uint64_t)*reinterpret_cast<llvm::support::ulittle64_t *>(location);
return 0;
}
/// \brief R_X86_64_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 0;
}
/// \brief R_X86_64_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);
// TODO: Make sure that the result zero extends to the 64bit value.
return 0;
}
/// \brief R_X86_64_32S - word32: S + A
int reloc32S(uint8_t *location, uint64_t P, uint64_t S, uint64_t A) {
int32_t result = (int32_t)(S + A);
*reinterpret_cast<llvm::support::little32_t *>(location) = result |
(int32_t)*reinterpret_cast<llvm::support::little32_t *>(location);
// TODO: Make sure that the result sign extends to the 64bit value.
return 0;
}
} // end anon namespace
namespace lld {
namespace elf {
X86_64KindHandler::X86_64KindHandler(){
_fixupHandler[R_X86_64_64] = reloc64;
_fixupHandler[R_X86_64_PC32] = relocPC32;
_fixupHandler[R_X86_64_32] = reloc32;
_fixupHandler[R_X86_64_32S] = reloc32S;
}
X86_64KindHandler::~X86_64KindHandler() {
}
Reference::Kind X86_64KindHandler::stringToKind(StringRef str) {
return llvm::StringSwitch<Reference::Kind>(str)
.Case("none", none)
.Case("R_X86_64_64", R_X86_64_64)
.Case("R_X86_64_PC32", R_X86_64_PC32)
.Case("R_X86_64_32S", R_X86_64_32S)
.Default(invalid);
}
StringRef X86_64KindHandler::kindToString(Reference::Kind kind) {
switch ((int32_t)kind) {
case R_X86_64_64:
return "R_X86_64_64";
case R_X86_64_PC32:
return "R_X86_64_PC32";
case R_X86_64_32S:
return "R_X86_64_32S";
default:
return "none";
}
}
bool X86_64KindHandler::isCallSite(Kind kind) {
llvm_unreachable("Unimplemented: X86KindHandler::isCallSite");
return false;
}
bool X86_64KindHandler::isPointer(Kind kind) {
llvm_unreachable("Unimplemented: X86KindHandler::isPointer");
return false;
}
bool X86_64KindHandler::isLazyImmediate(Kind kind) {
llvm_unreachable("Unimplemented: X86KindHandler::isLazyImmediate");
return false;
}
bool X86_64KindHandler::isLazyTarget(Kind kind) {
llvm_unreachable("Unimplemented: X86KindHandler::isLazyTarget");
return false;
}
void X86_64KindHandler::applyFixup(int32_t reloc, uint64_t addend,
uint8_t *location, uint64_t fixupAddress,
uint64_t targetAddress) {
if (reloc == llvm::ELF::R_X86_64_IRELATIVE)
return;
if (_fixupHandler[reloc])
_fixupHandler[reloc](location, fixupAddress, targetAddress, addend);
else {
llvm::errs() << "Unknown relocation type: " << reloc << "\n";
llvm_unreachable("Unknown relocation type.");
}
}
} // end namespace elf
} // end namespace lld
|
