shylie/llvm-project
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

PowerPC: Rename PPCMCExpr::VK_ to PPC::S_

Browse Source 
Prepare for removing PPCMCExpr. Adopt the newer naming convention with
AMDGPU/WebAssembly/VE/M68k.
This commit is contained in:
Fangrui Song 2025-06-15 13:17:22 -07:00
parent 444c6ae530
commit b839632bf4
15 changed files with 459 additions and 470 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
llvm/lib/Target/PowerPC/AsmParser/PPCAsmParser.cpp
View File

@ -745,8 +745,8 @@ public:
return CreateImm(CE->getValue(), S, E, IsPPC64);
if (const MCSymbolRefExpr *SRE = dyn_cast<MCSymbolRefExpr>(Val))
if (getSpecifier(SRE) == PPCMCExpr::VK_TLS ||
getSpecifier(SRE) == PPCMCExpr::VK_TLS_PCREL)
if (getSpecifier(SRE) == PPC::S_TLS ||
getSpecifier(SRE) == PPC::S_TLS_PCREL)
return CreateTLSReg(SRE, S, E, IsPPC64);
if (const PPCMCExpr *TE = dyn_cast<PPCMCExpr>(Val)) {
@ -1378,25 +1378,25 @@ const MCExpr *PPCAsmParser::extractSpecifier(const MCExpr *E,
auto *TE = cast<PPCMCExpr>(E);
Spec = TE->getSpecifier();
(void)extractSpecifier(TE->getSubExpr(), Spec);
Spec = PPCMCExpr::VK_None;
Spec = PPC::S_None;
} break;
case MCExpr::SymbolRef: {
const auto *SRE = cast<MCSymbolRefExpr>(E);
switch (getSpecifier(SRE)) {
case PPCMCExpr::VK_None:
case PPC::S_None:
default:
break;
case PPCMCExpr::VK_LO:
case PPCMCExpr::VK_HI:
case PPCMCExpr::VK_HA:
case PPCMCExpr::VK_HIGH:
case PPCMCExpr::VK_HIGHA:
case PPCMCExpr::VK_HIGHER:
case PPCMCExpr::VK_HIGHERA:
case PPCMCExpr::VK_HIGHEST:
case PPCMCExpr::VK_HIGHESTA:
if (Spec == PPCMCExpr::VK_None)
case PPC::S_LO:
case PPC::S_HI:
case PPC::S_HA:
case PPC::S_HIGH:
case PPC::S_HIGHA:
case PPC::S_HIGHER:
case PPC::S_HIGHERA:
case PPC::S_HIGHEST:
case PPC::S_HIGHESTA:
if (Spec == PPC::S_None)
Spec = getSpecifier(SRE);
else
Error(E->getLoc(), "cannot contain more than one relocation specifier");
@ -1408,7 +1408,7 @@ const MCExpr *PPCAsmParser::extractSpecifier(const MCExpr *E,
case MCExpr::Unary: {
const MCUnaryExpr *UE = cast<MCUnaryExpr>(E);
const MCExpr *Sub = extractSpecifier(UE->getSubExpr(), Spec);
if (Spec != PPCMCExpr::VK_None)
if (Spec != PPC::S_None)
return MCUnaryExpr::create(UE->getOpcode(), Sub, Context);
break;
}
@ -1417,7 +1417,7 @@ const MCExpr *PPCAsmParser::extractSpecifier(const MCExpr *E,
const MCBinaryExpr *BE = cast<MCBinaryExpr>(E);
const MCExpr *LHS = extractSpecifier(BE->getLHS(), Spec);
const MCExpr *RHS = extractSpecifier(BE->getRHS(), Spec);
if (Spec != PPCMCExpr::VK_None)
if (Spec != PPC::S_None)
return MCBinaryExpr::create(BE->getOpcode(), LHS, RHS, Context);
break;
}
@ -1436,9 +1436,9 @@ bool PPCAsmParser::parseExpression(const MCExpr *&EVal) {
if (getParser().parseExpression(EVal))
return true;
uint16_t Spec = PPCMCExpr::VK_None;
uint16_t Spec = PPC::S_None;
const MCExpr *E = extractSpecifier(EVal, Spec);
if (Spec != PPCMCExpr::VK_None)
if (Spec != PPC::S_None)
EVal = PPCMCExpr::create(Spec, E, getParser().getContext());
return false;
@ -1512,9 +1512,9 @@ bool PPCAsmParser::parseOperand(OperandVector &Operands) {
if (!(parseOptionalToken(AsmToken::Identifier) &&
Tok.getString().compare_insensitive("plt") == 0))
return Error(Tok.getLoc(), "expected 'plt'");
EVal = MCSymbolRefExpr::create(
getContext().getOrCreateSymbol(TlsGetAddr),
MCSymbolRefExpr::VariantKind(PPCMCExpr::VK_PLT), getContext());
EVal = MCSymbolRefExpr::create(getContext().getOrCreateSymbol(TlsGetAddr),
MCSymbolRefExpr::VariantKind(PPC::S_PLT),
getContext());
if (parseOptionalToken(AsmToken::Plus)) {
const MCExpr *Addend = nullptr;
SMLoc EndLoc;
@ -1826,15 +1826,15 @@ const MCExpr *PPCAsmParser::applySpecifier(const MCExpr *E, uint32_t Spec,
MCContext &Ctx) {
if (isa<MCConstantExpr>(E)) {
switch (PPCMCExpr::Specifier(Spec)) {
case PPCMCExpr::VK_LO:
case PPCMCExpr::VK_HI:
case PPCMCExpr::VK_HA:
case PPCMCExpr::VK_HIGH:
case PPCMCExpr::VK_HIGHA:
case PPCMCExpr::VK_HIGHER:
case PPCMCExpr::VK_HIGHERA:
case PPCMCExpr::VK_HIGHEST:
case PPCMCExpr::VK_HIGHESTA:
case PPC::S_LO:
case PPC::S_HI:
case PPC::S_HA:
case PPC::S_HIGH:
case PPC::S_HIGHA:
case PPC::S_HIGHER:
case PPC::S_HIGHERA:
case PPC::S_HIGHEST:
case PPC::S_HIGHESTA:
break;
default:
return nullptr;

2
llvm/lib/Target/PowerPC/MCTargetDesc/PPCAsmBackend.cpp
View File

@ -140,7 +140,7 @@ public:
// In PPC64 ELFv1, .quad .TOC.@tocbase in the .opd section is expected to
// reference the null symbol.
auto Target = TargetVal;
if (Target.getSpecifier() == PPCMCExpr::VK_TOCBASE)
if (Target.getSpecifier() == PPC::S_TOCBASE)
Target.setAddSym(nullptr);
return MCAsmBackend::addReloc(F, Fixup, Target, FixedValue, IsResolved);
}

272
llvm/lib/Target/PowerPC/MCTargetDesc/PPCELFObjectWriter.cpp
View File

@ -43,49 +43,49 @@ unsigned PPCELFObjectWriter::getRelocType(const MCFixup &Fixup,
SMLoc Loc = Fixup.getValue()->getLoc();
auto Spec = static_cast<PPCMCExpr::Specifier>(Target.getSpecifier());
switch (Spec) {
case PPCMCExpr::VK_DTPMOD:
case PPCMCExpr::VK_DTPREL:
case PPCMCExpr::VK_DTPREL_HA:
case PPCMCExpr::VK_DTPREL_HI:
case PPCMCExpr::VK_DTPREL_HIGH:
case PPCMCExpr::VK_DTPREL_HIGHA:
case PPCMCExpr::VK_DTPREL_HIGHER:
case PPCMCExpr::VK_DTPREL_HIGHERA:
case PPCMCExpr::VK_DTPREL_HIGHEST:
case PPCMCExpr::VK_DTPREL_HIGHESTA:
case PPCMCExpr::VK_DTPREL_LO:
case PPCMCExpr::VK_GOT_DTPREL:
case PPCMCExpr::VK_GOT_DTPREL_HA:
case PPCMCExpr::VK_GOT_DTPREL_HI:
case PPCMCExpr::VK_GOT_DTPREL_LO:
case PPCMCExpr::VK_GOT_TLSGD:
case PPCMCExpr::VK_GOT_TLSGD_HA:
case PPCMCExpr::VK_GOT_TLSGD_HI:
case PPCMCExpr::VK_GOT_TLSGD_LO:
case PPCMCExpr::VK_GOT_TLSGD_PCREL:
case PPCMCExpr::VK_GOT_TLSLD:
case PPCMCExpr::VK_GOT_TLSLD_HA:
case PPCMCExpr::VK_GOT_TLSLD_HI:
case PPCMCExpr::VK_GOT_TLSLD_LO:
case PPCMCExpr::VK_GOT_TPREL:
case PPCMCExpr::VK_GOT_TPREL_HA:
case PPCMCExpr::VK_GOT_TPREL_HI:
case PPCMCExpr::VK_GOT_TPREL_LO:
case PPCMCExpr::VK_GOT_TPREL_PCREL:
case PPCMCExpr::VK_TLS:
case PPCMCExpr::VK_TLSGD:
case PPCMCExpr::VK_TLSLD:
case PPCMCExpr::VK_TLS_PCREL:
case PPCMCExpr::VK_TPREL:
case PPCMCExpr::VK_TPREL_HA:
case PPCMCExpr::VK_TPREL_HI:
case PPCMCExpr::VK_TPREL_HIGH:
case PPCMCExpr::VK_TPREL_HIGHA:
case PPCMCExpr::VK_TPREL_HIGHER:
case PPCMCExpr::VK_TPREL_HIGHERA:
case PPCMCExpr::VK_TPREL_HIGHEST:
case PPCMCExpr::VK_TPREL_HIGHESTA:
case PPCMCExpr::VK_TPREL_LO:
case PPC::S_DTPMOD:
case PPC::S_DTPREL:
case PPC::S_DTPREL_HA:
case PPC::S_DTPREL_HI:
case PPC::S_DTPREL_HIGH:
case PPC::S_DTPREL_HIGHA:
case PPC::S_DTPREL_HIGHER:
case PPC::S_DTPREL_HIGHERA:
case PPC::S_DTPREL_HIGHEST:
case PPC::S_DTPREL_HIGHESTA:
case PPC::S_DTPREL_LO:
case PPC::S_GOT_DTPREL:
case PPC::S_GOT_DTPREL_HA:
case PPC::S_GOT_DTPREL_HI:
case PPC::S_GOT_DTPREL_LO:
case PPC::S_GOT_TLSGD:
case PPC::S_GOT_TLSGD_HA:
case PPC::S_GOT_TLSGD_HI:
case PPC::S_GOT_TLSGD_LO:
case PPC::S_GOT_TLSGD_PCREL:
case PPC::S_GOT_TLSLD:
case PPC::S_GOT_TLSLD_HA:
case PPC::S_GOT_TLSLD_HI:
case PPC::S_GOT_TLSLD_LO:
case PPC::S_GOT_TPREL:
case PPC::S_GOT_TPREL_HA:
case PPC::S_GOT_TPREL_HI:
case PPC::S_GOT_TPREL_LO:
case PPC::S_GOT_TPREL_PCREL:
case PPC::S_TLS:
case PPC::S_TLSGD:
case PPC::S_TLSLD:
case PPC::S_TLS_PCREL:
case PPC::S_TPREL:
case PPC::S_TPREL_HA:
case PPC::S_TPREL_HI:
case PPC::S_TPREL_HIGH:
case PPC::S_TPREL_HIGHA:
case PPC::S_TPREL_HIGHER:
case PPC::S_TPREL_HIGHERA:
case PPC::S_TPREL_HIGHEST:
case PPC::S_TPREL_HIGHESTA:
case PPC::S_TPREL_LO:
if (auto *SA = Target.getAddSym())
cast<MCSymbolELF>(SA)->setType(ELF::STT_TLS);
break;
@ -106,16 +106,16 @@ unsigned PPCELFObjectWriter::getRelocType(const MCFixup &Fixup,
default:
reportError(Loc, "unsupported relocation type");
break;
case PPCMCExpr::VK_None:
case PPC::S_None:
Type = ELF::R_PPC_REL24;
break;
case PPCMCExpr::VK_PLT:
case PPC::S_PLT:
Type = ELF::R_PPC_PLTREL24;
break;
case PPCMCExpr::VK_LOCAL:
case PPC::S_LOCAL:
Type = ELF::R_PPC_LOCAL24PC;
break;
case PPCMCExpr::VK_NOTOC:
case PPC::S_NOTOC:
Type = ELF::R_PPC64_REL24_NOTOC;
break;
}
@ -129,13 +129,13 @@ unsigned PPCELFObjectWriter::getRelocType(const MCFixup &Fixup,
default:
reportError(Loc, "unsupported relocation type");
return ELF::R_PPC_NONE;
case PPCMCExpr::VK_None:
case PPC::S_None:
return ELF::R_PPC_REL16;
case PPCMCExpr::VK_LO:
case PPC::S_LO:
return ELF::R_PPC_REL16_LO;
case PPCMCExpr::VK_HI:
case PPC::S_HI:
return ELF::R_PPC_REL16_HI;
case PPCMCExpr::VK_HA:
case PPC::S_HA:
return ELF::R_PPC_REL16_HA;
}
break;
@ -148,19 +148,19 @@ unsigned PPCELFObjectWriter::getRelocType(const MCFixup &Fixup,
default:
reportError(Loc, "unsupported relocation type");
break;
case PPCMCExpr::VK_PCREL:
case PPC::S_PCREL:
Type = ELF::R_PPC64_PCREL34;
break;
case PPCMCExpr::VK_GOT_PCREL:
case PPC::S_GOT_PCREL:
Type = ELF::R_PPC64_GOT_PCREL34;
break;
case PPCMCExpr::VK_GOT_TLSGD_PCREL:
case PPC::S_GOT_TLSGD_PCREL:
Type = ELF::R_PPC64_GOT_TLSGD_PCREL34;
break;
case PPCMCExpr::VK_GOT_TLSLD_PCREL:
case PPC::S_GOT_TLSLD_PCREL:
Type = ELF::R_PPC64_GOT_TLSLD_PCREL34;
break;
case PPCMCExpr::VK_GOT_TPREL_PCREL:
case PPC::S_GOT_TPREL_PCREL:
Type = ELF::R_PPC64_GOT_TPREL_PCREL34;
break;
}
@ -186,172 +186,172 @@ unsigned PPCELFObjectWriter::getRelocType(const MCFixup &Fixup,
default:
reportError(Loc, "unsupported relocation type");
break;
case PPCMCExpr::VK_LO:
case PPC::S_LO:
return ELF::R_PPC_ADDR16_LO;
case PPCMCExpr::VK_HI:
case PPC::S_HI:
return ELF::R_PPC_ADDR16_HI;
case PPCMCExpr::VK_HA:
case PPC::S_HA:
return ELF::R_PPC_ADDR16_HA;
case PPCMCExpr::VK_HIGH:
case PPC::S_HIGH:
return ELF::R_PPC64_ADDR16_HIGH;
case PPCMCExpr::VK_HIGHA:
case PPC::S_HIGHA:
return ELF::R_PPC64_ADDR16_HIGHA;
case PPCMCExpr::VK_HIGHER:
case PPC::S_HIGHER:
return ELF::R_PPC64_ADDR16_HIGHER;
case PPCMCExpr::VK_HIGHERA:
case PPC::S_HIGHERA:
return ELF::R_PPC64_ADDR16_HIGHERA;
case PPCMCExpr::VK_HIGHEST:
case PPC::S_HIGHEST:
return ELF::R_PPC64_ADDR16_HIGHEST;
case PPCMCExpr::VK_HIGHESTA:
case PPC::S_HIGHESTA:
return ELF::R_PPC64_ADDR16_HIGHESTA;
case PPCMCExpr::VK_None:
case PPC::S_None:
Type = ELF::R_PPC_ADDR16;
break;
case PPCMCExpr::VK_GOT:
case PPC::S_GOT:
Type = ELF::R_PPC_GOT16;
break;
case PPCMCExpr::VK_GOT_LO:
case PPC::S_GOT_LO:
Type = ELF::R_PPC_GOT16_LO;
break;
case PPCMCExpr::VK_GOT_HI:
case PPC::S_GOT_HI:
Type = ELF::R_PPC_GOT16_HI;
break;
case PPCMCExpr::VK_GOT_HA:
case PPC::S_GOT_HA:
Type = ELF::R_PPC_GOT16_HA;
break;
case PPCMCExpr::VK_TOC:
case PPC::S_TOC:
Type = ELF::R_PPC64_TOC16;
break;
case PPCMCExpr::VK_TOC_LO:
case PPC::S_TOC_LO:
Type = ELF::R_PPC64_TOC16_LO;
break;
case PPCMCExpr::VK_TOC_HI:
case PPC::S_TOC_HI:
Type = ELF::R_PPC64_TOC16_HI;
break;
case PPCMCExpr::VK_TOC_HA:
case PPC::S_TOC_HA:
Type = ELF::R_PPC64_TOC16_HA;
break;
case PPCMCExpr::VK_TPREL:
case PPC::S_TPREL:
Type = ELF::R_PPC_TPREL16;
break;
case PPCMCExpr::VK_TPREL_LO:
case PPC::S_TPREL_LO:
Type = ELF::R_PPC_TPREL16_LO;
break;
case PPCMCExpr::VK_TPREL_HI:
case PPC::S_TPREL_HI:
Type = ELF::R_PPC_TPREL16_HI;
break;
case PPCMCExpr::VK_TPREL_HA:
case PPC::S_TPREL_HA:
Type = ELF::R_PPC_TPREL16_HA;
break;
case PPCMCExpr::VK_TPREL_HIGH:
case PPC::S_TPREL_HIGH:
Type = ELF::R_PPC64_TPREL16_HIGH;
break;
case PPCMCExpr::VK_TPREL_HIGHA:
case PPC::S_TPREL_HIGHA:
Type = ELF::R_PPC64_TPREL16_HIGHA;
break;
case PPCMCExpr::VK_TPREL_HIGHER:
case PPC::S_TPREL_HIGHER:
Type = ELF::R_PPC64_TPREL16_HIGHER;
break;
case PPCMCExpr::VK_TPREL_HIGHERA:
case PPC::S_TPREL_HIGHERA:
Type = ELF::R_PPC64_TPREL16_HIGHERA;
break;
case PPCMCExpr::VK_TPREL_HIGHEST:
case PPC::S_TPREL_HIGHEST:
Type = ELF::R_PPC64_TPREL16_HIGHEST;
break;
case PPCMCExpr::VK_TPREL_HIGHESTA:
case PPC::S_TPREL_HIGHESTA:
Type = ELF::R_PPC64_TPREL16_HIGHESTA;
break;
case PPCMCExpr::VK_DTPREL:
case PPC::S_DTPREL:
Type = ELF::R_PPC64_DTPREL16;
break;
case PPCMCExpr::VK_DTPREL_LO:
case PPC::S_DTPREL_LO:
Type = ELF::R_PPC64_DTPREL16_LO;
break;
case PPCMCExpr::VK_DTPREL_HI:
case PPC::S_DTPREL_HI:
Type = ELF::R_PPC64_DTPREL16_HI;
break;
case PPCMCExpr::VK_DTPREL_HA:
case PPC::S_DTPREL_HA:
Type = ELF::R_PPC64_DTPREL16_HA;
break;
case PPCMCExpr::VK_DTPREL_HIGH:
case PPC::S_DTPREL_HIGH:
Type = ELF::R_PPC64_DTPREL16_HIGH;
break;
case PPCMCExpr::VK_DTPREL_HIGHA:
case PPC::S_DTPREL_HIGHA:
Type = ELF::R_PPC64_DTPREL16_HIGHA;
break;
case PPCMCExpr::VK_DTPREL_HIGHER:
case PPC::S_DTPREL_HIGHER:
Type = ELF::R_PPC64_DTPREL16_HIGHER;
break;
case PPCMCExpr::VK_DTPREL_HIGHERA:
case PPC::S_DTPREL_HIGHERA:
Type = ELF::R_PPC64_DTPREL16_HIGHERA;
break;
case PPCMCExpr::VK_DTPREL_HIGHEST:
case PPC::S_DTPREL_HIGHEST:
Type = ELF::R_PPC64_DTPREL16_HIGHEST;
break;
case PPCMCExpr::VK_DTPREL_HIGHESTA:
case PPC::S_DTPREL_HIGHESTA:
Type = ELF::R_PPC64_DTPREL16_HIGHESTA;
break;
case PPCMCExpr::VK_GOT_TLSGD:
case PPC::S_GOT_TLSGD:
if (is64Bit())
Type = ELF::R_PPC64_GOT_TLSGD16;
else
Type = ELF::R_PPC_GOT_TLSGD16;
break;
case PPCMCExpr::VK_GOT_TLSGD_LO:
case PPC::S_GOT_TLSGD_LO:
Type = ELF::R_PPC64_GOT_TLSGD16_LO;
break;
case PPCMCExpr::VK_GOT_TLSGD_HI:
case PPC::S_GOT_TLSGD_HI:
Type = ELF::R_PPC64_GOT_TLSGD16_HI;
break;
case PPCMCExpr::VK_GOT_TLSGD_HA:
case PPC::S_GOT_TLSGD_HA:
Type = ELF::R_PPC64_GOT_TLSGD16_HA;
break;
case PPCMCExpr::VK_GOT_TLSLD:
case PPC::S_GOT_TLSLD:
if (is64Bit())
Type = ELF::R_PPC64_GOT_TLSLD16;
else
Type = ELF::R_PPC_GOT_TLSLD16;
break;
case PPCMCExpr::VK_GOT_TLSLD_LO:
case PPC::S_GOT_TLSLD_LO:
Type = ELF::R_PPC64_GOT_TLSLD16_LO;
break;
case PPCMCExpr::VK_GOT_TLSLD_HI:
case PPC::S_GOT_TLSLD_HI:
Type = ELF::R_PPC64_GOT_TLSLD16_HI;
break;
case PPCMCExpr::VK_GOT_TLSLD_HA:
case PPC::S_GOT_TLSLD_HA:
Type = ELF::R_PPC64_GOT_TLSLD16_HA;
break;
case PPCMCExpr::VK_GOT_TPREL:
case PPC::S_GOT_TPREL:
/* We don't have R_PPC64_GOT_TPREL16, but since GOT offsets
are always 4-aligned, we can use R_PPC64_GOT_TPREL16_DS. */
Type = ELF::R_PPC64_GOT_TPREL16_DS;
break;
case PPCMCExpr::VK_GOT_TPREL_LO:
case PPC::S_GOT_TPREL_LO:
/* We don't have R_PPC64_GOT_TPREL16_LO, but since GOT offsets
are always 4-aligned, we can use R_PPC64_GOT_TPREL16_LO_DS. */
Type = ELF::R_PPC64_GOT_TPREL16_LO_DS;
break;
case PPCMCExpr::VK_GOT_TPREL_HI:
case PPC::S_GOT_TPREL_HI:
Type = ELF::R_PPC64_GOT_TPREL16_HI;
break;
case PPCMCExpr::VK_GOT_DTPREL:
case PPC::S_GOT_DTPREL:
/* We don't have R_PPC64_GOT_DTPREL16, but since GOT offsets
are always 4-aligned, we can use R_PPC64_GOT_DTPREL16_DS. */
Type = ELF::R_PPC64_GOT_DTPREL16_DS;
break;
case PPCMCExpr::VK_GOT_DTPREL_LO:
case PPC::S_GOT_DTPREL_LO:
/* We don't have R_PPC64_GOT_DTPREL16_LO, but since GOT offsets
are always 4-aligned, we can use R_PPC64_GOT_DTPREL16_LO_DS. */
Type = ELF::R_PPC64_GOT_DTPREL16_LO_DS;
break;
case PPCMCExpr::VK_GOT_TPREL_HA:
case PPC::S_GOT_TPREL_HA:
Type = ELF::R_PPC64_GOT_TPREL16_HA;
break;
case PPCMCExpr::VK_GOT_DTPREL_HI:
case PPC::S_GOT_DTPREL_HI:
Type = ELF::R_PPC64_GOT_DTPREL16_HI;
break;
case PPCMCExpr::VK_GOT_DTPREL_HA:
case PPC::S_GOT_DTPREL_HA:
Type = ELF::R_PPC64_GOT_DTPREL16_HA;
break;
}
@ -362,45 +362,45 @@ unsigned PPCELFObjectWriter::getRelocType(const MCFixup &Fixup,
default:
reportError(Loc, "unsupported relocation type");
break;
case PPCMCExpr::VK_LO:
case PPC::S_LO:
return ELF::R_PPC64_ADDR16_LO_DS;
case PPCMCExpr::VK_None:
case PPC::S_None:
Type = ELF::R_PPC64_ADDR16_DS;
break;
case PPCMCExpr::VK_GOT:
case PPC::S_GOT:
Type = ELF::R_PPC64_GOT16_DS;
break;
case PPCMCExpr::VK_GOT_LO:
case PPC::S_GOT_LO:
Type = ELF::R_PPC64_GOT16_LO_DS;
break;
case PPCMCExpr::VK_TOC:
case PPC::S_TOC:
Type = ELF::R_PPC64_TOC16_DS;
break;
case PPCMCExpr::VK_TOC_LO:
case PPC::S_TOC_LO:
Type = ELF::R_PPC64_TOC16_LO_DS;
break;
case PPCMCExpr::VK_TPREL:
case PPC::S_TPREL:
Type = ELF::R_PPC64_TPREL16_DS;
break;
case PPCMCExpr::VK_TPREL_LO:
case PPC::S_TPREL_LO:
Type = ELF::R_PPC64_TPREL16_LO_DS;
break;
case PPCMCExpr::VK_DTPREL:
case PPC::S_DTPREL:
Type = ELF::R_PPC64_DTPREL16_DS;
break;
case PPCMCExpr::VK_DTPREL_LO:
case PPC::S_DTPREL_LO:
Type = ELF::R_PPC64_DTPREL16_LO_DS;
break;
case PPCMCExpr::VK_GOT_TPREL:
case PPC::S_GOT_TPREL:
Type = ELF::R_PPC64_GOT_TPREL16_DS;
break;
case PPCMCExpr::VK_GOT_TPREL_LO:
case PPC::S_GOT_TPREL_LO:
Type = ELF::R_PPC64_GOT_TPREL16_LO_DS;
break;
case PPCMCExpr::VK_GOT_DTPREL:
case PPC::S_GOT_DTPREL:
Type = ELF::R_PPC64_GOT_DTPREL16_DS;
break;
case PPCMCExpr::VK_GOT_DTPREL_LO:
case PPC::S_GOT_DTPREL_LO:
Type = ELF::R_PPC64_GOT_DTPREL16_LO_DS;
break;
}
@ -410,25 +410,25 @@ unsigned PPCELFObjectWriter::getRelocType(const MCFixup &Fixup,
default:
reportError(Loc, "unsupported relocation type");
break;
case PPCMCExpr::VK_TLSGD:
case PPC::S_TLSGD:
if (is64Bit())
Type = ELF::R_PPC64_TLSGD;
else
Type = ELF::R_PPC_TLSGD;
break;
case PPCMCExpr::VK_TLSLD:
case PPC::S_TLSLD:
if (is64Bit())
Type = ELF::R_PPC64_TLSLD;
else
Type = ELF::R_PPC_TLSLD;
break;
case PPCMCExpr::VK_TLS:
case PPC::S_TLS:
if (is64Bit())
Type = ELF::R_PPC64_TLS;
else
Type = ELF::R_PPC_TLS;
break;
case PPCMCExpr::VK_TLS_PCREL:
case PPC::S_TLS_PCREL:
Type = ELF::R_PPC64_TLS;
break;
}
@ -438,10 +438,10 @@ unsigned PPCELFObjectWriter::getRelocType(const MCFixup &Fixup,
default:
reportError(Loc, "unsupported relocation type");
break;
case PPCMCExpr::VK_DTPREL:
case PPC::S_DTPREL:
Type = ELF::R_PPC64_DTPREL34;
break;
case PPCMCExpr::VK_TPREL:
case PPC::S_TPREL:
Type = ELF::R_PPC64_TPREL34;
break;
}
@ -451,26 +451,26 @@ unsigned PPCELFObjectWriter::getRelocType(const MCFixup &Fixup,
default:
reportError(Loc, "unsupported relocation type");
break;
case PPCMCExpr::VK_TOCBASE:
case PPC::S_TOCBASE:
Type = ELF::R_PPC64_TOC;
break;
case PPCMCExpr::VK_None:
case PPC::S_None:
Type = ELF::R_PPC64_ADDR64;
break;
case PPCMCExpr::VK_DTPMOD:
case PPC::S_DTPMOD:
Type = ELF::R_PPC64_DTPMOD64;
break;
case PPCMCExpr::VK_TPREL:
case PPC::S_TPREL:
Type = ELF::R_PPC64_TPREL64;
break;
case PPCMCExpr::VK_DTPREL:
case PPC::S_DTPREL:
Type = ELF::R_PPC64_DTPREL64;
break;
}
break;
case FK_Data_4:
switch (Spec) {
case PPCMCExpr::VK_DTPREL:
case PPC::S_DTPREL:
Type = ELF::R_PPC_DTPREL32;
break;
default:

8
llvm/lib/Target/PowerPC/MCTargetDesc/PPCELFStreamer.cpp
View File

@ -139,7 +139,7 @@ void PPCELFStreamer::emitGOTToPCRelReloc(const MCInst &Inst) {
// Cast the last operand to MCSymbolRefExpr to get the symbol.
const MCExpr *Expr = Operand.getExpr();
const MCSymbolRefExpr *SymExpr = static_cast<const MCSymbolRefExpr *>(Expr);
assert(getSpecifier(SymExpr) == PPCMCExpr::VK_PCREL_OPT &&
assert(getSpecifier(SymExpr) == PPC::S_PCREL_OPT &&
"Expecting a symbol of type VK_PCREL_OPT");
MCSymbol *LabelSym =
getContext().getOrCreateSymbol(SymExpr->getSymbol().getName());
@ -174,7 +174,7 @@ void PPCELFStreamer::emitGOTToPCRelLabel(const MCInst &Inst) {
// Cast the last operand to MCSymbolRefExpr to get the symbol.
const MCExpr *Expr = Operand.getExpr();
const MCSymbolRefExpr *SymExpr = static_cast<const MCSymbolRefExpr *>(Expr);
assert(getSpecifier(SymExpr) == PPCMCExpr::VK_PCREL_OPT &&
assert(getSpecifier(SymExpr) == PPC::S_PCREL_OPT &&
"Expecting a symbol of type VK_PCREL_OPT");
MCSymbol *LabelSym =
getContext().getOrCreateSymbol(SymExpr->getSymbol().getName());
@ -190,7 +190,7 @@ void PPCELFStreamer::emitGOTToPCRelLabel(const MCInst &Inst) {
// The above is a pair of such instructions and this function will not return
// std::nullopt for either one of them. In both cases we are looking for the
// last operand <MCOperand Expr:(.Lpcrel@<<invalid>>)> which needs to be an
// MCExpr and has the flag PPCMCExpr::VK_PCREL_OPT. After that we just
// MCExpr and has the flag PPC::S_PCREL_OPT. After that we just
// look at the opcode and in the case of PLDpc we will return true. For the load
// (or store) this function will return false indicating it has found the second
// instruciton in the pair.
@ -212,7 +212,7 @@ std::optional<bool> llvm::isPartOfGOTToPCRelPair(const MCInst &Inst,
// Check for the variant kind VK_PCREL_OPT in this expression.
const MCExpr *Expr = Operand.getExpr();
const MCSymbolRefExpr *SymExpr = static_cast<const MCSymbolRefExpr *>(Expr);
if (!SymExpr || getSpecifier(SymExpr) != PPCMCExpr::VK_PCREL_OPT)
if (!SymExpr || getSpecifier(SymExpr) != PPC::S_PCREL_OPT)
return std::nullopt;
return (Inst.getOpcode() == PPC::PLDpc);

8
llvm/lib/Target/PowerPC/MCTargetDesc/PPCInstPrinter.cpp
View File

@ -92,7 +92,7 @@ void PPCInstPrinter::printInst(const MCInst *MI, uint64_t Address,
const MCSymbolRefExpr *SymExpr =
static_cast<const MCSymbolRefExpr *>(Expr);
if (SymExpr && getSpecifier(SymExpr) == PPCMCExpr::VK_PCREL_OPT) {
if (SymExpr && getSpecifier(SymExpr) == PPC::S_PCREL_OPT) {
const MCSymbol &Symbol = SymExpr->getSymbol();
if (MI->getOpcode() == PPC::PLDpc) {
printInstruction(MI, Address, STI, O);
@ -579,13 +579,13 @@ void PPCInstPrinter::printTLSCall(const MCInst *MI, unsigned OpNo,
// because we do not want the assembly to print out the @notoc at the
// end like __tls_get_addr(x@tlsgd)@notoc. Instead we want it to look
// like __tls_get_addr@notoc(x@tlsgd).
if (getSpecifier(RefExp) == PPCMCExpr::VK_NOTOC)
if (getSpecifier(RefExp) == PPC::S_NOTOC)
O << '@' << MAI.getSpecifierName(RefExp->getKind());
O << '(';
printOperand(MI, OpNo + 1, STI, O);
O << ')';
if (getSpecifier(RefExp) != PPCMCExpr::VK_None &&
getSpecifier(RefExp) != PPCMCExpr::VK_NOTOC)
if (getSpecifier(RefExp) != PPC::S_None &&
getSpecifier(RefExp) != PPC::S_NOTOC)
O << '@' << MAI.getSpecifierName(RefExp->getKind());
if (Rhs) {
SmallString<0> Buf;

152
llvm/lib/Target/PowerPC/MCTargetDesc/PPCMCAsmInfo.cpp
View File

@ -20,82 +20,82 @@ using namespace llvm;
void PPCELFMCAsmInfo::anchor() { }
const MCAsmInfo::VariantKindDesc variantKindDescs[] = {
{PPCMCExpr::VK_DTPREL, "DTPREL"},
{PPCMCExpr::VK_GOT, "GOT"},
{PPCMCExpr::VK_GOT_HA, "got@ha"},
{PPCMCExpr::VK_GOT_HI, "got@h"},
{PPCMCExpr::VK_GOT_LO, "got@l"},
{PPCMCExpr::VK_HA, "ha"},
{PPCMCExpr::VK_HI, "h"},
{PPCMCExpr::VK_HIGH, "high"},
{PPCMCExpr::VK_HIGHA, "higha"},
{PPCMCExpr::VK_HIGHER, "higher"},
{PPCMCExpr::VK_HIGHERA, "highera"},
{PPCMCExpr::VK_HIGHEST, "highest"},
{PPCMCExpr::VK_HIGHESTA, "highesta"},
{PPCMCExpr::VK_LO, "l"},
{PPCMCExpr::VK_L, "l"}, // FIXME: share the name with VK_LO
{PPCMCExpr::VK_PCREL, "PCREL"},
{PPCMCExpr::VK_PLT, "PLT"},
{PPCMCExpr::VK_TLSGD, "tlsgd"},
{PPCMCExpr::VK_TLSLD, "tlsld"},
{PPCMCExpr::VK_TOC, "toc"},
{PPCMCExpr::VK_TOCBASE, "tocbase"},
{PPCMCExpr::VK_TOC_HA, "toc@ha"},
{PPCMCExpr::VK_TOC_HI, "toc@h"},
{PPCMCExpr::VK_TOC_LO, "toc@l"},
{PPCMCExpr::VK_TPREL, "TPREL"},
{PPCMCExpr::VK_AIX_TLSGD, "gd"},
{PPCMCExpr::VK_AIX_TLSGDM, "m"},
{PPCMCExpr::VK_AIX_TLSIE, "ie"},
{PPCMCExpr::VK_AIX_TLSLD, "ld"},
{PPCMCExpr::VK_AIX_TLSLE, "le"},
{PPCMCExpr::VK_AIX_TLSML, "ml"},
{PPCMCExpr::VK_DTPMOD, "dtpmod"},
{PPCMCExpr::VK_DTPREL_HA, "dtprel@ha"},
{PPCMCExpr::VK_DTPREL_HI, "dtprel@h"},
{PPCMCExpr::VK_DTPREL_HIGH, "dtprel@high"},
{PPCMCExpr::VK_DTPREL_HIGHA, "dtprel@higha"},
{PPCMCExpr::VK_DTPREL_HIGHER, "dtprel@higher"},
{PPCMCExpr::VK_DTPREL_HIGHERA, "dtprel@highera"},
{PPCMCExpr::VK_DTPREL_HIGHEST, "dtprel@highest"},
{PPCMCExpr::VK_DTPREL_HIGHESTA, "dtprel@highesta"},
{PPCMCExpr::VK_DTPREL_LO, "dtprel@l"},
{PPCMCExpr::VK_GOT_DTPREL, "got@dtprel"},
{PPCMCExpr::VK_GOT_DTPREL_HA, "got@dtprel@ha"},
{PPCMCExpr::VK_GOT_DTPREL_HI, "got@dtprel@h"},
{PPCMCExpr::VK_GOT_DTPREL_LO, "got@dtprel@l"},
{PPCMCExpr::VK_GOT_PCREL, "got@pcrel"},
{PPCMCExpr::VK_GOT_TLSGD, "got@tlsgd"},
{PPCMCExpr::VK_GOT_TLSGD_HA, "got@tlsgd@ha"},
{PPCMCExpr::VK_GOT_TLSGD_HI, "got@tlsgd@h"},
{PPCMCExpr::VK_GOT_TLSGD_LO, "got@tlsgd@l"},
{PPCMCExpr::VK_GOT_TLSGD_PCREL, "got@tlsgd@pcrel"},
{PPCMCExpr::VK_GOT_TLSLD, "got@tlsld"},
{PPCMCExpr::VK_GOT_TLSLD_HA, "got@tlsld@ha"},
{PPCMCExpr::VK_GOT_TLSLD_HI, "got@tlsld@h"},
{PPCMCExpr::VK_GOT_TLSLD_LO, "got@tlsld@l"},
{PPCMCExpr::VK_GOT_TLSLD_PCREL, "got@tlsld@pcrel"},
{PPCMCExpr::VK_GOT_TPREL, "got@tprel"},
{PPCMCExpr::VK_GOT_TPREL_HA, "got@tprel@ha"},
{PPCMCExpr::VK_GOT_TPREL_HI, "got@tprel@h"},
{PPCMCExpr::VK_GOT_TPREL_LO, "got@tprel@l"},
{PPCMCExpr::VK_GOT_TPREL_PCREL, "got@tprel@pcrel"},
{PPCMCExpr::VK_LOCAL, "local"},
{PPCMCExpr::VK_NOTOC, "notoc"},
{PPCMCExpr::VK_PCREL_OPT, "<<invalid>>"},
{PPCMCExpr::VK_TLS, "tls"},
{PPCMCExpr::VK_TLS_PCREL, "tls@pcrel"},
{PPCMCExpr::VK_TPREL_HA, "tprel@ha"},
{PPCMCExpr::VK_TPREL_HI, "tprel@h"},
{PPCMCExpr::VK_TPREL_HIGH, "tprel@high"},
{PPCMCExpr::VK_TPREL_HIGHA, "tprel@higha"},
{PPCMCExpr::VK_TPREL_HIGHER, "tprel@higher"},
{PPCMCExpr::VK_TPREL_HIGHERA, "tprel@highera"},
{PPCMCExpr::VK_TPREL_HIGHEST, "tprel@highest"},
{PPCMCExpr::VK_TPREL_HIGHESTA, "tprel@highesta"},
{PPCMCExpr::VK_TPREL_LO, "tprel@l"},
{PPCMCExpr::VK_U, "u"},
{PPC::S_DTPREL, "DTPREL"},
{PPC::S_GOT, "GOT"},
{PPC::S_GOT_HA, "got@ha"},
{PPC::S_GOT_HI, "got@h"},
{PPC::S_GOT_LO, "got@l"},
{PPC::S_HA, "ha"},
{PPC::S_HI, "h"},
{PPC::S_HIGH, "high"},
{PPC::S_HIGHA, "higha"},
{PPC::S_HIGHER, "higher"},
{PPC::S_HIGHERA, "highera"},
{PPC::S_HIGHEST, "highest"},
{PPC::S_HIGHESTA, "highesta"},
{PPC::S_LO, "l"},
{PPC::S_L, "l"}, // FIXME: share the name with VK_LO
{PPC::S_PCREL, "PCREL"},
{PPC::S_PLT, "PLT"},
{PPC::S_TLSGD, "tlsgd"},
{PPC::S_TLSLD, "tlsld"},
{PPC::S_TOC, "toc"},
{PPC::S_TOCBASE, "tocbase"},
{PPC::S_TOC_HA, "toc@ha"},
{PPC::S_TOC_HI, "toc@h"},
{PPC::S_TOC_LO, "toc@l"},
{PPC::S_TPREL, "TPREL"},
{PPC::S_AIX_TLSGD, "gd"},
{PPC::S_AIX_TLSGDM, "m"},
{PPC::S_AIX_TLSIE, "ie"},
{PPC::S_AIX_TLSLD, "ld"},
{PPC::S_AIX_TLSLE, "le"},
{PPC::S_AIX_TLSML, "ml"},
{PPC::S_DTPMOD, "dtpmod"},
{PPC::S_DTPREL_HA, "dtprel@ha"},
{PPC::S_DTPREL_HI, "dtprel@h"},
{PPC::S_DTPREL_HIGH, "dtprel@high"},
{PPC::S_DTPREL_HIGHA, "dtprel@higha"},
{PPC::S_DTPREL_HIGHER, "dtprel@higher"},
{PPC::S_DTPREL_HIGHERA, "dtprel@highera"},
{PPC::S_DTPREL_HIGHEST, "dtprel@highest"},
{PPC::S_DTPREL_HIGHESTA, "dtprel@highesta"},
{PPC::S_DTPREL_LO, "dtprel@l"},
{PPC::S_GOT_DTPREL, "got@dtprel"},
{PPC::S_GOT_DTPREL_HA, "got@dtprel@ha"},
{PPC::S_GOT_DTPREL_HI, "got@dtprel@h"},
{PPC::S_GOT_DTPREL_LO, "got@dtprel@l"},
{PPC::S_GOT_PCREL, "got@pcrel"},
{PPC::S_GOT_TLSGD, "got@tlsgd"},
{PPC::S_GOT_TLSGD_HA, "got@tlsgd@ha"},
{PPC::S_GOT_TLSGD_HI, "got@tlsgd@h"},
{PPC::S_GOT_TLSGD_LO, "got@tlsgd@l"},
{PPC::S_GOT_TLSGD_PCREL, "got@tlsgd@pcrel"},
{PPC::S_GOT_TLSLD, "got@tlsld"},
{PPC::S_GOT_TLSLD_HA, "got@tlsld@ha"},
{PPC::S_GOT_TLSLD_HI, "got@tlsld@h"},
{PPC::S_GOT_TLSLD_LO, "got@tlsld@l"},
{PPC::S_GOT_TLSLD_PCREL, "got@tlsld@pcrel"},
{PPC::S_GOT_TPREL, "got@tprel"},
{PPC::S_GOT_TPREL_HA, "got@tprel@ha"},
{PPC::S_GOT_TPREL_HI, "got@tprel@h"},
{PPC::S_GOT_TPREL_LO, "got@tprel@l"},
{PPC::S_GOT_TPREL_PCREL, "got@tprel@pcrel"},
{PPC::S_LOCAL, "local"},
{PPC::S_NOTOC, "notoc"},
{PPC::S_PCREL_OPT, "<<invalid>>"},
{PPC::S_TLS, "tls"},
{PPC::S_TLS_PCREL, "tls@pcrel"},
{PPC::S_TPREL_HA, "tprel@ha"},
{PPC::S_TPREL_HI, "tprel@h"},
{PPC::S_TPREL_HIGH, "tprel@high"},
{PPC::S_TPREL_HIGHA, "tprel@higha"},
{PPC::S_TPREL_HIGHER, "tprel@higher"},
{PPC::S_TPREL_HIGHERA, "tprel@highera"},
{PPC::S_TPREL_HIGHEST, "tprel@highest"},
{PPC::S_TPREL_HIGHESTA, "tprel@highesta"},
{PPC::S_TPREL_LO, "tprel@l"},
{PPC::S_U, "u"},
};
PPCELFMCAsmInfo::PPCELFMCAsmInfo(bool is64Bit, const Triple& T) {

84
llvm/lib/Target/PowerPC/MCTargetDesc/PPCMCAsmInfo.h
View File

@ -33,6 +33,90 @@ public:
explicit PPCXCOFFMCAsmInfo(bool is64Bit, const Triple &);
};
namespace PPC {
enum Specifier {
S_None,
S_LO,
S_HI,
S_HA,
S_HIGH,
S_HIGHA,
S_HIGHER,
S_HIGHERA,
S_HIGHEST,
S_HIGHESTA,
S_AIX_TLSGD, // symbol@gd
S_AIX_TLSGDM, // symbol@m
S_AIX_TLSIE, // symbol@ie
S_AIX_TLSLD, // symbol@ld
S_AIX_TLSLE, // symbol@le
S_AIX_TLSML, // symbol@ml
S_DTPMOD, // symbol@dtpmod
S_DTPREL, // symbol@dprel
S_DTPREL_HA, // symbol@dtprel@ha
S_DTPREL_HI, // symbol@dtprel@h
S_DTPREL_HIGH, // symbol@dtprel@high
S_DTPREL_HIGHA, // symbol@dtprel@higha
S_DTPREL_HIGHER, // symbol@dtprel@higher
S_DTPREL_HIGHERA, // symbol@dtprel@highera
S_DTPREL_HIGHEST, // symbol@dtprel@highest
S_DTPREL_HIGHESTA, // symbol@dtprel@highesta
S_DTPREL_LO, // symbol@dtprel@l
S_GOT, // symbol@got
S_GOT_DTPREL, // symbol@got@dtprel
S_GOT_DTPREL_HA, // symbol@got@dtprel@ha
S_GOT_DTPREL_HI, // symbol@got@dtprel@h
S_GOT_DTPREL_LO, // symbol@got@dtprel@l
S_GOT_HA, // symbol@got@ha
S_GOT_HI, // symbol@got@h
S_GOT_LO, // symbol@got@l
S_GOT_PCREL, // symbol@got@pcrel
S_GOT_TLSGD, // symbol@got@tlsgd
S_GOT_TLSGD_HA, // symbol@got@tlsgd@ha
S_GOT_TLSGD_HI, // symbol@got@tlsgd@h
S_GOT_TLSGD_LO, // symbol@got@tlsgd@l
S_GOT_TLSGD_PCREL, // symbol@got@tlsgd@pcrel
S_GOT_TLSLD, // symbol@got@tlsld
S_GOT_TLSLD_HA, // symbol@got@tlsld@ha
S_GOT_TLSLD_HI, // symbol@got@tlsld@h
S_GOT_TLSLD_LO, // symbol@got@tlsld@l
S_GOT_TLSLD_PCREL, // symbol@got@tlsld@pcrel
S_GOT_TPREL, // symbol@got@tprel
S_GOT_TPREL_HA, // symbol@got@tprel@ha
S_GOT_TPREL_HI, // symbol@got@tprel@h
S_GOT_TPREL_LO, // symbol@got@tprel@l
S_GOT_TPREL_PCREL, // symbol@got@tprel@pcrel
S_L, // symbol@l
S_LOCAL, // symbol@local
S_NOTOC, // symbol@notoc
S_PCREL,
S_PCREL_OPT, // .reloc expr, R_PPC64_PCREL_OPT, expr
S_PLT, // symbol@plt
S_TLS, // symbol@tls
S_TLSGD, // symbol@tlsgd
S_TLSLD, // symbol@tlsld
S_TLS_PCREL, // symbol@tls@pcrel
S_TOC, // symbol@toc
S_TOCBASE, // symbol@tocbase
S_TOC_HA, // symbol@toc@ha
S_TOC_HI, // symbol@toc@h
S_TOC_LO, // symbol@toc@l
S_TPREL, // symbol@tprel
S_TPREL_HA, // symbol@tprel@ha
S_TPREL_HI, // symbol@tprel@h
S_TPREL_HIGH, // symbol@tprel@high
S_TPREL_HIGHA, // symbol@tprel@higha
S_TPREL_HIGHER, // symbol@tprel@higher
S_TPREL_HIGHERA, // symbol@tprel@highera
S_TPREL_HIGHEST, // symbol@tprel@highest
S_TPREL_HIGHESTA, // symbol@tprel@highesta
S_TPREL_LO, // symbol@tprel@l
S_U, // symbol@u
};
}
} // namespace llvm
#endif

16
llvm/lib/Target/PowerPC/MCTargetDesc/PPCMCCodeEmitter.cpp
View File

@ -329,11 +329,11 @@ PPCMCCodeEmitter::getDispRI34PCRelEncoding(const MCInst &MI, unsigned OpNo,
const MCSymbolRefExpr *SRE = cast<MCSymbolRefExpr>(Expr);
(void)SRE;
// Currently these are the only valid PCRelative Relocations.
assert((getSpecifier(SRE) == PPCMCExpr::VK_PCREL ||
getSpecifier(SRE) == PPCMCExpr::VK_GOT_PCREL ||
getSpecifier(SRE) == PPCMCExpr::VK_GOT_TLSGD_PCREL ||
getSpecifier(SRE) == PPCMCExpr::VK_GOT_TLSLD_PCREL ||
getSpecifier(SRE) == PPCMCExpr::VK_GOT_TPREL_PCREL) &&
assert((getSpecifier(SRE) == PPC::S_PCREL ||
getSpecifier(SRE) == PPC::S_GOT_PCREL ||
getSpecifier(SRE) == PPC::S_GOT_TLSGD_PCREL ||
getSpecifier(SRE) == PPC::S_GOT_TLSLD_PCREL ||
getSpecifier(SRE) == PPC::S_GOT_TPREL_PCREL) &&
"VariantKind must be VK_PCREL or VK_GOT_PCREL or "
"VK_GOT_TLSGD_PCREL or VK_GOT_TLSLD_PCREL or "
"VK_GOT_TPREL_PCREL.");
@ -368,8 +368,8 @@ PPCMCCodeEmitter::getDispRI34PCRelEncoding(const MCInst &MI, unsigned OpNo,
"Value must fit in 34 bits.");
// Currently these are the only valid PCRelative Relocations.
assert((getSpecifier(SRE) == PPCMCExpr::VK_PCREL ||
getSpecifier(SRE) == PPCMCExpr::VK_GOT_PCREL) &&
assert((getSpecifier(SRE) == PPC::S_PCREL ||
getSpecifier(SRE) == PPC::S_GOT_PCREL) &&
"VariantKind must be VK_PCREL or VK_GOT_PCREL");
// Generate the fixup for the relocation.
Fixups.push_back(
@ -433,7 +433,7 @@ unsigned PPCMCCodeEmitter::getTLSRegEncoding(const MCInst &MI, unsigned OpNo,
// if using PC relative memops.
const MCExpr *Expr = MO.getExpr();
const MCSymbolRefExpr *SRE = cast<MCSymbolRefExpr>(Expr);
bool IsPCRel = getSpecifier(SRE) == PPCMCExpr::VK_TLS_PCREL;
bool IsPCRel = getSpecifier(SRE) == PPC::S_TLS_PCREL;
Fixups.push_back(MCFixup::create(IsPCRel ? 1 : 0, Expr,
(MCFixupKind)PPC::fixup_ppc_nofixup));
const Triple &TT = STI.getTargetTriple();

23
llvm/lib/Target/PowerPC/MCTargetDesc/PPCMCExpr.cpp
View File

@ -21,6 +21,11 @@ const PPCMCExpr *PPCMCExpr::create(Specifier S, const MCExpr *Expr,
return new (Ctx) PPCMCExpr(S, Expr);
}
const PPCMCExpr *PPCMCExpr::create(const MCExpr *Expr, Specifier S,
MCContext &Ctx) {
return new (Ctx) PPCMCExpr(S, Expr);
}
void PPCMCExpr::printImpl(raw_ostream &OS, const MCAsmInfo *MAI) const {
getSubExpr()->print(OS, MAI);
OS << '@' << MAI->getSpecifierName(specifier);
@ -44,23 +49,23 @@ PPCMCExpr::evaluateAsConstant(int64_t &Res) const {
std::optional<int64_t> PPCMCExpr::evaluateAsInt64(int64_t Value) const {
switch (specifier) {
case VK_LO:
case PPC::S_LO:
return Value & 0xffff;
case VK_HI:
case PPC::S_HI:
return (Value >> 16) & 0xffff;
case VK_HA:
case PPC::S_HA:
return ((Value + 0x8000) >> 16) & 0xffff;
case VK_HIGH:
case PPC::S_HIGH:
return (Value >> 16) & 0xffff;
case VK_HIGHA:
case PPC::S_HIGHA:
return ((Value + 0x8000) >> 16) & 0xffff;
case VK_HIGHER:
case PPC::S_HIGHER:
return (Value >> 32) & 0xffff;
case VK_HIGHERA:
case PPC::S_HIGHERA:
return ((Value + 0x8000) >> 32) & 0xffff;
case VK_HIGHEST:
case PPC::S_HIGHEST:
return (Value >> 48) & 0xffff;
case VK_HIGHESTA:
case PPC::S_HIGHESTA:
return ((Value + 0x8000) >> 48) & 0xffff;
default:
return {};

96
llvm/lib/Target/PowerPC/MCTargetDesc/PPCMCExpr.h
View File

@ -9,6 +9,7 @@
#ifndef LLVM_LIB_TARGET_POWERPC_MCTARGETDESC_PPCMCEXPR_H
#define LLVM_LIB_TARGET_POWERPC_MCTARGETDESC_PPCMCEXPR_H
#include "PPCMCAsmInfo.h"
#include "llvm/MC/MCExpr.h"
#include "llvm/MC/MCValue.h"
#include <optional>
@ -18,87 +19,6 @@ namespace llvm {
class PPCMCExpr : public MCSpecifierExpr {
public:
using Specifier = uint16_t;
enum {
VK_None,
VK_LO = MCSymbolRefExpr::FirstTargetSpecifier,
VK_HI,
VK_HA,
VK_HIGH,
VK_HIGHA,
VK_HIGHER,
VK_HIGHERA,
VK_HIGHEST,
VK_HIGHESTA,
VK_AIX_TLSGD, // symbol@gd
VK_AIX_TLSGDM, // symbol@m
VK_AIX_TLSIE, // symbol@ie
VK_AIX_TLSLD, // symbol@ld
VK_AIX_TLSLE, // symbol@le
VK_AIX_TLSML, // symbol@ml
VK_DTPMOD, // symbol@dtpmod
VK_DTPREL, // symbol@dprel
VK_DTPREL_HA, // symbol@dtprel@ha
VK_DTPREL_HI, // symbol@dtprel@h
VK_DTPREL_HIGH, // symbol@dtprel@high
VK_DTPREL_HIGHA, // symbol@dtprel@higha
VK_DTPREL_HIGHER, // symbol@dtprel@higher
VK_DTPREL_HIGHERA, // symbol@dtprel@highera
VK_DTPREL_HIGHEST, // symbol@dtprel@highest
VK_DTPREL_HIGHESTA, // symbol@dtprel@highesta
VK_DTPREL_LO, // symbol@dtprel@l
VK_GOT, // symbol@got
VK_GOT_DTPREL, // symbol@got@dtprel
VK_GOT_DTPREL_HA, // symbol@got@dtprel@ha
VK_GOT_DTPREL_HI, // symbol@got@dtprel@h
VK_GOT_DTPREL_LO, // symbol@got@dtprel@l
VK_GOT_HA, // symbol@got@ha
VK_GOT_HI, // symbol@got@h
VK_GOT_LO, // symbol@got@l
VK_GOT_PCREL, // symbol@got@pcrel
VK_GOT_TLSGD, // symbol@got@tlsgd
VK_GOT_TLSGD_HA, // symbol@got@tlsgd@ha
VK_GOT_TLSGD_HI, // symbol@got@tlsgd@h
VK_GOT_TLSGD_LO, // symbol@got@tlsgd@l
VK_GOT_TLSGD_PCREL, // symbol@got@tlsgd@pcrel
VK_GOT_TLSLD, // symbol@got@tlsld
VK_GOT_TLSLD_HA, // symbol@got@tlsld@ha
VK_GOT_TLSLD_HI, // symbol@got@tlsld@h
VK_GOT_TLSLD_LO, // symbol@got@tlsld@l
VK_GOT_TLSLD_PCREL, // symbol@got@tlsld@pcrel
VK_GOT_TPREL, // symbol@got@tprel
VK_GOT_TPREL_HA, // symbol@got@tprel@ha
VK_GOT_TPREL_HI, // symbol@got@tprel@h
VK_GOT_TPREL_LO, // symbol@got@tprel@l
VK_GOT_TPREL_PCREL, // symbol@got@tprel@pcrel
VK_L, // symbol@l
VK_LOCAL, // symbol@local
VK_NOTOC, // symbol@notoc
VK_PCREL,
VK_PCREL_OPT, // .reloc expr, R_PPC64_PCREL_OPT, expr
VK_PLT, // symbol@plt
VK_TLS, // symbol@tls
VK_TLSGD, // symbol@tlsgd
VK_TLSLD, // symbol@tlsld
VK_TLS_PCREL, // symbol@tls@pcrel
VK_TOC, // symbol@toc
VK_TOCBASE, // symbol@tocbase
VK_TOC_HA, // symbol@toc@ha
VK_TOC_HI, // symbol@toc@h
VK_TOC_LO, // symbol@toc@l
VK_TPREL, // symbol@tprel
VK_TPREL_HA, // symbol@tprel@ha
VK_TPREL_HI, // symbol@tprel@h
VK_TPREL_HIGH, // symbol@tprel@high
VK_TPREL_HIGHA, // symbol@tprel@higha
VK_TPREL_HIGHER, // symbol@tprel@higher
VK_TPREL_HIGHERA, // symbol@tprel@highera
VK_TPREL_HIGHEST, // symbol@tprel@highest
VK_TPREL_HIGHESTA, // symbol@tprel@highesta
VK_TPREL_LO, // symbol@tprel@l
VK_U, // symbol@u
};
private:
std::optional<int64_t> evaluateAsInt64(int64_t Value) const;
@ -109,18 +29,8 @@ private:
public:
static const PPCMCExpr *create(Specifier S, const MCExpr *Expr,
MCContext &Ctx);
static const PPCMCExpr *createLo(const MCExpr *Expr, MCContext &Ctx) {
return create(VK_LO, Expr, Ctx);
}
static const PPCMCExpr *createHi(const MCExpr *Expr, MCContext &Ctx) {
return create(VK_HI, Expr, Ctx);
}
static const PPCMCExpr *createHa(const MCExpr *Expr, MCContext &Ctx) {
return create(VK_HA, Expr, Ctx);
}
static const PPCMCExpr *create(const MCExpr *Expr, Specifier S,
MCContext &Ctx);
void printImpl(raw_ostream &OS, const MCAsmInfo *MAI) const override;
bool evaluateAsRelocatableImpl(MCValue &Res,

6
llvm/lib/Target/PowerPC/MCTargetDesc/PPCMCTargetDesc.cpp
View File

@ -221,9 +221,9 @@ public:
// variables. Finally for local-exec and initial-exec, we have a thread
// pointer, in r13 for 64-bit mode and returned by .__get_tpointer for
// 32-bit mode.
if (Kind == PPCMCExpr::VK_AIX_TLSGD || Kind == PPCMCExpr::VK_AIX_TLSGDM ||
Kind == PPCMCExpr::VK_AIX_TLSIE || Kind == PPCMCExpr::VK_AIX_TLSLE ||
Kind == PPCMCExpr::VK_AIX_TLSLD || Kind == PPCMCExpr::VK_AIX_TLSML)
if (Kind == PPC::S_AIX_TLSGD || Kind == PPC::S_AIX_TLSGDM ||
Kind == PPC::S_AIX_TLSIE || Kind == PPC::S_AIX_TLSLE ||
Kind == PPC::S_AIX_TLSLD || Kind == PPC::S_AIX_TLSML)
OS << "\t.tc " << TCSym->getName() << "," << XSym->getName() << "@"
<< getContext().getAsmInfo()->getSpecifierName(Kind) << '\n';
else

34
llvm/lib/Target/PowerPC/MCTargetDesc/PPCXCOFFObjectWriter.cpp
View File

@ -61,15 +61,15 @@ std::pair<uint8_t, uint8_t> PPCXCOFFObjectWriter::getRelocTypeAndSignSize(
switch (Specifier) {
default:
report_fatal_error("Unsupported modifier for half16 fixup.");
case PPCMCExpr::VK_None:
case PPC::S_None:
return {XCOFF::RelocationType::R_TOC, SignAndSizeForHalf16};
case PPCMCExpr::VK_U:
case PPC::S_U:
return {XCOFF::RelocationType::R_TOCU, SignAndSizeForHalf16};
case PPCMCExpr::VK_L:
case PPC::S_L:
return {XCOFF::RelocationType::R_TOCL, SignAndSizeForHalf16};
case PPCMCExpr::VK_AIX_TLSLE:
case PPC::S_AIX_TLSLE:
return {XCOFF::RelocationType::R_TLS_LE, SignAndSizeForHalf16};
case PPCMCExpr::VK_AIX_TLSLD:
case PPC::S_AIX_TLSLD:
return {XCOFF::RelocationType::R_TLS_LD, SignAndSizeForHalf16};
}
} break;
@ -80,13 +80,13 @@ std::pair<uint8_t, uint8_t> PPCXCOFFObjectWriter::getRelocTypeAndSignSize(
switch (Specifier) {
default:
llvm_unreachable("Unsupported Modifier");
case PPCMCExpr::VK_None:
case PPC::S_None:
return {XCOFF::RelocationType::R_TOC, 15};
case PPCMCExpr::VK_L:
case PPC::S_L:
return {XCOFF::RelocationType::R_TOCL, 15};
case PPCMCExpr::VK_AIX_TLSLE:
case PPC::S_AIX_TLSLE:
return {XCOFF::RelocationType::R_TLS_LE, 15};
case PPCMCExpr::VK_AIX_TLSLD:
case PPC::S_AIX_TLSLD:
return {XCOFF::RelocationType::R_TLS_LD, 15};
}
} break;
@ -97,7 +97,7 @@ std::pair<uint8_t, uint8_t> PPCXCOFFObjectWriter::getRelocTypeAndSignSize(
case PPC::fixup_ppc_br24abs:
return {XCOFF::RelocationType::R_RBA, EncodedSignednessIndicator | 25};
case PPC::fixup_ppc_nofixup: {
if (Specifier == PPCMCExpr::VK_None)
if (Specifier == PPC::S_None)
return {XCOFF::RelocationType::R_REF, 0};
else
llvm_unreachable("Unsupported Modifier");
@ -110,19 +110,19 @@ std::pair<uint8_t, uint8_t> PPCXCOFFObjectWriter::getRelocTypeAndSignSize(
switch (Specifier) {
default:
report_fatal_error("Unsupported modifier");
case PPCMCExpr::VK_AIX_TLSGD:
case PPC::S_AIX_TLSGD:
return {XCOFF::RelocationType::R_TLS, SignAndSizeForFKData};
case PPCMCExpr::VK_AIX_TLSGDM:
case PPC::S_AIX_TLSGDM:
return {XCOFF::RelocationType::R_TLSM, SignAndSizeForFKData};
case PPCMCExpr::VK_AIX_TLSIE:
case PPC::S_AIX_TLSIE:
return {XCOFF::RelocationType::R_TLS_IE, SignAndSizeForFKData};
case PPCMCExpr::VK_AIX_TLSLE:
case PPC::S_AIX_TLSLE:
return {XCOFF::RelocationType::R_TLS_LE, SignAndSizeForFKData};
case PPCMCExpr::VK_AIX_TLSLD:
case PPC::S_AIX_TLSLD:
return {XCOFF::RelocationType::R_TLS_LD, SignAndSizeForFKData};
case PPCMCExpr::VK_AIX_TLSML:
case PPC::S_AIX_TLSML:
return {XCOFF::RelocationType::R_TLSML, SignAndSizeForFKData};
case PPCMCExpr::VK_None:
case PPC::S_None:
return {XCOFF::RelocationType::R_POS, SignAndSizeForFKData};
}
}

118
llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp
View File

@ -108,9 +108,9 @@ template <>
struct DenseMapInfo<std::pair<const MCSymbol *, PPCMCExpr::Specifier>> {
using TOCKey = std::pair<const MCSymbol *, PPCMCExpr::Specifier>;
static inline TOCKey getEmptyKey() { return {nullptr, PPCMCExpr::VK_None}; }
static inline TOCKey getEmptyKey() { return {nullptr, PPC::S_None}; }
static inline TOCKey getTombstoneKey() {
return {(const MCSymbol *)1, PPCMCExpr::VK_None};
return {(const MCSymbol *)1, PPC::S_None};
}
static unsigned getHashValue(const TOCKey &PairVal) {
return detail::combineHashValue(
@ -174,9 +174,8 @@ public:
TOCType_EHBlock
};
MCSymbol *
lookUpOrCreateTOCEntry(const MCSymbol *Sym, TOCEntryType Type,
PPCMCExpr::Specifier Kind = PPCMCExpr::VK_None);
MCSymbol *lookUpOrCreateTOCEntry(const MCSymbol *Sym, TOCEntryType Type,
PPCMCExpr::Specifier Kind = PPC::S_None);
bool doInitialization(Module &M) override {
if (!TOC.empty())
@ -691,13 +690,13 @@ void PPCAsmPrinter::EmitAIXTlsCallHelper(const MachineInstr *MI) {
/// the current output stream.
void PPCAsmPrinter::emitTlsCall(const MachineInstr *MI,
PPCMCExpr::Specifier VK) {
PPCMCExpr::Specifier Kind = PPCMCExpr::VK_None;
PPCMCExpr::Specifier Kind = PPC::S_None;
unsigned Opcode = PPC::BL8_NOP_TLS;
assert(MI->getNumOperands() >= 3 && "Expecting at least 3 operands from MI");
if (MI->getOperand(2).getTargetFlags() == PPCII::MO_GOT_TLSGD_PCREL_FLAG ||
MI->getOperand(2).getTargetFlags() == PPCII::MO_GOT_TLSLD_PCREL_FLAG) {
Kind = PPCMCExpr::VK_NOTOC;
Kind = PPC::S_NOTOC;
Opcode = PPC::BL8_NOTOC_TLS;
}
const Module *M = MF->getFunction().getParent();
@ -730,13 +729,13 @@ void PPCAsmPrinter::emitTlsCall(const MachineInstr *MI,
MCSymbol *TlsGetAddr = OutContext.getOrCreateSymbol("__tls_get_addr");
if (Subtarget->is32BitELFABI() && isPositionIndependent())
Kind = PPCMCExpr::VK_PLT;
Kind = PPC::S_PLT;
const MCExpr *TlsRef = MCSymbolRefExpr::create(
TlsGetAddr, MCSymbolRefExpr::VariantKind(Kind), OutContext);
// Add 32768 offset to the symbol so we follow up the latest GOT/PLT ABI.
if (Kind == PPCMCExpr::VK_PLT && Subtarget->isSecurePlt() &&
if (Kind == PPC::S_PLT && Subtarget->isSecurePlt() &&
M->getPICLevel() == PICLevel::BigPIC)
TlsRef = MCBinaryExpr::createAdd(
TlsRef, MCConstantExpr::create(32768, OutContext), OutContext);
@ -861,7 +860,7 @@ void PPCAsmPrinter::emitInstruction(const MachineInstr *MI) {
auto getTOCEntryLoadingExprForXCOFF =
[IsPPC64, getTOCRelocAdjustedExprForXCOFF,
this](const MCSymbol *MOSymbol, const MCExpr *Expr,
PPCMCExpr::Specifier VK = PPCMCExpr::VK_None) -> const MCExpr * {
PPCMCExpr::Specifier VK = PPC::S_None) -> const MCExpr * {
const unsigned EntryByteSize = IsPPC64 ? 8 : 4;
const auto TOCEntryIter = TOC.find({MOSymbol, VK});
assert(TOCEntryIter != TOC.end() &&
@ -886,9 +885,9 @@ void PPCAsmPrinter::emitInstruction(const MachineInstr *MI) {
assert(MO.isGlobal() && "Only expecting a global MachineOperand here!\n");
TLSModel::Model Model = TM.getTLSModel(MO.getGlobal());
if (Model == TLSModel::LocalExec)
return PPCMCExpr::VK_AIX_TLSLE;
return PPC::S_AIX_TLSLE;
if (Model == TLSModel::InitialExec)
return PPCMCExpr::VK_AIX_TLSIE;
return PPC::S_AIX_TLSIE;
// On AIX, TLS model opt may have turned local-dynamic accesses into
// initial-exec accesses.
PPCFunctionInfo *FuncInfo = MF->getInfo<PPCFunctionInfo>();
@ -896,7 +895,7 @@ void PPCAsmPrinter::emitInstruction(const MachineInstr *MI) {
FuncInfo->isAIXFuncUseTLSIEForLD()) {
LLVM_DEBUG(
dbgs() << "Current function uses IE access for default LD vars.\n");
return PPCMCExpr::VK_AIX_TLSIE;
return PPC::S_AIX_TLSIE;
}
llvm_unreachable("Only expecting local-exec or initial-exec accesses!");
}
@ -904,17 +903,17 @@ void PPCAsmPrinter::emitInstruction(const MachineInstr *MI) {
// the variable offset and the other for the region handle). They are
// differentiated by MO_TLSGD_FLAG and MO_TLSGDM_FLAG.
if (Flag == PPCII::MO_TLSGDM_FLAG)
return PPCMCExpr::VK_AIX_TLSGDM;
return PPC::S_AIX_TLSGDM;
if (Flag == PPCII::MO_TLSGD_FLAG || Flag == PPCII::MO_GOT_TLSGD_PCREL_FLAG)
return PPCMCExpr::VK_AIX_TLSGD;
return PPC::S_AIX_TLSGD;
// For local-dynamic TLS access on AIX, we have one TOC entry for the symbol
// (the variable offset) and one shared TOC entry for the module handle.
// They are differentiated by MO_TLSLD_FLAG and MO_TLSLDM_FLAG.
if (Flag == PPCII::MO_TLSLD_FLAG && IsAIX)
return PPCMCExpr::VK_AIX_TLSLD;
return PPC::S_AIX_TLSLD;
if (Flag == PPCII::MO_TLSLDM_FLAG && IsAIX)
return PPCMCExpr::VK_AIX_TLSML;
return PPCMCExpr::VK_None;
return PPC::S_AIX_TLSML;
return PPC::S_None;
};
// Lower multi-instruction pseudo operations.
@ -955,8 +954,7 @@ void PPCAsmPrinter::emitInstruction(const MachineInstr *MI) {
OutContext.getOrCreateSymbol(StringRef("_GLOBAL_OFFSET_TABLE_"));
const MCExpr *OffsExpr = MCBinaryExpr::createSub(
MCSymbolRefExpr::create(
GOTSymbol, MCSymbolRefExpr::VariantKind(PPCMCExpr::VK_LOCAL),
OutContext),
GOTSymbol, MCSymbolRefExpr::VariantKind(PPC::S_LOCAL), OutContext),
MCConstantExpr::create(4, OutContext), OutContext);
// Emit the 'bl'.
@ -1002,12 +1000,14 @@ void PPCAsmPrinter::emitInstruction(const MachineInstr *MI) {
const MCExpr *DeltaExpr = MCBinaryExpr::createSub(
MCSymbolRefExpr::create(BaseSymbol, OutContext), PB, OutContext);
const MCExpr *DeltaHi = PPCMCExpr::createHa(DeltaExpr, OutContext);
const MCExpr *DeltaHi =
PPCMCExpr::create(DeltaExpr, PPC::S_HA, OutContext);
EmitToStreamer(
*OutStreamer,
MCInstBuilder(PPC::ADDIS).addReg(PICR).addReg(PICR).addExpr(DeltaHi));
const MCExpr *DeltaLo = PPCMCExpr::createLo(DeltaExpr, OutContext);
const MCExpr *DeltaLo =
PPCMCExpr::create(DeltaExpr, PPC::S_LO, OutContext);
EmitToStreamer(
*OutStreamer,
MCInstBuilder(PPC::ADDI).addReg(PICR).addReg(PICR).addExpr(DeltaLo));
@ -1055,7 +1055,7 @@ void PPCAsmPrinter::emitInstruction(const MachineInstr *MI) {
// Create a reference to the GOT entry for the symbol. The GOT entry will be
// synthesized later.
if (PL == PICLevel::SmallPIC && !IsAIX) {
const MCExpr *Exp = symbolWithSpecifier(MOSymbol, PPCMCExpr::VK_GOT);
const MCExpr *Exp = symbolWithSpecifier(MOSymbol, PPC::S_GOT);
TmpInst.getOperand(1) = MCOperand::createExpr(Exp);
EmitToStreamer(*OutStreamer, TmpInst);
return;
@ -1144,8 +1144,7 @@ void PPCAsmPrinter::emitInstruction(const MachineInstr *MI) {
MCSymbol *TOCEntry =
lookUpOrCreateTOCEntry(MOSymbol, getTOCEntryTypeForMO(MO), VK);
PPCMCExpr::Specifier VKExpr =
IsAIX ? PPCMCExpr::VK_None : PPCMCExpr::VK_TOC;
PPCMCExpr::Specifier VKExpr = IsAIX ? PPC::S_None : PPC::S_TOC;
const MCExpr *Exp = symbolWithSpecifier(TOCEntry, VKExpr);
TmpInst.getOperand(1) = MCOperand::createExpr(
IsAIX ? getTOCEntryLoadingExprForXCOFF(MOSymbol, Exp, VK) : Exp);
@ -1195,7 +1194,7 @@ void PPCAsmPrinter::emitInstruction(const MachineInstr *MI) {
MOSymbol = lookUpOrCreateTOCEntry(MOSymbol, getTOCEntryTypeForMO(MO), VK);
}
const MCExpr *Exp = symbolWithSpecifier(MOSymbol, PPCMCExpr::VK_U);
const MCExpr *Exp = symbolWithSpecifier(MOSymbol, PPC::S_U);
TmpInst.getOperand(2) = MCOperand::createExpr(Exp);
EmitToStreamer(*OutStreamer, TmpInst);
return;
@ -1227,7 +1226,7 @@ void PPCAsmPrinter::emitInstruction(const MachineInstr *MI) {
// 'MOSymbol'.
MCSymbol *TOCEntry =
lookUpOrCreateTOCEntry(MOSymbol, getTOCEntryTypeForMO(MO), VK);
const MCExpr *Exp = symbolWithSpecifier(TOCEntry, PPCMCExpr::VK_L);
const MCExpr *Exp = symbolWithSpecifier(TOCEntry, PPC::S_L);
TmpInst.getOperand(1) = MCOperand::createExpr(Exp);
EmitToStreamer(*OutStreamer, TmpInst);
return;
@ -1260,7 +1259,7 @@ void PPCAsmPrinter::emitInstruction(const MachineInstr *MI) {
(MO.isCPI() && CM == CodeModel::Large))
MOSymbol = lookUpOrCreateTOCEntry(MOSymbol, getTOCEntryTypeForMO(MO), VK);
VK = IsAIX ? PPCMCExpr::VK_U : PPCMCExpr::VK_TOC_HA;
VK = IsAIX ? PPC::S_U : PPC::S_TOC_HA;
const MCExpr *Exp = symbolWithSpecifier(MOSymbol, VK);
@ -1302,7 +1301,7 @@ void PPCAsmPrinter::emitInstruction(const MachineInstr *MI) {
if (!MO.isCPI() || CM == CodeModel::Large)
MOSymbol = lookUpOrCreateTOCEntry(MOSymbol, getTOCEntryTypeForMO(MO), VK);
VK = IsAIX ? PPCMCExpr::VK_L : PPCMCExpr::VK_TOC_LO;
VK = IsAIX ? PPC::S_L : PPC::S_TOC_LO;
const MCExpr *Exp = symbolWithSpecifier(MOSymbol, VK);
TmpInst.getOperand(1) = MCOperand::createExpr(Exp);
EmitToStreamer(*OutStreamer, TmpInst);
@ -1332,8 +1331,7 @@ void PPCAsmPrinter::emitInstruction(const MachineInstr *MI) {
const MCExpr *Exp = MCSymbolRefExpr::create(
MOSymbol,
MCSymbolRefExpr::VariantKind(IsAIX ? PPCMCExpr::VK_L
: PPCMCExpr::VK_TOC_LO),
MCSymbolRefExpr::VariantKind(IsAIX ? PPC::S_L : PPC::S_TOC_LO),
OutContext);
TmpInst.getOperand(2) = MCOperand::createExpr(Exp);
@ -1348,7 +1346,7 @@ void PPCAsmPrinter::emitInstruction(const MachineInstr *MI) {
const GlobalValue *GValue = MO.getGlobal();
MCSymbol *MOSymbol = getSymbol(GValue);
const MCExpr *SymGotTprel =
symbolWithSpecifier(MOSymbol, PPCMCExpr::VK_GOT_TPREL_HA);
symbolWithSpecifier(MOSymbol, PPC::S_GOT_TPREL_HA);
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDIS8)
.addReg(MI->getOperand(0).getReg())
.addReg(MI->getOperand(1).getReg())
@ -1365,9 +1363,8 @@ void PPCAsmPrinter::emitInstruction(const MachineInstr *MI) {
const MachineOperand &MO = MI->getOperand(1);
const GlobalValue *GValue = MO.getGlobal();
MCSymbol *MOSymbol = getSymbol(GValue);
const MCExpr *Exp =
symbolWithSpecifier(MOSymbol, IsPPC64 ? PPCMCExpr::VK_GOT_TPREL_LO
: PPCMCExpr::VK_GOT_TPREL);
const MCExpr *Exp = symbolWithSpecifier(
MOSymbol, IsPPC64 ? PPC::S_GOT_TPREL_LO : PPC::S_GOT_TPREL);
TmpInst.getOperand(1) = MCOperand::createExpr(Exp);
EmitToStreamer(*OutStreamer, TmpInst);
return;
@ -1405,11 +1402,9 @@ void PPCAsmPrinter::emitInstruction(const MachineInstr *MI) {
MCSymbol *GOTSymbol =
OutContext.getOrCreateSymbol(StringRef("_GLOBAL_OFFSET_TABLE_"));
const MCExpr *SymGotTlsL = PPCMCExpr::create(
PPCMCExpr::VK_LO, MCSymbolRefExpr::create(GOTSymbol, OutContext),
OutContext);
PPC::S_LO, MCSymbolRefExpr::create(GOTSymbol, OutContext), OutContext);
const MCExpr *SymGotTlsHA = PPCMCExpr::create(
PPCMCExpr::VK_HA, MCSymbolRefExpr::create(GOTSymbol, OutContext),
OutContext);
PPC::S_HA, MCSymbolRefExpr::create(GOTSymbol, OutContext), OutContext);
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::LI)
.addReg(MI->getOperand(0).getReg())
.addExpr(SymGotTlsL));
@ -1427,7 +1422,7 @@ void PPCAsmPrinter::emitInstruction(const MachineInstr *MI) {
const GlobalValue *GValue = MO.getGlobal();
MCSymbol *MOSymbol = getSymbol(GValue);
const MCExpr *SymGotTlsGD =
symbolWithSpecifier(MOSymbol, PPCMCExpr::VK_GOT_TLSGD_HA);
symbolWithSpecifier(MOSymbol, PPC::S_GOT_TLSGD_HA);
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDIS8)
.addReg(MI->getOperand(0).getReg())
.addReg(MI->getOperand(1).getReg())
@ -1443,9 +1438,8 @@ void PPCAsmPrinter::emitInstruction(const MachineInstr *MI) {
const MachineOperand &MO = MI->getOperand(2);
const GlobalValue *GValue = MO.getGlobal();
MCSymbol *MOSymbol = getSymbol(GValue);
const MCExpr *SymGotTlsGD =
symbolWithSpecifier(MOSymbol, IsPPC64 ? PPCMCExpr::VK_GOT_TLSGD_LO
: PPCMCExpr::VK_GOT_TLSGD);
const MCExpr *SymGotTlsGD = symbolWithSpecifier(
MOSymbol, IsPPC64 ? PPC::S_GOT_TLSGD_LO : PPC::S_GOT_TLSGD);
EmitToStreamer(*OutStreamer,
MCInstBuilder(IsPPC64 ? PPC::ADDI8 : PPC::ADDI)
.addReg(MI->getOperand(0).getReg())
@ -1470,7 +1464,7 @@ void PPCAsmPrinter::emitInstruction(const MachineInstr *MI) {
case PPC::GETtlsADDR32: {
// Transform: %r3 = GETtlsADDR32 %r3, @sym
// Into: BL_TLS __tls_get_addr(sym at tlsgd)@PLT
emitTlsCall(MI, PPCMCExpr::VK_TLSGD);
emitTlsCall(MI, PPC::S_TLSGD);
return;
}
case PPC::GETtlsTpointer32AIX: {
@ -1487,7 +1481,7 @@ void PPCAsmPrinter::emitInstruction(const MachineInstr *MI) {
const GlobalValue *GValue = MO.getGlobal();
MCSymbol *MOSymbol = getSymbol(GValue);
const MCExpr *SymGotTlsLD =
symbolWithSpecifier(MOSymbol, PPCMCExpr::VK_GOT_TLSLD_HA);
symbolWithSpecifier(MOSymbol, PPC::S_GOT_TLSLD_HA);
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDIS8)
.addReg(MI->getOperand(0).getReg())
.addReg(MI->getOperand(1).getReg())
@ -1503,9 +1497,8 @@ void PPCAsmPrinter::emitInstruction(const MachineInstr *MI) {
const MachineOperand &MO = MI->getOperand(2);
const GlobalValue *GValue = MO.getGlobal();
MCSymbol *MOSymbol = getSymbol(GValue);
const MCExpr *SymGotTlsLD =
symbolWithSpecifier(MOSymbol, IsPPC64 ? PPCMCExpr::VK_GOT_TLSLD_LO
: PPCMCExpr::VK_GOT_TLSLD);
const MCExpr *SymGotTlsLD = symbolWithSpecifier(
MOSymbol, IsPPC64 ? PPC::S_GOT_TLSLD_LO : PPC::S_GOT_TLSLD);
EmitToStreamer(*OutStreamer,
MCInstBuilder(IsPPC64 ? PPC::ADDI8 : PPC::ADDI)
.addReg(MI->getOperand(0).getReg())
@ -1520,7 +1513,7 @@ void PPCAsmPrinter::emitInstruction(const MachineInstr *MI) {
case PPC::GETtlsldADDR32: {
// Transform: %r3 = GETtlsldADDR32 %r3, @sym
// Into: BL_TLS __tls_get_addr(sym at tlsld)@PLT
emitTlsCall(MI, PPCMCExpr::VK_TLSLD);
emitTlsCall(MI, PPC::S_TLSLD);
return;
}
case PPC::ADDISdtprelHA:
@ -1532,8 +1525,7 @@ void PPCAsmPrinter::emitInstruction(const MachineInstr *MI) {
const MachineOperand &MO = MI->getOperand(2);
const GlobalValue *GValue = MO.getGlobal();
MCSymbol *MOSymbol = getSymbol(GValue);
const MCExpr *SymDtprel =
symbolWithSpecifier(MOSymbol, PPCMCExpr::VK_DTPREL_HA);
const MCExpr *SymDtprel = symbolWithSpecifier(MOSymbol, PPC::S_DTPREL_HA);
EmitToStreamer(
*OutStreamer,
MCInstBuilder(IsPPC64 ? PPC::ADDIS8 : PPC::ADDIS)
@ -1548,8 +1540,7 @@ void PPCAsmPrinter::emitInstruction(const MachineInstr *MI) {
const MachineOperand &MO = MI->getOperand(2);
const GlobalValue *GValue = MO.getGlobal();
MCSymbol *MOSymbol = getSymbol(GValue);
const MCExpr *SymDtprel =
symbolWithSpecifier(MOSymbol, PPCMCExpr::VK_DTPREL);
const MCExpr *SymDtprel = symbolWithSpecifier(MOSymbol, PPC::S_DTPREL);
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::PADDI8)
.addReg(MI->getOperand(0).getReg())
.addReg(MI->getOperand(1).getReg())
@ -1566,8 +1557,7 @@ void PPCAsmPrinter::emitInstruction(const MachineInstr *MI) {
const MachineOperand &MO = MI->getOperand(2);
const GlobalValue *GValue = MO.getGlobal();
MCSymbol *MOSymbol = getSymbol(GValue);
const MCExpr *SymDtprel =
symbolWithSpecifier(MOSymbol, PPCMCExpr::VK_DTPREL_LO);
const MCExpr *SymDtprel = symbolWithSpecifier(MOSymbol, PPC::S_DTPREL_LO);
EmitToStreamer(*OutStreamer,
MCInstBuilder(IsPPC64 ? PPC::ADDI8 : PPC::ADDI)
.addReg(MI->getOperand(0).getReg())
@ -1737,9 +1727,8 @@ PPCAsmPrinter::getAdjustedFasterLocalExpr(const MachineOperand &MO,
// assume that the address of extern TLS variables are zero.
const MCExpr *Expr = MCSymbolRefExpr::create(
getSymbol(GValue),
MCSymbolRefExpr::VariantKind(Model == TLSModel::LocalExec
? PPCMCExpr::VK_AIX_TLSLE
: PPCMCExpr::VK_AIX_TLSLD),
MCSymbolRefExpr::VariantKind(
Model == TLSModel::LocalExec ? PPC::S_AIX_TLSLE : PPC::S_AIX_TLSLD),
OutContext);
Expr = MCBinaryExpr::createAdd(
Expr, MCConstantExpr::create(Offset, OutContext), OutContext);
@ -2028,8 +2017,7 @@ void PPCLinuxAsmPrinter::emitFunctionEntryLabel() {
// Generates a R_PPC64_TOC relocation for TOC base insertion.
OutStreamer->emitValue(
MCSymbolRefExpr::create(
Symbol2, MCSymbolRefExpr::VariantKind(PPCMCExpr::VK_TOCBASE),
OutContext),
Symbol2, MCSymbolRefExpr::VariantKind(PPC::S_TOCBASE), OutContext),
8 /*size*/);
// Emit a null environment pointer.
OutStreamer->emitIntValue(0, 8 /* size */);
@ -2136,13 +2124,15 @@ void PPCLinuxAsmPrinter::emitFunctionBodyStart() {
MCBinaryExpr::createSub(MCSymbolRefExpr::create(TOCSymbol, OutContext),
GlobalEntryLabelExp, OutContext);
const MCExpr *TOCDeltaHi = PPCMCExpr::createHa(TOCDeltaExpr, OutContext);
const MCExpr *TOCDeltaHi =
PPCMCExpr::create(TOCDeltaExpr, PPC::S_HA, OutContext);
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDIS)
.addReg(PPC::X2)
.addReg(PPC::X12)
.addExpr(TOCDeltaHi));
const MCExpr *TOCDeltaLo = PPCMCExpr::createLo(TOCDeltaExpr, OutContext);
const MCExpr *TOCDeltaLo =
PPCMCExpr::create(TOCDeltaExpr, PPC::S_LO, OutContext);
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDI)
.addReg(PPC::X2)
.addReg(PPC::X2)
@ -3007,9 +2997,9 @@ void PPCAIXAsmPrinter::emitEndOfAsmFile(Module &M) {
// new symbol to prefix the name with a dot.
// If TLS model opt is turned on, create a new symbol to prefix the name
// with a dot.
if (I.first.second == PPCMCExpr::VK_AIX_TLSGDM ||
if (I.first.second == PPC::S_AIX_TLSGDM ||
(Subtarget->hasAIXShLibTLSModelOpt() &&
I.first.second == PPCMCExpr::VK_AIX_TLSLD)) {
I.first.second == PPC::S_AIX_TLSLD)) {
SmallString<128> Name;
StringRef Prefix = ".";
Name += Prefix;

44
llvm/lib/Target/PowerPC/PPCMCInstLower.cpp
View File

@ -54,31 +54,31 @@ static MCSymbol *GetSymbolFromOperand(const MachineOperand &MO,
static MCOperand GetSymbolRef(const MachineOperand &MO, const MCSymbol *Symbol,
AsmPrinter &Printer) {
MCContext &Ctx = Printer.OutContext;
PPCMCExpr::Specifier RefKind = PPCMCExpr::VK_None;
PPCMCExpr::Specifier RefKind = PPC::S_None;
unsigned access = MO.getTargetFlags();
switch (access) {
case PPCII::MO_TPREL_LO:
RefKind = PPCMCExpr::VK_TPREL_LO;
RefKind = PPC::S_TPREL_LO;
break;
case PPCII::MO_TPREL_HA:
RefKind = PPCMCExpr::VK_TPREL_HA;
RefKind = PPC::S_TPREL_HA;
break;
case PPCII::MO_DTPREL_LO:
RefKind = PPCMCExpr::VK_DTPREL_LO;
RefKind = PPC::S_DTPREL_LO;
break;
case PPCII::MO_TLSLD_LO:
RefKind = PPCMCExpr::VK_GOT_TLSLD_LO;
RefKind = PPC::S_GOT_TLSLD_LO;
break;
case PPCII::MO_TOC_LO:
RefKind = PPCMCExpr::VK_TOC_LO;
RefKind = PPC::S_TOC_LO;
break;
case PPCII::MO_TLS:
RefKind = PPCMCExpr::VK_TLS;
RefKind = PPC::S_TLS;
break;
case PPCII::MO_TLS_PCREL_FLAG:
RefKind = PPCMCExpr::VK_TLS_PCREL;
RefKind = PPC::S_TLS_PCREL;
break;
}
@ -87,19 +87,19 @@ static MCOperand GetSymbolRef(const MachineOperand &MO, const MCSymbol *Symbol,
const MachineFunction *MF = MI->getMF();
if (MO.getTargetFlags() == PPCII::MO_PLT)
RefKind = PPCMCExpr::VK_PLT;
RefKind = PPC::S_PLT;
else if (MO.getTargetFlags() == PPCII::MO_PCREL_FLAG)
RefKind = PPCMCExpr::VK_PCREL;
RefKind = PPC::S_PCREL;
else if (MO.getTargetFlags() == PPCII::MO_GOT_PCREL_FLAG)
RefKind = PPCMCExpr::VK_GOT_PCREL;
RefKind = PPC::S_GOT_PCREL;
else if (MO.getTargetFlags() == PPCII::MO_TPREL_PCREL_FLAG)
RefKind = PPCMCExpr::VK_TPREL;
RefKind = PPC::S_TPREL;
else if (MO.getTargetFlags() == PPCII::MO_GOT_TLSGD_PCREL_FLAG)
RefKind = PPCMCExpr::VK_GOT_TLSGD_PCREL;
RefKind = PPC::S_GOT_TLSGD_PCREL;
else if (MO.getTargetFlags() == PPCII::MO_GOT_TLSLD_PCREL_FLAG)
RefKind = PPCMCExpr::VK_GOT_TLSLD_PCREL;
RefKind = PPC::S_GOT_TLSLD_PCREL;
else if (MO.getTargetFlags() == PPCII::MO_GOT_TPREL_PCREL_FLAG)
RefKind = PPCMCExpr::VK_GOT_TPREL_PCREL;
RefKind = PPC::S_GOT_TPREL_PCREL;
else if (MO.getTargetFlags() == PPCII::MO_TPREL_FLAG ||
MO.getTargetFlags() == PPCII::MO_TLSLD_FLAG) {
assert(MO.isGlobal() && "Only expecting a global MachineOperand here!");
@ -110,14 +110,14 @@ static MCOperand GetSymbolRef(const MachineOperand &MO, const MCSymbol *Symbol,
// the relocation type in case the result is used for purposes other than a
// TOC reference. In TOC reference cases, this result is discarded.
if (Model == TLSModel::LocalExec)
RefKind = PPCMCExpr::VK_AIX_TLSLE;
RefKind = PPC::S_AIX_TLSLE;
else if (Model == TLSModel::LocalDynamic &&
FuncInfo->isAIXFuncUseTLSIEForLD())
// On AIX, TLS model opt may have turned local-dynamic accesses into
// initial-exec accesses.
RefKind = PPCMCExpr::VK_AIX_TLSIE;
RefKind = PPC::S_AIX_TLSIE;
else if (Model == TLSModel::LocalDynamic)
RefKind = PPCMCExpr::VK_AIX_TLSLD;
RefKind = PPC::S_AIX_TLSLD;
}
const Module *M = MF->getFunction().getParent();
@ -130,10 +130,10 @@ static MCOperand GetSymbolRef(const MachineOperand &MO, const MCSymbol *Symbol,
if (MIOpcode == PPC::TAILB || MIOpcode == PPC::TAILB8 ||
MIOpcode == PPC::TCRETURNdi || MIOpcode == PPC::TCRETURNdi8 ||
MIOpcode == PPC::BL8_NOTOC || MIOpcode == PPC::BL8_NOTOC_RM) {
RefKind = PPCMCExpr::VK_NOTOC;
RefKind = PPC::S_NOTOC;
}
if (MO.getTargetFlags() == PPCII::MO_PCREL_OPT_FLAG)
RefKind = PPCMCExpr::VK_PCREL_OPT;
RefKind = PPC::S_PCREL_OPT;
}
const MCExpr *Expr = MCSymbolRefExpr::create(
@ -164,11 +164,11 @@ static MCOperand GetSymbolRef(const MachineOperand &MO, const MCSymbol *Symbol,
switch (access) {
case PPCII::MO_LO:
case PPCII::MO_PIC_LO_FLAG:
Expr = PPCMCExpr::createLo(Expr, Ctx);
Expr = PPCMCExpr::create(Expr, PPC::S_LO, Ctx);
break;
case PPCII::MO_HA:
case PPCII::MO_PIC_HA_FLAG:
Expr = PPCMCExpr::createHa(Expr, Ctx);
Expr = PPCMCExpr::create(Expr, PPC::S_HA, Ctx);
break;
}

6
llvm/lib/Target/PowerPC/PPCTargetObjectFile.cpp
View File

@ -7,7 +7,7 @@
//===----------------------------------------------------------------------===//
#include "PPCTargetObjectFile.h"
#include "MCTargetDesc/PPCMCExpr.h"
#include "MCTargetDesc/PPCMCAsmInfo.h"
#include "llvm/IR/GlobalVariable.h"
#include "llvm/MC/MCContext.h"
#include "llvm/MC/MCExpr.h"
@ -49,8 +49,8 @@ MCSection *PPC64LinuxTargetObjectFile::SelectSectionForGlobal(
const MCExpr *PPC64LinuxTargetObjectFile::
getDebugThreadLocalSymbol(const MCSymbol *Sym) const {
const MCExpr *Expr = MCSymbolRefExpr::create(
Sym, MCSymbolRefExpr::VariantKind(PPCMCExpr::VK_DTPREL), getContext());
const MCExpr *Expr =
MCSymbolRefExpr::create(Sym, PPC::S_DTPREL, getContext());
return MCBinaryExpr::createAdd(Expr,
MCConstantExpr::create(0x8000, getContext()),
getContext());