mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2025-02-23 05:29:23 +00:00
6880f0e19f
The IR @foo = private constant i32 42 is valid, but before this patch we would produce an invalid MachO from it. It was invalid because it would use an L label in a section where the liker needs the labels in order to atomize it. One way of fixing it would be to just reject this IR in the backend, but that would not be very front end friendly. What this patch does is use an 'l' prefix in sections that we know the linker requires symbols for atomizing them. This allows frontends to just use private and not worry about which sections they go to or how the linker handles them. One small issue with this strategy is that now a symbol name depends on the section, which is not available before codegen. This is not a problem in practice. The reason is that it only happens with private linkage, which will be ignored by the non codegen users (llvm-nm and llvm-ar). git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@201608 91177308-0d34-0410-b5e6-96231b3b80d8
109 lines
3.9 KiB
C++
109 lines
3.9 KiB
C++
//===-- X86TargetObjectFile.cpp - X86 Object Info -------------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "X86TargetObjectFile.h"
|
|
#include "llvm/IR/Mangler.h"
|
|
#include "llvm/IR/Operator.h"
|
|
#include "llvm/MC/MCContext.h"
|
|
#include "llvm/MC/MCExpr.h"
|
|
#include "llvm/MC/MCSectionELF.h"
|
|
#include "llvm/Support/Dwarf.h"
|
|
#include "llvm/Target/TargetLowering.h"
|
|
|
|
using namespace llvm;
|
|
using namespace dwarf;
|
|
|
|
const MCExpr *X86_64MachoTargetObjectFile::getTTypeGlobalReference(
|
|
const GlobalValue *GV, unsigned Encoding, Mangler &Mang,
|
|
const TargetMachine &TM, MachineModuleInfo *MMI,
|
|
MCStreamer &Streamer) const {
|
|
|
|
// On Darwin/X86-64, we can reference dwarf symbols with foo@GOTPCREL+4, which
|
|
// is an indirect pc-relative reference.
|
|
if (Encoding & (DW_EH_PE_indirect | DW_EH_PE_pcrel)) {
|
|
const MCSymbol *Sym = TM.getTargetLowering()->getSymbol(GV, Mang);
|
|
const MCExpr *Res =
|
|
MCSymbolRefExpr::Create(Sym, MCSymbolRefExpr::VK_GOTPCREL, getContext());
|
|
const MCExpr *Four = MCConstantExpr::Create(4, getContext());
|
|
return MCBinaryExpr::CreateAdd(Res, Four, getContext());
|
|
}
|
|
|
|
return TargetLoweringObjectFileMachO::getTTypeGlobalReference(
|
|
GV, Encoding, Mang, TM, MMI, Streamer);
|
|
}
|
|
|
|
MCSymbol *X86_64MachoTargetObjectFile::getCFIPersonalitySymbol(
|
|
const GlobalValue *GV, Mangler &Mang, const TargetMachine &TM,
|
|
MachineModuleInfo *MMI) const {
|
|
return TM.getTargetLowering()->getSymbol(GV, Mang);
|
|
}
|
|
|
|
void
|
|
X86LinuxTargetObjectFile::Initialize(MCContext &Ctx, const TargetMachine &TM) {
|
|
TargetLoweringObjectFileELF::Initialize(Ctx, TM);
|
|
InitializeELF(TM.Options.UseInitArray);
|
|
}
|
|
|
|
const MCExpr *
|
|
X86LinuxTargetObjectFile::getDebugThreadLocalSymbol(
|
|
const MCSymbol *Sym) const {
|
|
return MCSymbolRefExpr::Create(Sym, MCSymbolRefExpr::VK_DTPOFF, getContext());
|
|
}
|
|
|
|
const MCExpr *X86WindowsTargetObjectFile::getExecutableRelativeSymbol(
|
|
const ConstantExpr *CE, Mangler &Mang, const TargetMachine &TM) const {
|
|
// We are looking for the difference of two symbols, need a subtraction
|
|
// operation.
|
|
const SubOperator *Sub = dyn_cast<SubOperator>(CE);
|
|
if (!Sub)
|
|
return 0;
|
|
|
|
// Symbols must first be numbers before we can subtract them, we need to see a
|
|
// ptrtoint on both subtraction operands.
|
|
const PtrToIntOperator *SubLHS =
|
|
dyn_cast<PtrToIntOperator>(Sub->getOperand(0));
|
|
const PtrToIntOperator *SubRHS =
|
|
dyn_cast<PtrToIntOperator>(Sub->getOperand(1));
|
|
if (!SubLHS || !SubRHS)
|
|
return 0;
|
|
|
|
// Our symbols should exist in address space zero, cowardly no-op if
|
|
// otherwise.
|
|
if (SubLHS->getPointerAddressSpace() != 0 ||
|
|
SubRHS->getPointerAddressSpace() != 0)
|
|
return 0;
|
|
|
|
// Both ptrtoint instructions must wrap global variables:
|
|
// - Only global variables are eligible for image relative relocations.
|
|
// - The subtrahend refers to the special symbol __ImageBase, a global.
|
|
const GlobalVariable *GVLHS =
|
|
dyn_cast<GlobalVariable>(SubLHS->getPointerOperand());
|
|
const GlobalVariable *GVRHS =
|
|
dyn_cast<GlobalVariable>(SubRHS->getPointerOperand());
|
|
if (!GVLHS || !GVRHS)
|
|
return 0;
|
|
|
|
// We expect __ImageBase to be a global variable without a section, externally
|
|
// defined.
|
|
//
|
|
// It should look something like this: @__ImageBase = external constant i8
|
|
if (GVRHS->isThreadLocal() || GVRHS->getName() != "__ImageBase" ||
|
|
!GVRHS->hasExternalLinkage() || GVRHS->hasInitializer() ||
|
|
GVRHS->hasSection())
|
|
return 0;
|
|
|
|
// An image-relative, thread-local, symbol makes no sense.
|
|
if (GVLHS->isThreadLocal())
|
|
return 0;
|
|
|
|
return MCSymbolRefExpr::Create(TM.getTargetLowering()->getSymbol(GVLHS, Mang),
|
|
MCSymbolRefExpr::VK_COFF_IMGREL32,
|
|
getContext());
|
|
}
|