Skip to content

Commit 71884b6

Browse files
MaskRayMaskRay
authored
[AArch64] Transition from MCSymbolRefExpr::VariantKind constants
Shift ELF `@plt` and `@gotpcrel` references in data directives, as well as Mach-O `@specifier` notations, to use `AArch64MCExpr::Specifier` constants. This is a follow-up to #132595. COFF-specific specifiers are not moved yet. In addition, partition @-specifiers into COFF, ELF, and Mach-O, so that mix-and-match is rejected at parse time. ELF and Mach-O specifiers are distinct, with `None` being the only shared value. For Mach-O-specific specifiers, we adopt the `M_xxx` naming convention. Pull Request: #133214
1 parent d59594d commit 71884b6

15 files changed

+157
-118
lines changed

‎llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -37,7 +37,7 @@ class TargetLoweringObjectFileELF : public TargetLoweringObjectFile {
3737
SmallPtrSet<GlobalObject *, 2> Used;
3838

3939
protected:
40-
uint8_t PLTRelativeSpecifier = 0;
40+
uint16_t PLTRelativeSpecifier = 0;
4141

4242
public:
4343
~TargetLoweringObjectFileELF() override = default;

‎llvm/include/llvm/MC/MCAsmInfo.h‎

Lines changed: 4 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -65,10 +65,13 @@ class MCAsmInfo {
6565
/// quote, e.g., `'A`.
6666
};
6767

68-
struct VariantKindDesc {
68+
// This describes a @ style relocation specifier (expr@specifier) supported by
69+
// AsmParser::parsePrimaryExpr.
70+
struct AtSpecifier {
6971
uint32_t Kind;
7072
StringRef Name;
7173
};
74+
using VariantKindDesc = AtSpecifier;
7275

7376
protected:
7477
//===------------------------------------------------------------------===//

‎llvm/include/llvm/MC/MCExpr.h‎

Lines changed: 0 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -198,14 +198,6 @@ class MCSymbolRefExpr : public MCExpr {
198198

199199
VK_GOT,
200200
VK_GOTPCREL,
201-
VK_PLT,
202-
VK_TLVP, // Mach-O thread local variable relocations
203-
VK_TLVPPAGE,
204-
VK_TLVPPAGEOFF,
205-
VK_PAGE,
206-
VK_PAGEOFF,
207-
VK_GOTPAGE,
208-
VK_GOTPAGEOFF,
209201
VK_SECREL,
210202
VK_WEAKREF, // The link between the symbols in .weakref foo, bar
211203

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

Lines changed: 9 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -151,31 +151,32 @@ MCOperand AArch64MCInstLower::lowerSymbolOperandMachO(const MachineOperand &MO,
151151
MCSymbol *Sym) const {
152152
// FIXME: We would like an efficient form for this, so we don't have to do a
153153
// lot of extra uniquing.
154-
MCSymbolRefExpr::VariantKind RefKind = MCSymbolRefExpr::VK_None;
154+
auto Spec = AArch64MCExpr::None;
155155
if ((MO.getTargetFlags() & AArch64II::MO_GOT) != 0) {
156156
if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_PAGE)
157-
RefKind = MCSymbolRefExpr::VK_GOTPAGE;
157+
Spec = AArch64MCExpr::M_GOTPAGE;
158158
else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) ==
159159
AArch64II::MO_PAGEOFF)
160-
RefKind = MCSymbolRefExpr::VK_GOTPAGEOFF;
160+
Spec = AArch64MCExpr::M_GOTPAGEOFF;
161161
else
162162
llvm_unreachable("Unexpected target flags with MO_GOT on GV operand");
163163
} else if ((MO.getTargetFlags() & AArch64II::MO_TLS) != 0) {
164164
if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_PAGE)
165-
RefKind = MCSymbolRefExpr::VK_TLVPPAGE;
165+
Spec = AArch64MCExpr::M_TLVPPAGE;
166166
else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) ==
167167
AArch64II::MO_PAGEOFF)
168-
RefKind = MCSymbolRefExpr::VK_TLVPPAGEOFF;
168+
Spec = AArch64MCExpr::M_TLVPPAGEOFF;
169169
else
170170
llvm_unreachable("Unexpected target flags with MO_TLS on GV operand");
171171
} else {
172172
if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_PAGE)
173-
RefKind = MCSymbolRefExpr::VK_PAGE;
173+
Spec = AArch64MCExpr::M_PAGE;
174174
else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) ==
175175
AArch64II::MO_PAGEOFF)
176-
RefKind = MCSymbolRefExpr::VK_PAGEOFF;
176+
Spec = AArch64MCExpr::M_PAGEOFF;
177177
}
178-
const MCExpr *Expr = MCSymbolRefExpr::create(Sym, RefKind, Ctx);
178+
// TODO: Migrate to AArch64MCExpr::create like ELF.
179+
const MCExpr *Expr = MCSymbolRefExpr::create(Sym, Spec, Ctx);
179180
if (!MO.isJTI() && MO.getOffset())
180181
Expr = MCBinaryExpr::createAdd(
181182
Expr, MCConstantExpr::create(MO.getOffset(), Ctx), Ctx);

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

Lines changed: 6 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -25,6 +25,9 @@ using namespace dwarf;
2525
void AArch64_ELFTargetObjectFile::Initialize(MCContext &Ctx,
2626
const TargetMachine &TM) {
2727
TargetLoweringObjectFileELF::Initialize(Ctx, TM);
28+
PLTRelativeSpecifier = AArch64MCExpr::VK_PLT;
29+
SupportIndirectSymViaGOTPCRel = true;
30+
2831
// AARCH64 ELF ABI does not define static relocation type for TLS offset
2932
// within a module. Do not generate AT_location for TLS variables.
3033
SupportDebugThreadLocalLocation = false;
@@ -58,7 +61,7 @@ const MCExpr *AArch64_ELFTargetObjectFile::getIndirectSymViaGOTPCRel(
5861
int64_t Offset, MachineModuleInfo *MMI, MCStreamer &Streamer) const {
5962
int64_t FinalOffset = Offset + MV.getConstant();
6063
const MCExpr *Res =
61-
MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_GOTPCREL, getContext());
64+
MCSymbolRefExpr::create(Sym, AArch64MCExpr::VK_GOTPCREL, getContext());
6265
const MCExpr *Off = MCConstantExpr::create(FinalOffset, getContext());
6366
return MCBinaryExpr::createAdd(Res, Off, getContext());
6467
}
@@ -77,7 +80,7 @@ const MCExpr *AArch64_MachoTargetObjectFile::getTTypeGlobalReference(
7780
if (Encoding & (DW_EH_PE_indirect | DW_EH_PE_pcrel)) {
7881
const MCSymbol *Sym = TM.getSymbol(GV);
7982
const MCExpr *Res =
80-
MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_GOT, getContext());
83+
MCSymbolRefExpr::create(Sym, AArch64MCExpr::M_GOT, getContext());
8184
MCSymbol *PCSym = getContext().createTempSymbol();
8285
Streamer.emitLabel(PCSym);
8386
const MCExpr *PC = MCSymbolRefExpr::create(PCSym, getContext());
@@ -102,7 +105,7 @@ const MCExpr *AArch64_MachoTargetObjectFile::getIndirectSymViaGOTPCRel(
102105
// On ARM64 Darwin, we can reference symbols with foo@GOT-., which
103106
// is an indirect pc-relative reference.
104107
const MCExpr *Res =
105-
MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_GOT, getContext());
108+
MCSymbolRefExpr::create(Sym, AArch64MCExpr::M_GOT, getContext());
106109
MCSymbol *PCSym = getContext().createTempSymbol();
107110
Streamer.emitLabel(PCSym);
108111
const MCExpr *PC = MCSymbolRefExpr::create(PCSym, getContext());

‎llvm/lib/Target/AArch64/AArch64TargetObjectFile.h‎

Lines changed: 0 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -20,11 +20,6 @@ class AArch64_ELFTargetObjectFile : public TargetLoweringObjectFileELF {
2020
void Initialize(MCContext &Ctx, const TargetMachine &TM) override;
2121

2222
public:
23-
AArch64_ELFTargetObjectFile() {
24-
PLTRelativeSpecifier = MCSymbolRefExpr::VK_PLT;
25-
SupportIndirectSymViaGOTPCRel = true;
26-
}
27-
2823
const MCExpr *getIndirectSymViaGOTPCRel(const GlobalValue *GV,
2924
const MCSymbol *Sym,
3025
const MCValue &MV, int64_t Offset,

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

Lines changed: 37 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -339,7 +339,7 @@ class AArch64AsmParser : public MCTargetAsmParser {
339339

340340
static bool classifySymbolRef(const MCExpr *Expr,
341341
AArch64MCExpr::Specifier &ELFSpec,
342-
MCSymbolRefExpr::VariantKind &DarwinRefKind,
342+
AArch64MCExpr::Specifier &DarwinSpec,
343343
int64_t &Addend);
344344
};
345345

@@ -889,16 +889,16 @@ class AArch64Operand : public MCParsedAsmOperand {
889889

890890
bool isSymbolicUImm12Offset(const MCExpr *Expr) const {
891891
AArch64MCExpr::Specifier ELFSpec;
892-
MCSymbolRefExpr::VariantKind DarwinRefKind;
892+
AArch64MCExpr::Specifier DarwinSpec;
893893
int64_t Addend;
894-
if (!AArch64AsmParser::classifySymbolRef(Expr, ELFSpec, DarwinRefKind,
894+
if (!AArch64AsmParser::classifySymbolRef(Expr, ELFSpec, DarwinSpec,
895895
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

901-
if (DarwinRefKind == MCSymbolRefExpr::VK_PAGEOFF ||
901+
if (DarwinSpec == AArch64MCExpr::M_PAGEOFF ||
902902
llvm::is_contained(
903903
{AArch64MCExpr::VK_LO12, AArch64MCExpr::VK_GOT_LO12,
904904
AArch64MCExpr::VK_GOT_AUTH_LO12, AArch64MCExpr::VK_DTPREL_LO12,
@@ -912,8 +912,8 @@ class AArch64Operand : public MCParsedAsmOperand {
912912
// size when converted, so there is no "out of range" condition when using
913913
// @pageoff.
914914
return true;
915-
} else if (DarwinRefKind == MCSymbolRefExpr::VK_GOTPAGEOFF ||
916-
DarwinRefKind == MCSymbolRefExpr::VK_TLVPPAGEOFF) {
915+
} else if (DarwinSpec == AArch64MCExpr::M_GOTPAGEOFF ||
916+
DarwinSpec == AArch64MCExpr::M_TLVPPAGEOFF) {
917917
// @gotpageoff/@tlvppageoff can only be used directly, not with an addend.
918918
return Addend == 0;
919919
}
@@ -1006,13 +1006,13 @@ class AArch64Operand : public MCParsedAsmOperand {
10061006
}
10071007

10081008
AArch64MCExpr::Specifier ELFSpec;
1009-
MCSymbolRefExpr::VariantKind DarwinRefKind;
1009+
AArch64MCExpr::Specifier DarwinSpec;
10101010
int64_t Addend;
1011-
if (AArch64AsmParser::classifySymbolRef(Expr, ELFSpec, DarwinRefKind,
1011+
if (AArch64AsmParser::classifySymbolRef(Expr, ELFSpec, DarwinSpec,
10121012
Addend)) {
1013-
return DarwinRefKind == MCSymbolRefExpr::VK_PAGEOFF ||
1014-
DarwinRefKind == MCSymbolRefExpr::VK_TLVPPAGEOFF ||
1015-
(DarwinRefKind == MCSymbolRefExpr::VK_GOTPAGEOFF && Addend == 0) ||
1013+
return DarwinSpec == AArch64MCExpr::M_PAGEOFF ||
1014+
DarwinSpec == AArch64MCExpr::M_TLVPPAGEOFF ||
1015+
(DarwinSpec == AArch64MCExpr::M_GOTPAGEOFF && Addend == 0) ||
10161016
llvm::is_contained(
10171017
{AArch64MCExpr::VK_LO12, AArch64MCExpr::VK_GOT_AUTH_LO12,
10181018
AArch64MCExpr::VK_DTPREL_HI12, AArch64MCExpr::VK_DTPREL_LO12,
@@ -1120,13 +1120,13 @@ class AArch64Operand : public MCParsedAsmOperand {
11201120
return false;
11211121

11221122
AArch64MCExpr::Specifier ELFSpec;
1123-
MCSymbolRefExpr::VariantKind DarwinRefKind;
1123+
AArch64MCExpr::Specifier DarwinSpec;
11241124
int64_t Addend;
1125-
if (!AArch64AsmParser::classifySymbolRef(getImm(), ELFSpec, DarwinRefKind,
1125+
if (!AArch64AsmParser::classifySymbolRef(getImm(), ELFSpec, DarwinSpec,
11261126
Addend)) {
11271127
return false;
11281128
}
1129-
if (DarwinRefKind != MCSymbolRefExpr::VK_None)
1129+
if (DarwinSpec != AArch64MCExpr::None)
11301130
return false;
11311131

11321132
return llvm::is_contained(AllowedModifiers, ELFSpec);
@@ -3297,22 +3297,22 @@ ParseStatus AArch64AsmParser::tryParseAdrpLabel(OperandVector &Operands) {
32973297
return ParseStatus::Failure;
32983298

32993299
AArch64MCExpr::Specifier ELFSpec;
3300-
MCSymbolRefExpr::VariantKind DarwinRefKind;
3300+
AArch64MCExpr::Specifier DarwinSpec;
33013301
int64_t Addend;
3302-
if (classifySymbolRef(Expr, ELFSpec, DarwinRefKind, Addend)) {
3303-
if (DarwinRefKind == MCSymbolRefExpr::VK_None &&
3302+
if (classifySymbolRef(Expr, ELFSpec, DarwinSpec, Addend)) {
3303+
if (DarwinSpec == AArch64MCExpr::None &&
33043304
ELFSpec == AArch64MCExpr::VK_INVALID) {
33053305
// No modifier was specified at all; this is the syntax for an ELF basic
33063306
// ADRP relocation (unfortunately).
33073307
Expr =
33083308
AArch64MCExpr::create(Expr, AArch64MCExpr::VK_ABS_PAGE, getContext());
3309-
} else if ((DarwinRefKind == MCSymbolRefExpr::VK_GOTPAGE ||
3310-
DarwinRefKind == MCSymbolRefExpr::VK_TLVPPAGE) &&
3309+
} else if ((DarwinSpec == AArch64MCExpr::M_GOTPAGE ||
3310+
DarwinSpec == AArch64MCExpr::M_TLVPPAGE) &&
33113311
Addend != 0) {
33123312
return Error(S, "gotpage label reference not allowed an addend");
3313-
} else if (DarwinRefKind != MCSymbolRefExpr::VK_PAGE &&
3314-
DarwinRefKind != MCSymbolRefExpr::VK_GOTPAGE &&
3315-
DarwinRefKind != MCSymbolRefExpr::VK_TLVPPAGE &&
3313+
} else if (DarwinSpec != AArch64MCExpr::M_PAGE &&
3314+
DarwinSpec != AArch64MCExpr::M_GOTPAGE &&
3315+
DarwinSpec != AArch64MCExpr::M_TLVPPAGE &&
33163316
ELFSpec != AArch64MCExpr::VK_ABS_PAGE_NC &&
33173317
ELFSpec != AArch64MCExpr::VK_GOT_PAGE &&
33183318
ELFSpec != AArch64MCExpr::VK_GOT_AUTH_PAGE &&
@@ -3351,10 +3351,10 @@ ParseStatus AArch64AsmParser::tryParseAdrLabel(OperandVector &Operands) {
33513351
return ParseStatus::Failure;
33523352

33533353
AArch64MCExpr::Specifier ELFSpec;
3354-
MCSymbolRefExpr::VariantKind DarwinRefKind;
3354+
AArch64MCExpr::Specifier DarwinSpec;
33553355
int64_t Addend;
3356-
if (classifySymbolRef(Expr, ELFSpec, DarwinRefKind, Addend)) {
3357-
if (DarwinRefKind == MCSymbolRefExpr::VK_None &&
3356+
if (classifySymbolRef(Expr, ELFSpec, DarwinSpec, Addend)) {
3357+
if (DarwinSpec == AArch64MCExpr::None &&
33583358
ELFSpec == AArch64MCExpr::VK_INVALID) {
33593359
// No modifier was specified at all; this is the syntax for an ELF basic
33603360
// ADR relocation (unfortunately).
@@ -5817,13 +5817,13 @@ bool AArch64AsmParser::validateInstruction(MCInst &Inst, SMLoc &IDLoc,
58175817
if (Inst.getOperand(2).isExpr()) {
58185818
const MCExpr *Expr = Inst.getOperand(2).getExpr();
58195819
AArch64MCExpr::Specifier ELFSpec;
5820-
MCSymbolRefExpr::VariantKind DarwinRefKind;
5820+
AArch64MCExpr::Specifier DarwinSpec;
58215821
int64_t Addend;
5822-
if (classifySymbolRef(Expr, ELFSpec, DarwinRefKind, Addend)) {
5822+
if (classifySymbolRef(Expr, ELFSpec, DarwinSpec, Addend)) {
58235823

58245824
// Only allow these with ADDXri.
5825-
if ((DarwinRefKind == MCSymbolRefExpr::VK_PAGEOFF ||
5826-
DarwinRefKind == MCSymbolRefExpr::VK_TLVPPAGEOFF) &&
5825+
if ((DarwinSpec == AArch64MCExpr::M_PAGEOFF ||
5826+
DarwinSpec == AArch64MCExpr::M_TLVPPAGEOFF) &&
58275827
Inst.getOpcode() == AArch64::ADDXri)
58285828
return false;
58295829

@@ -8192,11 +8192,12 @@ bool AArch64AsmParser::parseAuthExpr(const MCExpr *&Res, SMLoc &EndLoc) {
81928192
return false;
81938193
}
81948194

8195-
bool AArch64AsmParser::classifySymbolRef(
8196-
const MCExpr *Expr, AArch64MCExpr::Specifier &ELFSpec,
8197-
MCSymbolRefExpr::VariantKind &DarwinRefKind, int64_t &Addend) {
8195+
bool AArch64AsmParser::classifySymbolRef(const MCExpr *Expr,
8196+
AArch64MCExpr::Specifier &ELFSpec,
8197+
AArch64MCExpr::Specifier &DarwinSpec,
8198+
int64_t &Addend) {
81988199
ELFSpec = AArch64MCExpr::VK_INVALID;
8199-
DarwinRefKind = MCSymbolRefExpr::VK_None;
8200+
DarwinSpec = AArch64MCExpr::None;
82008201
Addend = 0;
82018202

82028203
if (const AArch64MCExpr *AE = dyn_cast<AArch64MCExpr>(Expr)) {
@@ -8207,7 +8208,7 @@ bool AArch64AsmParser::classifySymbolRef(
82078208
const MCSymbolRefExpr *SE = dyn_cast<MCSymbolRefExpr>(Expr);
82088209
if (SE) {
82098210
// It's a simple symbol reference with no addend.
8210-
DarwinRefKind = SE->getKind();
8211+
DarwinSpec = AArch64MCExpr::Specifier(SE->getKind());
82118212
return true;
82128213
}
82138214

@@ -8223,13 +8224,13 @@ bool AArch64AsmParser::classifySymbolRef(
82238224
return false;
82248225

82258226
if (Res.getSymA())
8226-
DarwinRefKind = Res.getSymA()->getKind();
8227+
DarwinSpec = AArch64MCExpr::Specifier(Res.getSymA()->getKind());
82278228
Addend = Res.getConstant();
82288229

82298230
// It's some symbol reference + a constant addend, but really
82308231
// shouldn't use both Darwin and ELF syntax.
82318232
return ELFSpec == AArch64MCExpr::VK_INVALID ||
8232-
DarwinRefKind == MCSymbolRefExpr::VK_None;
8233+
DarwinSpec == AArch64MCExpr::None;
82338234
}
82348235

82358236
/// Force static initialization.

‎llvm/lib/Target/AArch64/Disassembler/AArch64ExternalSymbolizer.cpp‎

Lines changed: 13 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -7,6 +7,7 @@
77
//===----------------------------------------------------------------------===//
88

99
#include "AArch64ExternalSymbolizer.h"
10+
#include "MCTargetDesc/AArch64MCExpr.h"
1011
#include "Utils/AArch64BaseInfo.h"
1112
#include "llvm/MC/MCContext.h"
1213
#include "llvm/MC/MCExpr.h"
@@ -19,23 +20,23 @@ using namespace llvm;
1920

2021
#define DEBUG_TYPE "aarch64-disassembler"
2122

22-
static MCSymbolRefExpr::VariantKind
23-
getVariant(uint64_t LLVMDisassembler_VariantKind) {
23+
static AArch64MCExpr::Specifier
24+
getMachOSpecifier(uint64_t LLVMDisassembler_VariantKind) {
2425
switch (LLVMDisassembler_VariantKind) {
2526
case LLVMDisassembler_VariantKind_None:
26-
return MCSymbolRefExpr::VK_None;
27+
return AArch64MCExpr::None;
2728
case LLVMDisassembler_VariantKind_ARM64_PAGE:
28-
return MCSymbolRefExpr::VK_PAGE;
29+
return AArch64MCExpr::M_PAGE;
2930
case LLVMDisassembler_VariantKind_ARM64_PAGEOFF:
30-
return MCSymbolRefExpr::VK_PAGEOFF;
31+
return AArch64MCExpr::M_PAGEOFF;
3132
case LLVMDisassembler_VariantKind_ARM64_GOTPAGE:
32-
return MCSymbolRefExpr::VK_GOTPAGE;
33+
return AArch64MCExpr::M_GOTPAGE;
3334
case LLVMDisassembler_VariantKind_ARM64_GOTPAGEOFF:
34-
return MCSymbolRefExpr::VK_GOTPAGEOFF;
35+
return AArch64MCExpr::M_GOTPAGEOFF;
3536
case LLVMDisassembler_VariantKind_ARM64_TLVP:
36-
return MCSymbolRefExpr::VK_TLVPPAGE;
37+
return AArch64MCExpr::M_TLVPPAGE;
3738
case LLVMDisassembler_VariantKind_ARM64_TLVOFF:
38-
return MCSymbolRefExpr::VK_TLVPPAGEOFF;
39+
return AArch64MCExpr::M_TLVPPAGEOFF;
3940
default:
4041
llvm_unreachable("bad LLVMDisassembler_VariantKind");
4142
}
@@ -170,9 +171,9 @@ bool AArch64ExternalSymbolizer::tryAddingSymbolicOperand(
170171
if (SymbolicOp.AddSymbol.Name) {
171172
StringRef Name(SymbolicOp.AddSymbol.Name);
172173
MCSymbol *Sym = Ctx.getOrCreateSymbol(Name);
173-
MCSymbolRefExpr::VariantKind Variant = getVariant(SymbolicOp.VariantKind);
174-
if (Variant != MCSymbolRefExpr::VK_None)
175-
Add = MCSymbolRefExpr::create(Sym, Variant, Ctx);
174+
auto Spec = getMachOSpecifier(SymbolicOp.VariantKind);
175+
if (Spec != AArch64MCExpr::None)
176+
Add = MCSymbolRefExpr::create(Sym, Spec, Ctx);
176177
else
177178
Add = MCSymbolRefExpr::create(Sym, Ctx);
178179
} else {

0 commit comments

Comments
 (0)