Skip to content

Commit fd74783

Browse files
MaskRayMaskRay
committed
[𝘀𝗽𝗿] initial version
Created using spr 1.3.5-bogner
1 parent 441c9a9 commit fd74783

File tree

9 files changed

+112
-125
lines changed

9 files changed

+112
-125
lines changed

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

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -923,14 +923,14 @@ void AArch64AsmPrinter::emitHwasanMemaccessSymbols(Module &M) {
923923
MCInstBuilder(AArch64::ADRP)
924924
.addReg(AArch64::X16)
925925
.addExpr(AArch64MCExpr::create(
926-
HwasanTagMismatchRef, AArch64MCExpr::VariantKind::VK_GOT_PAGE,
926+
HwasanTagMismatchRef, AArch64MCExpr::Specifier::VK_GOT_PAGE,
927927
OutContext)));
928928
EmitToStreamer(
929929
MCInstBuilder(AArch64::LDRXui)
930930
.addReg(AArch64::X16)
931931
.addReg(AArch64::X16)
932932
.addExpr(AArch64MCExpr::create(
933-
HwasanTagMismatchRef, AArch64MCExpr::VariantKind::VK_GOT_LO12,
933+
HwasanTagMismatchRef, AArch64MCExpr::Specifier::VK_GOT_LO12,
934934
OutContext)));
935935
EmitToStreamer(MCInstBuilder(AArch64::BR).addReg(AArch64::X16));
936936
}

‎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 {
@@ -3304,12 +3297,12 @@ ParseStatus AArch64AsmParser::tryParseAdrpLabel(OperandVector &Operands) {
33043297
if (parseSymbolicImmVal(Expr))
33053298
return ParseStatus::Failure;
33063299

3307-
AArch64MCExpr::VariantKind ELFRefKind;
3300+
AArch64MCExpr::Specifier ELFSpec;
33083301
MCSymbolRefExpr::VariantKind DarwinRefKind;
33093302
int64_t Addend;
3310-
if (classifySymbolRef(Expr, ELFRefKind, DarwinRefKind, Addend)) {
3303+
if (classifySymbolRef(Expr, ELFSpec, DarwinRefKind, Addend)) {
33113304
if (DarwinRefKind == MCSymbolRefExpr::VK_None &&
3312-
ELFRefKind == AArch64MCExpr::VK_INVALID) {
3305+
ELFSpec == AArch64MCExpr::VK_INVALID) {
33133306
// No modifier was specified at all; this is the syntax for an ELF basic
33143307
// ADRP relocation (unfortunately).
33153308
Expr =
@@ -3321,13 +3314,13 @@ ParseStatus AArch64AsmParser::tryParseAdrpLabel(OperandVector &Operands) {
33213314
} else if (DarwinRefKind != MCSymbolRefExpr::VK_PAGE &&
33223315
DarwinRefKind != MCSymbolRefExpr::VK_GOTPAGE &&
33233316
DarwinRefKind != MCSymbolRefExpr::VK_TLVPPAGE &&
3324-
ELFRefKind != AArch64MCExpr::VK_ABS_PAGE_NC &&
3325-
ELFRefKind != AArch64MCExpr::VK_GOT_PAGE &&
3326-
ELFRefKind != AArch64MCExpr::VK_GOT_AUTH_PAGE &&
3327-
ELFRefKind != AArch64MCExpr::VK_GOT_PAGE_LO15 &&
3328-
ELFRefKind != AArch64MCExpr::VK_GOTTPREL_PAGE &&
3329-
ELFRefKind != AArch64MCExpr::VK_TLSDESC_PAGE &&
3330-
ELFRefKind != AArch64MCExpr::VK_TLSDESC_AUTH_PAGE) {
3317+
ELFSpec != AArch64MCExpr::VK_ABS_PAGE_NC &&
3318+
ELFSpec != AArch64MCExpr::VK_GOT_PAGE &&
3319+
ELFSpec != AArch64MCExpr::VK_GOT_AUTH_PAGE &&
3320+
ELFSpec != AArch64MCExpr::VK_GOT_PAGE_LO15 &&
3321+
ELFSpec != AArch64MCExpr::VK_GOTTPREL_PAGE &&
3322+
ELFSpec != AArch64MCExpr::VK_TLSDESC_PAGE &&
3323+
ELFSpec != AArch64MCExpr::VK_TLSDESC_AUTH_PAGE) {
33313324
// The operand must be an @page or @gotpage qualified symbolref.
33323325
return Error(S, "page or gotpage label reference expected");
33333326
}
@@ -3358,16 +3351,16 @@ ParseStatus AArch64AsmParser::tryParseAdrLabel(OperandVector &Operands) {
33583351
if (parseSymbolicImmVal(Expr))
33593352
return ParseStatus::Failure;
33603353

3361-
AArch64MCExpr::VariantKind ELFRefKind;
3354+
AArch64MCExpr::Specifier ELFSpec;
33623355
MCSymbolRefExpr::VariantKind DarwinRefKind;
33633356
int64_t Addend;
3364-
if (classifySymbolRef(Expr, ELFRefKind, DarwinRefKind, Addend)) {
3357+
if (classifySymbolRef(Expr, ELFSpec, DarwinRefKind, Addend)) {
33653358
if (DarwinRefKind == MCSymbolRefExpr::VK_None &&
3366-
ELFRefKind == AArch64MCExpr::VK_INVALID) {
3359+
ELFSpec == AArch64MCExpr::VK_INVALID) {
33673360
// No modifier was specified at all; this is the syntax for an ELF basic
33683361
// ADR relocation (unfortunately).
33693362
Expr = AArch64MCExpr::create(Expr, AArch64MCExpr::VK_ABS, getContext());
3370-
} else if (ELFRefKind != AArch64MCExpr::VK_GOT_AUTH_PAGE) {
3363+
} else if (ELFSpec != AArch64MCExpr::VK_GOT_AUTH_PAGE) {
33713364
// For tiny code model, we use :got_auth: operator to fill 21-bit imm of
33723365
// adr. It's not actually GOT entry page address but the GOT address
33733366
// itself - we just share the same variant kind with :got_auth: operator
@@ -4408,7 +4401,7 @@ bool AArch64AsmParser::parseRegister(OperandVector &Operands) {
44084401

44094402
bool AArch64AsmParser::parseSymbolicImmVal(const MCExpr *&ImmVal) {
44104403
bool HasELFModifier = false;
4411-
AArch64MCExpr::VariantKind RefKind;
4404+
AArch64MCExpr::Specifier RefKind;
44124405

44134406
if (parseOptionalToken(AsmToken::Colon)) {
44144407
HasELFModifier = true;
@@ -4418,7 +4411,7 @@ bool AArch64AsmParser::parseSymbolicImmVal(const MCExpr *&ImmVal) {
44184411

44194412
std::string LowerCase = getTok().getIdentifier().lower();
44204413
RefKind =
4421-
StringSwitch<AArch64MCExpr::VariantKind>(LowerCase)
4414+
StringSwitch<AArch64MCExpr::Specifier>(LowerCase)
44224415
.Case("lo12", AArch64MCExpr::VK_LO12)
44234416
.Case("abs_g3", AArch64MCExpr::VK_ABS_G3)
44244417
.Case("abs_g2", AArch64MCExpr::VK_ABS_G2)
@@ -5824,10 +5817,10 @@ bool AArch64AsmParser::validateInstruction(MCInst &Inst, SMLoc &IDLoc,
58245817
// some slight duplication here.
58255818
if (Inst.getOperand(2).isExpr()) {
58265819
const MCExpr *Expr = Inst.getOperand(2).getExpr();
5827-
AArch64MCExpr::VariantKind ELFRefKind;
5820+
AArch64MCExpr::Specifier ELFSpec;
58285821
MCSymbolRefExpr::VariantKind DarwinRefKind;
58295822
int64_t Addend;
5830-
if (classifySymbolRef(Expr, ELFRefKind, DarwinRefKind, Addend)) {
5823+
if (classifySymbolRef(Expr, ELFSpec, DarwinRefKind, Addend)) {
58315824

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

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

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

82158203
if (const AArch64MCExpr *AE = dyn_cast<AArch64MCExpr>(Expr)) {
8216-
ELFRefKind = AE->getKind();
8204+
ELFSpec = AE->getSpecifier();
82178205
Expr = AE->getSubExpr();
82188206
}
82198207

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

8233-
// Treat expressions with an ELFRefKind (like ":abs_g1:3", or
8221+
// Treat expressions with an ELFSpec (like ":abs_g1:3", or
82348222
// ":abs_g1:x" where x is constant) as symbolic even if there is no symbol.
8235-
if (!Res.getSymA() && ELFRefKind == AArch64MCExpr::VK_INVALID)
8223+
if (!Res.getSymA() && ELFSpec == AArch64MCExpr::VK_INVALID)
82368224
return false;
82378225

82388226
if (Res.getSymA())
@@ -8241,7 +8229,7 @@ AArch64AsmParser::classifySymbolRef(const MCExpr *Expr,
82418229

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

‎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
@@ -57,8 +57,7 @@ AArch64ELFObjectWriter::AArch64ELFObjectWriter(uint8_t OSABI, bool IsILP32)
5757

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

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

0 commit comments

Comments
 (0)