Skip to content

Commit fe6fb91

Browse files
MaskRayMaskRay
authored
[RISCV] Replace @plt/@gotpcrel in data directives with %pltpcrel %gotpcrel
clang -fexperimental-relative-c++-abi-vtables might generate `@plt` and `@gotpcrel` specifiers in data directives. The syntax is not used in humand-written assembly code, and is not supported by GNU assembler. Note: the `@plt` in `.word foo@plt` is different from the legacy `call func@plt` (where `@plt` is simply ignored). The `@plt` syntax was selected was simply due to a quirk of AsmParser: the syntax was supported by all targets until I updated it to be an opt-in feature in a067175 RISC-V favors the `%specifier(expr)` syntax following MIPS and Sparc, and we should follow this convention. This PR adds support for `.word %pltpcrel(foo+offset)` and `.word %gotpcrel(foo)`, and drops `@plt` and `@gotpcrel`. * MCValue::SymA can no longer have a SymbolVariant. Add an assert similar to that of AArch64ELFObjectWriter.cpp before https://reviews.llvm.org/D81446 (see my analysis at https://maskray.me/blog/2025-03-16-relocation-generation-in-assemblers if intrigued) * `jump foo@plt, x31` now has a different diagnostic. Pull Request: #132569
1 parent 666faa7 commit fe6fb91

31 files changed

+331
-150
lines changed

‎lld/test/ELF/riscv-reloc-plt32.s

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -18,6 +18,6 @@
1818
.globl _start
1919
_start:
2020
.data
21-
.word foo@PLT - .
22-
.word foo@PLT - . + 1
23-
.word foo@PLT - . - 1
21+
.word %pltpcrel(foo)
22+
.word %pltpcrel(foo + 1)
23+
.word %pltpcrel(foo - 1)

‎lld/test/ELF/riscv-undefined-weak.s

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -97,4 +97,4 @@ branch:
9797
# PC-NOT: .plt:
9898
# PLT: .plt:
9999

100-
.word target@plt - .
100+
.word %pltpcrel(target)

‎lld/test/ELF/riscv64-reloc-got32-pcrel.s

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -12,16 +12,16 @@ bar:
1212

1313
.globl _start
1414
_start: // PC = 0x33a8
15-
// bar@GOTPCREL = 0x2398 (got entry for `bar`) - 0x33a8 (.) = 0xf0efffff
16-
// bar@GOTPCREL+4 = 0x2398 (got entry for `bar`) - 0x33ac (.) + 4 = 0xf0efffff
17-
// bar@GOTPCREL-4 = 0x2398 (got entry for `bar`) - 0x33b0 (.) - 4 = 0xe4efffff
15+
// %gotpcrel(bar) = 0x2398 (got entry for `bar`) - 0x33a8 (.) = 0xf0efffff
16+
// %gotpcrel(bar+4) = 0x2398 (got entry for `bar`) - 0x33ac (.) + 4 = 0xf0efffff
17+
// %gotpcrel(bar-4) = 0x2398 (got entry for `bar`) - 0x33b0 (.) - 4 = 0xe4efffff
1818
// CHECK: Contents of section .data:
1919
// CHECK-NEXT: {{.*}} f0efffff f0efffff e4efffff
20-
.word bar@GOTPCREL
21-
.word bar@GOTPCREL+4
22-
.word bar@GOTPCREL-4
20+
.word %gotpcrel(bar)
21+
.word %gotpcrel(bar+4)
22+
.word %gotpcrel(bar-4)
2323

2424
// WARN: relocation R_RISCV_GOT32_PCREL out of range: {{.*}} is not in [-2147483648, 2147483647]; references 'baz'
2525
// WARN: relocation R_RISCV_GOT32_PCREL out of range: {{.*}} is not in [-2147483648, 2147483647]; references 'baz'
26-
.word baz@GOTPCREL+0xffffffff
27-
.word baz@GOTPCREL-0xffffffff
26+
.word %gotpcrel(baz+0xffffffff)
27+
.word %gotpcrel(baz-0xffffffff)

‎llvm/include/llvm/CodeGen/AsmPrinter.h

Lines changed: 4 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -497,7 +497,10 @@ class AsmPrinter : public MachineFunctionPass {
497497
unsigned MaxBytesToEmit = 0) const;
498498

499499
/// Lower the specified LLVM Constant to an MCExpr.
500-
virtual const MCExpr *lowerConstant(const Constant *CV);
500+
/// When BaseCV is present, we are lowering the element at BaseCV plus Offset.
501+
virtual const MCExpr *lowerConstant(const Constant *CV,
502+
const Constant *BaseCV = nullptr,
503+
uint64_t Offset = 0);
501504

502505
/// Print a general LLVM constant to the .s file.
503506
/// On AIX, when an alias refers to a sub-element of a global variable, the

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

Lines changed: 15 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -40,7 +40,6 @@ class TargetLoweringObjectFileELF : public TargetLoweringObjectFile {
4040
uint8_t PLTRelativeSpecifier = 0;
4141

4242
public:
43-
TargetLoweringObjectFileELF();
4443
~TargetLoweringObjectFileELF() override = default;
4544

4645
void Initialize(MCContext &Ctx, const TargetMachine &TM) override;
@@ -112,11 +111,22 @@ class TargetLoweringObjectFileELF : public TargetLoweringObjectFile {
112111
MCSection *getStaticDtorSection(unsigned Priority,
113112
const MCSymbol *KeySym) const override;
114113

114+
virtual const MCExpr *createTargetMCExpr(const MCExpr *Expr,
115+
uint8_t Specifier) const {
116+
return nullptr;
117+
}
118+
const MCExpr *
119+
lowerSymbolDifference(const MCSymbol *LHS, const MCSymbol *RHS,
120+
int64_t Addend,
121+
std::optional<int64_t> PCRelativeOffset) const;
115122
const MCExpr *lowerRelativeReference(const GlobalValue *LHS,
116-
const GlobalValue *RHS,
123+
const GlobalValue *RHS, int64_t Addend,
124+
std::optional<int64_t> PCRelativeOffset,
117125
const TargetMachine &TM) const override;
118126

119-
const MCExpr *lowerDSOLocalEquivalent(const DSOLocalEquivalent *Equiv,
127+
const MCExpr *lowerDSOLocalEquivalent(const MCSymbol *LHS,
128+
const MCSymbol *RHS, int64_t Addend,
129+
std::optional<int64_t> PCRelativeOffset,
120130
const TargetMachine &TM) const override;
121131

122132
MCSection *getSectionForCommandLines() const override;
@@ -206,7 +216,8 @@ class TargetLoweringObjectFileCOFF : public TargetLoweringObjectFile {
206216
const MCSymbol *KeySym) const override;
207217

208218
const MCExpr *lowerRelativeReference(const GlobalValue *LHS,
209-
const GlobalValue *RHS,
219+
const GlobalValue *RHS, int64_t Addend,
220+
std::optional<int64_t> PCRelativeOffset,
210221
const TargetMachine &TM) const override;
211222

212223
/// Given a mergeable constant with the specified size and relocation

‎llvm/include/llvm/MC/MCParser/MCTargetAsmParser.h

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -396,6 +396,12 @@ class MCTargetAsmParser : public MCAsmParserExtension {
396396
virtual bool parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc) {
397397
return getParser().parsePrimaryExpr(Res, EndLoc, nullptr);
398398
}
399+
// Parse an expression in a data directive, possibly with a relocation
400+
// specifier.
401+
virtual bool parseDataExpr(const MCExpr *&Res) {
402+
SMLoc EndLoc;
403+
return getParser().parseExpression(Res, EndLoc);
404+
}
399405

400406
virtual bool parseRegister(MCRegister &Reg, SMLoc &StartLoc,
401407
SMLoc &EndLoc) = 0;

‎llvm/include/llvm/Target/TargetLoweringObjectFile.h

Lines changed: 10 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -51,7 +51,7 @@ class TargetLoweringObjectFile : public MCObjectFileInfo {
5151
bool SupportIndirectSymViaGOTPCRel = false;
5252
bool SupportGOTPCRelWithOffset = true;
5353
bool SupportDebugThreadLocalLocation = true;
54-
bool SupportDSOLocalEquivalentLowering = false;
54+
uint32_t PLTPCRelativeSpecifier = 0;
5555

5656
/// PersonalityEncoding, LSDAEncoding, TTypeEncoding - Some encoding values
5757
/// for EH.
@@ -196,20 +196,19 @@ class TargetLoweringObjectFile : public MCObjectFileInfo {
196196
/// emitting the address in debug info.
197197
virtual const MCExpr *getDebugThreadLocalSymbol(const MCSymbol *Sym) const;
198198

199-
virtual const MCExpr *lowerRelativeReference(const GlobalValue *LHS,
200-
const GlobalValue *RHS,
201-
const TargetMachine &TM) const {
199+
virtual const MCExpr *lowerRelativeReference(
200+
const GlobalValue *LHS, const GlobalValue *RHS, int64_t Addend,
201+
std::optional<int64_t> PCRelativeOffset, const TargetMachine &TM) const {
202202
return nullptr;
203203
}
204204

205-
/// Target supports a native lowering of a dso_local_equivalent constant
206-
/// without needing to replace it with equivalent IR.
207-
bool supportDSOLocalEquivalentLowering() const {
208-
return SupportDSOLocalEquivalentLowering;
209-
}
205+
/// Target supports a PC-relative relocation that references the PLT of a
206+
/// function.
207+
bool hasPLTPCRelative() const { return PLTPCRelativeSpecifier; }
210208

211-
virtual const MCExpr *lowerDSOLocalEquivalent(const DSOLocalEquivalent *Equiv,
212-
const TargetMachine &TM) const {
209+
virtual const MCExpr *lowerDSOLocalEquivalent(
210+
const MCSymbol *LHS, const MCSymbol *RHS, int64_t Addend,
211+
std::optional<int64_t> PCRelativeOffset, const TargetMachine &TM) const {
213212
return nullptr;
214213
}
215214

‎llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

Lines changed: 39 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -3363,7 +3363,9 @@ void AsmPrinter::emitAlignment(Align Alignment, const GlobalObject *GV,
33633363
// Constant emission.
33643364
//===----------------------------------------------------------------------===//
33653365

3366-
const MCExpr *AsmPrinter::lowerConstant(const Constant *CV) {
3366+
const MCExpr *AsmPrinter::lowerConstant(const Constant *CV,
3367+
const Constant *BaseCV,
3368+
uint64_t Offset) {
33673369
MCContext &Ctx = OutContext;
33683370

33693371
if (CV->isNullValue() || isa<UndefValue>(CV))
@@ -3382,7 +3384,8 @@ const MCExpr *AsmPrinter::lowerConstant(const Constant *CV) {
33823384
return lowerBlockAddressConstant(*BA);
33833385

33843386
if (const auto *Equiv = dyn_cast<DSOLocalEquivalent>(CV))
3385-
return getObjFileLowering().lowerDSOLocalEquivalent(Equiv, TM);
3387+
return getObjFileLowering().lowerDSOLocalEquivalent(
3388+
getSymbol(Equiv->getGlobalValue()), nullptr, 0, std::nullopt, TM);
33863389

33873390
if (const NoCFIValue *NC = dyn_cast<NoCFIValue>(CV))
33883391
return MCSymbolRefExpr::create(getSymbol(NC->getGlobalValue()), Ctx);
@@ -3428,7 +3431,7 @@ const MCExpr *AsmPrinter::lowerConstant(const Constant *CV) {
34283431
// is reasonable to treat their delta as a 32-bit value.
34293432
[[fallthrough]];
34303433
case Instruction::BitCast:
3431-
return lowerConstant(CE->getOperand(0));
3434+
return lowerConstant(CE->getOperand(0), BaseCV, Offset);
34323435

34333436
case Instruction::IntToPtr: {
34343437
const DataLayout &DL = getDataLayout();
@@ -3467,33 +3470,42 @@ const MCExpr *AsmPrinter::lowerConstant(const Constant *CV) {
34673470
}
34683471

34693472
case Instruction::Sub: {
3470-
GlobalValue *LHSGV;
3471-
APInt LHSOffset;
3473+
GlobalValue *LHSGV, *RHSGV;
3474+
APInt LHSOffset, RHSOffset;
34723475
DSOLocalEquivalent *DSOEquiv;
34733476
if (IsConstantOffsetFromGlobal(CE->getOperand(0), LHSGV, LHSOffset,
3474-
getDataLayout(), &DSOEquiv)) {
3475-
GlobalValue *RHSGV;
3476-
APInt RHSOffset;
3477-
if (IsConstantOffsetFromGlobal(CE->getOperand(1), RHSGV, RHSOffset,
3478-
getDataLayout())) {
3479-
const MCExpr *RelocExpr =
3480-
getObjFileLowering().lowerRelativeReference(LHSGV, RHSGV, TM);
3481-
if (!RelocExpr) {
3482-
const MCExpr *LHSExpr =
3483-
MCSymbolRefExpr::create(getSymbol(LHSGV), Ctx);
3484-
if (DSOEquiv &&
3485-
getObjFileLowering().supportDSOLocalEquivalentLowering())
3486-
LHSExpr =
3487-
getObjFileLowering().lowerDSOLocalEquivalent(DSOEquiv, TM);
3488-
RelocExpr = MCBinaryExpr::createSub(
3489-
LHSExpr, MCSymbolRefExpr::create(getSymbol(RHSGV), Ctx), Ctx);
3490-
}
3491-
int64_t Addend = (LHSOffset - RHSOffset).getSExtValue();
3477+
getDataLayout(), &DSOEquiv) &&
3478+
IsConstantOffsetFromGlobal(CE->getOperand(1), RHSGV, RHSOffset,
3479+
getDataLayout())) {
3480+
auto *LHSSym = getSymbol(LHSGV);
3481+
auto *RHSSym = getSymbol(RHSGV);
3482+
int64_t Addend = (LHSOffset - RHSOffset).getSExtValue();
3483+
std::optional<int64_t> PCRelativeOffset;
3484+
if (getObjFileLowering().hasPLTPCRelative() && RHSGV == BaseCV)
3485+
PCRelativeOffset = Offset;
3486+
3487+
// Try the generic symbol difference first.
3488+
const MCExpr *Res = getObjFileLowering().lowerRelativeReference(
3489+
LHSGV, RHSGV, Addend, PCRelativeOffset, TM);
3490+
3491+
// (ELF-specific) If the generic symbol difference does not apply, and
3492+
// LHS is a dso_local_equivalent of a dso_preemptable function,
3493+
// reference the PLT entry instead.
3494+
if (DSOEquiv && TM.getTargetTriple().isOSBinFormatELF() &&
3495+
!(LHSGV->isDSOLocal() || LHSGV->isImplicitDSOLocal()))
3496+
Res = getObjFileLowering().lowerDSOLocalEquivalent(
3497+
LHSSym, RHSSym, Addend, PCRelativeOffset, TM);
3498+
3499+
// Otherwise, return LHS-RHS+Addend.
3500+
if (!Res) {
3501+
Res =
3502+
MCBinaryExpr::createSub(MCSymbolRefExpr::create(LHSSym, Ctx),
3503+
MCSymbolRefExpr::create(RHSSym, Ctx), Ctx);
34923504
if (Addend != 0)
3493-
RelocExpr = MCBinaryExpr::createAdd(
3494-
RelocExpr, MCConstantExpr::create(Addend, Ctx), Ctx);
3495-
return RelocExpr;
3505+
Res = MCBinaryExpr::createAdd(
3506+
Res, MCConstantExpr::create(Addend, Ctx), Ctx);
34963507
}
3508+
return Res;
34973509
}
34983510

34993511
const MCExpr *LHS = lowerConstant(CE->getOperand(0));
@@ -4023,7 +4035,7 @@ static void emitGlobalConstantImpl(const DataLayout &DL, const Constant *CV,
40234035

40244036
// Otherwise, it must be a ConstantExpr. Lower it to an MCExpr, then emit it
40254037
// thread the streamer with EmitValue.
4026-
const MCExpr *ME = AP.lowerConstant(CV);
4038+
const MCExpr *ME = AP.lowerConstant(CV, BaseCV, Offset);
40274039

40284040
// Since lowerConstant already folded and got rid of all IR pointer and
40294041
// integer casts, detect GOT equivalent accesses by looking into the MCExpr

‎llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

Lines changed: 51 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -115,10 +115,6 @@ static void GetObjCImageInfo(Module &M, unsigned &Version, unsigned &Flags,
115115
// ELF
116116
//===----------------------------------------------------------------------===//
117117

118-
TargetLoweringObjectFileELF::TargetLoweringObjectFileELF() {
119-
SupportDSOLocalEquivalentLowering = true;
120-
}
121-
122118
void TargetLoweringObjectFileELF::Initialize(MCContext &Ctx,
123119
const TargetMachine &TgtM) {
124120
TargetLoweringObjectFile::Initialize(Ctx, TgtM);
@@ -1174,9 +1170,37 @@ MCSection *TargetLoweringObjectFileELF::getStaticDtorSection(
11741170
KeySym);
11751171
}
11761172

1173+
const MCExpr *TargetLoweringObjectFileELF::lowerSymbolDifference(
1174+
const MCSymbol *LHS, const MCSymbol *RHS, int64_t Addend,
1175+
std::optional<int64_t> PCRelativeOffset) const {
1176+
auto &Ctx = getContext();
1177+
const MCExpr *Res;
1178+
// Return a relocatable expression with the PLT specifier, %plt(GV) or
1179+
// %plt(GV-RHS).
1180+
if (PCRelativeOffset && PLTPCRelativeSpecifier) {
1181+
Res = MCSymbolRefExpr::create(LHS, Ctx);
1182+
// The current location is RHS plus *PCRelativeOffset. Compensate for it.
1183+
Addend += *PCRelativeOffset;
1184+
if (Addend)
1185+
Res = MCBinaryExpr::createAdd(Res, MCConstantExpr::create(Addend, Ctx),
1186+
Ctx);
1187+
return createTargetMCExpr(Res, PLTPCRelativeSpecifier);
1188+
}
1189+
1190+
if (!PLTRelativeSpecifier)
1191+
return nullptr;
1192+
Res = MCBinaryExpr::createSub(
1193+
MCSymbolRefExpr::create(LHS, PLTRelativeSpecifier, Ctx),
1194+
MCSymbolRefExpr::create(RHS, Ctx), Ctx);
1195+
if (Addend)
1196+
Res =
1197+
MCBinaryExpr::createAdd(Res, MCConstantExpr::create(Addend, Ctx), Ctx);
1198+
return Res;
1199+
}
1200+
11771201
const MCExpr *TargetLoweringObjectFileELF::lowerRelativeReference(
1178-
const GlobalValue *LHS, const GlobalValue *RHS,
1179-
const TargetMachine &TM) const {
1202+
const GlobalValue *LHS, const GlobalValue *RHS, int64_t Addend,
1203+
std::optional<int64_t> PCRelativeOffset, const TargetMachine &TM) const {
11801204
// We may only use a PLT-relative relocation to refer to unnamed_addr
11811205
// functions.
11821206
if (!LHS->hasGlobalUnnamedAddr() || !LHS->getValueType()->isFunctionTy())
@@ -1188,24 +1212,22 @@ const MCExpr *TargetLoweringObjectFileELF::lowerRelativeReference(
11881212
RHS->isThreadLocal())
11891213
return nullptr;
11901214

1191-
return MCBinaryExpr::createSub(
1192-
MCSymbolRefExpr::create(TM.getSymbol(LHS), PLTRelativeSpecifier,
1193-
getContext()),
1194-
MCSymbolRefExpr::create(TM.getSymbol(RHS), getContext()), getContext());
1215+
return lowerSymbolDifference(TM.getSymbol(LHS), TM.getSymbol(RHS), Addend,
1216+
PCRelativeOffset);
11951217
}
11961218

1219+
// Reference the PLT entry of a function, optionally with a subtrahend (`RHS`).
11971220
const MCExpr *TargetLoweringObjectFileELF::lowerDSOLocalEquivalent(
1198-
const DSOLocalEquivalent *Equiv, const TargetMachine &TM) const {
1199-
assert(supportDSOLocalEquivalentLowering());
1200-
1201-
const auto *GV = Equiv->getGlobalValue();
1202-
1203-
// A PLT entry is not needed for dso_local globals.
1204-
if (GV->isDSOLocal() || GV->isImplicitDSOLocal())
1205-
return MCSymbolRefExpr::create(TM.getSymbol(GV), getContext());
1206-
1207-
return MCSymbolRefExpr::create(TM.getSymbol(GV), PLTRelativeSpecifier,
1208-
getContext());
1221+
const MCSymbol *LHS, const MCSymbol *RHS, int64_t Addend,
1222+
std::optional<int64_t> PCRelativeOffset, const TargetMachine &TM) const {
1223+
if (RHS)
1224+
return lowerSymbolDifference(LHS, RHS, Addend, PCRelativeOffset);
1225+
1226+
// Only the legacy MCSymbolRefExpr::VariantKind approach is implemented.
1227+
// Reference LHS@plt or LHS@plt - RHS.
1228+
if (PLTRelativeSpecifier)
1229+
return MCSymbolRefExpr::create(LHS, PLTRelativeSpecifier, getContext());
1230+
return nullptr;
12091231
}
12101232

12111233
MCSection *TargetLoweringObjectFileELF::getSectionForCommandLines() const {
@@ -2044,8 +2066,8 @@ MCSection *TargetLoweringObjectFileCOFF::getStaticDtorSection(
20442066
}
20452067

20462068
const MCExpr *TargetLoweringObjectFileCOFF::lowerRelativeReference(
2047-
const GlobalValue *LHS, const GlobalValue *RHS,
2048-
const TargetMachine &TM) const {
2069+
const GlobalValue *LHS, const GlobalValue *RHS, int64_t Addend,
2070+
std::optional<int64_t> PCRelativeOffset, const TargetMachine &TM) const {
20492071
const Triple &T = TM.getTargetTriple();
20502072
if (T.isOSCygMing())
20512073
return nullptr;
@@ -2069,9 +2091,12 @@ const MCExpr *TargetLoweringObjectFileCOFF::lowerRelativeReference(
20692091
cast<GlobalVariable>(RHS)->hasInitializer() || RHS->hasSection())
20702092
return nullptr;
20712093

2072-
return MCSymbolRefExpr::create(TM.getSymbol(LHS),
2073-
MCSymbolRefExpr::VK_COFF_IMGREL32,
2074-
getContext());
2094+
const MCExpr *Res = MCSymbolRefExpr::create(
2095+
TM.getSymbol(LHS), MCSymbolRefExpr::VK_COFF_IMGREL32, getContext());
2096+
if (Addend != 0)
2097+
Res = MCBinaryExpr::createAdd(
2098+
Res, MCConstantExpr::create(Addend, getContext()), getContext());
2099+
return Res;
20752100
}
20762101

20772102
static std::string APIntToHexString(const APInt &AI) {

‎llvm/lib/MC/MCAssembler.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -237,7 +237,7 @@ bool MCAssembler::evaluateFixup(const MCFixup &Fixup, const MCFragment *DF,
237237
// A linker relaxation target may emit ADD/SUB relocations for A-B+C. Let
238238
// recordRelocation handle non-VK_None cases like A@plt-B+C.
239239
if (!IsResolved && Target.getSymA() && Target.getSubSym() &&
240-
Target.getSymA()->getKind() == MCSymbolRefExpr::VK_None &&
240+
Target.getRefKind() == 0 &&
241241
getBackend().handleAddSubRelocations(*this, *DF, Fixup, Target, Value))
242242
return true;
243243

‎llvm/lib/MC/MCParser/AsmParser.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3144,7 +3144,7 @@ bool AsmParser::parseDirectiveValue(StringRef IDVal, unsigned Size) {
31443144
auto parseOp = [&]() -> bool {
31453145
const MCExpr *Value;
31463146
SMLoc ExprLoc = getLexer().getLoc();
3147-
if (checkForValidSection() || parseExpression(Value))
3147+
if (checkForValidSection() || getTargetParser().parseDataExpr(Value))
31483148
return true;
31493149
// Special case constant expressions to match code generator.
31503150
if (const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(Value)) {

0 commit comments

Comments
 (0)