124 lines
3.8 KiB
C++
124 lines
3.8 KiB
C++
//===- 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 (_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
|