caio/clang-p2996
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[AArch64] Rename VariantKind to Specifier

Browse Source 
Follow the naming of most other backends.

> "Relocation modifier" suggests adjustments happen during the linker's relocation step rather than the assembler's expression evaluation.
> "Relocation specifier" is clear, aligns with Arm and IBM AIX's documentation, and fits the assembler's role seamlessly.

In addition, rename `AArch64MCExpr::Kind` and `getKind`, which confusingly shadow the base class `Kind` and `getKind`.

DarwinRefKind, which still uses MCSymbolRefExpr::VariantKind, is not renamed.

Pull Request: https://github.com/llvm/llvm-project/pull/132595
This commit is contained in:
Fangrui Song
2025-03-26 09:01:20 -07:00
committed by GitHub
parent 6ecc67fb32
commit ac8e18cdce
10 changed files with 137 additions and 164 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
llvm/lib/Target/AArch64/AArch64AsmPrinter.cpp
View File

@@ -919,19 +919,17 @@ void AArch64AsmPrinter::emitHwasanMemaccessSymbols(Module &M) {
// Intentionally load the GOT entry and branch to it, rather than possibly
// late binding the function, which may clobber the registers before we
// have a chance to save them.
EmitToStreamer(
MCInstBuilder(AArch64::ADRP)
.addReg(AArch64::X16)
.addExpr(AArch64MCExpr::create(
HwasanTagMismatchRef, AArch64MCExpr::VariantKind::VK_GOT_PAGE,
OutContext)));
EmitToStreamer(
MCInstBuilder(AArch64::LDRXui)
.addReg(AArch64::X16)
.addReg(AArch64::X16)
.addExpr(AArch64MCExpr::create(
HwasanTagMismatchRef, AArch64MCExpr::VariantKind::VK_GOT_LO12,
OutContext)));
EmitToStreamer(MCInstBuilder(AArch64::ADRP)
.addReg(AArch64::X16)
.addExpr(AArch64MCExpr::create(
HwasanTagMismatchRef, AArch64MCExpr::VK_GOT_PAGE,
OutContext)));
EmitToStreamer(MCInstBuilder(AArch64::LDRXui)
.addReg(AArch64::X16)
.addReg(AArch64::X16)
.addExpr(AArch64MCExpr::create(
HwasanTagMismatchRef, AArch64MCExpr::VK_GOT_LO12,
OutContext)));
EmitToStreamer(MCInstBuilder(AArch64::BR).addReg(AArch64::X16));
}
}

6
llvm/lib/Target/AArch64/AArch64MCInstLower.cpp
View File

@@ -266,8 +266,8 @@ MCOperand AArch64MCInstLower::lowerSymbolOperandELF(const MachineOperand &MO,
Expr = MCBinaryExpr::createAdd(
Expr, MCConstantExpr::create(MO.getOffset(), Ctx), Ctx);
AArch64MCExpr::VariantKind RefKind;
RefKind = static_cast<AArch64MCExpr::VariantKind>(RefFlags);
AArch64MCExpr::Specifier RefKind;
RefKind = static_cast<AArch64MCExpr::Specifier>(RefFlags);
Expr = AArch64MCExpr::create(Expr, RefKind, Ctx);
return MCOperand::createExpr(Expr);
@@ -320,7 +320,7 @@ MCOperand AArch64MCInstLower::lowerSymbolOperandCOFF(const MachineOperand &MO,
Expr = MCBinaryExpr::createAdd(
Expr, MCConstantExpr::create(MO.getOffset(), Ctx), Ctx);
auto RefKind = static_cast<AArch64MCExpr::VariantKind>(RefFlags);
auto RefKind = static_cast<AArch64MCExpr::Specifier>(RefFlags);
assert(RefKind != AArch64MCExpr::VK_INVALID &&
"Invalid relocation requested");
Expr = AArch64MCExpr::create(Expr, RefKind, Ctx);

144
llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp
View File

@@ -338,7 +338,7 @@ public:
bool parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc) override;
static bool classifySymbolRef(const MCExpr *Expr,
AArch64MCExpr::VariantKind &ELFRefKind,
AArch64MCExpr::Specifier &ELFSpec,
MCSymbolRefExpr::VariantKind &DarwinRefKind,
int64_t &Addend);
};
@@ -888,30 +888,26 @@ public:
}
bool isSymbolicUImm12Offset(const MCExpr *Expr) const {
AArch64MCExpr::VariantKind ELFRefKind;
AArch64MCExpr::Specifier ELFSpec;
MCSymbolRefExpr::VariantKind DarwinRefKind;
int64_t Addend;
if (!AArch64AsmParser::classifySymbolRef(Expr, ELFRefKind, DarwinRefKind,
Addend)) {
if (!AArch64AsmParser::classifySymbolRef(Expr, ELFSpec, DarwinRefKind,
Addend)) {
// If we don't understand the expression, assume the best and
// let the fixup and relocation code deal with it.
return true;
}
if (DarwinRefKind == MCSymbolRefExpr::VK_PAGEOFF ||
ELFRefKind == AArch64MCExpr::VK_LO12 ||
ELFRefKind == AArch64MCExpr::VK_GOT_LO12 ||
ELFRefKind == AArch64MCExpr::VK_GOT_AUTH_LO12 ||
ELFRefKind == AArch64MCExpr::VK_DTPREL_LO12 ||
ELFRefKind == AArch64MCExpr::VK_DTPREL_LO12_NC ||
ELFRefKind == AArch64MCExpr::VK_TPREL_LO12 ||
ELFRefKind == AArch64MCExpr::VK_TPREL_LO12_NC ||
ELFRefKind == AArch64MCExpr::VK_GOTTPREL_LO12_NC ||
ELFRefKind == AArch64MCExpr::VK_TLSDESC_LO12 ||
ELFRefKind == AArch64MCExpr::VK_TLSDESC_AUTH_LO12 ||
ELFRefKind == AArch64MCExpr::VK_SECREL_LO12 ||
ELFRefKind == AArch64MCExpr::VK_SECREL_HI12 ||
ELFRefKind == AArch64MCExpr::VK_GOT_PAGE_LO15) {
llvm::is_contained(
{AArch64MCExpr::VK_LO12, AArch64MCExpr::VK_GOT_LO12,
AArch64MCExpr::VK_GOT_AUTH_LO12, AArch64MCExpr::VK_DTPREL_LO12,
AArch64MCExpr::VK_DTPREL_LO12_NC, AArch64MCExpr::VK_TPREL_LO12,
AArch64MCExpr::VK_TPREL_LO12_NC,
AArch64MCExpr::VK_GOTTPREL_LO12_NC, AArch64MCExpr::VK_TLSDESC_LO12,
AArch64MCExpr::VK_TLSDESC_AUTH_LO12, AArch64MCExpr::VK_SECREL_LO12,
AArch64MCExpr::VK_SECREL_HI12, AArch64MCExpr::VK_GOT_PAGE_LO15},
ELFSpec)) {
// Note that we don't range-check the addend. It's adjusted modulo page
// size when converted, so there is no "out of range" condition when using
// @pageoff.
@@ -1009,26 +1005,24 @@ public:
Expr = getImm();
}
AArch64MCExpr::VariantKind ELFRefKind;
AArch64MCExpr::Specifier ELFSpec;
MCSymbolRefExpr::VariantKind DarwinRefKind;
int64_t Addend;
if (AArch64AsmParser::classifySymbolRef(Expr, ELFRefKind,
DarwinRefKind, Addend)) {
if (AArch64AsmParser::classifySymbolRef(Expr, ELFSpec, DarwinRefKind,
Addend)) {
return DarwinRefKind == MCSymbolRefExpr::VK_PAGEOFF ||
DarwinRefKind == MCSymbolRefExpr::VK_TLVPPAGEOFF ||
(DarwinRefKind == MCSymbolRefExpr::VK_GOTPAGEOFF && Addend == 0) ||
ELFRefKind == AArch64MCExpr::VK_LO12 ||
ELFRefKind == AArch64MCExpr::VK_GOT_AUTH_LO12 ||
ELFRefKind == AArch64MCExpr::VK_DTPREL_HI12 ||
ELFRefKind == AArch64MCExpr::VK_DTPREL_LO12 ||
ELFRefKind == AArch64MCExpr::VK_DTPREL_LO12_NC ||
ELFRefKind == AArch64MCExpr::VK_TPREL_HI12 ||
ELFRefKind == AArch64MCExpr::VK_TPREL_LO12 ||
ELFRefKind == AArch64MCExpr::VK_TPREL_LO12_NC ||
ELFRefKind == AArch64MCExpr::VK_TLSDESC_LO12 ||
ELFRefKind == AArch64MCExpr::VK_TLSDESC_AUTH_LO12 ||
ELFRefKind == AArch64MCExpr::VK_SECREL_HI12 ||
ELFRefKind == AArch64MCExpr::VK_SECREL_LO12;
llvm::is_contained(
{AArch64MCExpr::VK_LO12, AArch64MCExpr::VK_GOT_AUTH_LO12,
AArch64MCExpr::VK_DTPREL_HI12, AArch64MCExpr::VK_DTPREL_LO12,
AArch64MCExpr::VK_DTPREL_LO12_NC,
AArch64MCExpr::VK_TPREL_HI12, AArch64MCExpr::VK_TPREL_LO12,
AArch64MCExpr::VK_TPREL_LO12_NC,
AArch64MCExpr::VK_TLSDESC_LO12,
AArch64MCExpr::VK_TLSDESC_AUTH_LO12,
AArch64MCExpr::VK_SECREL_HI12, AArch64MCExpr::VK_SECREL_LO12},
ELFSpec);
}
// If it's a constant, it should be a real immediate in range.
@@ -1121,22 +1115,21 @@ public:
return (Val >= -((1<<(N-1)) << 2) && Val <= (((1<<(N-1))-1) << 2));
}
bool
isMovWSymbol(ArrayRef<AArch64MCExpr::VariantKind> AllowedModifiers) const {
bool isMovWSymbol(ArrayRef<AArch64MCExpr::Specifier> AllowedModifiers) const {
if (!isImm())
return false;
AArch64MCExpr::VariantKind ELFRefKind;
AArch64MCExpr::Specifier ELFSpec;
MCSymbolRefExpr::VariantKind DarwinRefKind;
int64_t Addend;
if (!AArch64AsmParser::classifySymbolRef(getImm(), ELFRefKind,
DarwinRefKind, Addend)) {
if (!AArch64AsmParser::classifySymbolRef(getImm(), ELFSpec, DarwinRefKind,
Addend)) {
return false;
}
if (DarwinRefKind != MCSymbolRefExpr::VK_None)
return false;
return llvm::is_contained(AllowedModifiers, ELFRefKind);
return llvm::is_contained(AllowedModifiers, ELFSpec);
}
bool isMovWSymbolG3() const {
@@ -3303,12 +3296,12 @@ ParseStatus AArch64AsmParser::tryParseAdrpLabel(OperandVector &Operands) {
if (parseSymbolicImmVal(Expr))
return ParseStatus::Failure;
AArch64MCExpr::VariantKind ELFRefKind;
AArch64MCExpr::Specifier ELFSpec;
MCSymbolRefExpr::VariantKind DarwinRefKind;
int64_t Addend;
if (classifySymbolRef(Expr, ELFRefKind, DarwinRefKind, Addend)) {
if (classifySymbolRef(Expr, ELFSpec, DarwinRefKind, Addend)) {
if (DarwinRefKind == MCSymbolRefExpr::VK_None &&
ELFRefKind == AArch64MCExpr::VK_INVALID) {
ELFSpec == AArch64MCExpr::VK_INVALID) {
// No modifier was specified at all; this is the syntax for an ELF basic
// ADRP relocation (unfortunately).
Expr =
@@ -3320,13 +3313,13 @@ ParseStatus AArch64AsmParser::tryParseAdrpLabel(OperandVector &Operands) {
} else if (DarwinRefKind != MCSymbolRefExpr::VK_PAGE &&
DarwinRefKind != MCSymbolRefExpr::VK_GOTPAGE &&
DarwinRefKind != MCSymbolRefExpr::VK_TLVPPAGE &&
ELFRefKind != AArch64MCExpr::VK_ABS_PAGE_NC &&
ELFRefKind != AArch64MCExpr::VK_GOT_PAGE &&
ELFRefKind != AArch64MCExpr::VK_GOT_AUTH_PAGE &&
ELFRefKind != AArch64MCExpr::VK_GOT_PAGE_LO15 &&
ELFRefKind != AArch64MCExpr::VK_GOTTPREL_PAGE &&
ELFRefKind != AArch64MCExpr::VK_TLSDESC_PAGE &&
ELFRefKind != AArch64MCExpr::VK_TLSDESC_AUTH_PAGE) {
ELFSpec != AArch64MCExpr::VK_ABS_PAGE_NC &&
ELFSpec != AArch64MCExpr::VK_GOT_PAGE &&
ELFSpec != AArch64MCExpr::VK_GOT_AUTH_PAGE &&
ELFSpec != AArch64MCExpr::VK_GOT_PAGE_LO15 &&
ELFSpec != AArch64MCExpr::VK_GOTTPREL_PAGE &&
ELFSpec != AArch64MCExpr::VK_TLSDESC_PAGE &&
ELFSpec != AArch64MCExpr::VK_TLSDESC_AUTH_PAGE) {
// The operand must be an @page or @gotpage qualified symbolref.
return Error(S, "page or gotpage label reference expected");
}
@@ -3357,16 +3350,16 @@ ParseStatus AArch64AsmParser::tryParseAdrLabel(OperandVector &Operands) {
if (parseSymbolicImmVal(Expr))
return ParseStatus::Failure;
AArch64MCExpr::VariantKind ELFRefKind;
AArch64MCExpr::Specifier ELFSpec;
MCSymbolRefExpr::VariantKind DarwinRefKind;
int64_t Addend;
if (classifySymbolRef(Expr, ELFRefKind, DarwinRefKind, Addend)) {
if (classifySymbolRef(Expr, ELFSpec, DarwinRefKind, Addend)) {
if (DarwinRefKind == MCSymbolRefExpr::VK_None &&
ELFRefKind == AArch64MCExpr::VK_INVALID) {
ELFSpec == AArch64MCExpr::VK_INVALID) {
// No modifier was specified at all; this is the syntax for an ELF basic
// ADR relocation (unfortunately).
Expr = AArch64MCExpr::create(Expr, AArch64MCExpr::VK_ABS, getContext());
} else if (ELFRefKind != AArch64MCExpr::VK_GOT_AUTH_PAGE) {
} else if (ELFSpec != AArch64MCExpr::VK_GOT_AUTH_PAGE) {
// For tiny code model, we use :got_auth: operator to fill 21-bit imm of
// adr. It's not actually GOT entry page address but the GOT address
// itself - we just share the same variant kind with :got_auth: operator
@@ -4407,7 +4400,7 @@ bool AArch64AsmParser::parseRegister(OperandVector &Operands) {
bool AArch64AsmParser::parseSymbolicImmVal(const MCExpr *&ImmVal) {
bool HasELFModifier = false;
AArch64MCExpr::VariantKind RefKind;
AArch64MCExpr::Specifier RefKind;
if (parseOptionalToken(AsmToken::Colon)) {
HasELFModifier = true;
@@ -4417,7 +4410,7 @@ bool AArch64AsmParser::parseSymbolicImmVal(const MCExpr *&ImmVal) {
std::string LowerCase = getTok().getIdentifier().lower();
RefKind =
StringSwitch<AArch64MCExpr::VariantKind>(LowerCase)
StringSwitch<AArch64MCExpr::Specifier>(LowerCase)
.Case("lo12", AArch64MCExpr::VK_LO12)
.Case("abs_g3", AArch64MCExpr::VK_ABS_G3)
.Case("abs_g2", AArch64MCExpr::VK_ABS_G2)
@@ -5823,10 +5816,10 @@ bool AArch64AsmParser::validateInstruction(MCInst &Inst, SMLoc &IDLoc,
// some slight duplication here.
if (Inst.getOperand(2).isExpr()) {
const MCExpr *Expr = Inst.getOperand(2).getExpr();
AArch64MCExpr::VariantKind ELFRefKind;
AArch64MCExpr::Specifier ELFSpec;
MCSymbolRefExpr::VariantKind DarwinRefKind;
int64_t Addend;
if (classifySymbolRef(Expr, ELFRefKind, DarwinRefKind, Addend)) {
if (classifySymbolRef(Expr, ELFSpec, DarwinRefKind, Addend)) {
// Only allow these with ADDXri.
if ((DarwinRefKind == MCSymbolRefExpr::VK_PAGEOFF ||
@@ -5835,18 +5828,15 @@ bool AArch64AsmParser::validateInstruction(MCInst &Inst, SMLoc &IDLoc,
return false;
// Only allow these with ADDXri/ADDWri
if ((ELFRefKind == AArch64MCExpr::VK_LO12 ||
ELFRefKind == AArch64MCExpr::VK_GOT_AUTH_LO12 ||
ELFRefKind == AArch64MCExpr::VK_DTPREL_HI12 ||
ELFRefKind == AArch64MCExpr::VK_DTPREL_LO12 ||
ELFRefKind == AArch64MCExpr::VK_DTPREL_LO12_NC ||
ELFRefKind == AArch64MCExpr::VK_TPREL_HI12 ||
ELFRefKind == AArch64MCExpr::VK_TPREL_LO12 ||
ELFRefKind == AArch64MCExpr::VK_TPREL_LO12_NC ||
ELFRefKind == AArch64MCExpr::VK_TLSDESC_LO12 ||
ELFRefKind == AArch64MCExpr::VK_TLSDESC_AUTH_LO12 ||
ELFRefKind == AArch64MCExpr::VK_SECREL_LO12 ||
ELFRefKind == AArch64MCExpr::VK_SECREL_HI12) &&
if (llvm::is_contained(
{AArch64MCExpr::VK_LO12, AArch64MCExpr::VK_GOT_AUTH_LO12,
AArch64MCExpr::VK_DTPREL_HI12, AArch64MCExpr::VK_DTPREL_LO12,
AArch64MCExpr::VK_DTPREL_LO12_NC, AArch64MCExpr::VK_TPREL_HI12,
AArch64MCExpr::VK_TPREL_LO12, AArch64MCExpr::VK_TPREL_LO12_NC,
AArch64MCExpr::VK_TLSDESC_LO12,
AArch64MCExpr::VK_TLSDESC_AUTH_LO12,
AArch64MCExpr::VK_SECREL_LO12, AArch64MCExpr::VK_SECREL_HI12},
ELFSpec) &&
(Inst.getOpcode() == AArch64::ADDXri ||
Inst.getOpcode() == AArch64::ADDWri))
return false;
@@ -8202,17 +8192,15 @@ bool AArch64AsmParser::parseAuthExpr(const MCExpr *&Res, SMLoc &EndLoc) {
return false;
}
bool
AArch64AsmParser::classifySymbolRef(const MCExpr *Expr,
AArch64MCExpr::VariantKind &ELFRefKind,
MCSymbolRefExpr::VariantKind &DarwinRefKind,
int64_t &Addend) {
ELFRefKind = AArch64MCExpr::VK_INVALID;
bool AArch64AsmParser::classifySymbolRef(
const MCExpr *Expr, AArch64MCExpr::Specifier &ELFSpec,
MCSymbolRefExpr::VariantKind &DarwinRefKind, int64_t &Addend) {
ELFSpec = AArch64MCExpr::VK_INVALID;
DarwinRefKind = MCSymbolRefExpr::VK_None;
Addend = 0;
if (const AArch64MCExpr *AE = dyn_cast<AArch64MCExpr>(Expr)) {
ELFRefKind = AE->getKind();
ELFSpec = AE->getSpecifier();
Expr = AE->getSubExpr();
}
@@ -8229,9 +8217,9 @@ AArch64AsmParser::classifySymbolRef(const MCExpr *Expr,
if (!Relocatable || Res.getSymB())
return false;
// Treat expressions with an ELFRefKind (like ":abs_g1:3", or
// Treat expressions with an ELFSpec (like ":abs_g1:3", or
// ":abs_g1:x" where x is constant) as symbolic even if there is no symbol.
if (!Res.getSymA() && ELFRefKind == AArch64MCExpr::VK_INVALID)
if (!Res.getSymA() && ELFSpec == AArch64MCExpr::VK_INVALID)
return false;
if (Res.getSymA())
@@ -8240,7 +8228,7 @@ AArch64AsmParser::classifySymbolRef(const MCExpr *Expr,
// It's some symbol reference + a constant addend, but really
// shouldn't use both Darwin and ELF syntax.
return ELFRefKind == AArch64MCExpr::VK_INVALID ||
return ELFSpec == AArch64MCExpr::VK_INVALID ||
DarwinRefKind == MCSymbolRefExpr::VK_None;
}

12
llvm/lib/Target/AArch64/MCTargetDesc/AArch64AsmBackend.cpp
View File

@@ -221,8 +221,8 @@ static uint64_t adjustFixupValue(const MCFixup &Fixup, const MCValue &Target,
Ctx.reportError(Fixup.getLoc(), "fixup must be 16-byte aligned");
return Value >> 4;
case AArch64::fixup_aarch64_movw: {
AArch64MCExpr::VariantKind RefKind =
static_cast<AArch64MCExpr::VariantKind>(Target.getRefKind());
AArch64MCExpr::Specifier RefKind =
static_cast<AArch64MCExpr::Specifier>(Target.getRefKind());
if (AArch64MCExpr::getSymbolLoc(RefKind) != AArch64MCExpr::VK_ABS &&
AArch64MCExpr::getSymbolLoc(RefKind) != AArch64MCExpr::VK_SABS) {
if (!RefKind) {
@@ -422,8 +422,8 @@ void AArch64AsmBackend::applyFixup(const MCAssembler &Asm, const MCFixup &Fixup,
bool IsResolved,
const MCSubtargetInfo *STI) const {
if (Fixup.getTargetKind() == FK_Data_8 && TheTriple.isOSBinFormatELF()) {
auto RefKind = static_cast<AArch64MCExpr::VariantKind>(Target.getRefKind());
AArch64MCExpr::VariantKind SymLoc = AArch64MCExpr::getSymbolLoc(RefKind);
auto RefKind = static_cast<AArch64MCExpr::Specifier>(Target.getRefKind());
AArch64MCExpr::Specifier SymLoc = AArch64MCExpr::getSymbolLoc(RefKind);
if (SymLoc == AArch64AuthMCExpr::VK_AUTH ||
SymLoc == AArch64AuthMCExpr::VK_AUTHADDR) {
assert(Value == 0);
@@ -474,8 +474,8 @@ void AArch64AsmBackend::applyFixup(const MCAssembler &Asm, const MCFixup &Fixup,
// FIXME: getFixupKindInfo() and getFixupKindNumBytes() could be fixed to
// handle this more cleanly. This may affect the output of -show-mc-encoding.
AArch64MCExpr::VariantKind RefKind =
static_cast<AArch64MCExpr::VariantKind>(Target.getRefKind());
AArch64MCExpr::Specifier RefKind =
static_cast<AArch64MCExpr::Specifier>(Target.getRefKind());
if (AArch64MCExpr::getSymbolLoc(RefKind) == AArch64MCExpr::VK_SABS ||
(!RefKind && Fixup.getTargetKind() == AArch64::fixup_aarch64_movw)) {
// If the immediate is negative, generate MOVN else MOVZ.

11
llvm/lib/Target/AArch64/MCTargetDesc/AArch64ELFObjectWriter.cpp
View File

@@ -58,8 +58,7 @@ AArch64ELFObjectWriter::AArch64ELFObjectWriter(uint8_t OSABI, bool IsILP32)
// assumes IsILP32 is true
static bool isNonILP32reloc(const MCFixup &Fixup,
AArch64MCExpr::VariantKind RefKind,
MCContext &Ctx) {
AArch64MCExpr::Specifier RefKind, MCContext &Ctx) {
if (Fixup.getTargetKind() != AArch64::fixup_aarch64_movw)
return false;
switch (RefKind) {
@@ -112,9 +111,9 @@ unsigned AArch64ELFObjectWriter::getRelocType(MCContext &Ctx,
unsigned Kind = Fixup.getTargetKind();
if (Kind >= FirstLiteralRelocationKind)
return Kind - FirstLiteralRelocationKind;
AArch64MCExpr::VariantKind RefKind =
static_cast<AArch64MCExpr::VariantKind>(Target.getRefKind());
AArch64MCExpr::VariantKind SymLoc = AArch64MCExpr::getSymbolLoc(RefKind);
AArch64MCExpr::Specifier RefKind =
static_cast<AArch64MCExpr::Specifier>(Target.getRefKind());
AArch64MCExpr::Specifier SymLoc = AArch64MCExpr::getSymbolLoc(RefKind);
bool IsNC = AArch64MCExpr::isNotChecked(RefKind);
assert((!Target.getSymA() ||
@@ -403,7 +402,7 @@ unsigned AArch64ELFObjectWriter::getRelocType(MCContext &Ctx,
if ((SymLoc == AArch64MCExpr::VK_GOT ||
SymLoc == AArch64MCExpr::VK_GOT_AUTH) &&
IsNC) {
AArch64MCExpr::VariantKind AddressLoc =
AArch64MCExpr::Specifier AddressLoc =
AArch64MCExpr::getAddressFrag(RefKind);
bool IsAuth = (SymLoc == AArch64MCExpr::VK_GOT_AUTH);
if (!IsILP32) {

4
llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCCodeEmitter.cpp
View File

@@ -309,7 +309,7 @@ AArch64MCCodeEmitter::getAddSubImmOpValue(const MCInst &MI, unsigned OpIdx,
// Set the shift bit of the add instruction for relocation types
// R_AARCH64_TLSLE_ADD_TPREL_HI12 and R_AARCH64_TLSLD_ADD_DTPREL_HI12.
if (const AArch64MCExpr *A64E = dyn_cast<AArch64MCExpr>(Expr)) {
AArch64MCExpr::VariantKind RefKind = A64E->getKind();
AArch64MCExpr::Specifier RefKind = A64E->getSpecifier();
if (RefKind == AArch64MCExpr::VK_TPREL_HI12 ||
RefKind == AArch64MCExpr::VK_DTPREL_HI12 ||
RefKind == AArch64MCExpr::VK_SECREL_HI12)
@@ -719,7 +719,7 @@ unsigned AArch64MCCodeEmitter::fixMOVZ(const MCInst &MI, unsigned EncodedValue,
const MCExpr *E = UImm16MO.getExpr();
if (const AArch64MCExpr *A64E = dyn_cast<AArch64MCExpr>(E)) {
switch (A64E->getKind()) {
switch (A64E->getSpecifier()) {
case AArch64MCExpr::VK_DTPREL_G2:
case AArch64MCExpr::VK_DTPREL_G1:
case AArch64MCExpr::VK_DTPREL_G0:

25
llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCExpr.cpp
View File

@@ -6,7 +6,7 @@
//
//===----------------------------------------------------------------------===//
//
// This file contains the implementation of the assembly expression modifiers
// This file contains the implementation of the relocation specifiers
// accepted by the AArch64 architecture (e.g. ":lo12:", ":gottprel_g1:", ...).
//
//===----------------------------------------------------------------------===//
@@ -24,14 +24,14 @@ using namespace llvm;
#define DEBUG_TYPE "aarch64symbolrefexpr"
const AArch64MCExpr *AArch64MCExpr::create(const MCExpr *Expr, VariantKind Kind,
MCContext &Ctx) {
return new (Ctx) AArch64MCExpr(Expr, Kind);
const AArch64MCExpr *AArch64MCExpr::create(const MCExpr *Expr, Specifier S,
MCContext &Ctx) {
return new (Ctx) AArch64MCExpr(Expr, S);
}
StringRef AArch64MCExpr::getVariantKindName() const {
StringRef AArch64MCExpr::getSpecifierName() const {
// clang-format off
switch (static_cast<uint32_t>(getKind())) {
switch (static_cast<uint32_t>(getSpecifier())) {
case VK_CALL: return "";
case VK_LO12: return ":lo12:";
case VK_ABS_G3: return ":abs_g3:";
@@ -90,13 +90,13 @@ StringRef AArch64MCExpr::getVariantKindName() const {
case VK_GOT_AUTH_PAGE: return ":got_auth:";
case VK_GOT_AUTH_LO12: return ":got_auth_lo12:";
default:
llvm_unreachable("Invalid ELF symbol kind");
llvm_unreachable("Invalid relocation specifier");
}
// clang-format on
}
void AArch64MCExpr::printImpl(raw_ostream &OS, const MCAsmInfo *MAI) const {
OS << getVariantKindName();
OS << getSpecifierName();
Expr->print(OS, MAI);
}
@@ -146,12 +146,3 @@ void AArch64AuthMCExpr::visitUsedExpr(MCStreamer &Streamer) const {
MCFragment *AArch64AuthMCExpr::findAssociatedFragment() const {
llvm_unreachable("FIXME: what goes here?");
}
bool AArch64AuthMCExpr::evaluateAsRelocatableImpl(
MCValue &Res, const MCAssembler *Asm) const {
if (!getSubExpr()->evaluateAsRelocatable(Res, Asm))
return false;
Res = MCValue::get(Res.getSymA(), nullptr, Res.getConstant(), getKind());
return true;
}

35
llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCExpr.h
View File

@@ -23,7 +23,7 @@ namespace llvm {
class AArch64MCExpr : public MCTargetExpr {
public:
enum VariantKind {
enum Specifier : uint16_t {
// clang-format off
// Symbol locations specifying (roughly speaking) what calculation should be
// performed to construct the final address for the relocated
@@ -126,26 +126,25 @@ public:
private:
const MCExpr *Expr;
const VariantKind Kind;
const Specifier specifier;
protected:
explicit AArch64MCExpr(const MCExpr *Expr, VariantKind Kind)
: Expr(Expr), Kind(Kind) {}
explicit AArch64MCExpr(const MCExpr *Expr, Specifier S)
: Expr(Expr), specifier(S) {}
public:
/// @name Construction
/// @{
static const AArch64MCExpr *create(const MCExpr *Expr, VariantKind Kind,
MCContext &Ctx);
static const AArch64MCExpr *create(const MCExpr *Expr, Specifier,
MCContext &Ctx);
/// @}
/// @name Accessors
/// @{
/// Get the kind of this expression.
VariantKind getKind() const { return Kind; }
VariantKind getSpecifier() const { return Kind; }
Specifier getSpecifier() const { return specifier; }
/// Get the expression this modifier applies to.
const MCExpr *getSubExpr() const { return Expr; }
@@ -154,21 +153,21 @@ public:
/// @name VariantKind information extractors.
/// @{
static VariantKind getSymbolLoc(VariantKind Kind) {
return static_cast<VariantKind>(Kind & VK_SymLocBits);
static Specifier getSymbolLoc(Specifier S) {
return static_cast<Specifier>(S & VK_SymLocBits);
}
static VariantKind getAddressFrag(VariantKind Kind) {
return static_cast<VariantKind>(Kind & VK_AddressFragBits);
static Specifier getAddressFrag(Specifier S) {
return static_cast<Specifier>(S & VK_AddressFragBits);
}
static bool isNotChecked(VariantKind Kind) { return Kind & VK_NC; }
static bool isNotChecked(Specifier S) { return S & VK_NC; }
/// @}
/// Convert the variant kind into an ELF-appropriate modifier
/// Return the string representation of the ELF relocation specifier
/// (e.g. ":got:", ":lo12:").
StringRef getVariantKindName() const;
StringRef getSpecifierName() const;
void printImpl(raw_ostream &OS, const MCAsmInfo *MAI) const override;
@@ -199,7 +198,7 @@ public:
AArch64PACKey::ID getKey() const { return Key; }
uint16_t getDiscriminator() const { return Discriminator; }
bool hasAddressDiversity() const { return getKind() == VK_AUTHADDR; }
bool hasAddressDiversity() const { return getSpecifier() == VK_AUTHADDR; }
void printImpl(raw_ostream &OS, const MCAsmInfo *MAI) const override;
@@ -207,14 +206,12 @@ public:
MCFragment *findAssociatedFragment() const override;
bool evaluateAsRelocatableImpl(MCValue &Res,
const MCAssembler *Asm) const override;
static bool classof(const MCExpr *E) {
return isa<AArch64MCExpr>(E) && classof(cast<AArch64MCExpr>(E));
}
static bool classof(const AArch64MCExpr *E) {
return E->getKind() == VK_AUTH || E->getKind() == VK_AUTHADDR;
return E->getSpecifier() == VK_AUTH || E->getSpecifier() == VK_AUTHADDR;
}
};
} // end namespace llvm

22
llvm/lib/Target/AArch64/MCTargetDesc/AArch64WinCOFFObjectWriter.cpp
View File

@@ -66,15 +66,15 @@ unsigned AArch64WinCOFFObjectWriter::getRelocType(
const MCExpr *Expr = Fixup.getValue();
if (const AArch64MCExpr *A64E = dyn_cast<AArch64MCExpr>(Expr)) {
AArch64MCExpr::VariantKind RefKind = A64E->getKind();
switch (AArch64MCExpr::getSymbolLoc(RefKind)) {
AArch64MCExpr::Specifier Spec = A64E->getSpecifier();
switch (AArch64MCExpr::getSymbolLoc(Spec)) {
case AArch64MCExpr::VK_ABS:
case AArch64MCExpr::VK_SECREL:
// Supported
break;
default:
Ctx.reportError(Fixup.getLoc(), "relocation variant " +
A64E->getVariantKindName() +
Ctx.reportError(Fixup.getLoc(), "relocation specifier " +
A64E->getSpecifierName() +
" unsupported on COFF targets");
return COFF::IMAGE_REL_ARM64_ABSOLUTE; // Dummy return value
}
@@ -83,8 +83,8 @@ unsigned AArch64WinCOFFObjectWriter::getRelocType(
switch (FixupKind) {
default: {
if (const AArch64MCExpr *A64E = dyn_cast<AArch64MCExpr>(Expr)) {
Ctx.reportError(Fixup.getLoc(), "relocation type " +
A64E->getVariantKindName() +
Ctx.reportError(Fixup.getLoc(), "relocation specifier " +
A64E->getSpecifierName() +
" unsupported on COFF targets");
} else {
const MCFixupKindInfo &Info = MAB.getFixupKindInfo(Fixup.getKind());
@@ -118,10 +118,10 @@ unsigned AArch64WinCOFFObjectWriter::getRelocType(
case AArch64::fixup_aarch64_add_imm12:
if (const AArch64MCExpr *A64E = dyn_cast<AArch64MCExpr>(Expr)) {
AArch64MCExpr::VariantKind RefKind = A64E->getKind();
if (RefKind == AArch64MCExpr::VK_SECREL_LO12)
AArch64MCExpr::Specifier Spec = A64E->getSpecifier();
if (Spec == AArch64MCExpr::VK_SECREL_LO12)
return COFF::IMAGE_REL_ARM64_SECREL_LOW12A;
if (RefKind == AArch64MCExpr::VK_SECREL_HI12)
if (Spec == AArch64MCExpr::VK_SECREL_HI12)
return COFF::IMAGE_REL_ARM64_SECREL_HIGH12A;
}
return COFF::IMAGE_REL_ARM64_PAGEOFFSET_12A;
@@ -132,8 +132,8 @@ unsigned AArch64WinCOFFObjectWriter::getRelocType(
case AArch64::fixup_aarch64_ldst_imm12_scale8:
case AArch64::fixup_aarch64_ldst_imm12_scale16:
if (const AArch64MCExpr *A64E = dyn_cast<AArch64MCExpr>(Expr)) {
AArch64MCExpr::VariantKind RefKind = A64E->getKind();
if (RefKind == AArch64MCExpr::VK_SECREL_LO12)
AArch64MCExpr::Specifier Spec = A64E->getSpecifier();
if (Spec == AArch64MCExpr::VK_SECREL_LO12)
return COFF::IMAGE_REL_ARM64_SECREL_LOW12L;
}
return COFF::IMAGE_REL_ARM64_PAGEOFFSET_12L;

18
llvm/test/MC/AArch64/coff-relocations-diags.s
View File

@@ -1,45 +1,45 @@
// RUN: not llvm-mc -triple aarch64-win32 -filetype=obj %s -o /dev/null 2>&1 | FileCheck %s
adrp x0, :got:symbol
// CHECK: error: relocation variant :got: unsupported on COFF targets
// CHECK: [[#@LINE-1]]:3: error: relocation specifier :got: unsupported on COFF targets
// CHECK-NEXT: adrp x0, :got:symbol
// CHECK-NEXT: ^
ldr x0, [x0, :got_lo12:symbol]
// CHECK: error: relocation variant :got_lo12: unsupported on COFF targets
// CHECK: [[#@LINE-1]]:3: error: relocation specifier :got_lo12: unsupported on COFF targets
// CHECK-NEXT: ldr x0, [x0, :got_lo12:symbol]
// CHECK-NEXT: ^
adrp x0, :tlsdesc:symbol
// CHECK: error: relocation variant :tlsdesc: unsupported on COFF targets
// CHECK: [[#@LINE-1]]:3: error: relocation specifier :tlsdesc: unsupported on COFF targets
// CHECK-NEXT: adrp x0, :tlsdesc:symbol
// CHECK-NEXT: ^
add x0, x0, :tlsdesc_lo12:symbol
// CHECK: error: relocation variant :tlsdesc_lo12: unsupported on COFF targets
// CHECK: error: relocation specifier :tlsdesc_lo12: unsupported on COFF targets
// CHECK-NEXT: add x0, x0, :tlsdesc_lo12:symbol
// CHECK-NEXT: ^
adrp x0, :gottprel:symbol
// CHECK: error: relocation variant :gottprel: unsupported on COFF targets
// CHECK: error: relocation specifier :gottprel: unsupported on COFF targets
// CHECK-NEXT: adrp x0, :gottprel:symbol
// CHECK-NEXT: ^
ldr x0, [x0, :gottprel_lo12:symbol]
// CHECK: error: relocation variant :gottprel_lo12: unsupported on COFF targets
// CHECK: error: relocation specifier :gottprel_lo12: unsupported on COFF targets
// CHECK-NEXT: ldr x0, [x0, :gottprel_lo12:symbol]
// CHECK-NEXT: ^
add x0, x0, #:dtprel_hi12:symbol, lsl #12
// CHECK: error: relocation variant :dtprel_hi12: unsupported on COFF targets
// CHECK: error: relocation specifier :dtprel_hi12: unsupported on COFF targets
// CHECK-NEXT: add x0, x0, #:dtprel_hi12:symbol, lsl #12
// CHECK-NEXT: ^
add x0, x0, :dtprel_lo12:symbol
// CHECK: error: relocation variant :dtprel_lo12: unsupported on COFF targets
// CHECK: error: relocation specifier :dtprel_lo12: unsupported on COFF targets
// CHECK-NEXT: add x0, x0, :dtprel_lo12:symbol
// CHECK-NEXT: ^
label:
movz x0, #:abs_g0:symbol
// CHECK: error: relocation type :abs_g0: unsupported on COFF targets
// CHECK: error: relocation specifier :abs_g0: unsupported on COFF targets
// CHECK-NEXT: movz x0, #:abs_g0:symbol
// CHECK-NEXT: ^