Skip to content

Commit ac8e18c

Browse files
MaskRayMaskRay
authored
[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: #132595
1 parent 6ecc67f commit ac8e18c

File tree

10 files changed

+137
-164
lines changed

10 files changed

+137
-164
lines changed

‎llvm/lib/Target/AArch64/AArch64AsmPrinter.cpp‎

Lines changed: 11 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -919,19 +919,17 @@ void AArch64AsmPrinter::emitHwasanMemaccessSymbols(Module &M) {
919919
// Intentionally load the GOT entry and branch to it, rather than possibly
920920
// late binding the function, which may clobber the registers before we
921921
// have a chance to save them.
922-
EmitToStreamer(
923-
MCInstBuilder(AArch64::ADRP)
924-
.addReg(AArch64::X16)
925-
.addExpr(AArch64MCExpr::create(
926-
HwasanTagMismatchRef, AArch64MCExpr::VariantKind::VK_GOT_PAGE,
927-
OutContext)));
928-
EmitToStreamer(
929-
MCInstBuilder(AArch64::LDRXui)
930-
.addReg(AArch64::X16)
931-
.addReg(AArch64::X16)
932-
.addExpr(AArch64MCExpr::create(
933-
HwasanTagMismatchRef, AArch64MCExpr::VariantKind::VK_GOT_LO12,
934-
OutContext)));
922+
EmitToStreamer(MCInstBuilder(AArch64::ADRP)
923+
.addReg(AArch64::X16)
924+
.addExpr(AArch64MCExpr::create(
925+
HwasanTagMismatchRef, AArch64MCExpr::VK_GOT_PAGE,
926+
OutContext)));
927+
EmitToStreamer(MCInstBuilder(AArch64::LDRXui)
928+
.addReg(AArch64::X16)
929+
.addReg(AArch64::X16)
930+
.addExpr(AArch64MCExpr::create(
931+
HwasanTagMismatchRef, AArch64MCExpr::VK_GOT_LO12,
932+
OutContext)));
935933
EmitToStreamer(MCInstBuilder(AArch64::BR).addReg(AArch64::X16));
936934
}
937935
}

‎llvm/lib/Target/AArch64/AArch64MCInstLower.cpp‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -266,8 +266,8 @@ MCOperand AArch64MCInstLower::lowerSymbolOperandELF(const MachineOperand &MO,
266266
Expr = MCBinaryExpr::createAdd(
267267
Expr, MCConstantExpr::create(MO.getOffset(), Ctx), Ctx);
268268

269-
AArch64MCExpr::VariantKind RefKind;
270-
RefKind = static_cast<AArch64MCExpr::VariantKind>(RefFlags);
269+
AArch64MCExpr::Specifier RefKind;
270+
RefKind = static_cast<AArch64MCExpr::Specifier>(RefFlags);
271271
Expr = AArch64MCExpr::create(Expr, RefKind, Ctx);
272272

273273
return MCOperand::createExpr(Expr);
@@ -320,7 +320,7 @@ MCOperand AArch64MCInstLower::lowerSymbolOperandCOFF(const MachineOperand &MO,
320320
Expr = MCBinaryExpr::createAdd(
321321
Expr, MCConstantExpr::create(MO.getOffset(), Ctx), Ctx);
322322

323-
auto RefKind = static_cast<AArch64MCExpr::VariantKind>(RefFlags);
323+
auto RefKind = static_cast<AArch64MCExpr::Specifier>(RefFlags);
324324
assert(RefKind != AArch64MCExpr::VK_INVALID &&
325325
"Invalid relocation requested");
326326
Expr = AArch64MCExpr::create(Expr, RefKind, Ctx);

‎llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp‎

Lines changed: 66 additions & 78 deletions
Original file line numberDiff line numberDiff line change
@@ -338,7 +338,7 @@ class AArch64AsmParser : public MCTargetAsmParser {
338338
bool parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc) override;
339339

340340
static bool classifySymbolRef(const MCExpr *Expr,
341-
AArch64MCExpr::VariantKind &ELFRefKind,
341+
AArch64MCExpr::Specifier &ELFSpec,
342342
MCSymbolRefExpr::VariantKind &DarwinRefKind,
343343
int64_t &Addend);
344344
};
@@ -888,30 +888,26 @@ class AArch64Operand : public MCParsedAsmOperand {
888888
}
889889

890890
bool isSymbolicUImm12Offset(const MCExpr *Expr) const {
891-
AArch64MCExpr::VariantKind ELFRefKind;
891+
AArch64MCExpr::Specifier ELFSpec;
892892
MCSymbolRefExpr::VariantKind DarwinRefKind;
893893
int64_t Addend;
894-
if (!AArch64AsmParser::classifySymbolRef(Expr, ELFRefKind, DarwinRefKind,
895-
Addend)) {
894+
if (!AArch64AsmParser::classifySymbolRef(Expr, ELFSpec, DarwinRefKind,
895+
Addend)) {
896896
// If we don't understand the expression, assume the best and
897897
// let the fixup and relocation code deal with it.
898898
return true;
899899
}
900900

901901
if (DarwinRefKind == MCSymbolRefExpr::VK_PAGEOFF ||
902-
ELFRefKind == AArch64MCExpr::VK_LO12 ||
903-
ELFRefKind == AArch64MCExpr::VK_GOT_LO12 ||
904-
ELFRefKind == AArch64MCExpr::VK_GOT_AUTH_LO12 ||
905-
ELFRefKind == AArch64MCExpr::VK_DTPREL_LO12 ||
906-
ELFRefKind == AArch64MCExpr::VK_DTPREL_LO12_NC ||
907-
ELFRefKind == AArch64MCExpr::VK_TPREL_LO12 ||
908-
ELFRefKind == AArch64MCExpr::VK_TPREL_LO12_NC ||
909-
ELFRefKind == AArch64MCExpr::VK_GOTTPREL_LO12_NC ||
910-
ELFRefKind == AArch64MCExpr::VK_TLSDESC_LO12 ||
911-
ELFRefKind == AArch64MCExpr::VK_TLSDESC_AUTH_LO12 ||
912-
ELFRefKind == AArch64MCExpr::VK_SECREL_LO12 ||
913-
ELFRefKind == AArch64MCExpr::VK_SECREL_HI12 ||
914-
ELFRefKind == AArch64MCExpr::VK_GOT_PAGE_LO15) {
902+
llvm::is_contained(
903+
{AArch64MCExpr::VK_LO12, AArch64MCExpr::VK_GOT_LO12,
904+
AArch64MCExpr::VK_GOT_AUTH_LO12, AArch64MCExpr::VK_DTPREL_LO12,
905+
AArch64MCExpr::VK_DTPREL_LO12_NC, AArch64MCExpr::VK_TPREL_LO12,
906+
AArch64MCExpr::VK_TPREL_LO12_NC,
907+
AArch64MCExpr::VK_GOTTPREL_LO12_NC, AArch64MCExpr::VK_TLSDESC_LO12,
908+
AArch64MCExpr::VK_TLSDESC_AUTH_LO12, AArch64MCExpr::VK_SECREL_LO12,
909+
AArch64MCExpr::VK_SECREL_HI12, AArch64MCExpr::VK_GOT_PAGE_LO15},
910+
ELFSpec)) {
915911
// Note that we don't range-check the addend. It's adjusted modulo page
916912
// size when converted, so there is no "out of range" condition when using
917913
// @pageoff.
@@ -1009,26 +1005,24 @@ class AArch64Operand : public MCParsedAsmOperand {
10091005
Expr = getImm();
10101006
}
10111007

1012-
AArch64MCExpr::VariantKind ELFRefKind;
1008+
AArch64MCExpr::Specifier ELFSpec;
10131009
MCSymbolRefExpr::VariantKind DarwinRefKind;
10141010
int64_t Addend;
1015-
if (AArch64AsmParser::classifySymbolRef(Expr, ELFRefKind,
1016-
DarwinRefKind, Addend)) {
1011+
if (AArch64AsmParser::classifySymbolRef(Expr, ELFSpec, DarwinRefKind,
1012+
Addend)) {
10171013
return DarwinRefKind == MCSymbolRefExpr::VK_PAGEOFF ||
10181014
DarwinRefKind == MCSymbolRefExpr::VK_TLVPPAGEOFF ||
10191015
(DarwinRefKind == MCSymbolRefExpr::VK_GOTPAGEOFF && Addend == 0) ||
1020-
ELFRefKind == AArch64MCExpr::VK_LO12 ||
1021-
ELFRefKind == AArch64MCExpr::VK_GOT_AUTH_LO12 ||
1022-
ELFRefKind == AArch64MCExpr::VK_DTPREL_HI12 ||
1023-
ELFRefKind == AArch64MCExpr::VK_DTPREL_LO12 ||
1024-
ELFRefKind == AArch64MCExpr::VK_DTPREL_LO12_NC ||
1025-
ELFRefKind == AArch64MCExpr::VK_TPREL_HI12 ||
1026-
ELFRefKind == AArch64MCExpr::VK_TPREL_LO12 ||
1027-
ELFRefKind == AArch64MCExpr::VK_TPREL_LO12_NC ||
1028-
ELFRefKind == AArch64MCExpr::VK_TLSDESC_LO12 ||
1029-
ELFRefKind == AArch64MCExpr::VK_TLSDESC_AUTH_LO12 ||
1030-
ELFRefKind == AArch64MCExpr::VK_SECREL_HI12 ||
1031-
ELFRefKind == AArch64MCExpr::VK_SECREL_LO12;
1016+
llvm::is_contained(
1017+
{AArch64MCExpr::VK_LO12, AArch64MCExpr::VK_GOT_AUTH_LO12,
1018+
AArch64MCExpr::VK_DTPREL_HI12, AArch64MCExpr::VK_DTPREL_LO12,
1019+
AArch64MCExpr::VK_DTPREL_LO12_NC,
1020+
AArch64MCExpr::VK_TPREL_HI12, AArch64MCExpr::VK_TPREL_LO12,
1021+
AArch64MCExpr::VK_TPREL_LO12_NC,
1022+
AArch64MCExpr::VK_TLSDESC_LO12,
1023+
AArch64MCExpr::VK_TLSDESC_AUTH_LO12,
1024+
AArch64MCExpr::VK_SECREL_HI12, AArch64MCExpr::VK_SECREL_LO12},
1025+
ELFSpec);
10321026
}
10331027

10341028
// If it's a constant, it should be a real immediate in range.
@@ -1121,22 +1115,21 @@ class AArch64Operand : public MCParsedAsmOperand {
11211115
return (Val >= -((1<<(N-1)) << 2) && Val <= (((1<<(N-1))-1) << 2));
11221116
}
11231117

1124-
bool
1125-
isMovWSymbol(ArrayRef<AArch64MCExpr::VariantKind> AllowedModifiers) const {
1118+
bool isMovWSymbol(ArrayRef<AArch64MCExpr::Specifier> AllowedModifiers) const {
11261119
if (!isImm())
11271120
return false;
11281121

1129-
AArch64MCExpr::VariantKind ELFRefKind;
1122+
AArch64MCExpr::Specifier ELFSpec;
11301123
MCSymbolRefExpr::VariantKind DarwinRefKind;
11311124
int64_t Addend;
1132-
if (!AArch64AsmParser::classifySymbolRef(getImm(), ELFRefKind,
1133-
DarwinRefKind, Addend)) {
1125+
if (!AArch64AsmParser::classifySymbolRef(getImm(), ELFSpec, DarwinRefKind,
1126+
Addend)) {
11341127
return false;
11351128
}
11361129
if (DarwinRefKind != MCSymbolRefExpr::VK_None)
11371130
return false;
11381131

1139-
return llvm::is_contained(AllowedModifiers, ELFRefKind);
1132+
return llvm::is_contained(AllowedModifiers, ELFSpec);
11401133
}
11411134

11421135
bool isMovWSymbolG3() const {
@@ -3303,12 +3296,12 @@ ParseStatus AArch64AsmParser::tryParseAdrpLabel(OperandVector &Operands) {
33033296
if (parseSymbolicImmVal(Expr))
33043297
return ParseStatus::Failure;
33053298

3306-
AArch64MCExpr::VariantKind ELFRefKind;
3299+
AArch64MCExpr::Specifier ELFSpec;
33073300
MCSymbolRefExpr::VariantKind DarwinRefKind;
33083301
int64_t Addend;
3309-
if (classifySymbolRef(Expr, ELFRefKind, DarwinRefKind, Addend)) {
3302+
if (classifySymbolRef(Expr, ELFSpec, DarwinRefKind, Addend)) {
33103303
if (DarwinRefKind == MCSymbolRefExpr::VK_None &&
3311-
ELFRefKind == AArch64MCExpr::VK_INVALID) {
3304+
ELFSpec == AArch64MCExpr::VK_INVALID) {
33123305
// No modifier was specified at all; this is the syntax for an ELF basic
33133306
// ADRP relocation (unfortunately).
33143307
Expr =
@@ -3320,13 +3313,13 @@ ParseStatus AArch64AsmParser::tryParseAdrpLabel(OperandVector &Operands) {
33203313
} else if (DarwinRefKind != MCSymbolRefExpr::VK_PAGE &&
33213314
DarwinRefKind != MCSymbolRefExpr::VK_GOTPAGE &&
33223315
DarwinRefKind != MCSymbolRefExpr::VK_TLVPPAGE &&
3323-
ELFRefKind != AArch64MCExpr::VK_ABS_PAGE_NC &&
3324-
ELFRefKind != AArch64MCExpr::VK_GOT_PAGE &&
3325-
ELFRefKind != AArch64MCExpr::VK_GOT_AUTH_PAGE &&
3326-
ELFRefKind != AArch64MCExpr::VK_GOT_PAGE_LO15 &&
3327-
ELFRefKind != AArch64MCExpr::VK_GOTTPREL_PAGE &&
3328-
ELFRefKind != AArch64MCExpr::VK_TLSDESC_PAGE &&
3329-
ELFRefKind != AArch64MCExpr::VK_TLSDESC_AUTH_PAGE) {
3316+
ELFSpec != AArch64MCExpr::VK_ABS_PAGE_NC &&
3317+
ELFSpec != AArch64MCExpr::VK_GOT_PAGE &&
3318+
ELFSpec != AArch64MCExpr::VK_GOT_AUTH_PAGE &&
3319+
ELFSpec != AArch64MCExpr::VK_GOT_PAGE_LO15 &&
3320+
ELFSpec != AArch64MCExpr::VK_GOTTPREL_PAGE &&
3321+
ELFSpec != AArch64MCExpr::VK_TLSDESC_PAGE &&
3322+
ELFSpec != AArch64MCExpr::VK_TLSDESC_AUTH_PAGE) {
33303323
// The operand must be an @page or @gotpage qualified symbolref.
33313324
return Error(S, "page or gotpage label reference expected");
33323325
}
@@ -3357,16 +3350,16 @@ ParseStatus AArch64AsmParser::tryParseAdrLabel(OperandVector &Operands) {
33573350
if (parseSymbolicImmVal(Expr))
33583351
return ParseStatus::Failure;
33593352

3360-
AArch64MCExpr::VariantKind ELFRefKind;
3353+
AArch64MCExpr::Specifier ELFSpec;
33613354
MCSymbolRefExpr::VariantKind DarwinRefKind;
33623355
int64_t Addend;
3363-
if (classifySymbolRef(Expr, ELFRefKind, DarwinRefKind, Addend)) {
3356+
if (classifySymbolRef(Expr, ELFSpec, DarwinRefKind, Addend)) {
33643357
if (DarwinRefKind == MCSymbolRefExpr::VK_None &&
3365-
ELFRefKind == AArch64MCExpr::VK_INVALID) {
3358+
ELFSpec == AArch64MCExpr::VK_INVALID) {
33663359
// No modifier was specified at all; this is the syntax for an ELF basic
33673360
// ADR relocation (unfortunately).
33683361
Expr = AArch64MCExpr::create(Expr, AArch64MCExpr::VK_ABS, getContext());
3369-
} else if (ELFRefKind != AArch64MCExpr::VK_GOT_AUTH_PAGE) {
3362+
} else if (ELFSpec != AArch64MCExpr::VK_GOT_AUTH_PAGE) {
33703363
// For tiny code model, we use :got_auth: operator to fill 21-bit imm of
33713364
// adr. It's not actually GOT entry page address but the GOT address
33723365
// itself - we just share the same variant kind with :got_auth: operator
@@ -4407,7 +4400,7 @@ bool AArch64AsmParser::parseRegister(OperandVector &Operands) {
44074400

44084401
bool AArch64AsmParser::parseSymbolicImmVal(const MCExpr *&ImmVal) {
44094402
bool HasELFModifier = false;
4410-
AArch64MCExpr::VariantKind RefKind;
4403+
AArch64MCExpr::Specifier RefKind;
44114404

44124405
if (parseOptionalToken(AsmToken::Colon)) {
44134406
HasELFModifier = true;
@@ -4417,7 +4410,7 @@ bool AArch64AsmParser::parseSymbolicImmVal(const MCExpr *&ImmVal) {
44174410

44184411
std::string LowerCase = getTok().getIdentifier().lower();
44194412
RefKind =
4420-
StringSwitch<AArch64MCExpr::VariantKind>(LowerCase)
4413+
StringSwitch<AArch64MCExpr::Specifier>(LowerCase)
44214414
.Case("lo12", AArch64MCExpr::VK_LO12)
44224415
.Case("abs_g3", AArch64MCExpr::VK_ABS_G3)
44234416
.Case("abs_g2", AArch64MCExpr::VK_ABS_G2)
@@ -5823,10 +5816,10 @@ bool AArch64AsmParser::validateInstruction(MCInst &Inst, SMLoc &IDLoc,
58235816
// some slight duplication here.
58245817
if (Inst.getOperand(2).isExpr()) {
58255818
const MCExpr *Expr = Inst.getOperand(2).getExpr();
5826-
AArch64MCExpr::VariantKind ELFRefKind;
5819+
AArch64MCExpr::Specifier ELFSpec;
58275820
MCSymbolRefExpr::VariantKind DarwinRefKind;
58285821
int64_t Addend;
5829-
if (classifySymbolRef(Expr, ELFRefKind, DarwinRefKind, Addend)) {
5822+
if (classifySymbolRef(Expr, ELFSpec, DarwinRefKind, Addend)) {
58305823

58315824
// Only allow these with ADDXri.
58325825
if ((DarwinRefKind == MCSymbolRefExpr::VK_PAGEOFF ||
@@ -5835,18 +5828,15 @@ bool AArch64AsmParser::validateInstruction(MCInst &Inst, SMLoc &IDLoc,
58355828
return false;
58365829

58375830
// Only allow these with ADDXri/ADDWri
5838-
if ((ELFRefKind == AArch64MCExpr::VK_LO12 ||
5839-
ELFRefKind == AArch64MCExpr::VK_GOT_AUTH_LO12 ||
5840-
ELFRefKind == AArch64MCExpr::VK_DTPREL_HI12 ||
5841-
ELFRefKind == AArch64MCExpr::VK_DTPREL_LO12 ||
5842-
ELFRefKind == AArch64MCExpr::VK_DTPREL_LO12_NC ||
5843-
ELFRefKind == AArch64MCExpr::VK_TPREL_HI12 ||
5844-
ELFRefKind == AArch64MCExpr::VK_TPREL_LO12 ||
5845-
ELFRefKind == AArch64MCExpr::VK_TPREL_LO12_NC ||
5846-
ELFRefKind == AArch64MCExpr::VK_TLSDESC_LO12 ||
5847-
ELFRefKind == AArch64MCExpr::VK_TLSDESC_AUTH_LO12 ||
5848-
ELFRefKind == AArch64MCExpr::VK_SECREL_LO12 ||
5849-
ELFRefKind == AArch64MCExpr::VK_SECREL_HI12) &&
5831+
if (llvm::is_contained(
5832+
{AArch64MCExpr::VK_LO12, AArch64MCExpr::VK_GOT_AUTH_LO12,
5833+
AArch64MCExpr::VK_DTPREL_HI12, AArch64MCExpr::VK_DTPREL_LO12,
5834+
AArch64MCExpr::VK_DTPREL_LO12_NC, AArch64MCExpr::VK_TPREL_HI12,
5835+
AArch64MCExpr::VK_TPREL_LO12, AArch64MCExpr::VK_TPREL_LO12_NC,
5836+
AArch64MCExpr::VK_TLSDESC_LO12,
5837+
AArch64MCExpr::VK_TLSDESC_AUTH_LO12,
5838+
AArch64MCExpr::VK_SECREL_LO12, AArch64MCExpr::VK_SECREL_HI12},
5839+
ELFSpec) &&
58505840
(Inst.getOpcode() == AArch64::ADDXri ||
58515841
Inst.getOpcode() == AArch64::ADDWri))
58525842
return false;
@@ -8202,17 +8192,15 @@ bool AArch64AsmParser::parseAuthExpr(const MCExpr *&Res, SMLoc &EndLoc) {
82028192
return false;
82038193
}
82048194

8205-
bool
8206-
AArch64AsmParser::classifySymbolRef(const MCExpr *Expr,
8207-
AArch64MCExpr::VariantKind &ELFRefKind,
8208-
MCSymbolRefExpr::VariantKind &DarwinRefKind,
8209-
int64_t &Addend) {
8210-
ELFRefKind = AArch64MCExpr::VK_INVALID;
8195+
bool AArch64AsmParser::classifySymbolRef(
8196+
const MCExpr *Expr, AArch64MCExpr::Specifier &ELFSpec,
8197+
MCSymbolRefExpr::VariantKind &DarwinRefKind, int64_t &Addend) {
8198+
ELFSpec = AArch64MCExpr::VK_INVALID;
82118199
DarwinRefKind = MCSymbolRefExpr::VK_None;
82128200
Addend = 0;
82138201

82148202
if (const AArch64MCExpr *AE = dyn_cast<AArch64MCExpr>(Expr)) {
8215-
ELFRefKind = AE->getKind();
8203+
ELFSpec = AE->getSpecifier();
82168204
Expr = AE->getSubExpr();
82178205
}
82188206

@@ -8229,9 +8217,9 @@ AArch64AsmParser::classifySymbolRef(const MCExpr *Expr,
82298217
if (!Relocatable || Res.getSymB())
82308218
return false;
82318219

8232-
// Treat expressions with an ELFRefKind (like ":abs_g1:3", or
8220+
// Treat expressions with an ELFSpec (like ":abs_g1:3", or
82338221
// ":abs_g1:x" where x is constant) as symbolic even if there is no symbol.
8234-
if (!Res.getSymA() && ELFRefKind == AArch64MCExpr::VK_INVALID)
8222+
if (!Res.getSymA() && ELFSpec == AArch64MCExpr::VK_INVALID)
82358223
return false;
82368224

82378225
if (Res.getSymA())
@@ -8240,7 +8228,7 @@ AArch64AsmParser::classifySymbolRef(const MCExpr *Expr,
82408228

82418229
// It's some symbol reference + a constant addend, but really
82428230
// shouldn't use both Darwin and ELF syntax.
8243-
return ELFRefKind == AArch64MCExpr::VK_INVALID ||
8231+
return ELFSpec == AArch64MCExpr::VK_INVALID ||
82448232
DarwinRefKind == MCSymbolRefExpr::VK_None;
82458233
}
82468234

‎llvm/lib/Target/AArch64/MCTargetDesc/AArch64AsmBackend.cpp‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -221,8 +221,8 @@ static uint64_t adjustFixupValue(const MCFixup &Fixup, const MCValue &Target,
221221
Ctx.reportError(Fixup.getLoc(), "fixup must be 16-byte aligned");
222222
return Value >> 4;
223223
case AArch64::fixup_aarch64_movw: {
224-
AArch64MCExpr::VariantKind RefKind =
225-
static_cast<AArch64MCExpr::VariantKind>(Target.getRefKind());
224+
AArch64MCExpr::Specifier RefKind =
225+
static_cast<AArch64MCExpr::Specifier>(Target.getRefKind());
226226
if (AArch64MCExpr::getSymbolLoc(RefKind) != AArch64MCExpr::VK_ABS &&
227227
AArch64MCExpr::getSymbolLoc(RefKind) != AArch64MCExpr::VK_SABS) {
228228
if (!RefKind) {
@@ -422,8 +422,8 @@ void AArch64AsmBackend::applyFixup(const MCAssembler &Asm, const MCFixup &Fixup,
422422
bool IsResolved,
423423
const MCSubtargetInfo *STI) const {
424424
if (Fixup.getTargetKind() == FK_Data_8 && TheTriple.isOSBinFormatELF()) {
425-
auto RefKind = static_cast<AArch64MCExpr::VariantKind>(Target.getRefKind());
426-
AArch64MCExpr::VariantKind SymLoc = AArch64MCExpr::getSymbolLoc(RefKind);
425+
auto RefKind = static_cast<AArch64MCExpr::Specifier>(Target.getRefKind());
426+
AArch64MCExpr::Specifier SymLoc = AArch64MCExpr::getSymbolLoc(RefKind);
427427
if (SymLoc == AArch64AuthMCExpr::VK_AUTH ||
428428
SymLoc == AArch64AuthMCExpr::VK_AUTHADDR) {
429429
assert(Value == 0);
@@ -474,8 +474,8 @@ void AArch64AsmBackend::applyFixup(const MCAssembler &Asm, const MCFixup &Fixup,
474474

475475
// FIXME: getFixupKindInfo() and getFixupKindNumBytes() could be fixed to
476476
// handle this more cleanly. This may affect the output of -show-mc-encoding.
477-
AArch64MCExpr::VariantKind RefKind =
478-
static_cast<AArch64MCExpr::VariantKind>(Target.getRefKind());
477+
AArch64MCExpr::Specifier RefKind =
478+
static_cast<AArch64MCExpr::Specifier>(Target.getRefKind());
479479
if (AArch64MCExpr::getSymbolLoc(RefKind) == AArch64MCExpr::VK_SABS ||
480480
(!RefKind && Fixup.getTargetKind() == AArch64::fixup_aarch64_movw)) {
481481
// If the immediate is negative, generate MOVN else MOVZ.

‎llvm/lib/Target/AArch64/MCTargetDesc/AArch64ELFObjectWriter.cpp‎

Lines changed: 5 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -58,8 +58,7 @@ AArch64ELFObjectWriter::AArch64ELFObjectWriter(uint8_t OSABI, bool IsILP32)
5858

5959
// assumes IsILP32 is true
6060
static bool isNonILP32reloc(const MCFixup &Fixup,
61-
AArch64MCExpr::VariantKind RefKind,
62-
MCContext &Ctx) {
61+
AArch64MCExpr::Specifier RefKind, MCContext &Ctx) {
6362
if (Fixup.getTargetKind() != AArch64::fixup_aarch64_movw)
6463
return false;
6564
switch (RefKind) {
@@ -112,9 +111,9 @@ unsigned AArch64ELFObjectWriter::getRelocType(MCContext &Ctx,
112111
unsigned Kind = Fixup.getTargetKind();
113112
if (Kind >= FirstLiteralRelocationKind)
114113
return Kind - FirstLiteralRelocationKind;
115-
AArch64MCExpr::VariantKind RefKind =
116-
static_cast<AArch64MCExpr::VariantKind>(Target.getRefKind());
117-
AArch64MCExpr::VariantKind SymLoc = AArch64MCExpr::getSymbolLoc(RefKind);
114+
AArch64MCExpr::Specifier RefKind =
115+
static_cast<AArch64MCExpr::Specifier>(Target.getRefKind());
116+
AArch64MCExpr::Specifier SymLoc = AArch64MCExpr::getSymbolLoc(RefKind);
118117
bool IsNC = AArch64MCExpr::isNotChecked(RefKind);
119118

120119
assert((!Target.getSymA() ||
@@ -403,7 +402,7 @@ unsigned AArch64ELFObjectWriter::getRelocType(MCContext &Ctx,
403402
if ((SymLoc == AArch64MCExpr::VK_GOT ||
404403
SymLoc == AArch64MCExpr::VK_GOT_AUTH) &&
405404
IsNC) {
406-
AArch64MCExpr::VariantKind AddressLoc =
405+
AArch64MCExpr::Specifier AddressLoc =
407406
AArch64MCExpr::getAddressFrag(RefKind);
408407
bool IsAuth = (SymLoc == AArch64MCExpr::VK_GOT_AUTH);
409408
if (!IsILP32) {

0 commit comments

Comments
 (0)