[llvm] ac8e18c - [AArch64] Rename VariantKind to Specifier
via llvm-commits
llvm-commits at lists.llvm.org
Wed Mar 26 09:01:23 PDT 2025
Author: Fangrui Song
Date: 2025-03-26T09:01:20-07:00
New Revision: ac8e18cdcecbef0c1e5080aec4ad655f61b1a249
URL: https://github.com/llvm/llvm-project/commit/ac8e18cdcecbef0c1e5080aec4ad655f61b1a249
DIFF: https://github.com/llvm/llvm-project/commit/ac8e18cdcecbef0c1e5080aec4ad655f61b1a249.diff
LOG: [AArch64] Rename VariantKind to Specifier
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
Added:
Modified:
llvm/lib/Target/AArch64/AArch64AsmPrinter.cpp
llvm/lib/Target/AArch64/AArch64MCInstLower.cpp
llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp
llvm/lib/Target/AArch64/MCTargetDesc/AArch64AsmBackend.cpp
llvm/lib/Target/AArch64/MCTargetDesc/AArch64ELFObjectWriter.cpp
llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCCodeEmitter.cpp
llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCExpr.cpp
llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCExpr.h
llvm/lib/Target/AArch64/MCTargetDesc/AArch64WinCOFFObjectWriter.cpp
llvm/test/MC/AArch64/coff-relocations-diags.s
Removed:
################################################################################
diff --git a/llvm/lib/Target/AArch64/AArch64AsmPrinter.cpp b/llvm/lib/Target/AArch64/AArch64AsmPrinter.cpp
index 79b190388eb75..e3ad085bc5a29 100644
--- a/llvm/lib/Target/AArch64/AArch64AsmPrinter.cpp
+++ b/llvm/lib/Target/AArch64/AArch64AsmPrinter.cpp
@@ -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));
}
}
diff --git a/llvm/lib/Target/AArch64/AArch64MCInstLower.cpp b/llvm/lib/Target/AArch64/AArch64MCInstLower.cpp
index db8522cabd681..6a02a75ddbb4d 100644
--- a/llvm/lib/Target/AArch64/AArch64MCInstLower.cpp
+++ b/llvm/lib/Target/AArch64/AArch64MCInstLower.cpp
@@ -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);
diff --git a/llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp b/llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp
index 10123c51badb4..5be4bd9ec6b26 100644
--- a/llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp
+++ b/llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp
@@ -338,7 +338,7 @@ class AArch64AsmParser : public MCTargetAsmParser {
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 @@ class AArch64Operand : public MCParsedAsmOperand {
}
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 @@ class AArch64Operand : public MCParsedAsmOperand {
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 @@ class AArch64Operand : public MCParsedAsmOperand {
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;
}
diff --git a/llvm/lib/Target/AArch64/MCTargetDesc/AArch64AsmBackend.cpp b/llvm/lib/Target/AArch64/MCTargetDesc/AArch64AsmBackend.cpp
index 8309c789d0ace..c5accb5e3b51b 100644
--- a/llvm/lib/Target/AArch64/MCTargetDesc/AArch64AsmBackend.cpp
+++ b/llvm/lib/Target/AArch64/MCTargetDesc/AArch64AsmBackend.cpp
@@ -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.
diff --git a/llvm/lib/Target/AArch64/MCTargetDesc/AArch64ELFObjectWriter.cpp b/llvm/lib/Target/AArch64/MCTargetDesc/AArch64ELFObjectWriter.cpp
index 3079541a23ead..a509edf160d32 100644
--- a/llvm/lib/Target/AArch64/MCTargetDesc/AArch64ELFObjectWriter.cpp
+++ b/llvm/lib/Target/AArch64/MCTargetDesc/AArch64ELFObjectWriter.cpp
@@ -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) {
diff --git a/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCCodeEmitter.cpp b/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCCodeEmitter.cpp
index 552477ebca26c..bd43c73396463 100644
--- a/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCCodeEmitter.cpp
+++ b/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCCodeEmitter.cpp
@@ -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:
diff --git a/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCExpr.cpp b/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCExpr.cpp
index 072b77b376bde..bdfc7361f8cd7 100644
--- a/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCExpr.cpp
+++ b/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCExpr.cpp
@@ -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;
-}
diff --git a/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCExpr.h b/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCExpr.h
index 57fecb9cfe16a..50abaa9861538 100644
--- a/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCExpr.h
+++ b/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCExpr.h
@@ -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 @@ class AArch64MCExpr : public MCTargetExpr {
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 @@ class AArch64MCExpr : public MCTargetExpr {
/// @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 @@ class AArch64AuthMCExpr final : public AArch64MCExpr {
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 @@ class AArch64AuthMCExpr final : public AArch64MCExpr {
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
diff --git a/llvm/lib/Target/AArch64/MCTargetDesc/AArch64WinCOFFObjectWriter.cpp b/llvm/lib/Target/AArch64/MCTargetDesc/AArch64WinCOFFObjectWriter.cpp
index 47228025ce259..4213edafa9a0f 100644
--- a/llvm/lib/Target/AArch64/MCTargetDesc/AArch64WinCOFFObjectWriter.cpp
+++ b/llvm/lib/Target/AArch64/MCTargetDesc/AArch64WinCOFFObjectWriter.cpp
@@ -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;
diff --git a/llvm/test/MC/AArch64/coff-relocations-diags.s b/llvm/test/MC/AArch64/coff-relocations-diags.s
index a3c7534ac9c65..e03ba377dc18b 100644
--- a/llvm/test/MC/AArch64/coff-relocations-diags.s
+++ b/llvm/test/MC/AArch64/coff-relocations-diags.s
@@ -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: ^
More information about the llvm-commits
mailing list