mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2025-01-08 18:31:23 +00:00
edaa58ee66
When targeting the Darwin assembler, we need to generate markers ha16() and lo16() to designate the high and low parts of a (symbolic) immediate. This is necessary not just for plain symbols, but also for certain symbolic expression, typically along the lines of ha16(A - B). The latter doesn't work when simply using VariantKind flags on the symbol reference. This is why the current back-end uses hacks (explicitly called out as such via multiple FIXMEs) in the symbolLo/symbolHi print methods. This patch uses target-defined MCExpr codes to represent the Darwin ha16/lo16 constructs, following along the lines of the equivalent solution used by the ARM back end to handle their :upper16: / :lower16: markers. This allows us to get rid of special handling both in the symbolLo/symbolHi print method and in the common code MCExpr::print routine. Instead, the ha16 / lo16 markers are printed simply in a custom print routine for the target MCExpr types. (As a result, the symbolLo/symbolHi print methods can now replaced by a single printS16ImmOperand routine that also handles symbolic operands.) The patch also provides a EvaluateAsRelocatableImpl routine to handle ha16/lo16 constructs. This is not actually used at the moment by any in-tree code, but is provided as it makes merging into David Fang's out-of-tree Mach-O object writer simpler. Since there is no longer any need to treat VK_PPC_GAS_HA16 and VK_PPC_DARWIN_HA16 differently, they are merged into a single VK_PPC_ADDR16_HA (and likewise for the _LO16 types). git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@182616 91177308-0d34-0410-b5e6-96231b3b80d8
109 lines
2.9 KiB
C++
109 lines
2.9 KiB
C++
//===-- PPCMCExpr.cpp - PPC specific MC expression classes ----------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#define DEBUG_TYPE "ppcmcexpr"
|
|
#include "PPCMCExpr.h"
|
|
#include "llvm/MC/MCAssembler.h"
|
|
#include "llvm/MC/MCContext.h"
|
|
|
|
using namespace llvm;
|
|
|
|
const PPCMCExpr*
|
|
PPCMCExpr::Create(VariantKind Kind, const MCExpr *Expr,
|
|
MCContext &Ctx) {
|
|
return new (Ctx) PPCMCExpr(Kind, Expr);
|
|
}
|
|
|
|
void PPCMCExpr::PrintImpl(raw_ostream &OS) const {
|
|
switch (Kind) {
|
|
default: llvm_unreachable("Invalid kind!");
|
|
case VK_PPC_HA16: OS << "ha16"; break;
|
|
case VK_PPC_LO16: OS << "lo16"; break;
|
|
}
|
|
|
|
OS << '(';
|
|
getSubExpr()->print(OS);
|
|
OS << ')';
|
|
}
|
|
|
|
bool
|
|
PPCMCExpr::EvaluateAsRelocatableImpl(MCValue &Res,
|
|
const MCAsmLayout *Layout) const {
|
|
MCValue Value;
|
|
|
|
if (!getSubExpr()->EvaluateAsRelocatable(Value, *Layout))
|
|
return false;
|
|
|
|
if (Value.isAbsolute()) {
|
|
int64_t Result = Value.getConstant();
|
|
switch (Kind) {
|
|
default:
|
|
llvm_unreachable("Invalid kind!");
|
|
case VK_PPC_HA16:
|
|
Result = ((Result >> 16) + ((Result & 0x8000) ? 1 : 0)) & 0xffff;
|
|
break;
|
|
case VK_PPC_LO16:
|
|
Result = Result & 0xffff;
|
|
break;
|
|
}
|
|
Res = MCValue::get(Result);
|
|
} else {
|
|
MCContext &Context = Layout->getAssembler().getContext();
|
|
const MCSymbolRefExpr *Sym = Value.getSymA();
|
|
MCSymbolRefExpr::VariantKind Modifier = Sym->getKind();
|
|
if (Modifier != MCSymbolRefExpr::VK_None)
|
|
return false;
|
|
switch (Kind) {
|
|
default:
|
|
llvm_unreachable("Invalid kind!");
|
|
case VK_PPC_HA16:
|
|
Modifier = MCSymbolRefExpr::VK_PPC_ADDR16_HA;
|
|
break;
|
|
case VK_PPC_LO16:
|
|
Modifier = MCSymbolRefExpr::VK_PPC_ADDR16_LO;
|
|
break;
|
|
}
|
|
Sym = MCSymbolRefExpr::Create(&Sym->getSymbol(), Modifier, Context);
|
|
Res = MCValue::get(Sym, Value.getSymB(), Value.getConstant());
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// FIXME: This basically copies MCObjectStreamer::AddValueSymbols. Perhaps
|
|
// that method should be made public?
|
|
static void AddValueSymbols_(const MCExpr *Value, MCAssembler *Asm) {
|
|
switch (Value->getKind()) {
|
|
case MCExpr::Target:
|
|
llvm_unreachable("Can't handle nested target expr!");
|
|
|
|
case MCExpr::Constant:
|
|
break;
|
|
|
|
case MCExpr::Binary: {
|
|
const MCBinaryExpr *BE = cast<MCBinaryExpr>(Value);
|
|
AddValueSymbols_(BE->getLHS(), Asm);
|
|
AddValueSymbols_(BE->getRHS(), Asm);
|
|
break;
|
|
}
|
|
|
|
case MCExpr::SymbolRef:
|
|
Asm->getOrCreateSymbolData(cast<MCSymbolRefExpr>(Value)->getSymbol());
|
|
break;
|
|
|
|
case MCExpr::Unary:
|
|
AddValueSymbols_(cast<MCUnaryExpr>(Value)->getSubExpr(), Asm);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void PPCMCExpr::AddValueSymbols(MCAssembler *Asm) const {
|
|
AddValueSymbols_(getSubExpr(), Asm);
|
|
}
|