diff --git a/bolt/lib/Target/AArch64/AArch64MCPlusBuilder.cpp b/bolt/lib/Target/AArch64/AArch64MCPlusBuilder.cpp index e6e0aeba34572..612c1304efd60 100644 --- a/bolt/lib/Target/AArch64/AArch64MCPlusBuilder.cpp +++ b/bolt/lib/Target/AArch64/AArch64MCPlusBuilder.cpp @@ -1081,7 +1081,7 @@ class AArch64MCPlusBuilder : public MCPlusBuilder { if (isADR(Inst) || RelType == ELF::R_AARCH64_ADR_PREL_LO21 || RelType == ELF::R_AARCH64_TLSDESC_ADR_PREL21) { - return MCSpecifierExpr::create(Expr, AArch64MCExpr::VK_ABS, Ctx); + return MCSpecifierExpr::create(Expr, AArch64::S_ABS, Ctx); } else if (isADRP(Inst) || RelType == ELF::R_AARCH64_ADR_PREL_PG_HI21 || RelType == ELF::R_AARCH64_ADR_PREL_PG_HI21_NC || RelType == ELF::R_AARCH64_TLSDESC_ADR_PAGE21 || @@ -1089,7 +1089,7 @@ class AArch64MCPlusBuilder : public MCPlusBuilder { RelType == ELF::R_AARCH64_ADR_GOT_PAGE) { // Never emit a GOT reloc, we handled this in // RewriteInstance::readRelocations(). - return MCSpecifierExpr::create(Expr, AArch64MCExpr::VK_ABS_PAGE, Ctx); + return MCSpecifierExpr::create(Expr, AArch64::S_ABS_PAGE, Ctx); } else { switch (RelType) { case ELF::R_AARCH64_ADD_ABS_LO12_NC: @@ -1103,18 +1103,18 @@ class AArch64MCPlusBuilder : public MCPlusBuilder { case ELF::R_AARCH64_TLSDESC_LD64_LO12: case ELF::R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC: case ELF::R_AARCH64_TLSLE_ADD_TPREL_LO12_NC: - return MCSpecifierExpr::create(Expr, AArch64MCExpr::VK_LO12, Ctx); + return MCSpecifierExpr::create(Expr, AArch64::S_LO12, Ctx); case ELF::R_AARCH64_MOVW_UABS_G3: - return MCSpecifierExpr::create(Expr, AArch64MCExpr::VK_ABS_G3, Ctx); + return MCSpecifierExpr::create(Expr, AArch64::S_ABS_G3, Ctx); case ELF::R_AARCH64_MOVW_UABS_G2: case ELF::R_AARCH64_MOVW_UABS_G2_NC: - return MCSpecifierExpr::create(Expr, AArch64MCExpr::VK_ABS_G2_NC, Ctx); + return MCSpecifierExpr::create(Expr, AArch64::S_ABS_G2_NC, Ctx); case ELF::R_AARCH64_MOVW_UABS_G1: case ELF::R_AARCH64_MOVW_UABS_G1_NC: - return MCSpecifierExpr::create(Expr, AArch64MCExpr::VK_ABS_G1_NC, Ctx); + return MCSpecifierExpr::create(Expr, AArch64::S_ABS_G1_NC, Ctx); case ELF::R_AARCH64_MOVW_UABS_G0: case ELF::R_AARCH64_MOVW_UABS_G0_NC: - return MCSpecifierExpr::create(Expr, AArch64MCExpr::VK_ABS_G0_NC, Ctx); + return MCSpecifierExpr::create(Expr, AArch64::S_ABS_G0_NC, Ctx); default: break; } @@ -2028,7 +2028,7 @@ class AArch64MCPlusBuilder : public MCPlusBuilder { Inst.setOpcode(AArch64::MOVZXi); Inst.addOperand(MCOperand::createReg(AArch64::X16)); Inst.addOperand(MCOperand::createExpr( - MCSpecifierExpr::create(Target, AArch64MCExpr::VK_ABS_G3, *Ctx))); + MCSpecifierExpr::create(Target, AArch64::S_ABS_G3, *Ctx))); Inst.addOperand(MCOperand::createImm(0x30)); Seq.emplace_back(Inst); @@ -2037,7 +2037,7 @@ class AArch64MCPlusBuilder : public MCPlusBuilder { Inst.addOperand(MCOperand::createReg(AArch64::X16)); Inst.addOperand(MCOperand::createReg(AArch64::X16)); Inst.addOperand(MCOperand::createExpr( - MCSpecifierExpr::create(Target, AArch64MCExpr::VK_ABS_G2_NC, *Ctx))); + MCSpecifierExpr::create(Target, AArch64::S_ABS_G2_NC, *Ctx))); Inst.addOperand(MCOperand::createImm(0x20)); Seq.emplace_back(Inst); @@ -2046,7 +2046,7 @@ class AArch64MCPlusBuilder : public MCPlusBuilder { Inst.addOperand(MCOperand::createReg(AArch64::X16)); Inst.addOperand(MCOperand::createReg(AArch64::X16)); Inst.addOperand(MCOperand::createExpr( - MCSpecifierExpr::create(Target, AArch64MCExpr::VK_ABS_G1_NC, *Ctx))); + MCSpecifierExpr::create(Target, AArch64::S_ABS_G1_NC, *Ctx))); Inst.addOperand(MCOperand::createImm(0x10)); Seq.emplace_back(Inst); @@ -2055,7 +2055,7 @@ class AArch64MCPlusBuilder : public MCPlusBuilder { Inst.addOperand(MCOperand::createReg(AArch64::X16)); Inst.addOperand(MCOperand::createReg(AArch64::X16)); Inst.addOperand(MCOperand::createExpr( - MCSpecifierExpr::create(Target, AArch64MCExpr::VK_ABS_G0_NC, *Ctx))); + MCSpecifierExpr::create(Target, AArch64::S_ABS_G0_NC, *Ctx))); Inst.addOperand(MCOperand::createImm(0)); Seq.emplace_back(Inst); diff --git a/llvm/lib/Target/AArch64/AArch64AsmPrinter.cpp b/llvm/lib/Target/AArch64/AArch64AsmPrinter.cpp index a16c104d8bef5..dd10050592190 100644 --- a/llvm/lib/Target/AArch64/AArch64AsmPrinter.cpp +++ b/llvm/lib/Target/AArch64/AArch64AsmPrinter.cpp @@ -19,7 +19,7 @@ #include "AArch64TargetObjectFile.h" #include "MCTargetDesc/AArch64AddressingModes.h" #include "MCTargetDesc/AArch64InstPrinter.h" -#include "MCTargetDesc/AArch64MCExpr.h" +#include "MCTargetDesc/AArch64MCAsmInfo.h" #include "MCTargetDesc/AArch64MCTargetDesc.h" #include "MCTargetDesc/AArch64TargetStreamer.h" #include "TargetInfo/AArch64TargetInfo.h" @@ -910,15 +910,15 @@ void AArch64AsmPrinter::emitHwasanMemaccessSymbols(Module &M) { // have a chance to save them. EmitToStreamer(MCInstBuilder(AArch64::ADRP) .addReg(AArch64::X16) - .addExpr(MCSpecifierExpr::create( - HwasanTagMismatchRef, AArch64MCExpr::VK_GOT_PAGE, - OutContext))); + .addExpr(MCSpecifierExpr::create(HwasanTagMismatchRef, + AArch64::S_GOT_PAGE, + OutContext))); EmitToStreamer(MCInstBuilder(AArch64::LDRXui) .addReg(AArch64::X16) .addReg(AArch64::X16) - .addExpr(MCSpecifierExpr::create( - HwasanTagMismatchRef, AArch64MCExpr::VK_GOT_LO12, - OutContext))); + .addExpr(MCSpecifierExpr::create(HwasanTagMismatchRef, + AArch64::S_GOT_LO12, + OutContext))); EmitToStreamer(MCInstBuilder(AArch64::BR).addReg(AArch64::X16)); } } diff --git a/llvm/lib/Target/AArch64/AArch64MCInstLower.cpp b/llvm/lib/Target/AArch64/AArch64MCInstLower.cpp index fd3ce6c72e508..f864404c1fd20 100644 --- a/llvm/lib/Target/AArch64/AArch64MCInstLower.cpp +++ b/llvm/lib/Target/AArch64/AArch64MCInstLower.cpp @@ -13,7 +13,7 @@ #include "AArch64MCInstLower.h" #include "AArch64MachineFunctionInfo.h" -#include "MCTargetDesc/AArch64MCExpr.h" +#include "MCTargetDesc/AArch64MCAsmInfo.h" #include "Utils/AArch64BaseInfo.h" #include "llvm/CodeGen/AsmPrinter.h" #include "llvm/CodeGen/MachineBasicBlock.h" @@ -147,29 +147,29 @@ MCOperand AArch64MCInstLower::lowerSymbolOperandMachO(const MachineOperand &MO, MCSymbol *Sym) const { // FIXME: We would like an efficient form for this, so we don't have to do a // lot of extra uniquing. - auto Spec = AArch64MCExpr::None; + auto Spec = AArch64::S_None; if ((MO.getTargetFlags() & AArch64II::MO_GOT) != 0) { if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_PAGE) - Spec = AArch64MCExpr::M_GOTPAGE; + Spec = AArch64::S_MACHO_GOTPAGE; else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_PAGEOFF) - Spec = AArch64MCExpr::M_GOTPAGEOFF; + Spec = AArch64::S_MACHO_GOTPAGEOFF; else llvm_unreachable("Unexpected target flags with MO_GOT on GV operand"); } else if ((MO.getTargetFlags() & AArch64II::MO_TLS) != 0) { if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_PAGE) - Spec = AArch64MCExpr::M_TLVPPAGE; + Spec = AArch64::S_MACHO_TLVPPAGE; else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_PAGEOFF) - Spec = AArch64MCExpr::M_TLVPPAGEOFF; + Spec = AArch64::S_MACHO_TLVPPAGEOFF; else llvm_unreachable("Unexpected target flags with MO_TLS on GV operand"); } else { if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_PAGE) - Spec = AArch64MCExpr::M_PAGE; + Spec = AArch64::S_MACHO_PAGE; else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_PAGEOFF) - Spec = AArch64MCExpr::M_PAGEOFF; + Spec = AArch64::S_MACHO_PAGEOFF; } // TODO: Migrate to MCSpecifierExpr::create like ELF. const MCExpr *Expr = MCSymbolRefExpr::create(Sym, Spec, Ctx); @@ -186,8 +186,8 @@ MCOperand AArch64MCInstLower::lowerSymbolOperandELF(const MachineOperand &MO, if (MO.getTargetFlags() & AArch64II::MO_GOT) { const MachineFunction *MF = MO.getParent()->getParent()->getParent(); RefFlags |= (MF->getInfo()->hasELFSignedGOT() - ? AArch64MCExpr::VK_GOT_AUTH - : AArch64MCExpr::VK_GOT); + ? AArch64::S_GOT_AUTH + : AArch64::S_GOT); } else if (MO.getTargetFlags() & AArch64II::MO_TLS) { TLSModel::Model Model; if (MO.isGlobal()) { @@ -211,13 +211,13 @@ MCOperand AArch64MCInstLower::lowerSymbolOperandELF(const MachineOperand &MO, } switch (Model) { case TLSModel::InitialExec: - RefFlags |= AArch64MCExpr::VK_GOTTPREL; + RefFlags |= AArch64::S_GOTTPREL; break; case TLSModel::LocalExec: - RefFlags |= AArch64MCExpr::VK_TPREL; + RefFlags |= AArch64::S_TPREL; break; case TLSModel::LocalDynamic: - RefFlags |= AArch64MCExpr::VK_DTPREL; + RefFlags |= AArch64::S_DTPREL; break; case TLSModel::GeneralDynamic: { // TODO: it's probably better to introduce MO_TLS_AUTH or smth and avoid @@ -226,37 +226,37 @@ MCOperand AArch64MCInstLower::lowerSymbolOperandELF(const MachineOperand &MO, // making the field wider breaks static assertions. const MachineFunction *MF = MO.getParent()->getParent()->getParent(); RefFlags |= MF->getInfo()->hasELFSignedGOT() - ? AArch64MCExpr::VK_TLSDESC_AUTH - : AArch64MCExpr::VK_TLSDESC; + ? AArch64::S_TLSDESC_AUTH + : AArch64::S_TLSDESC; break; } } } else if (MO.getTargetFlags() & AArch64II::MO_PREL) { - RefFlags |= AArch64MCExpr::VK_PREL; + RefFlags |= AArch64::S_PREL; } else { // No modifier means this is a generic reference, classified as absolute for // the cases where it matters (:abs_g0: etc). - RefFlags |= AArch64MCExpr::VK_ABS; + RefFlags |= AArch64::S_ABS; } if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_PAGE) - RefFlags |= AArch64MCExpr::VK_PAGE; + RefFlags |= AArch64::S_PAGE; else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_PAGEOFF) - RefFlags |= AArch64MCExpr::VK_PAGEOFF; + RefFlags |= AArch64::S_PAGEOFF; else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_G3) - RefFlags |= AArch64MCExpr::VK_G3; + RefFlags |= AArch64::S_G3; else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_G2) - RefFlags |= AArch64MCExpr::VK_G2; + RefFlags |= AArch64::S_G2; else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_G1) - RefFlags |= AArch64MCExpr::VK_G1; + RefFlags |= AArch64::S_G1; else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_G0) - RefFlags |= AArch64MCExpr::VK_G0; + RefFlags |= AArch64::S_G0; else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_HI12) - RefFlags |= AArch64MCExpr::VK_HI12; + RefFlags |= AArch64::S_HI12; if (MO.getTargetFlags() & AArch64II::MO_NC) - RefFlags |= AArch64MCExpr::VK_NC; + RefFlags |= AArch64::S_NC; const MCExpr *Expr = MCSymbolRefExpr::create(Sym, Ctx); if (!MO.isJTI() && MO.getOffset()) @@ -276,31 +276,31 @@ MCOperand AArch64MCInstLower::lowerSymbolOperandCOFF(const MachineOperand &MO, if (MO.getTargetFlags() & AArch64II::MO_TLS) { if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_PAGEOFF) - RefFlags |= AArch64MCExpr::VK_SECREL_LO12; + RefFlags |= AArch64::S_SECREL_LO12; else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_HI12) - RefFlags |= AArch64MCExpr::VK_SECREL_HI12; + RefFlags |= AArch64::S_SECREL_HI12; } else if (MO.getTargetFlags() & AArch64II::MO_S) { - RefFlags |= AArch64MCExpr::VK_SABS; + RefFlags |= AArch64::S_SABS; } else { - RefFlags |= AArch64MCExpr::VK_ABS; + RefFlags |= AArch64::S_ABS; if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_PAGE) - RefFlags |= AArch64MCExpr::VK_PAGE; + RefFlags |= AArch64::S_PAGE; else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_PAGEOFF) - RefFlags |= AArch64MCExpr::VK_PAGEOFF | AArch64MCExpr::VK_NC; + RefFlags |= AArch64::S_PAGEOFF | AArch64::S_NC; } if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_G3) - RefFlags |= AArch64MCExpr::VK_G3; + RefFlags |= AArch64::S_G3; else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_G2) - RefFlags |= AArch64MCExpr::VK_G2; + RefFlags |= AArch64::S_G2; else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_G1) - RefFlags |= AArch64MCExpr::VK_G1; + RefFlags |= AArch64::S_G1; else if ((MO.getTargetFlags() & AArch64II::MO_FRAGMENT) == AArch64II::MO_G0) - RefFlags |= AArch64MCExpr::VK_G0; + RefFlags |= AArch64::S_G0; // FIXME: Currently we only set VK_NC for MO_G3/MO_G2/MO_G1/MO_G0. This is // because setting VK_NC for others would mean setting their respective @@ -309,7 +309,7 @@ MCOperand AArch64MCInstLower::lowerSymbolOperandCOFF(const MachineOperand &MO, auto MOFrag = (MO.getTargetFlags() & AArch64II::MO_FRAGMENT); if (MOFrag == AArch64II::MO_G3 || MOFrag == AArch64II::MO_G2 || MOFrag == AArch64II::MO_G1 || MOFrag == AArch64II::MO_G0) - RefFlags |= AArch64MCExpr::VK_NC; + RefFlags |= AArch64::S_NC; } const MCExpr *Expr = MCSymbolRefExpr::create(Sym, Ctx); @@ -318,8 +318,7 @@ MCOperand AArch64MCInstLower::lowerSymbolOperandCOFF(const MachineOperand &MO, Expr, MCConstantExpr::create(MO.getOffset(), Ctx), Ctx); auto RefKind = static_cast(RefFlags); - assert(RefKind != AArch64MCExpr::VK_INVALID && - "Invalid relocation requested"); + assert(RefKind != AArch64::S_INVALID && "Invalid relocation requested"); Expr = MCSpecifierExpr::create(Expr, RefKind, Ctx); return MCOperand::createExpr(Expr); diff --git a/llvm/lib/Target/AArch64/AArch64TargetObjectFile.cpp b/llvm/lib/Target/AArch64/AArch64TargetObjectFile.cpp index b9ba2a41877ec..c218831ce0400 100644 --- a/llvm/lib/Target/AArch64/AArch64TargetObjectFile.cpp +++ b/llvm/lib/Target/AArch64/AArch64TargetObjectFile.cpp @@ -8,7 +8,7 @@ #include "AArch64TargetObjectFile.h" #include "AArch64TargetMachine.h" -#include "MCTargetDesc/AArch64MCExpr.h" +#include "MCTargetDesc/AArch64MCAsmInfo.h" #include "MCTargetDesc/AArch64TargetStreamer.h" #include "llvm/BinaryFormat/Dwarf.h" #include "llvm/CodeGen/MachineModuleInfoImpls.h" @@ -25,7 +25,7 @@ using namespace dwarf; void AArch64_ELFTargetObjectFile::Initialize(MCContext &Ctx, const TargetMachine &TM) { TargetLoweringObjectFileELF::Initialize(Ctx, TM); - PLTRelativeSpecifier = AArch64MCExpr::VK_PLT; + PLTRelativeSpecifier = AArch64::S_PLT; SupportIndirectSymViaGOTPCRel = true; // AARCH64 ELF ABI does not define static relocation type for TLS offset @@ -61,7 +61,7 @@ const MCExpr *AArch64_ELFTargetObjectFile::getIndirectSymViaGOTPCRel( int64_t Offset, MachineModuleInfo *MMI, MCStreamer &Streamer) const { int64_t FinalOffset = Offset + MV.getConstant(); const MCExpr *Res = - MCSymbolRefExpr::create(Sym, AArch64MCExpr::VK_GOTPCREL, getContext()); + MCSymbolRefExpr::create(Sym, AArch64::S_GOTPCREL, getContext()); const MCExpr *Off = MCConstantExpr::create(FinalOffset, getContext()); return MCBinaryExpr::createAdd(Res, Off, getContext()); } @@ -80,7 +80,7 @@ const MCExpr *AArch64_MachoTargetObjectFile::getTTypeGlobalReference( if (Encoding & (DW_EH_PE_indirect | DW_EH_PE_pcrel)) { const MCSymbol *Sym = TM.getSymbol(GV); const MCExpr *Res = - MCSymbolRefExpr::create(Sym, AArch64MCExpr::M_GOT, getContext()); + MCSymbolRefExpr::create(Sym, AArch64::S_MACHO_GOT, getContext()); MCSymbol *PCSym = getContext().createTempSymbol(); Streamer.emitLabel(PCSym); const MCExpr *PC = MCSymbolRefExpr::create(PCSym, getContext()); @@ -105,7 +105,7 @@ const MCExpr *AArch64_MachoTargetObjectFile::getIndirectSymViaGOTPCRel( // On ARM64 Darwin, we can reference symbols with foo@GOT-., which // is an indirect pc-relative reference. const MCExpr *Res = - MCSymbolRefExpr::create(Sym, AArch64MCExpr::M_GOT, getContext()); + MCSymbolRefExpr::create(Sym, AArch64::S_MACHO_GOT, getContext()); MCSymbol *PCSym = getContext().createTempSymbol(); Streamer.emitLabel(PCSym); const MCExpr *PC = MCSymbolRefExpr::create(PCSym, getContext()); diff --git a/llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp b/llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp index faa82abbd898a..f16fc6cfefa42 100644 --- a/llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp +++ b/llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp @@ -9,7 +9,7 @@ #include "AArch64InstrInfo.h" #include "MCTargetDesc/AArch64AddressingModes.h" #include "MCTargetDesc/AArch64InstPrinter.h" -#include "MCTargetDesc/AArch64MCExpr.h" +#include "MCTargetDesc/AArch64MCAsmInfo.h" #include "MCTargetDesc/AArch64MCTargetDesc.h" #include "MCTargetDesc/AArch64TargetStreamer.h" #include "TargetInfo/AArch64TargetInfo.h" @@ -901,22 +901,21 @@ class AArch64Operand : public MCParsedAsmOperand { return true; } - if (DarwinSpec == AArch64MCExpr::M_PAGEOFF || + if (DarwinSpec == AArch64::S_MACHO_PAGEOFF || llvm::is_contained( - {AArch64MCExpr::VK_LO12, AArch64MCExpr::VK_GOT_LO12, - AArch64MCExpr::VK_GOT_AUTH_LO12, AArch64MCExpr::VK_DTPREL_LO12, - AArch64MCExpr::VK_DTPREL_LO12_NC, AArch64MCExpr::VK_TPREL_LO12, - AArch64MCExpr::VK_TPREL_LO12_NC, - AArch64MCExpr::VK_GOTTPREL_LO12_NC, AArch64MCExpr::VK_TLSDESC_LO12, - AArch64MCExpr::VK_TLSDESC_AUTH_LO12, AArch64MCExpr::VK_SECREL_LO12, - AArch64MCExpr::VK_SECREL_HI12, AArch64MCExpr::VK_GOT_PAGE_LO15}, + {AArch64::S_LO12, AArch64::S_GOT_LO12, AArch64::S_GOT_AUTH_LO12, + AArch64::S_DTPREL_LO12, AArch64::S_DTPREL_LO12_NC, + AArch64::S_TPREL_LO12, AArch64::S_TPREL_LO12_NC, + AArch64::S_GOTTPREL_LO12_NC, AArch64::S_TLSDESC_LO12, + AArch64::S_TLSDESC_AUTH_LO12, AArch64::S_SECREL_LO12, + AArch64::S_SECREL_HI12, AArch64::S_GOT_PAGE_LO15}, ELFSpec)) { // Note that we don't range-check the addend. It's adjusted modulo page // size when converted, so there is no "out of range" condition when using // @pageoff. return true; - } else if (DarwinSpec == AArch64MCExpr::M_GOTPAGEOFF || - DarwinSpec == AArch64MCExpr::M_TLVPPAGEOFF) { + } else if (DarwinSpec == AArch64::S_MACHO_GOTPAGEOFF || + DarwinSpec == AArch64::S_MACHO_TLVPPAGEOFF) { // @gotpageoff/@tlvppageoff can only be used directly, not with an addend. return Addend == 0; } @@ -1013,18 +1012,16 @@ class AArch64Operand : public MCParsedAsmOperand { int64_t Addend; if (AArch64AsmParser::classifySymbolRef(Expr, ELFSpec, DarwinSpec, Addend)) { - return DarwinSpec == AArch64MCExpr::M_PAGEOFF || - DarwinSpec == AArch64MCExpr::M_TLVPPAGEOFF || - (DarwinSpec == AArch64MCExpr::M_GOTPAGEOFF && Addend == 0) || + return DarwinSpec == AArch64::S_MACHO_PAGEOFF || + DarwinSpec == AArch64::S_MACHO_TLVPPAGEOFF || + (DarwinSpec == AArch64::S_MACHO_GOTPAGEOFF && Addend == 0) || llvm::is_contained( - {AArch64MCExpr::VK_LO12, AArch64MCExpr::VK_GOT_AUTH_LO12, - AArch64MCExpr::VK_DTPREL_HI12, AArch64MCExpr::VK_DTPREL_LO12, - AArch64MCExpr::VK_DTPREL_LO12_NC, - AArch64MCExpr::VK_TPREL_HI12, AArch64MCExpr::VK_TPREL_LO12, - AArch64MCExpr::VK_TPREL_LO12_NC, - AArch64MCExpr::VK_TLSDESC_LO12, - AArch64MCExpr::VK_TLSDESC_AUTH_LO12, - AArch64MCExpr::VK_SECREL_HI12, AArch64MCExpr::VK_SECREL_LO12}, + {AArch64::S_LO12, AArch64::S_GOT_AUTH_LO12, + AArch64::S_DTPREL_HI12, AArch64::S_DTPREL_LO12, + AArch64::S_DTPREL_LO12_NC, AArch64::S_TPREL_HI12, + AArch64::S_TPREL_LO12, AArch64::S_TPREL_LO12_NC, + AArch64::S_TLSDESC_LO12, AArch64::S_TLSDESC_AUTH_LO12, + AArch64::S_SECREL_HI12, AArch64::S_SECREL_LO12}, ELFSpec); } @@ -1129,40 +1126,37 @@ class AArch64Operand : public MCParsedAsmOperand { Addend)) { return false; } - if (DarwinSpec != AArch64MCExpr::None) + if (DarwinSpec != AArch64::S_None) return false; return llvm::is_contained(AllowedModifiers, ELFSpec); } bool isMovWSymbolG3() const { - return isMovWSymbol({AArch64MCExpr::VK_ABS_G3, AArch64MCExpr::VK_PREL_G3}); + return isMovWSymbol({AArch64::S_ABS_G3, AArch64::S_PREL_G3}); } bool isMovWSymbolG2() const { - return isMovWSymbol( - {AArch64MCExpr::VK_ABS_G2, AArch64MCExpr::VK_ABS_G2_S, - AArch64MCExpr::VK_ABS_G2_NC, AArch64MCExpr::VK_PREL_G2, - AArch64MCExpr::VK_PREL_G2_NC, AArch64MCExpr::VK_TPREL_G2, - AArch64MCExpr::VK_DTPREL_G2}); + return isMovWSymbol({AArch64::S_ABS_G2, AArch64::S_ABS_G2_S, + AArch64::S_ABS_G2_NC, AArch64::S_PREL_G2, + AArch64::S_PREL_G2_NC, AArch64::S_TPREL_G2, + AArch64::S_DTPREL_G2}); } bool isMovWSymbolG1() const { - return isMovWSymbol( - {AArch64MCExpr::VK_ABS_G1, AArch64MCExpr::VK_ABS_G1_S, - AArch64MCExpr::VK_ABS_G1_NC, AArch64MCExpr::VK_PREL_G1, - AArch64MCExpr::VK_PREL_G1_NC, AArch64MCExpr::VK_GOTTPREL_G1, - AArch64MCExpr::VK_TPREL_G1, AArch64MCExpr::VK_TPREL_G1_NC, - AArch64MCExpr::VK_DTPREL_G1, AArch64MCExpr::VK_DTPREL_G1_NC}); + return isMovWSymbol({AArch64::S_ABS_G1, AArch64::S_ABS_G1_S, + AArch64::S_ABS_G1_NC, AArch64::S_PREL_G1, + AArch64::S_PREL_G1_NC, AArch64::S_GOTTPREL_G1, + AArch64::S_TPREL_G1, AArch64::S_TPREL_G1_NC, + AArch64::S_DTPREL_G1, AArch64::S_DTPREL_G1_NC}); } bool isMovWSymbolG0() const { - return isMovWSymbol( - {AArch64MCExpr::VK_ABS_G0, AArch64MCExpr::VK_ABS_G0_S, - AArch64MCExpr::VK_ABS_G0_NC, AArch64MCExpr::VK_PREL_G0, - AArch64MCExpr::VK_PREL_G0_NC, AArch64MCExpr::VK_GOTTPREL_G0_NC, - AArch64MCExpr::VK_TPREL_G0, AArch64MCExpr::VK_TPREL_G0_NC, - AArch64MCExpr::VK_DTPREL_G0, AArch64MCExpr::VK_DTPREL_G0_NC}); + return isMovWSymbol({AArch64::S_ABS_G0, AArch64::S_ABS_G0_S, + AArch64::S_ABS_G0_NC, AArch64::S_PREL_G0, + AArch64::S_PREL_G0_NC, AArch64::S_GOTTPREL_G0_NC, + AArch64::S_TPREL_G0, AArch64::S_TPREL_G0_NC, + AArch64::S_DTPREL_G0, AArch64::S_DTPREL_G0_NC}); } template @@ -3303,26 +3297,24 @@ ParseStatus AArch64AsmParser::tryParseAdrpLabel(OperandVector &Operands) { AArch64MCExpr::Specifier DarwinSpec; int64_t Addend; if (classifySymbolRef(Expr, ELFSpec, DarwinSpec, Addend)) { - if (DarwinSpec == AArch64MCExpr::None && - ELFSpec == AArch64MCExpr::VK_INVALID) { + if (DarwinSpec == AArch64::S_None && ELFSpec == AArch64::S_INVALID) { // No modifier was specified at all; this is the syntax for an ELF basic // ADRP relocation (unfortunately). - Expr = MCSpecifierExpr::create(Expr, AArch64MCExpr::VK_ABS_PAGE, - getContext()); - } else if ((DarwinSpec == AArch64MCExpr::M_GOTPAGE || - DarwinSpec == AArch64MCExpr::M_TLVPPAGE) && + Expr = MCSpecifierExpr::create(Expr, AArch64::S_ABS_PAGE, getContext()); + } else if ((DarwinSpec == AArch64::S_MACHO_GOTPAGE || + DarwinSpec == AArch64::S_MACHO_TLVPPAGE) && Addend != 0) { return Error(S, "gotpage label reference not allowed an addend"); - } else if (DarwinSpec != AArch64MCExpr::M_PAGE && - DarwinSpec != AArch64MCExpr::M_GOTPAGE && - DarwinSpec != AArch64MCExpr::M_TLVPPAGE && - ELFSpec != AArch64MCExpr::VK_ABS_PAGE_NC && - ELFSpec != AArch64MCExpr::VK_GOT_PAGE && - ELFSpec != AArch64MCExpr::VK_GOT_AUTH_PAGE && - ELFSpec != AArch64MCExpr::VK_GOT_PAGE_LO15 && - ELFSpec != AArch64MCExpr::VK_GOTTPREL_PAGE && - ELFSpec != AArch64MCExpr::VK_TLSDESC_PAGE && - ELFSpec != AArch64MCExpr::VK_TLSDESC_AUTH_PAGE) { + } else if (DarwinSpec != AArch64::S_MACHO_PAGE && + DarwinSpec != AArch64::S_MACHO_GOTPAGE && + DarwinSpec != AArch64::S_MACHO_TLVPPAGE && + ELFSpec != AArch64::S_ABS_PAGE_NC && + ELFSpec != AArch64::S_GOT_PAGE && + ELFSpec != AArch64::S_GOT_AUTH_PAGE && + ELFSpec != AArch64::S_GOT_PAGE_LO15 && + ELFSpec != AArch64::S_GOTTPREL_PAGE && + ELFSpec != AArch64::S_TLSDESC_PAGE && + ELFSpec != AArch64::S_TLSDESC_AUTH_PAGE) { // The operand must be an @page or @gotpage qualified symbolref. return Error(S, "page or gotpage label reference expected"); } @@ -3357,12 +3349,11 @@ ParseStatus AArch64AsmParser::tryParseAdrLabel(OperandVector &Operands) { AArch64MCExpr::Specifier DarwinSpec; int64_t Addend; if (classifySymbolRef(Expr, ELFSpec, DarwinSpec, Addend)) { - if (DarwinSpec == AArch64MCExpr::None && - ELFSpec == AArch64MCExpr::VK_INVALID) { + if (DarwinSpec == AArch64::S_None && ELFSpec == AArch64::S_INVALID) { // No modifier was specified at all; this is the syntax for an ELF basic // ADR relocation (unfortunately). - Expr = MCSpecifierExpr::create(Expr, AArch64MCExpr::VK_ABS, getContext()); - } else if (ELFSpec != AArch64MCExpr::VK_GOT_AUTH_PAGE) { + Expr = MCSpecifierExpr::create(Expr, AArch64::S_ABS, getContext()); + } else if (ELFSpec != AArch64::S_GOT_AUTH_PAGE) { // For tiny code model, we use :got_auth: operator to fill 21-bit imm of // adr. It's not actually GOT entry page address but the GOT address // itself - we just share the same variant kind with :got_auth: operator @@ -4411,61 +4402,60 @@ bool AArch64AsmParser::parseSymbolicImmVal(const MCExpr *&ImmVal) { return TokError("expect relocation specifier in operand after ':'"); std::string LowerCase = getTok().getIdentifier().lower(); - RefKind = - StringSwitch(LowerCase) - .Case("lo12", AArch64MCExpr::VK_LO12) - .Case("abs_g3", AArch64MCExpr::VK_ABS_G3) - .Case("abs_g2", AArch64MCExpr::VK_ABS_G2) - .Case("abs_g2_s", AArch64MCExpr::VK_ABS_G2_S) - .Case("abs_g2_nc", AArch64MCExpr::VK_ABS_G2_NC) - .Case("abs_g1", AArch64MCExpr::VK_ABS_G1) - .Case("abs_g1_s", AArch64MCExpr::VK_ABS_G1_S) - .Case("abs_g1_nc", AArch64MCExpr::VK_ABS_G1_NC) - .Case("abs_g0", AArch64MCExpr::VK_ABS_G0) - .Case("abs_g0_s", AArch64MCExpr::VK_ABS_G0_S) - .Case("abs_g0_nc", AArch64MCExpr::VK_ABS_G0_NC) - .Case("prel_g3", AArch64MCExpr::VK_PREL_G3) - .Case("prel_g2", AArch64MCExpr::VK_PREL_G2) - .Case("prel_g2_nc", AArch64MCExpr::VK_PREL_G2_NC) - .Case("prel_g1", AArch64MCExpr::VK_PREL_G1) - .Case("prel_g1_nc", AArch64MCExpr::VK_PREL_G1_NC) - .Case("prel_g0", AArch64MCExpr::VK_PREL_G0) - .Case("prel_g0_nc", AArch64MCExpr::VK_PREL_G0_NC) - .Case("dtprel_g2", AArch64MCExpr::VK_DTPREL_G2) - .Case("dtprel_g1", AArch64MCExpr::VK_DTPREL_G1) - .Case("dtprel_g1_nc", AArch64MCExpr::VK_DTPREL_G1_NC) - .Case("dtprel_g0", AArch64MCExpr::VK_DTPREL_G0) - .Case("dtprel_g0_nc", AArch64MCExpr::VK_DTPREL_G0_NC) - .Case("dtprel_hi12", AArch64MCExpr::VK_DTPREL_HI12) - .Case("dtprel_lo12", AArch64MCExpr::VK_DTPREL_LO12) - .Case("dtprel_lo12_nc", AArch64MCExpr::VK_DTPREL_LO12_NC) - .Case("pg_hi21_nc", AArch64MCExpr::VK_ABS_PAGE_NC) - .Case("tprel_g2", AArch64MCExpr::VK_TPREL_G2) - .Case("tprel_g1", AArch64MCExpr::VK_TPREL_G1) - .Case("tprel_g1_nc", AArch64MCExpr::VK_TPREL_G1_NC) - .Case("tprel_g0", AArch64MCExpr::VK_TPREL_G0) - .Case("tprel_g0_nc", AArch64MCExpr::VK_TPREL_G0_NC) - .Case("tprel_hi12", AArch64MCExpr::VK_TPREL_HI12) - .Case("tprel_lo12", AArch64MCExpr::VK_TPREL_LO12) - .Case("tprel_lo12_nc", AArch64MCExpr::VK_TPREL_LO12_NC) - .Case("tlsdesc_lo12", AArch64MCExpr::VK_TLSDESC_LO12) - .Case("tlsdesc_auth_lo12", AArch64MCExpr::VK_TLSDESC_AUTH_LO12) - .Case("got", AArch64MCExpr::VK_GOT_PAGE) - .Case("gotpage_lo15", AArch64MCExpr::VK_GOT_PAGE_LO15) - .Case("got_lo12", AArch64MCExpr::VK_GOT_LO12) - .Case("got_auth", AArch64MCExpr::VK_GOT_AUTH_PAGE) - .Case("got_auth_lo12", AArch64MCExpr::VK_GOT_AUTH_LO12) - .Case("gottprel", AArch64MCExpr::VK_GOTTPREL_PAGE) - .Case("gottprel_lo12", AArch64MCExpr::VK_GOTTPREL_LO12_NC) - .Case("gottprel_g1", AArch64MCExpr::VK_GOTTPREL_G1) - .Case("gottprel_g0_nc", AArch64MCExpr::VK_GOTTPREL_G0_NC) - .Case("tlsdesc", AArch64MCExpr::VK_TLSDESC_PAGE) - .Case("tlsdesc_auth", AArch64MCExpr::VK_TLSDESC_AUTH_PAGE) - .Case("secrel_lo12", AArch64MCExpr::VK_SECREL_LO12) - .Case("secrel_hi12", AArch64MCExpr::VK_SECREL_HI12) - .Default(AArch64MCExpr::VK_INVALID); - - if (RefKind == AArch64MCExpr::VK_INVALID) + RefKind = StringSwitch(LowerCase) + .Case("lo12", AArch64::S_LO12) + .Case("abs_g3", AArch64::S_ABS_G3) + .Case("abs_g2", AArch64::S_ABS_G2) + .Case("abs_g2_s", AArch64::S_ABS_G2_S) + .Case("abs_g2_nc", AArch64::S_ABS_G2_NC) + .Case("abs_g1", AArch64::S_ABS_G1) + .Case("abs_g1_s", AArch64::S_ABS_G1_S) + .Case("abs_g1_nc", AArch64::S_ABS_G1_NC) + .Case("abs_g0", AArch64::S_ABS_G0) + .Case("abs_g0_s", AArch64::S_ABS_G0_S) + .Case("abs_g0_nc", AArch64::S_ABS_G0_NC) + .Case("prel_g3", AArch64::S_PREL_G3) + .Case("prel_g2", AArch64::S_PREL_G2) + .Case("prel_g2_nc", AArch64::S_PREL_G2_NC) + .Case("prel_g1", AArch64::S_PREL_G1) + .Case("prel_g1_nc", AArch64::S_PREL_G1_NC) + .Case("prel_g0", AArch64::S_PREL_G0) + .Case("prel_g0_nc", AArch64::S_PREL_G0_NC) + .Case("dtprel_g2", AArch64::S_DTPREL_G2) + .Case("dtprel_g1", AArch64::S_DTPREL_G1) + .Case("dtprel_g1_nc", AArch64::S_DTPREL_G1_NC) + .Case("dtprel_g0", AArch64::S_DTPREL_G0) + .Case("dtprel_g0_nc", AArch64::S_DTPREL_G0_NC) + .Case("dtprel_hi12", AArch64::S_DTPREL_HI12) + .Case("dtprel_lo12", AArch64::S_DTPREL_LO12) + .Case("dtprel_lo12_nc", AArch64::S_DTPREL_LO12_NC) + .Case("pg_hi21_nc", AArch64::S_ABS_PAGE_NC) + .Case("tprel_g2", AArch64::S_TPREL_G2) + .Case("tprel_g1", AArch64::S_TPREL_G1) + .Case("tprel_g1_nc", AArch64::S_TPREL_G1_NC) + .Case("tprel_g0", AArch64::S_TPREL_G0) + .Case("tprel_g0_nc", AArch64::S_TPREL_G0_NC) + .Case("tprel_hi12", AArch64::S_TPREL_HI12) + .Case("tprel_lo12", AArch64::S_TPREL_LO12) + .Case("tprel_lo12_nc", AArch64::S_TPREL_LO12_NC) + .Case("tlsdesc_lo12", AArch64::S_TLSDESC_LO12) + .Case("tlsdesc_auth_lo12", AArch64::S_TLSDESC_AUTH_LO12) + .Case("got", AArch64::S_GOT_PAGE) + .Case("gotpage_lo15", AArch64::S_GOT_PAGE_LO15) + .Case("got_lo12", AArch64::S_GOT_LO12) + .Case("got_auth", AArch64::S_GOT_AUTH_PAGE) + .Case("got_auth_lo12", AArch64::S_GOT_AUTH_LO12) + .Case("gottprel", AArch64::S_GOTTPREL_PAGE) + .Case("gottprel_lo12", AArch64::S_GOTTPREL_LO12_NC) + .Case("gottprel_g1", AArch64::S_GOTTPREL_G1) + .Case("gottprel_g0_nc", AArch64::S_GOTTPREL_G0_NC) + .Case("tlsdesc", AArch64::S_TLSDESC_PAGE) + .Case("tlsdesc_auth", AArch64::S_TLSDESC_AUTH_PAGE) + .Case("secrel_lo12", AArch64::S_SECREL_LO12) + .Case("secrel_hi12", AArch64::S_SECREL_HI12) + .Default(AArch64::S_INVALID); + + if (RefKind == AArch64::S_INVALID) return TokError("expect relocation specifier in operand after ':'"); Lex(); // Eat identifier @@ -5852,20 +5842,19 @@ bool AArch64AsmParser::validateInstruction(MCInst &Inst, SMLoc &IDLoc, if (classifySymbolRef(Expr, ELFSpec, DarwinSpec, Addend)) { // Only allow these with ADDXri. - if ((DarwinSpec == AArch64MCExpr::M_PAGEOFF || - DarwinSpec == AArch64MCExpr::M_TLVPPAGEOFF) && + if ((DarwinSpec == AArch64::S_MACHO_PAGEOFF || + DarwinSpec == AArch64::S_MACHO_TLVPPAGEOFF) && Inst.getOpcode() == AArch64::ADDXri) return false; // Only allow these with ADDXri/ADDWri if (llvm::is_contained( - {AArch64MCExpr::VK_LO12, AArch64MCExpr::VK_GOT_AUTH_LO12, - AArch64MCExpr::VK_DTPREL_HI12, AArch64MCExpr::VK_DTPREL_LO12, - AArch64MCExpr::VK_DTPREL_LO12_NC, AArch64MCExpr::VK_TPREL_HI12, - AArch64MCExpr::VK_TPREL_LO12, AArch64MCExpr::VK_TPREL_LO12_NC, - AArch64MCExpr::VK_TLSDESC_LO12, - AArch64MCExpr::VK_TLSDESC_AUTH_LO12, - AArch64MCExpr::VK_SECREL_LO12, AArch64MCExpr::VK_SECREL_HI12}, + {AArch64::S_LO12, AArch64::S_GOT_AUTH_LO12, + AArch64::S_DTPREL_HI12, AArch64::S_DTPREL_LO12, + AArch64::S_DTPREL_LO12_NC, AArch64::S_TPREL_HI12, + AArch64::S_TPREL_LO12, AArch64::S_TPREL_LO12_NC, + AArch64::S_TLSDESC_LO12, AArch64::S_TLSDESC_AUTH_LO12, + AArch64::S_SECREL_LO12, AArch64::S_SECREL_HI12}, ELFSpec) && (Inst.getOpcode() == AArch64::ADDXri || Inst.getOpcode() == AArch64::ADDWri)) @@ -7360,7 +7349,7 @@ bool AArch64AsmParser::parseDirectiveTLSDescCall(SMLoc L) { MCSymbol *Sym = getContext().getOrCreateSymbol(Name); const MCExpr *Expr = MCSymbolRefExpr::create(Sym, getContext()); - Expr = MCSpecifierExpr::create(Expr, AArch64MCExpr::VK_TLSDESC, getContext()); + Expr = MCSpecifierExpr::create(Expr, AArch64::S_TLSDESC, getContext()); MCInst Inst; Inst.setOpcode(AArch64::TLSDESCCALL); @@ -8192,18 +8181,18 @@ bool AArch64AsmParser::parseDataExpr(const MCExpr *&Res) { if (Identifier == "auth") return parseAuthExpr(Res, EndLoc); - auto Spec = AArch64MCExpr::None; + auto Spec = AArch64::S_None; if (STI->getTargetTriple().isOSBinFormatMachO()) { if (Identifier == "got") - Spec = AArch64MCExpr::M_GOT; + Spec = AArch64::S_MACHO_GOT; } else { // Unofficial, experimental syntax that will be changed. if (Identifier == "gotpcrel") - Spec = AArch64MCExpr::VK_GOTPCREL; + Spec = AArch64::S_GOTPCREL; else if (Identifier == "plt") - Spec = AArch64MCExpr::VK_PLT; + Spec = AArch64::S_PLT; } - if (Spec == AArch64MCExpr::None) + if (Spec == AArch64::S_None) return Error(Loc, "invalid relocation specifier"); if (auto *SRE = dyn_cast(Res)) Res = MCSymbolRefExpr::create(&SRE->getSymbol(), Spec, getContext(), @@ -8284,8 +8273,8 @@ bool AArch64AsmParser::classifySymbolRef(const MCExpr *Expr, AArch64MCExpr::Specifier &ELFSpec, AArch64MCExpr::Specifier &DarwinSpec, int64_t &Addend) { - ELFSpec = AArch64MCExpr::VK_INVALID; - DarwinSpec = AArch64MCExpr::None; + ELFSpec = AArch64::S_INVALID; + DarwinSpec = AArch64::S_None; Addend = 0; if (auto *AE = dyn_cast(Expr)) { @@ -8308,7 +8297,7 @@ bool AArch64AsmParser::classifySymbolRef(const MCExpr *Expr, // Treat expressions with an ELFSpec (like ":abs_g1:3", or // ":abs_g1:x" where x is constant) as symbolic even if there is no symbol. - if (!Res.getAddSym() && ELFSpec == AArch64MCExpr::VK_INVALID) + if (!Res.getAddSym() && ELFSpec == AArch64::S_INVALID) return false; if (Res.getAddSym()) @@ -8317,8 +8306,7 @@ bool AArch64AsmParser::classifySymbolRef(const MCExpr *Expr, // It's some symbol reference + a constant addend, but really // shouldn't use both Darwin and ELF syntax. - return ELFSpec == AArch64MCExpr::VK_INVALID || - DarwinSpec == AArch64MCExpr::None; + return ELFSpec == AArch64::S_INVALID || DarwinSpec == AArch64::S_None; } /// Force static initialization. diff --git a/llvm/lib/Target/AArch64/Disassembler/AArch64ExternalSymbolizer.cpp b/llvm/lib/Target/AArch64/Disassembler/AArch64ExternalSymbolizer.cpp index f2528bc121045..3a8a0ef46b035 100644 --- a/llvm/lib/Target/AArch64/Disassembler/AArch64ExternalSymbolizer.cpp +++ b/llvm/lib/Target/AArch64/Disassembler/AArch64ExternalSymbolizer.cpp @@ -7,7 +7,7 @@ //===----------------------------------------------------------------------===// #include "AArch64ExternalSymbolizer.h" -#include "MCTargetDesc/AArch64MCExpr.h" +#include "MCTargetDesc/AArch64MCAsmInfo.h" #include "llvm/MC/MCContext.h" #include "llvm/MC/MCExpr.h" #include "llvm/MC/MCInst.h" @@ -19,23 +19,23 @@ using namespace llvm; #define DEBUG_TYPE "aarch64-disassembler" -static AArch64MCExpr::Specifier +static AArch64::Specifier getMachOSpecifier(uint64_t LLVMDisassembler_VariantKind) { switch (LLVMDisassembler_VariantKind) { case LLVMDisassembler_VariantKind_None: - return AArch64MCExpr::None; + return AArch64::S_None; case LLVMDisassembler_VariantKind_ARM64_PAGE: - return AArch64MCExpr::M_PAGE; + return AArch64::S_MACHO_PAGE; case LLVMDisassembler_VariantKind_ARM64_PAGEOFF: - return AArch64MCExpr::M_PAGEOFF; + return AArch64::S_MACHO_PAGEOFF; case LLVMDisassembler_VariantKind_ARM64_GOTPAGE: - return AArch64MCExpr::M_GOTPAGE; + return AArch64::S_MACHO_GOTPAGE; case LLVMDisassembler_VariantKind_ARM64_GOTPAGEOFF: - return AArch64MCExpr::M_GOTPAGEOFF; + return AArch64::S_MACHO_GOTPAGEOFF; case LLVMDisassembler_VariantKind_ARM64_TLVP: - return AArch64MCExpr::M_TLVPPAGE; + return AArch64::S_MACHO_TLVPPAGE; case LLVMDisassembler_VariantKind_ARM64_TLVOFF: - return AArch64MCExpr::M_TLVPPAGEOFF; + return AArch64::S_MACHO_TLVPPAGEOFF; default: llvm_unreachable("bad LLVMDisassembler_VariantKind"); } @@ -171,7 +171,7 @@ bool AArch64ExternalSymbolizer::tryAddingSymbolicOperand( StringRef Name(SymbolicOp.AddSymbol.Name); MCSymbol *Sym = Ctx.getOrCreateSymbol(Name); auto Spec = getMachOSpecifier(SymbolicOp.VariantKind); - if (Spec != AArch64MCExpr::None) + if (Spec != AArch64::S_None) Add = MCSymbolRefExpr::create(Sym, Spec, Ctx); else Add = MCSymbolRefExpr::create(Sym, Ctx); diff --git a/llvm/lib/Target/AArch64/MCTargetDesc/AArch64AsmBackend.cpp b/llvm/lib/Target/AArch64/MCTargetDesc/AArch64AsmBackend.cpp index 88ba2ef3fe1ff..38ea57161209c 100644 --- a/llvm/lib/Target/AArch64/MCTargetDesc/AArch64AsmBackend.cpp +++ b/llvm/lib/Target/AArch64/MCTargetDesc/AArch64AsmBackend.cpp @@ -221,8 +221,8 @@ static uint64_t adjustFixupValue(const MCFixup &Fixup, const MCValue &Target, case AArch64::fixup_aarch64_movw: { AArch64MCExpr::Specifier RefKind = static_cast(Target.getSpecifier()); - if (AArch64::getSymbolLoc(RefKind) != AArch64MCExpr::VK_ABS && - AArch64::getSymbolLoc(RefKind) != AArch64MCExpr::VK_SABS) { + if (AArch64::getSymbolLoc(RefKind) != AArch64::S_ABS && + AArch64::getSymbolLoc(RefKind) != AArch64::S_SABS) { if (!RefKind) { // The fixup is an expression if (SignedValue > 0xFFFF || SignedValue < -0xFFFF) @@ -250,17 +250,17 @@ static uint64_t adjustFixupValue(const MCFixup &Fixup, const MCValue &Target, return Value; } - if (AArch64::getSymbolLoc(RefKind) == AArch64MCExpr::VK_SABS) { + if (AArch64::getSymbolLoc(RefKind) == AArch64::S_SABS) { switch (AArch64::getAddressFrag(RefKind)) { - case AArch64MCExpr::VK_G0: + case AArch64::S_G0: break; - case AArch64MCExpr::VK_G1: + case AArch64::S_G1: SignedValue = SignedValue >> 16; break; - case AArch64MCExpr::VK_G2: + case AArch64::S_G2: SignedValue = SignedValue >> 32; break; - case AArch64MCExpr::VK_G3: + case AArch64::S_G3: SignedValue = SignedValue >> 48; break; default: @@ -269,15 +269,15 @@ static uint64_t adjustFixupValue(const MCFixup &Fixup, const MCValue &Target, } else { switch (AArch64::getAddressFrag(RefKind)) { - case AArch64MCExpr::VK_G0: + case AArch64::S_G0: break; - case AArch64MCExpr::VK_G1: + case AArch64::S_G1: Value = Value >> 16; break; - case AArch64MCExpr::VK_G2: + case AArch64::S_G2: Value = Value >> 32; break; - case AArch64MCExpr::VK_G3: + case AArch64::S_G3: Value = Value >> 48; break; default: @@ -285,9 +285,9 @@ static uint64_t adjustFixupValue(const MCFixup &Fixup, const MCValue &Target, } } - if (RefKind & AArch64MCExpr::VK_NC) { + if (RefKind & AArch64::S_NC) { Value &= 0xFFFF; - } else if (AArch64::getSymbolLoc(RefKind) == AArch64MCExpr::VK_SABS) { + } else if (AArch64::getSymbolLoc(RefKind) == AArch64::S_SABS) { if (SignedValue > 0xFFFF || SignedValue < -0xFFFF) Ctx.reportError(Fixup.getLoc(), "fixup value out of range"); @@ -423,8 +423,7 @@ void AArch64AsmBackend::applyFixup(const MCFragment &, const MCFixup &Fixup, if (Fixup.getTargetKind() == FK_Data_8 && TheTriple.isOSBinFormatELF()) { auto RefKind = static_cast(Target.getSpecifier()); AArch64MCExpr::Specifier SymLoc = AArch64::getSymbolLoc(RefKind); - if (SymLoc == AArch64MCExpr::VK_AUTH || - SymLoc == AArch64MCExpr::VK_AUTHADDR) { + if (SymLoc == AArch64::S_AUTH || SymLoc == AArch64::S_AUTHADDR) { const auto *Expr = dyn_cast(Fixup.getValue()); if (!Expr) { getContext().reportError(Fixup.getValue()->getLoc(), @@ -477,7 +476,7 @@ void AArch64AsmBackend::applyFixup(const MCFragment &, const MCFixup &Fixup, // handle this more cleanly. This may affect the output of -show-mc-encoding. AArch64MCExpr::Specifier RefKind = static_cast(Target.getSpecifier()); - if (AArch64::getSymbolLoc(RefKind) == AArch64MCExpr::VK_SABS || + if (AArch64::getSymbolLoc(RefKind) == AArch64::S_SABS || (!RefKind && Fixup.getTargetKind() == AArch64::fixup_aarch64_movw)) { // If the immediate is negative, generate MOVN else MOVZ. // (Bit 30 = 0) ==> MOVN, (Bit 30 = 1) ==> MOVZ. diff --git a/llvm/lib/Target/AArch64/MCTargetDesc/AArch64ELFObjectWriter.cpp b/llvm/lib/Target/AArch64/MCTargetDesc/AArch64ELFObjectWriter.cpp index 28aa4644a55fd..ebd5f30796195 100644 --- a/llvm/lib/Target/AArch64/MCTargetDesc/AArch64ELFObjectWriter.cpp +++ b/llvm/lib/Target/AArch64/MCTargetDesc/AArch64ELFObjectWriter.cpp @@ -61,18 +61,18 @@ bool AArch64ELFObjectWriter::isNonILP32reloc( if (Fixup.getTargetKind() != AArch64::fixup_aarch64_movw) return false; switch (RefKind) { - case AArch64MCExpr::VK_ABS_G3: - case AArch64MCExpr::VK_ABS_G2: - case AArch64MCExpr::VK_ABS_G2_S: - case AArch64MCExpr::VK_ABS_G2_NC: - case AArch64MCExpr::VK_ABS_G1_S: - case AArch64MCExpr::VK_ABS_G1_NC: - case AArch64MCExpr::VK_DTPREL_G2: - case AArch64MCExpr::VK_DTPREL_G1_NC: - case AArch64MCExpr::VK_TPREL_G2: - case AArch64MCExpr::VK_TPREL_G1_NC: - case AArch64MCExpr::VK_GOTTPREL_G1: - case AArch64MCExpr::VK_GOTTPREL_G0_NC: + case AArch64::S_ABS_G3: + case AArch64::S_ABS_G2: + case AArch64::S_ABS_G2_S: + case AArch64::S_ABS_G2_NC: + case AArch64::S_ABS_G1_S: + case AArch64::S_ABS_G1_NC: + case AArch64::S_DTPREL_G2: + case AArch64::S_DTPREL_G1_NC: + case AArch64::S_TPREL_G2: + case AArch64::S_TPREL_G1_NC: + case AArch64::S_GOTTPREL_G1: + case AArch64::S_GOTTPREL_G0_NC: reportError(Fixup.getLoc(), "absolute MOV relocation is not supported in ILP32"); return true; @@ -92,11 +92,11 @@ unsigned AArch64ELFObjectWriter::getRelocType(const MCFixup &Fixup, bool IsNC = AArch64::isNotChecked(RefKind); switch (SymLoc) { - case AArch64MCExpr::VK_DTPREL: - case AArch64MCExpr::VK_GOTTPREL: - case AArch64MCExpr::VK_TPREL: - case AArch64MCExpr::VK_TLSDESC: - case AArch64MCExpr::VK_TLSDESC_AUTH: + case AArch64::S_DTPREL: + case AArch64::S_GOTTPREL: + case AArch64::S_TPREL: + case AArch64::S_TLSDESC: + case AArch64::S_TLSDESC_AUTH: if (auto *SA = Target.getAddSym()) cast(SA)->setType(ELF::STT_TLS); break; @@ -117,8 +117,7 @@ unsigned AArch64ELFObjectWriter::getRelocType(const MCFixup &Fixup, case FK_Data_2: return R_CLS(PREL16); case FK_Data_4: { - return AArch64MCExpr::Specifier(Target.getSpecifier()) == - AArch64MCExpr::VK_PLT + return AArch64MCExpr::Specifier(Target.getSpecifier()) == AArch64::S_PLT ? R_CLS(PLT32) : R_CLS(PREL32); } @@ -130,7 +129,7 @@ unsigned AArch64ELFObjectWriter::getRelocType(const MCFixup &Fixup, } return ELF::R_AARCH64_PREL64; case AArch64::fixup_aarch64_pcrel_adr_imm21: - if (SymLoc == AArch64MCExpr::VK_GOT_AUTH) { + if (SymLoc == AArch64::S_GOT_AUTH) { if (IsILP32) { reportError(Fixup.getLoc(), "ADR AUTH relocation is not supported in ILP32"); @@ -138,13 +137,13 @@ unsigned AArch64ELFObjectWriter::getRelocType(const MCFixup &Fixup, } return ELF::R_AARCH64_AUTH_GOT_ADR_PREL_LO21; } - if (SymLoc != AArch64MCExpr::VK_ABS) + if (SymLoc != AArch64::S_ABS) reportError(Fixup.getLoc(), "invalid symbol kind for ADR relocation"); return R_CLS(ADR_PREL_LO21); case AArch64::fixup_aarch64_pcrel_adrp_imm21: - if (SymLoc == AArch64MCExpr::VK_ABS && !IsNC) + if (SymLoc == AArch64::S_ABS && !IsNC) return R_CLS(ADR_PREL_PG_HI21); - if (SymLoc == AArch64MCExpr::VK_ABS && IsNC) { + if (SymLoc == AArch64::S_ABS && IsNC) { if (IsILP32) { reportError(Fixup.getLoc(), "invalid fixup for 32-bit pcrel ADRP instruction " @@ -153,9 +152,9 @@ unsigned AArch64ELFObjectWriter::getRelocType(const MCFixup &Fixup, } return ELF::R_AARCH64_ADR_PREL_PG_HI21_NC; } - if (SymLoc == AArch64MCExpr::VK_GOT && !IsNC) + if (SymLoc == AArch64::S_GOT && !IsNC) return R_CLS(ADR_GOT_PAGE); - if (SymLoc == AArch64MCExpr::VK_GOT_AUTH && !IsNC) { + if (SymLoc == AArch64::S_GOT_AUTH && !IsNC) { if (IsILP32) { reportError(Fixup.getLoc(), "ADRP AUTH relocation is not supported in ILP32"); @@ -163,11 +162,11 @@ unsigned AArch64ELFObjectWriter::getRelocType(const MCFixup &Fixup, } return ELF::R_AARCH64_AUTH_ADR_GOT_PAGE; } - if (SymLoc == AArch64MCExpr::VK_GOTTPREL && !IsNC) + if (SymLoc == AArch64::S_GOTTPREL && !IsNC) return R_CLS(TLSIE_ADR_GOTTPREL_PAGE21); - if (SymLoc == AArch64MCExpr::VK_TLSDESC && !IsNC) + if (SymLoc == AArch64::S_TLSDESC && !IsNC) return R_CLS(TLSDESC_ADR_PAGE21); - if (SymLoc == AArch64MCExpr::VK_TLSDESC_AUTH && !IsNC) { + if (SymLoc == AArch64::S_TLSDESC_AUTH && !IsNC) { if (IsILP32) { reportError(Fixup.getLoc(), "ADRP AUTH relocation is not supported in ILP32"); @@ -182,11 +181,11 @@ unsigned AArch64ELFObjectWriter::getRelocType(const MCFixup &Fixup, case AArch64::fixup_aarch64_pcrel_call26: return R_CLS(CALL26); case AArch64::fixup_aarch64_ldr_pcrel_imm19: - if (SymLoc == AArch64MCExpr::VK_GOTTPREL) + if (SymLoc == AArch64::S_GOTTPREL) return R_CLS(TLSIE_LD_GOTTPREL_PREL19); - if (SymLoc == AArch64MCExpr::VK_GOT) + if (SymLoc == AArch64::S_GOT) return R_CLS(GOT_LD_PREL19); - if (SymLoc == AArch64MCExpr::VK_GOT_AUTH) { + if (SymLoc == AArch64::S_GOT_AUTH) { if (IsILP32) { reportError(Fixup.getLoc(), "LDR AUTH relocation is not supported in ILP32"); @@ -223,7 +222,7 @@ unsigned AArch64ELFObjectWriter::getRelocType(const MCFixup &Fixup, return R_CLS(ABS16); case FK_Data_4: return (!IsILP32 && AArch64MCExpr::Specifier(Target.getSpecifier()) == - AArch64MCExpr::VK_GOTPCREL) + AArch64::S_GOTPCREL) ? ELF::R_AARCH64_GOTPCREL32 : R_CLS(ABS32); case FK_Data_8: { @@ -233,27 +232,26 @@ unsigned AArch64ELFObjectWriter::getRelocType(const MCFixup &Fixup, "8 byte absolute data relocation is not supported in ILP32"); return ELF::R_AARCH64_NONE; } - if (RefKind == AArch64MCExpr::VK_AUTH || - RefKind == AArch64MCExpr::VK_AUTHADDR) + if (RefKind == AArch64::S_AUTH || RefKind == AArch64::S_AUTHADDR) return ELF::R_AARCH64_AUTH_ABS64; return ELF::R_AARCH64_ABS64; } case AArch64::fixup_aarch64_add_imm12: - if (RefKind == AArch64MCExpr::VK_DTPREL_HI12) + if (RefKind == AArch64::S_DTPREL_HI12) return R_CLS(TLSLD_ADD_DTPREL_HI12); - if (RefKind == AArch64MCExpr::VK_TPREL_HI12) + if (RefKind == AArch64::S_TPREL_HI12) return R_CLS(TLSLE_ADD_TPREL_HI12); - if (RefKind == AArch64MCExpr::VK_DTPREL_LO12_NC) + if (RefKind == AArch64::S_DTPREL_LO12_NC) return R_CLS(TLSLD_ADD_DTPREL_LO12_NC); - if (RefKind == AArch64MCExpr::VK_DTPREL_LO12) + if (RefKind == AArch64::S_DTPREL_LO12) return R_CLS(TLSLD_ADD_DTPREL_LO12); - if (RefKind == AArch64MCExpr::VK_TPREL_LO12_NC) + if (RefKind == AArch64::S_TPREL_LO12_NC) return R_CLS(TLSLE_ADD_TPREL_LO12_NC); - if (RefKind == AArch64MCExpr::VK_TPREL_LO12) + if (RefKind == AArch64::S_TPREL_LO12) return R_CLS(TLSLE_ADD_TPREL_LO12); - if (RefKind == AArch64MCExpr::VK_TLSDESC_LO12) + if (RefKind == AArch64::S_TLSDESC_LO12) return R_CLS(TLSDESC_ADD_LO12); - if (RefKind == AArch64MCExpr::VK_TLSDESC_AUTH_LO12) { + if (RefKind == AArch64::S_TLSDESC_AUTH_LO12) { if (IsILP32) { reportError(Fixup.getLoc(), "ADD AUTH relocation is not supported in ILP32"); @@ -261,7 +259,7 @@ unsigned AArch64ELFObjectWriter::getRelocType(const MCFixup &Fixup, } return ELF::R_AARCH64_AUTH_TLSDESC_ADD_LO12; } - if (RefKind == AArch64MCExpr::VK_GOT_AUTH_LO12 && IsNC) { + if (RefKind == AArch64::S_GOT_AUTH_LO12 && IsNC) { if (IsILP32) { reportError(Fixup.getLoc(), "ADD AUTH relocation is not supported in ILP32"); @@ -269,60 +267,60 @@ unsigned AArch64ELFObjectWriter::getRelocType(const MCFixup &Fixup, } return ELF::R_AARCH64_AUTH_GOT_ADD_LO12_NC; } - if (SymLoc == AArch64MCExpr::VK_ABS && IsNC) + if (SymLoc == AArch64::S_ABS && IsNC) return R_CLS(ADD_ABS_LO12_NC); reportError(Fixup.getLoc(), "invalid fixup for add (uimm12) instruction"); return ELF::R_AARCH64_NONE; case AArch64::fixup_aarch64_ldst_imm12_scale1: - if (SymLoc == AArch64MCExpr::VK_ABS && IsNC) + if (SymLoc == AArch64::S_ABS && IsNC) return R_CLS(LDST8_ABS_LO12_NC); - if (SymLoc == AArch64MCExpr::VK_DTPREL && !IsNC) + if (SymLoc == AArch64::S_DTPREL && !IsNC) return R_CLS(TLSLD_LDST8_DTPREL_LO12); - if (SymLoc == AArch64MCExpr::VK_DTPREL && IsNC) + if (SymLoc == AArch64::S_DTPREL && IsNC) return R_CLS(TLSLD_LDST8_DTPREL_LO12_NC); - if (SymLoc == AArch64MCExpr::VK_TPREL && !IsNC) + if (SymLoc == AArch64::S_TPREL && !IsNC) return R_CLS(TLSLE_LDST8_TPREL_LO12); - if (SymLoc == AArch64MCExpr::VK_TPREL && IsNC) + if (SymLoc == AArch64::S_TPREL && IsNC) return R_CLS(TLSLE_LDST8_TPREL_LO12_NC); reportError(Fixup.getLoc(), "invalid fixup for 8-bit load/store instruction"); return ELF::R_AARCH64_NONE; case AArch64::fixup_aarch64_ldst_imm12_scale2: - if (SymLoc == AArch64MCExpr::VK_ABS && IsNC) + if (SymLoc == AArch64::S_ABS && IsNC) return R_CLS(LDST16_ABS_LO12_NC); - if (SymLoc == AArch64MCExpr::VK_DTPREL && !IsNC) + if (SymLoc == AArch64::S_DTPREL && !IsNC) return R_CLS(TLSLD_LDST16_DTPREL_LO12); - if (SymLoc == AArch64MCExpr::VK_DTPREL && IsNC) + if (SymLoc == AArch64::S_DTPREL && IsNC) return R_CLS(TLSLD_LDST16_DTPREL_LO12_NC); - if (SymLoc == AArch64MCExpr::VK_TPREL && !IsNC) + if (SymLoc == AArch64::S_TPREL && !IsNC) return R_CLS(TLSLE_LDST16_TPREL_LO12); - if (SymLoc == AArch64MCExpr::VK_TPREL && IsNC) + if (SymLoc == AArch64::S_TPREL && IsNC) return R_CLS(TLSLE_LDST16_TPREL_LO12_NC); reportError(Fixup.getLoc(), "invalid fixup for 16-bit load/store instruction"); return ELF::R_AARCH64_NONE; case AArch64::fixup_aarch64_ldst_imm12_scale4: - if (SymLoc == AArch64MCExpr::VK_ABS && IsNC) + if (SymLoc == AArch64::S_ABS && IsNC) return R_CLS(LDST32_ABS_LO12_NC); - if (SymLoc == AArch64MCExpr::VK_DTPREL && !IsNC) + if (SymLoc == AArch64::S_DTPREL && !IsNC) return R_CLS(TLSLD_LDST32_DTPREL_LO12); - if (SymLoc == AArch64MCExpr::VK_DTPREL && IsNC) + if (SymLoc == AArch64::S_DTPREL && IsNC) return R_CLS(TLSLD_LDST32_DTPREL_LO12_NC); - if (SymLoc == AArch64MCExpr::VK_TPREL && !IsNC) + if (SymLoc == AArch64::S_TPREL && !IsNC) return R_CLS(TLSLE_LDST32_TPREL_LO12); - if (SymLoc == AArch64MCExpr::VK_TPREL && IsNC) + if (SymLoc == AArch64::S_TPREL && IsNC) return R_CLS(TLSLE_LDST32_TPREL_LO12_NC); - if (SymLoc == AArch64MCExpr::VK_GOT && IsNC) { + if (SymLoc == AArch64::S_GOT && IsNC) { if (IsILP32) return ELF::R_AARCH64_P32_LD32_GOT_LO12_NC; reportError(Fixup.getLoc(), "4 byte unchecked GOT load/store " "relocation is not supported in LP64"); return ELF::R_AARCH64_NONE; } - if (SymLoc == AArch64MCExpr::VK_GOT && !IsNC) { + if (SymLoc == AArch64::S_GOT && !IsNC) { if (IsILP32) { reportError( Fixup.getLoc(), @@ -330,14 +328,14 @@ unsigned AArch64ELFObjectWriter::getRelocType(const MCFixup &Fixup, } return ELF::R_AARCH64_NONE; } - if (SymLoc == AArch64MCExpr::VK_GOTTPREL && IsNC) { + if (SymLoc == AArch64::S_GOTTPREL && IsNC) { if (IsILP32) return ELF::R_AARCH64_P32_TLSIE_LD32_GOTTPREL_LO12_NC; reportError(Fixup.getLoc(), "32-bit load/store " "relocation is not supported in LP64"); return ELF::R_AARCH64_NONE; } - if (SymLoc == AArch64MCExpr::VK_TLSDESC && !IsNC) { + if (SymLoc == AArch64::S_TLSDESC && !IsNC) { if (IsILP32) return ELF::R_AARCH64_P32_TLSDESC_LD32_LO12; reportError( @@ -351,15 +349,13 @@ unsigned AArch64ELFObjectWriter::getRelocType(const MCFixup &Fixup, "fixup_aarch64_ldst_imm12_scale4"); return ELF::R_AARCH64_NONE; case AArch64::fixup_aarch64_ldst_imm12_scale8: - if (SymLoc == AArch64MCExpr::VK_ABS && IsNC) + if (SymLoc == AArch64::S_ABS && IsNC) return R_CLS(LDST64_ABS_LO12_NC); - if ((SymLoc == AArch64MCExpr::VK_GOT || - SymLoc == AArch64MCExpr::VK_GOT_AUTH) && - IsNC) { + if ((SymLoc == AArch64::S_GOT || SymLoc == AArch64::S_GOT_AUTH) && IsNC) { AArch64MCExpr::Specifier AddressLoc = AArch64::getAddressFrag(RefKind); - bool IsAuth = (SymLoc == AArch64MCExpr::VK_GOT_AUTH); + bool IsAuth = (SymLoc == AArch64::S_GOT_AUTH); if (!IsILP32) { - if (AddressLoc == AArch64MCExpr::VK_LO15) + if (AddressLoc == AArch64::S_LO15) return ELF::R_AARCH64_LD64_GOTPAGE_LO15; return (IsAuth ? ELF::R_AARCH64_AUTH_LD64_GOT_LO12_NC : ELF::R_AARCH64_LD64_GOT_LO12_NC); @@ -368,29 +364,29 @@ unsigned AArch64ELFObjectWriter::getRelocType(const MCFixup &Fixup, "64-bit load/store relocation is not supported in ILP32"); return ELF::R_AARCH64_NONE; } - if (SymLoc == AArch64MCExpr::VK_DTPREL && !IsNC) + if (SymLoc == AArch64::S_DTPREL && !IsNC) return R_CLS(TLSLD_LDST64_DTPREL_LO12); - if (SymLoc == AArch64MCExpr::VK_DTPREL && IsNC) + if (SymLoc == AArch64::S_DTPREL && IsNC) return R_CLS(TLSLD_LDST64_DTPREL_LO12_NC); - if (SymLoc == AArch64MCExpr::VK_TPREL && !IsNC) + if (SymLoc == AArch64::S_TPREL && !IsNC) return R_CLS(TLSLE_LDST64_TPREL_LO12); - if (SymLoc == AArch64MCExpr::VK_TPREL && IsNC) + if (SymLoc == AArch64::S_TPREL && IsNC) return R_CLS(TLSLE_LDST64_TPREL_LO12_NC); - if (SymLoc == AArch64MCExpr::VK_GOTTPREL && IsNC) { + if (SymLoc == AArch64::S_GOTTPREL && IsNC) { if (!IsILP32) return ELF::R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC; reportError(Fixup.getLoc(), "64-bit load/store relocation is not supported in ILP32"); return ELF::R_AARCH64_NONE; } - if (SymLoc == AArch64MCExpr::VK_TLSDESC) { + if (SymLoc == AArch64::S_TLSDESC) { if (!IsILP32) return ELF::R_AARCH64_TLSDESC_LD64_LO12; reportError(Fixup.getLoc(), "64-bit load/store relocation is not supported in ILP32"); return ELF::R_AARCH64_NONE; } - if (SymLoc == AArch64MCExpr::VK_TLSDESC_AUTH) { + if (SymLoc == AArch64::S_TLSDESC_AUTH) { if (!IsILP32) return ELF::R_AARCH64_AUTH_TLSDESC_LD64_LO12; reportError( @@ -402,15 +398,15 @@ unsigned AArch64ELFObjectWriter::getRelocType(const MCFixup &Fixup, "invalid fixup for 64-bit load/store instruction"); return ELF::R_AARCH64_NONE; case AArch64::fixup_aarch64_ldst_imm12_scale16: - if (SymLoc == AArch64MCExpr::VK_ABS && IsNC) + if (SymLoc == AArch64::S_ABS && IsNC) return R_CLS(LDST128_ABS_LO12_NC); - if (SymLoc == AArch64MCExpr::VK_DTPREL && !IsNC) + if (SymLoc == AArch64::S_DTPREL && !IsNC) return R_CLS(TLSLD_LDST128_DTPREL_LO12); - if (SymLoc == AArch64MCExpr::VK_DTPREL && IsNC) + if (SymLoc == AArch64::S_DTPREL && IsNC) return R_CLS(TLSLD_LDST128_DTPREL_LO12_NC); - if (SymLoc == AArch64MCExpr::VK_TPREL && !IsNC) + if (SymLoc == AArch64::S_TPREL && !IsNC) return R_CLS(TLSLE_LDST128_TPREL_LO12); - if (SymLoc == AArch64MCExpr::VK_TPREL && IsNC) + if (SymLoc == AArch64::S_TPREL && IsNC) return R_CLS(TLSLE_LDST128_TPREL_LO12_NC); reportError(Fixup.getLoc(), @@ -418,63 +414,63 @@ unsigned AArch64ELFObjectWriter::getRelocType(const MCFixup &Fixup, return ELF::R_AARCH64_NONE; // ILP32 case not reached here, tested with isNonILP32reloc case AArch64::fixup_aarch64_movw: - if (RefKind == AArch64MCExpr::VK_ABS_G3) + if (RefKind == AArch64::S_ABS_G3) return ELF::R_AARCH64_MOVW_UABS_G3; - if (RefKind == AArch64MCExpr::VK_ABS_G2) + if (RefKind == AArch64::S_ABS_G2) return ELF::R_AARCH64_MOVW_UABS_G2; - if (RefKind == AArch64MCExpr::VK_ABS_G2_S) + if (RefKind == AArch64::S_ABS_G2_S) return ELF::R_AARCH64_MOVW_SABS_G2; - if (RefKind == AArch64MCExpr::VK_ABS_G2_NC) + if (RefKind == AArch64::S_ABS_G2_NC) return ELF::R_AARCH64_MOVW_UABS_G2_NC; - if (RefKind == AArch64MCExpr::VK_ABS_G1) + if (RefKind == AArch64::S_ABS_G1) return R_CLS(MOVW_UABS_G1); - if (RefKind == AArch64MCExpr::VK_ABS_G1_S) + if (RefKind == AArch64::S_ABS_G1_S) return ELF::R_AARCH64_MOVW_SABS_G1; - if (RefKind == AArch64MCExpr::VK_ABS_G1_NC) + if (RefKind == AArch64::S_ABS_G1_NC) return ELF::R_AARCH64_MOVW_UABS_G1_NC; - if (RefKind == AArch64MCExpr::VK_ABS_G0) + if (RefKind == AArch64::S_ABS_G0) return R_CLS(MOVW_UABS_G0); - if (RefKind == AArch64MCExpr::VK_ABS_G0_S) + if (RefKind == AArch64::S_ABS_G0_S) return R_CLS(MOVW_SABS_G0); - if (RefKind == AArch64MCExpr::VK_ABS_G0_NC) + if (RefKind == AArch64::S_ABS_G0_NC) return R_CLS(MOVW_UABS_G0_NC); - if (RefKind == AArch64MCExpr::VK_PREL_G3) + if (RefKind == AArch64::S_PREL_G3) return ELF::R_AARCH64_MOVW_PREL_G3; - if (RefKind == AArch64MCExpr::VK_PREL_G2) + if (RefKind == AArch64::S_PREL_G2) return ELF::R_AARCH64_MOVW_PREL_G2; - if (RefKind == AArch64MCExpr::VK_PREL_G2_NC) + if (RefKind == AArch64::S_PREL_G2_NC) return ELF::R_AARCH64_MOVW_PREL_G2_NC; - if (RefKind == AArch64MCExpr::VK_PREL_G1) + if (RefKind == AArch64::S_PREL_G1) return R_CLS(MOVW_PREL_G1); - if (RefKind == AArch64MCExpr::VK_PREL_G1_NC) + if (RefKind == AArch64::S_PREL_G1_NC) return ELF::R_AARCH64_MOVW_PREL_G1_NC; - if (RefKind == AArch64MCExpr::VK_PREL_G0) + if (RefKind == AArch64::S_PREL_G0) return R_CLS(MOVW_PREL_G0); - if (RefKind == AArch64MCExpr::VK_PREL_G0_NC) + if (RefKind == AArch64::S_PREL_G0_NC) return R_CLS(MOVW_PREL_G0_NC); - if (RefKind == AArch64MCExpr::VK_DTPREL_G2) + if (RefKind == AArch64::S_DTPREL_G2) return ELF::R_AARCH64_TLSLD_MOVW_DTPREL_G2; - if (RefKind == AArch64MCExpr::VK_DTPREL_G1) + if (RefKind == AArch64::S_DTPREL_G1) return R_CLS(TLSLD_MOVW_DTPREL_G1); - if (RefKind == AArch64MCExpr::VK_DTPREL_G1_NC) + if (RefKind == AArch64::S_DTPREL_G1_NC) return ELF::R_AARCH64_TLSLD_MOVW_DTPREL_G1_NC; - if (RefKind == AArch64MCExpr::VK_DTPREL_G0) + if (RefKind == AArch64::S_DTPREL_G0) return R_CLS(TLSLD_MOVW_DTPREL_G0); - if (RefKind == AArch64MCExpr::VK_DTPREL_G0_NC) + if (RefKind == AArch64::S_DTPREL_G0_NC) return R_CLS(TLSLD_MOVW_DTPREL_G0_NC); - if (RefKind == AArch64MCExpr::VK_TPREL_G2) + if (RefKind == AArch64::S_TPREL_G2) return ELF::R_AARCH64_TLSLE_MOVW_TPREL_G2; - if (RefKind == AArch64MCExpr::VK_TPREL_G1) + if (RefKind == AArch64::S_TPREL_G1) return R_CLS(TLSLE_MOVW_TPREL_G1); - if (RefKind == AArch64MCExpr::VK_TPREL_G1_NC) + if (RefKind == AArch64::S_TPREL_G1_NC) return ELF::R_AARCH64_TLSLE_MOVW_TPREL_G1_NC; - if (RefKind == AArch64MCExpr::VK_TPREL_G0) + if (RefKind == AArch64::S_TPREL_G0) return R_CLS(TLSLE_MOVW_TPREL_G0); - if (RefKind == AArch64MCExpr::VK_TPREL_G0_NC) + if (RefKind == AArch64::S_TPREL_G0_NC) return R_CLS(TLSLE_MOVW_TPREL_G0_NC); - if (RefKind == AArch64MCExpr::VK_GOTTPREL_G1) + if (RefKind == AArch64::S_GOTTPREL_G1) return ELF::R_AARCH64_TLSIE_MOVW_GOTTPREL_G1; - if (RefKind == AArch64MCExpr::VK_GOTTPREL_G0_NC) + if (RefKind == AArch64::S_GOTTPREL_G0_NC) return ELF::R_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC; reportError(Fixup.getLoc(), "invalid fixup for movz/movk instruction"); return ELF::R_AARCH64_NONE; @@ -498,9 +494,9 @@ bool AArch64ELFObjectWriter::needsRelocateWithSymbol(const MCValue &Val, if (Val.getAddSym() && cast(Val.getAddSym())->isMemtag()) return true; - if ((Val.getSpecifier() & AArch64MCExpr::VK_GOT) == AArch64MCExpr::VK_GOT) + if ((Val.getSpecifier() & AArch64::S_GOT) == AArch64::S_GOT) return true; - return is_contained({AArch64MCExpr::VK_GOTPCREL, AArch64MCExpr::VK_PLT}, + return is_contained({AArch64::S_GOTPCREL, AArch64::S_PLT}, AArch64MCExpr::Specifier(Val.getSpecifier())); } diff --git a/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCAsmInfo.cpp b/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCAsmInfo.cpp index b2cd1d0f4156e..c08664944f727 100644 --- a/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCAsmInfo.cpp +++ b/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCAsmInfo.cpp @@ -34,86 +34,86 @@ static cl::opt AsmWriterVariant( const MCAsmInfo::AtSpecifier COFFAtSpecifiers[] = { {MCSymbolRefExpr::VK_COFF_IMGREL32, "IMGREL"}, - {AArch64MCExpr::M_PAGEOFF, "PAGEOFF"}, + {AArch64::S_MACHO_PAGEOFF, "PAGEOFF"}, }; const MCAsmInfo::AtSpecifier ELFAtSpecifiers[] = { - {AArch64MCExpr::VK_GOT, "GOT"}, - {AArch64MCExpr::VK_GOTPCREL, "GOTPCREL"}, - {AArch64MCExpr::VK_PLT, "PLT"}, + {AArch64::S_GOT, "GOT"}, + {AArch64::S_GOTPCREL, "GOTPCREL"}, + {AArch64::S_PLT, "PLT"}, }; const MCAsmInfo::AtSpecifier MachOAtSpecifiers[] = { - {AArch64MCExpr::M_GOT, "GOT"}, - {AArch64MCExpr::M_GOTPAGE, "GOTPAGE"}, - {AArch64MCExpr::M_GOTPAGEOFF, "GOTPAGEOFF"}, - {AArch64MCExpr::M_PAGE, "PAGE"}, - {AArch64MCExpr::M_PAGEOFF, "PAGEOFF"}, - {AArch64MCExpr::M_TLVP, "TLVP"}, - {AArch64MCExpr::M_TLVPPAGE, "TLVPPAGE"}, - {AArch64MCExpr::M_TLVPPAGEOFF, "TLVPPAGEOFF"}, + {AArch64::S_MACHO_GOT, "GOT"}, + {AArch64::S_MACHO_GOTPAGE, "GOTPAGE"}, + {AArch64::S_MACHO_GOTPAGEOFF, "GOTPAGEOFF"}, + {AArch64::S_MACHO_PAGE, "PAGE"}, + {AArch64::S_MACHO_PAGEOFF, "PAGEOFF"}, + {AArch64::S_MACHO_TLVP, "TLVP"}, + {AArch64::S_MACHO_TLVPPAGE, "TLVPPAGE"}, + {AArch64::S_MACHO_TLVPPAGEOFF, "TLVPPAGEOFF"}, }; StringRef AArch64::getSpecifierName(const MCSpecifierExpr &Expr) { // clang-format off switch (static_cast(Expr.getSpecifier())) { - case AArch64MCExpr::VK_CALL: return ""; - case AArch64MCExpr::VK_LO12: return ":lo12:"; - case AArch64MCExpr::VK_ABS_G3: return ":abs_g3:"; - case AArch64MCExpr::VK_ABS_G2: return ":abs_g2:"; - case AArch64MCExpr::VK_ABS_G2_S: return ":abs_g2_s:"; - case AArch64MCExpr::VK_ABS_G2_NC: return ":abs_g2_nc:"; - case AArch64MCExpr::VK_ABS_G1: return ":abs_g1:"; - case AArch64MCExpr::VK_ABS_G1_S: return ":abs_g1_s:"; - case AArch64MCExpr::VK_ABS_G1_NC: return ":abs_g1_nc:"; - case AArch64MCExpr::VK_ABS_G0: return ":abs_g0:"; - case AArch64MCExpr::VK_ABS_G0_S: return ":abs_g0_s:"; - case AArch64MCExpr::VK_ABS_G0_NC: return ":abs_g0_nc:"; - case AArch64MCExpr::VK_PREL_G3: return ":prel_g3:"; - case AArch64MCExpr::VK_PREL_G2: return ":prel_g2:"; - case AArch64MCExpr::VK_PREL_G2_NC: return ":prel_g2_nc:"; - case AArch64MCExpr::VK_PREL_G1: return ":prel_g1:"; - case AArch64MCExpr::VK_PREL_G1_NC: return ":prel_g1_nc:"; - case AArch64MCExpr::VK_PREL_G0: return ":prel_g0:"; - case AArch64MCExpr::VK_PREL_G0_NC: return ":prel_g0_nc:"; - case AArch64MCExpr::VK_DTPREL_G2: return ":dtprel_g2:"; - case AArch64MCExpr::VK_DTPREL_G1: return ":dtprel_g1:"; - case AArch64MCExpr::VK_DTPREL_G1_NC: return ":dtprel_g1_nc:"; - case AArch64MCExpr::VK_DTPREL_G0: return ":dtprel_g0:"; - case AArch64MCExpr::VK_DTPREL_G0_NC: return ":dtprel_g0_nc:"; - case AArch64MCExpr::VK_DTPREL_HI12: return ":dtprel_hi12:"; - case AArch64MCExpr::VK_DTPREL_LO12: return ":dtprel_lo12:"; - case AArch64MCExpr::VK_DTPREL_LO12_NC: return ":dtprel_lo12_nc:"; - case AArch64MCExpr::VK_TPREL_G2: return ":tprel_g2:"; - case AArch64MCExpr::VK_TPREL_G1: return ":tprel_g1:"; - case AArch64MCExpr::VK_TPREL_G1_NC: return ":tprel_g1_nc:"; - case AArch64MCExpr::VK_TPREL_G0: return ":tprel_g0:"; - case AArch64MCExpr::VK_TPREL_G0_NC: return ":tprel_g0_nc:"; - case AArch64MCExpr::VK_TPREL_HI12: return ":tprel_hi12:"; - case AArch64MCExpr::VK_TPREL_LO12: return ":tprel_lo12:"; - case AArch64MCExpr::VK_TPREL_LO12_NC: return ":tprel_lo12_nc:"; - case AArch64MCExpr::VK_TLSDESC_LO12: return ":tlsdesc_lo12:"; - case AArch64MCExpr::VK_TLSDESC_AUTH_LO12: return ":tlsdesc_auth_lo12:"; - case AArch64MCExpr::VK_ABS_PAGE: return ""; - case AArch64MCExpr::VK_ABS_PAGE_NC: return ":pg_hi21_nc:"; - case AArch64MCExpr::VK_GOT: return ":got:"; - case AArch64MCExpr::VK_GOT_PAGE: return ":got:"; - case AArch64MCExpr::VK_GOT_PAGE_LO15: return ":gotpage_lo15:"; - case AArch64MCExpr::VK_GOT_LO12: return ":got_lo12:"; - case AArch64MCExpr::VK_GOTTPREL: return ":gottprel:"; - case AArch64MCExpr::VK_GOTTPREL_PAGE: return ":gottprel:"; - case AArch64MCExpr::VK_GOTTPREL_LO12_NC: return ":gottprel_lo12:"; - case AArch64MCExpr::VK_GOTTPREL_G1: return ":gottprel_g1:"; - case AArch64MCExpr::VK_GOTTPREL_G0_NC: return ":gottprel_g0_nc:"; - case AArch64MCExpr::VK_TLSDESC: return ""; - case AArch64MCExpr::VK_TLSDESC_PAGE: return ":tlsdesc:"; - case AArch64MCExpr::VK_TLSDESC_AUTH: return ""; - case AArch64MCExpr::VK_TLSDESC_AUTH_PAGE: return ":tlsdesc_auth:"; - case AArch64MCExpr::VK_SECREL_LO12: return ":secrel_lo12:"; - case AArch64MCExpr::VK_SECREL_HI12: return ":secrel_hi12:"; - case AArch64MCExpr::VK_GOT_AUTH: return ":got_auth:"; - case AArch64MCExpr::VK_GOT_AUTH_PAGE: return ":got_auth:"; - case AArch64MCExpr::VK_GOT_AUTH_LO12: return ":got_auth_lo12:"; + case AArch64::S_CALL: return ""; + case AArch64::S_LO12: return ":lo12:"; + case AArch64::S_ABS_G3: return ":abs_g3:"; + case AArch64::S_ABS_G2: return ":abs_g2:"; + case AArch64::S_ABS_G2_S: return ":abs_g2_s:"; + case AArch64::S_ABS_G2_NC: return ":abs_g2_nc:"; + case AArch64::S_ABS_G1: return ":abs_g1:"; + case AArch64::S_ABS_G1_S: return ":abs_g1_s:"; + case AArch64::S_ABS_G1_NC: return ":abs_g1_nc:"; + case AArch64::S_ABS_G0: return ":abs_g0:"; + case AArch64::S_ABS_G0_S: return ":abs_g0_s:"; + case AArch64::S_ABS_G0_NC: return ":abs_g0_nc:"; + case AArch64::S_PREL_G3: return ":prel_g3:"; + case AArch64::S_PREL_G2: return ":prel_g2:"; + case AArch64::S_PREL_G2_NC: return ":prel_g2_nc:"; + case AArch64::S_PREL_G1: return ":prel_g1:"; + case AArch64::S_PREL_G1_NC: return ":prel_g1_nc:"; + case AArch64::S_PREL_G0: return ":prel_g0:"; + case AArch64::S_PREL_G0_NC: return ":prel_g0_nc:"; + case AArch64::S_DTPREL_G2: return ":dtprel_g2:"; + case AArch64::S_DTPREL_G1: return ":dtprel_g1:"; + case AArch64::S_DTPREL_G1_NC: return ":dtprel_g1_nc:"; + case AArch64::S_DTPREL_G0: return ":dtprel_g0:"; + case AArch64::S_DTPREL_G0_NC: return ":dtprel_g0_nc:"; + case AArch64::S_DTPREL_HI12: return ":dtprel_hi12:"; + case AArch64::S_DTPREL_LO12: return ":dtprel_lo12:"; + case AArch64::S_DTPREL_LO12_NC: return ":dtprel_lo12_nc:"; + case AArch64::S_TPREL_G2: return ":tprel_g2:"; + case AArch64::S_TPREL_G1: return ":tprel_g1:"; + case AArch64::S_TPREL_G1_NC: return ":tprel_g1_nc:"; + case AArch64::S_TPREL_G0: return ":tprel_g0:"; + case AArch64::S_TPREL_G0_NC: return ":tprel_g0_nc:"; + case AArch64::S_TPREL_HI12: return ":tprel_hi12:"; + case AArch64::S_TPREL_LO12: return ":tprel_lo12:"; + case AArch64::S_TPREL_LO12_NC: return ":tprel_lo12_nc:"; + case AArch64::S_TLSDESC_LO12: return ":tlsdesc_lo12:"; + case AArch64::S_TLSDESC_AUTH_LO12: return ":tlsdesc_auth_lo12:"; + case AArch64::S_ABS_PAGE: return ""; + case AArch64::S_ABS_PAGE_NC: return ":pg_hi21_nc:"; + case AArch64::S_GOT: return ":got:"; + case AArch64::S_GOT_PAGE: return ":got:"; + case AArch64::S_GOT_PAGE_LO15: return ":gotpage_lo15:"; + case AArch64::S_GOT_LO12: return ":got_lo12:"; + case AArch64::S_GOTTPREL: return ":gottprel:"; + case AArch64::S_GOTTPREL_PAGE: return ":gottprel:"; + case AArch64::S_GOTTPREL_LO12_NC: return ":gottprel_lo12:"; + case AArch64::S_GOTTPREL_G1: return ":gottprel_g1:"; + case AArch64::S_GOTTPREL_G0_NC: return ":gottprel_g0_nc:"; + case AArch64::S_TLSDESC: return ""; + case AArch64::S_TLSDESC_PAGE: return ":tlsdesc:"; + case AArch64::S_TLSDESC_AUTH: return ""; + case AArch64::S_TLSDESC_AUTH_PAGE: return ":tlsdesc_auth:"; + case AArch64::S_SECREL_LO12: return ":secrel_lo12:"; + case AArch64::S_SECREL_HI12: return ":secrel_hi12:"; + case AArch64::S_GOT_AUTH: return ":got_auth:"; + case AArch64::S_GOT_AUTH_PAGE: return ":got_auth:"; + case AArch64::S_GOT_AUTH_LO12: return ":got_auth_lo12:"; default: llvm_unreachable("Invalid relocation specifier"); } @@ -159,7 +159,7 @@ const MCExpr *AArch64MCAsmInfoDarwin::getExprForPersonalitySymbol( // version. MCContext &Context = Streamer.getContext(); const MCExpr *Res = - MCSymbolRefExpr::create(Sym, AArch64MCExpr::M_GOT, Context); + MCSymbolRefExpr::create(Sym, AArch64::S_MACHO_GOT, Context); MCSymbol *PCSym = Context.createTempSymbol(); Streamer.emitLabel(PCSym); const MCExpr *PC = MCSymbolRefExpr::create(PCSym, Context); diff --git a/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCAsmInfo.h b/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCAsmInfo.h index 58e87f8a208f3..5022bf780d566 100644 --- a/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCAsmInfo.h +++ b/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCAsmInfo.h @@ -60,21 +60,167 @@ struct AArch64MCAsmInfoGNUCOFF : public MCAsmInfoGNUCOFF { namespace AArch64 { using Specifier = uint16_t; +enum { + // clang-format off + S_None = 0, + // Symbol locations specifying (roughly speaking) what calculation should be + // performed to construct the final address for the relocated + // symbol. E.g. direct, via the GOT, ... + S_ABS = 0x001, + S_SABS = 0x002, + S_PREL = 0x003, + S_GOT = 0x004, + S_DTPREL = 0x005, + S_GOTTPREL = 0x006, + S_TPREL = 0x007, + S_TLSDESC = 0x008, + S_SECREL = 0x009, + S_AUTH = 0x00a, + S_AUTHADDR = 0x00b, + S_GOT_AUTH = 0x00c, + S_TLSDESC_AUTH = 0x00d, + S_SymLocBits = 0x00f, + + // Variants specifying which part of the final address calculation is + // used. E.g. the low 12 bits for an ADD/LDR, the middle 16 bits for a + // MOVZ/MOVK. + S_PAGE = 0x010, + S_PAGEOFF = 0x020, + S_HI12 = 0x030, + S_G0 = 0x040, + S_G1 = 0x050, + S_G2 = 0x060, + S_G3 = 0x070, + S_LO15 = 0x080, + S_AddressFragBits = 0x0f0, + + // Whether the final relocation is a checked one (where a linker should + // perform a range-check on the final address) or not. Note that this field + // is unfortunately sometimes omitted from the assembly syntax. E.g. :lo12: + // on its own is a non-checked relocation. We side with ELF on being + // explicit about this! + S_NC = 0x100, + + // Convenience definitions for referring to specific textual representations + // of relocation specifiers. Note that this means the "_NC" is sometimes + // omitted in line with assembly syntax here (S_LO12 rather than VK_LO12_NC + // since a user would write ":lo12:"). + S_CALL = S_ABS, + S_ABS_PAGE = S_ABS | S_PAGE, + S_ABS_PAGE_NC = S_ABS | S_PAGE | S_NC, + S_ABS_G3 = S_ABS | S_G3, + S_ABS_G2 = S_ABS | S_G2, + S_ABS_G2_S = S_SABS | S_G2, + S_ABS_G2_NC = S_ABS | S_G2 | S_NC, + S_ABS_G1 = S_ABS | S_G1, + S_ABS_G1_S = S_SABS | S_G1, + S_ABS_G1_NC = S_ABS | S_G1 | S_NC, + S_ABS_G0 = S_ABS | S_G0, + S_ABS_G0_S = S_SABS | S_G0, + S_ABS_G0_NC = S_ABS | S_G0 | S_NC, + S_LO12 = S_ABS | S_PAGEOFF | S_NC, + S_PREL_G3 = S_PREL | S_G3, + S_PREL_G2 = S_PREL | S_G2, + S_PREL_G2_NC = S_PREL | S_G2 | S_NC, + S_PREL_G1 = S_PREL | S_G1, + S_PREL_G1_NC = S_PREL | S_G1 | S_NC, + S_PREL_G0 = S_PREL | S_G0, + S_PREL_G0_NC = S_PREL | S_G0 | S_NC, + S_GOT_LO12 = S_GOT | S_PAGEOFF | S_NC, + S_GOT_PAGE = S_GOT | S_PAGE, + S_GOT_PAGE_LO15 = S_GOT | S_LO15 | S_NC, + S_GOT_AUTH_LO12 = S_GOT_AUTH | S_PAGEOFF | S_NC, + S_GOT_AUTH_PAGE = S_GOT_AUTH | S_PAGE, + S_DTPREL_G2 = S_DTPREL | S_G2, + S_DTPREL_G1 = S_DTPREL | S_G1, + S_DTPREL_G1_NC = S_DTPREL | S_G1 | S_NC, + S_DTPREL_G0 = S_DTPREL | S_G0, + S_DTPREL_G0_NC = S_DTPREL | S_G0 | S_NC, + S_DTPREL_HI12 = S_DTPREL | S_HI12, + S_DTPREL_LO12 = S_DTPREL | S_PAGEOFF, + S_DTPREL_LO12_NC = S_DTPREL | S_PAGEOFF | S_NC, + S_GOTTPREL_PAGE = S_GOTTPREL | S_PAGE, + S_GOTTPREL_LO12_NC = S_GOTTPREL | S_PAGEOFF | S_NC, + S_GOTTPREL_G1 = S_GOTTPREL | S_G1, + S_GOTTPREL_G0_NC = S_GOTTPREL | S_G0 | S_NC, + S_TPREL_G2 = S_TPREL | S_G2, + S_TPREL_G1 = S_TPREL | S_G1, + S_TPREL_G1_NC = S_TPREL | S_G1 | S_NC, + S_TPREL_G0 = S_TPREL | S_G0, + S_TPREL_G0_NC = S_TPREL | S_G0 | S_NC, + S_TPREL_HI12 = S_TPREL | S_HI12, + S_TPREL_LO12 = S_TPREL | S_PAGEOFF, + S_TPREL_LO12_NC = S_TPREL | S_PAGEOFF | S_NC, + S_TLSDESC_LO12 = S_TLSDESC | S_PAGEOFF, + S_TLSDESC_PAGE = S_TLSDESC | S_PAGE, + S_TLSDESC_AUTH_LO12 = S_TLSDESC_AUTH | S_PAGEOFF, + S_TLSDESC_AUTH_PAGE = S_TLSDESC_AUTH | S_PAGE, + S_SECREL_LO12 = S_SECREL | S_PAGEOFF, + S_SECREL_HI12 = S_SECREL | S_HI12, + + // ELF relocation specifiers in data directives: + S_PLT = 0x400, + S_GOTPCREL, + + // Mach-O @ relocation specifiers: + S_MACHO_GOT, + S_MACHO_GOTPAGE, + S_MACHO_GOTPAGEOFF, + S_MACHO_PAGE, + S_MACHO_PAGEOFF, + S_MACHO_TLVP, + S_MACHO_TLVPPAGE, + S_MACHO_TLVPPAGEOFF, + + S_INVALID = 0xfff + // clang-format on +}; + /// Return the string representation of the ELF relocation specifier /// (e.g. ":got:", ":lo12:"). StringRef getSpecifierName(const MCSpecifierExpr &Expr); inline Specifier getSymbolLoc(Specifier S) { - return static_cast(S & AArch64MCExpr::VK_SymLocBits); + return static_cast(S & AArch64::S_SymLocBits); } inline Specifier getAddressFrag(Specifier S) { - return static_cast(S & AArch64MCExpr::VK_AddressFragBits); + return static_cast(S & AArch64::S_AddressFragBits); } -inline bool isNotChecked(Specifier S) { return S & AArch64MCExpr::VK_NC; } +inline bool isNotChecked(Specifier S) { return S & AArch64::S_NC; } } // namespace AArch64 +class AArch64AuthMCExpr final : public MCSpecifierExpr { + uint16_t Discriminator; + AArch64PACKey::ID Key; + + explicit AArch64AuthMCExpr(const MCExpr *Expr, uint16_t Discriminator, + AArch64PACKey::ID Key, bool HasAddressDiversity) + : MCSpecifierExpr(Expr, HasAddressDiversity ? AArch64::S_AUTHADDR + : AArch64::S_AUTH), + Discriminator(Discriminator), Key(Key) {} + +public: + static const AArch64AuthMCExpr * + create(const MCExpr *Expr, uint16_t Discriminator, AArch64PACKey::ID Key, + bool HasAddressDiversity, MCContext &Ctx); + + AArch64PACKey::ID getKey() const { return Key; } + uint16_t getDiscriminator() const { return Discriminator; } + bool hasAddressDiversity() const { + return getSpecifier() == AArch64::S_AUTHADDR; + } + + void print(raw_ostream &OS, const MCAsmInfo *MAI) const; + + static bool classof(const MCExpr *E) { + auto *SE = dyn_cast(E); + return SE && (SE->getSpecifier() == AArch64::S_AUTH || + SE->getSpecifier() == AArch64::S_AUTHADDR); + } +}; + } // namespace llvm #endif diff --git a/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCCodeEmitter.cpp b/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCCodeEmitter.cpp index 6db0d7de45e58..bf1eb091fe754 100644 --- a/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCCodeEmitter.cpp +++ b/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCCodeEmitter.cpp @@ -12,7 +12,7 @@ #include "MCTargetDesc/AArch64AddressingModes.h" #include "MCTargetDesc/AArch64FixupKinds.h" -#include "MCTargetDesc/AArch64MCExpr.h" +#include "MCTargetDesc/AArch64MCAsmInfo.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/Statistic.h" #include "llvm/BinaryFormat/ELF.h" @@ -310,9 +310,8 @@ AArch64MCCodeEmitter::getAddSubImmOpValue(const MCInst &MI, unsigned OpIdx, // R_AARCH64_TLSLE_ADD_TPREL_HI12 and R_AARCH64_TLSLD_ADD_DTPREL_HI12. if (auto *A64E = dyn_cast(Expr)) { AArch64MCExpr::Specifier RefKind = A64E->getSpecifier(); - if (RefKind == AArch64MCExpr::VK_TPREL_HI12 || - RefKind == AArch64MCExpr::VK_DTPREL_HI12 || - RefKind == AArch64MCExpr::VK_SECREL_HI12) + if (RefKind == AArch64::S_TPREL_HI12 || RefKind == AArch64::S_DTPREL_HI12 || + RefKind == AArch64::S_SECREL_HI12) ShiftVal = 12; } return ShiftVal == 0 ? 0 : (1 << ShiftVal); @@ -720,13 +719,13 @@ unsigned AArch64MCCodeEmitter::fixMOVZ(const MCInst &MI, unsigned EncodedValue, const MCExpr *E = UImm16MO.getExpr(); if (auto *A64E = dyn_cast(E)) { switch (A64E->getSpecifier()) { - case AArch64MCExpr::VK_DTPREL_G2: - case AArch64MCExpr::VK_DTPREL_G1: - case AArch64MCExpr::VK_DTPREL_G0: - case AArch64MCExpr::VK_GOTTPREL_G1: - case AArch64MCExpr::VK_TPREL_G2: - case AArch64MCExpr::VK_TPREL_G1: - case AArch64MCExpr::VK_TPREL_G0: + case AArch64::S_DTPREL_G2: + case AArch64::S_DTPREL_G1: + case AArch64::S_DTPREL_G0: + case AArch64::S_GOTTPREL_G1: + case AArch64::S_TPREL_G2: + case AArch64::S_TPREL_G1: + case AArch64::S_TPREL_G0: return EncodedValue & ~(1u << 30); default: // Nothing to do for an unsigned fixup. diff --git a/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCExpr.h b/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCExpr.h index 8ffd14e338e11..0148088ac1da5 100644 --- a/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCExpr.h +++ b/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCExpr.h @@ -23,152 +23,8 @@ namespace llvm { namespace AArch64MCExpr { using Specifier = uint16_t; -enum { - // clang-format off - None = 0, - // Symbol locations specifying (roughly speaking) what calculation should be - // performed to construct the final address for the relocated - // symbol. E.g. direct, via the GOT, ... - VK_ABS = 0x001, - VK_SABS = 0x002, - VK_PREL = 0x003, - VK_GOT = 0x004, - VK_DTPREL = 0x005, - VK_GOTTPREL = 0x006, - VK_TPREL = 0x007, - VK_TLSDESC = 0x008, - VK_SECREL = 0x009, - VK_AUTH = 0x00a, - VK_AUTHADDR = 0x00b, - VK_GOT_AUTH = 0x00c, - VK_TLSDESC_AUTH = 0x00d, - VK_SymLocBits = 0x00f, - - // Variants specifying which part of the final address calculation is - // used. E.g. the low 12 bits for an ADD/LDR, the middle 16 bits for a - // MOVZ/MOVK. - VK_PAGE = 0x010, - VK_PAGEOFF = 0x020, - VK_HI12 = 0x030, - VK_G0 = 0x040, - VK_G1 = 0x050, - VK_G2 = 0x060, - VK_G3 = 0x070, - VK_LO15 = 0x080, - VK_AddressFragBits = 0x0f0, - - // Whether the final relocation is a checked one (where a linker should - // perform a range-check on the final address) or not. Note that this field - // is unfortunately sometimes omitted from the assembly syntax. E.g. :lo12: - // on its own is a non-checked relocation. We side with ELF on being - // explicit about this! - VK_NC = 0x100, - - // Convenience definitions for referring to specific textual representations - // of relocation specifiers. Note that this means the "_NC" is sometimes - // omitted in line with assembly syntax here (VK_LO12 rather than VK_LO12_NC - // since a user would write ":lo12:"). - VK_CALL = VK_ABS, - VK_ABS_PAGE = VK_ABS | VK_PAGE, - VK_ABS_PAGE_NC = VK_ABS | VK_PAGE | VK_NC, - VK_ABS_G3 = VK_ABS | VK_G3, - VK_ABS_G2 = VK_ABS | VK_G2, - VK_ABS_G2_S = VK_SABS | VK_G2, - VK_ABS_G2_NC = VK_ABS | VK_G2 | VK_NC, - VK_ABS_G1 = VK_ABS | VK_G1, - VK_ABS_G1_S = VK_SABS | VK_G1, - VK_ABS_G1_NC = VK_ABS | VK_G1 | VK_NC, - VK_ABS_G0 = VK_ABS | VK_G0, - VK_ABS_G0_S = VK_SABS | VK_G0, - VK_ABS_G0_NC = VK_ABS | VK_G0 | VK_NC, - VK_LO12 = VK_ABS | VK_PAGEOFF | VK_NC, - VK_PREL_G3 = VK_PREL | VK_G3, - VK_PREL_G2 = VK_PREL | VK_G2, - VK_PREL_G2_NC = VK_PREL | VK_G2 | VK_NC, - VK_PREL_G1 = VK_PREL | VK_G1, - VK_PREL_G1_NC = VK_PREL | VK_G1 | VK_NC, - VK_PREL_G0 = VK_PREL | VK_G0, - VK_PREL_G0_NC = VK_PREL | VK_G0 | VK_NC, - VK_GOT_LO12 = VK_GOT | VK_PAGEOFF | VK_NC, - VK_GOT_PAGE = VK_GOT | VK_PAGE, - VK_GOT_PAGE_LO15 = VK_GOT | VK_LO15 | VK_NC, - VK_GOT_AUTH_LO12 = VK_GOT_AUTH | VK_PAGEOFF | VK_NC, - VK_GOT_AUTH_PAGE = VK_GOT_AUTH | VK_PAGE, - VK_DTPREL_G2 = VK_DTPREL | VK_G2, - VK_DTPREL_G1 = VK_DTPREL | VK_G1, - VK_DTPREL_G1_NC = VK_DTPREL | VK_G1 | VK_NC, - VK_DTPREL_G0 = VK_DTPREL | VK_G0, - VK_DTPREL_G0_NC = VK_DTPREL | VK_G0 | VK_NC, - VK_DTPREL_HI12 = VK_DTPREL | VK_HI12, - VK_DTPREL_LO12 = VK_DTPREL | VK_PAGEOFF, - VK_DTPREL_LO12_NC = VK_DTPREL | VK_PAGEOFF | VK_NC, - VK_GOTTPREL_PAGE = VK_GOTTPREL | VK_PAGE, - VK_GOTTPREL_LO12_NC = VK_GOTTPREL | VK_PAGEOFF | VK_NC, - VK_GOTTPREL_G1 = VK_GOTTPREL | VK_G1, - VK_GOTTPREL_G0_NC = VK_GOTTPREL | VK_G0 | VK_NC, - VK_TPREL_G2 = VK_TPREL | VK_G2, - VK_TPREL_G1 = VK_TPREL | VK_G1, - VK_TPREL_G1_NC = VK_TPREL | VK_G1 | VK_NC, - VK_TPREL_G0 = VK_TPREL | VK_G0, - VK_TPREL_G0_NC = VK_TPREL | VK_G0 | VK_NC, - VK_TPREL_HI12 = VK_TPREL | VK_HI12, - VK_TPREL_LO12 = VK_TPREL | VK_PAGEOFF, - VK_TPREL_LO12_NC = VK_TPREL | VK_PAGEOFF | VK_NC, - VK_TLSDESC_LO12 = VK_TLSDESC | VK_PAGEOFF, - VK_TLSDESC_PAGE = VK_TLSDESC | VK_PAGE, - VK_TLSDESC_AUTH_LO12 = VK_TLSDESC_AUTH | VK_PAGEOFF, - VK_TLSDESC_AUTH_PAGE = VK_TLSDESC_AUTH | VK_PAGE, - VK_SECREL_LO12 = VK_SECREL | VK_PAGEOFF, - VK_SECREL_HI12 = VK_SECREL | VK_HI12, - - // ELF relocation specifiers in data directives: - VK_PLT = 0x400, - VK_GOTPCREL, - - // Mach-O @ relocation specifiers: - M_GOT, - M_GOTPAGE, - M_GOTPAGEOFF, - M_PAGE, - M_PAGEOFF, - M_TLVP, - M_TLVPPAGE, - M_TLVPPAGEOFF, - - VK_INVALID = 0xfff - // clang-format on -}; } // namespace AArch64MCExpr -class AArch64AuthMCExpr final : public MCSpecifierExpr { - uint16_t Discriminator; - AArch64PACKey::ID Key; - - explicit AArch64AuthMCExpr(const MCExpr *Expr, uint16_t Discriminator, - AArch64PACKey::ID Key, bool HasAddressDiversity) - : MCSpecifierExpr(Expr, HasAddressDiversity ? AArch64MCExpr::VK_AUTHADDR - : AArch64MCExpr::VK_AUTH), - Discriminator(Discriminator), Key(Key) {} - -public: - static const AArch64AuthMCExpr * - create(const MCExpr *Expr, uint16_t Discriminator, AArch64PACKey::ID Key, - bool HasAddressDiversity, MCContext &Ctx); - - AArch64PACKey::ID getKey() const { return Key; } - uint16_t getDiscriminator() const { return Discriminator; } - bool hasAddressDiversity() const { - return getSpecifier() == AArch64MCExpr::VK_AUTHADDR; - } - - void print(raw_ostream &OS, const MCAsmInfo *MAI) const; - - static bool classof(const MCExpr *E) { - auto *SE = dyn_cast(E); - return SE && (SE->getSpecifier() == AArch64MCExpr::VK_AUTH || - SE->getSpecifier() == AArch64MCExpr::VK_AUTHADDR); - } -}; } // end namespace llvm #endif diff --git a/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MachObjectWriter.cpp b/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MachObjectWriter.cpp index bce99b10f23b5..2ade306c196e6 100644 --- a/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MachObjectWriter.cpp +++ b/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MachObjectWriter.cpp @@ -7,7 +7,7 @@ //===----------------------------------------------------------------------===// #include "MCTargetDesc/AArch64FixupKinds.h" -#include "MCTargetDesc/AArch64MCExpr.h" +#include "MCTargetDesc/AArch64MCAsmInfo.h" #include "MCTargetDesc/AArch64MCTargetDesc.h" #include "llvm/ADT/Twine.h" #include "llvm/BinaryFormat/MachO.h" @@ -66,12 +66,12 @@ bool AArch64MachObjectWriter::getAArch64FixupKindMachOInfo( return true; case FK_Data_4: Log2Size = Log2_32(4); - if (Spec == AArch64MCExpr::M_GOT) + if (Spec == AArch64::S_MACHO_GOT) RelocType = unsigned(MachO::ARM64_RELOC_POINTER_TO_GOT); return true; case FK_Data_8: Log2Size = Log2_32(8); - if (Spec == AArch64MCExpr::M_GOT) + if (Spec == AArch64::S_MACHO_GOT) RelocType = unsigned(MachO::ARM64_RELOC_POINTER_TO_GOT); return true; case AArch64::fixup_aarch64_add_imm12: @@ -84,13 +84,13 @@ bool AArch64MachObjectWriter::getAArch64FixupKindMachOInfo( switch (Spec) { default: return false; - case AArch64MCExpr::M_PAGEOFF: + case AArch64::S_MACHO_PAGEOFF: RelocType = unsigned(MachO::ARM64_RELOC_PAGEOFF12); return true; - case AArch64MCExpr::M_GOTPAGEOFF: + case AArch64::S_MACHO_GOTPAGEOFF: RelocType = unsigned(MachO::ARM64_RELOC_GOT_LOAD_PAGEOFF12); return true; - case AArch64MCExpr::M_TLVPPAGEOFF: + case AArch64::S_MACHO_TLVPPAGEOFF: RelocType = unsigned(MachO::ARM64_RELOC_TLVP_LOAD_PAGEOFF12); return true; } @@ -101,13 +101,13 @@ bool AArch64MachObjectWriter::getAArch64FixupKindMachOInfo( default: reportError(Fixup.getLoc(), "ADR/ADRP relocations must be GOT relative"); return false; - case AArch64MCExpr::M_PAGE: + case AArch64::S_MACHO_PAGE: RelocType = unsigned(MachO::ARM64_RELOC_PAGE21); return true; - case AArch64MCExpr::M_GOTPAGE: + case AArch64::S_MACHO_GOTPAGE: RelocType = unsigned(MachO::ARM64_RELOC_GOT_LOAD_PAGE21); return true; - case AArch64MCExpr::M_TLVPPAGE: + case AArch64::S_MACHO_TLVPPAGE: RelocType = unsigned(MachO::ARM64_RELOC_TLVP_LOAD_PAGE21); return true; } @@ -218,7 +218,7 @@ void AArch64MachObjectWriter::recordRelocation( // Check for "_foo@got - .", which comes through here as: // Ltmp0: // ... _foo@got - Ltmp0 - if (Target.getSpecifier() == AArch64MCExpr::M_GOT && + if (Target.getSpecifier() == AArch64::S_MACHO_GOT && Asm.getSymbolOffset(*B) == Asm.getFragmentOffset(*Fragment) + Fixup.getOffset()) { // SymB is the PC, so use a PC-rel pointer-to-GOT relocation. @@ -229,7 +229,7 @@ void AArch64MachObjectWriter::recordRelocation( MRE.r_word1 = (IsPCRel << 24) | (Log2Size << 25) | (Type << 28); Writer->addRelocation(A_Base, Fragment->getParent(), MRE); return; - } else if (Target.getSpecifier() != AArch64MCExpr::None) { + } else if (Target.getSpecifier() != AArch64::S_None) { // Otherwise, neither symbol can be modified. reportError(Fixup.getLoc(), "unsupported relocation of modified symbol"); return; @@ -382,8 +382,8 @@ void AArch64MachObjectWriter::recordRelocation( Value = 0; } - if (Target.getSpecifier() == AArch64MCExpr::VK_AUTH || - Target.getSpecifier() == AArch64MCExpr::VK_AUTHADDR) { + if (Target.getSpecifier() == AArch64::S_AUTH || + Target.getSpecifier() == AArch64::S_AUTHADDR) { auto *Expr = cast(Fixup.getValue()); assert(Type == MachO::ARM64_RELOC_UNSIGNED); diff --git a/llvm/lib/Target/AArch64/MCTargetDesc/AArch64WinCOFFObjectWriter.cpp b/llvm/lib/Target/AArch64/MCTargetDesc/AArch64WinCOFFObjectWriter.cpp index 70df95029c33b..35727b916b650 100644 --- a/llvm/lib/Target/AArch64/MCTargetDesc/AArch64WinCOFFObjectWriter.cpp +++ b/llvm/lib/Target/AArch64/MCTargetDesc/AArch64WinCOFFObjectWriter.cpp @@ -67,8 +67,8 @@ unsigned AArch64WinCOFFObjectWriter::getRelocType( if (auto *A64E = dyn_cast(Expr)) { AArch64MCExpr::Specifier Spec = A64E->getSpecifier(); switch (AArch64::getSymbolLoc(Spec)) { - case AArch64MCExpr::VK_ABS: - case AArch64MCExpr::VK_SECREL: + case AArch64::S_ABS: + case AArch64::S_SECREL: // Supported break; default: @@ -118,9 +118,9 @@ unsigned AArch64WinCOFFObjectWriter::getRelocType( case AArch64::fixup_aarch64_add_imm12: if (auto *A64E = dyn_cast(Expr)) { AArch64MCExpr::Specifier Spec = A64E->getSpecifier(); - if (Spec == AArch64MCExpr::VK_SECREL_LO12) + if (Spec == AArch64::S_SECREL_LO12) return COFF::IMAGE_REL_ARM64_SECREL_LOW12A; - if (Spec == AArch64MCExpr::VK_SECREL_HI12) + if (Spec == AArch64::S_SECREL_HI12) return COFF::IMAGE_REL_ARM64_SECREL_HIGH12A; } return COFF::IMAGE_REL_ARM64_PAGEOFFSET_12A; @@ -132,7 +132,7 @@ unsigned AArch64WinCOFFObjectWriter::getRelocType( case AArch64::fixup_aarch64_ldst_imm12_scale16: if (auto *A64E = dyn_cast(Expr)) { AArch64MCExpr::Specifier Spec = A64E->getSpecifier(); - if (Spec == AArch64MCExpr::VK_SECREL_LO12) + if (Spec == AArch64::S_SECREL_LO12) return COFF::IMAGE_REL_ARM64_SECREL_LOW12L; } return COFF::IMAGE_REL_ARM64_PAGEOFFSET_12L;