[SOL] Adjustments after LLVM 20 update

Author: LucasSte

clang/lib/Basic/Targets/BPF.cpp

@@ -95,12 +95,6 @@ ArrayRef<Builtin::Info> BPFTargetInfo::getTargetBuiltins() const {
 
 bool BPFTargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
                                          DiagnosticsEngine &Diags) {
-  // TODO: The SBF back-end now provides the sbf target. Issue deprecation
-  // warning directing use of '-target sbf' instead. Eventually remove the
-  // +solana support from the BPF back-end.
-  if (getTriple().getArch() != llvm::Triple::sbf && HasSolanaFeature)
-    Diags.Report(diag::warn_drv_no_solana_with_bpf);
-
   for (const auto &Feature : Features) {
     if (Feature == "+alu32") {
       HasAlu32 = true;

clang/test/Misc/warning-flags.c

@@ -45,7 +45,6 @@ CHECK-NEXT:   warn_double_const_requires_fp64
 CHECK-NEXT:   warn_drv_amdgpu_cov6
 CHECK-NEXT:   warn_drv_assuming_mfloat_abi_is
 CHECK-NEXT:   warn_drv_clang_unsupported
-CHECK-NEXT:   warn_drv_no_solana_with_bpf
 CHECK-NEXT:   warn_drv_pch_not_first_include
 CHECK-NEXT:   warn_expected_qualified_after_typename
 CHECK-NEXT:   warn_fe_backend_unsupported

lld/ELF/Arch/SBF.cpp

@@ -25,7 +25,7 @@ namespace elf {
 namespace {
 class SBF final : public TargetInfo {
 public:
-  SBF();
+  SBF(Ctx & ctx);
   RelExpr getRelExpr(RelType type, const Symbol &s,
                      const uint8_t *loc) const override;
   RelType getDynRel(RelType type) const override;
@@ -54,7 +54,7 @@ RelExpr SBF::getRelExpr(RelType type, const Symbol &s,
     case R_SBF_64_64:
       return R_ABS;
     default:
-      error(getErrorLocation(loc) + "unrecognized reloc " + toString(type));
+      Err(ctx) << getErrorLoc(ctx, loc) << "unrecognized reloc " << type.v;
   }
   return R_NONE;
 }
@@ -113,12 +113,12 @@ void SBF::relocate(uint8_t *loc, const Relocation &rel, uint64_t val) const {
       break;
     }
     default:
-      error(getErrorLocation(loc) + "unrecognized reloc " + toString(rel.type));
+      Err(ctx) << getErrorLoc(ctx, loc) << "unrecognized reloc " << rel.type.v;
   }
 }
 
-static uint32_t getEFlags(InputFile *file) {
-  if (config->ekind == ELF64BEKind)
+static uint32_t getEFlags(InputFile *file, Ctx &ctx) {
+  if (ctx.arg.ekind == ELF64BEKind)
     return cast<ObjFile<ELF64BE>>(file)->getObj().getHeader().e_flags;
   return cast<ObjFile<ELF64LE>>(file)->getObj().getHeader().e_flags;
 }
@@ -129,7 +129,7 @@ uint32_t SBF::calcEFlags() const {
   // Ensure that all the object files were compiled with the same flags, as
   // different flags indicate different ABIs.
   for (InputFile *f : ctx.objectFiles) {
-    uint32_t flags = getEFlags(f);
+    uint32_t flags = getEFlags(f, ctx);
     if (ret == 0) {
       ret = flags;
     } else if (ret != flags) {

lld/ELF/InputSection.cpp

@@ -1043,7 +1043,7 @@ void InputSection::relocateNonAlloc(Ctx &ctx, uint8_t *buf,
     const uint64_t offset = rel.r_offset;
 
     // FIX: Temporary remap BPF_64_64 relocations in debug sections.
-    if (config->emachine == EM_SBF && type == R_SBF_64_64 && isDebug)
+    if (ctx.arg.emachine == EM_SBF && type == R_SBF_64_64 && isDebug)
       type = R_BPF_64_ABS64;
 
     uint8_t *bufLoc = buf + offset;

llvm/lib/Target/SBF/AsmParser/SBFAsmParser.cpp

@@ -9,7 +9,6 @@
 #include "MCTargetDesc/SBFMCTargetDesc.h"
 #include "MCTargetDesc/SBFInstPrinter.h"
 #include "TargetInfo/SBFTargetInfo.h"
-#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
@@ -18,7 +17,6 @@
 #include "llvm/MC/MCParser/MCAsmLexer.h"
 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
 #include "llvm/MC/MCParser/MCTargetAsmParser.h"
-#include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/TargetRegistry.h"
@@ -33,7 +31,7 @@ class SBFAsmParser : public MCTargetAsmParser {
 
   SMLoc getLoc() const { return getParser().getTok().getLoc(); }
 
-  bool MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
+  bool matchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
                                OperandVector &Operands, MCStreamer &Out,
                                uint64_t &ErrorInfo,
                                bool MatchingInlineAsm) override;
@@ -43,7 +41,7 @@ class SBFAsmParser : public MCTargetAsmParser {
   ParseStatus tryParseRegister(MCRegister &Reg, SMLoc &StartLoc,
                                         SMLoc &EndLoc) override;
 
-  bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
+  bool parseInstruction(ParseInstructionInfo &Info, StringRef Name,
                         SMLoc NameLoc, OperandVector &Operands) override;
 
 #define GET_ASSEMBLER_HEADER
@@ -80,7 +78,7 @@ struct SBFOperand : public MCParsedAsmOperand {
   } Kind;
 
   struct RegOp {
-    unsigned RegNum;
+    MCRegister RegNum;
   };
 
   struct ImmOp {
@@ -203,10 +201,10 @@ struct SBFOperand : public MCParsedAsmOperand {
     return Op;
   }
 
-  static std::unique_ptr<SBFOperand> createReg(unsigned RegNo, SMLoc S,
+  static std::unique_ptr<SBFOperand> createReg(MCRegister Reg, SMLoc S,
                                                SMLoc E) {
     auto Op = std::make_unique<SBFOperand>(Register);
-    Op->Reg.RegNum = RegNo;
+    Op->Reg.RegNum = Reg;
     Op->StartLoc = S;
     Op->EndLoc = E;
     return Op;
@@ -261,7 +259,7 @@ struct SBFOperand : public MCParsedAsmOperand {
 #define GET_MATCHER_IMPLEMENTATION
 #include "SBFGenAsmMatcher.inc"
 
-bool SBFAsmParser::MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
+bool SBFAsmParser::matchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
                                            OperandVector &Operands,
                                            MCStreamer &Out, uint64_t &ErrorInfo,
                                            bool MatchingInlineAsm) {
@@ -331,13 +329,13 @@ OperandMatchResultTy SBFAsmParser::parseRegister(OperandVector &Operands) {
     return MatchOperand_NoMatch;
   case AsmToken::Identifier:
     StringRef Name = getLexer().getTok().getIdentifier();
-    unsigned RegNo = MatchRegisterName(Name);
+    MCRegister Reg = MatchRegisterName(Name);
 
-    if (RegNo == 0)
+    if (!Reg)
       return MatchOperand_NoMatch;
 
     getLexer().Lex();
-    Operands.push_back(SBFOperand::createReg(RegNo, S, E));
+    Operands.push_back(SBFOperand::createReg(Reg, S, E));
   }
   return MatchOperand_Success;
 }
@@ -420,7 +418,7 @@ bool SBFAsmParser::parseOperand(OperandVector &Operands, StringRef Mnemonic) {
 }
 
 /// Parse an SBF instruction.
-bool SBFAsmParser::ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
+bool SBFAsmParser::parseInstruction(ParseInstructionInfo &Info, StringRef Name,
                                     SMLoc NameLoc, OperandVector &Operands) {
   // First operand is token for instruction mnemonic.
   Operands.push_back(SBFOperand::createToken(Name, NameLoc));

llvm/lib/Target/SBF/BTFDebug.cpp

@@ -707,7 +707,7 @@ void BTFDebug::visitArrayType(const DICompositeType *CTy, uint32_t &TypeId) {
     if (auto *Element = dyn_cast_or_null<DINode>(Elements[I]))
       if (Element->getTag() == dwarf::DW_TAG_subrange_type) {
         const DISubrange *SR = cast<DISubrange>(Element);
-        auto *CI = SR->getCount().dyn_cast<ConstantInt *>();
+        auto *CI = dyn_cast<ConstantInt *>(SR->getCount());
         int64_t Count = CI->getSExtValue();
 
         // For struct s { int b; char c[]; }, the c[] will be represented
@@ -1493,17 +1493,15 @@ void BTFDebug::processGlobals(bool ProcessingMapDef) {
       continue;
 
     // Find or create a DataSec
-    if (DataSecEntries.find(std::string(SecName)) == DataSecEntries.end()) {
-      DataSecEntries[std::string(SecName)] =
-          std::make_unique<BTFKindDataSec>(Asm, std::string(SecName));
-    }
+    auto [It, Inserted] = DataSecEntries.try_emplace(std::string(SecName));
+    if (Inserted)
+      It->second = std::make_unique<BTFKindDataSec>(Asm, std::string(SecName));
 
     // Calculate symbol size
     const DataLayout &DL = Global.getParent()->getDataLayout();
     uint32_t Size = DL.getTypeAllocSize(Global.getValueType());
 
-    DataSecEntries[std::string(SecName)]->addDataSecEntry(VarId,
-        Asm->getSymbol(&Global), Size);
+    It->second->addDataSecEntry(VarId, Asm->getSymbol(&Global), Size);
   }
 }
 
@@ -1584,14 +1582,12 @@ void BTFDebug::processFuncPrototypes(const Function *F) {
   if (F->hasSection()) {
     StringRef SecName = F->getSection();
 
-    if (DataSecEntries.find(std::string(SecName)) == DataSecEntries.end()) {
-      DataSecEntries[std::string(SecName)] =
-          std::make_unique<BTFKindDataSec>(Asm, std::string(SecName));
-    }
+    auto [It, Inserted] = DataSecEntries.try_emplace(std::string(SecName));
+    if (Inserted)
+      It->second = std::make_unique<BTFKindDataSec>(Asm, std::string(SecName));
 
     // We really don't know func size, set it to 0.
-    DataSecEntries[std::string(SecName)]->addDataSecEntry(FuncId,
-        Asm->getSymbol(F), 0);
+    It->second->addDataSecEntry(FuncId, Asm->getSymbol(F), 0);
   }
 }
 

llvm/lib/Target/SBF/MCTargetDesc/SBFInstPrinter.h

@@ -32,7 +32,8 @@ class SBFInstPrinter : public MCInstPrinter {
   void printBrTargetOperand(const MCInst *MI, unsigned OpNo, raw_ostream &O);
 
   // Autogenerated by tblgen.
-  std::pair<const char *, uint64_t> getMnemonic(const MCInst *MI) override;
+  std::pair<const char *, uint64_t>
+  getMnemonic(const MCInst &MI) const override;
   void printInstruction(const MCInst *MI, uint64_t Address, raw_ostream &O);
   static const char *getRegisterName(MCRegister Reg);
 };

llvm/lib/Target/SBF/MCTargetDesc/SBFMCTargetDesc.cpp

@@ -19,6 +19,7 @@
 #include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCELFObjectWriter.h"
 #include "llvm/MC/MCELFStreamer.h"
 #include "llvm/MC/MCInstrAnalysis.h"
 #include "llvm/MC/MCInstrInfo.h"

llvm/lib/Target/SBF/SBFAbstractMemberAccess.cpp

@@ -101,13 +101,13 @@ uint32_t SBFCoreSharedInfo::SeqNum;
 Instruction *SBFCoreSharedInfo::insertPassThrough(Module *M, BasicBlock *BB,
                                                   Instruction *Input,
                                                   Instruction *Before) {
-  Function *Fn = Intrinsic::getDeclaration(
+  Function *Fn = Intrinsic::getOrInsertDeclaration(
       M, Intrinsic::bpf_passthrough, {Input->getType(), Input->getType()});
   Constant *SeqNumVal = ConstantInt::get(Type::getInt32Ty(BB->getContext()),
                                          SBFCoreSharedInfo::SeqNum++);
 
   auto *NewInst = CallInst::Create(Fn, {SeqNumVal, Input});
-  NewInst->insertBefore(Before);
+  NewInst->insertBefore(Before->getIterator());
   return NewInst;
 }
 } // namespace llvm
@@ -223,10 +223,9 @@ bool SBFAbstractMemberAccess::run(Function &F) {
 
 void SBFAbstractMemberAccess::ResetMetadata(struct CallInfo &CInfo) {
   if (auto Ty = dyn_cast<DICompositeType>(CInfo.Metadata)) {
-    if (AnonRecords.find(Ty) != AnonRecords.end()) {
-      if (AnonRecords[Ty] != nullptr)
-        CInfo.Metadata = AnonRecords[Ty];
-    }
+    auto It = AnonRecords.find(Ty);
+    if (It != AnonRecords.end() && It->second != nullptr)
+      CInfo.Metadata = It->second;
   }
 }
 
@@ -236,18 +235,13 @@ void SBFAbstractMemberAccess::CheckCompositeType(DIDerivedType *ParentTy,
       ParentTy->getTag() != dwarf::DW_TAG_typedef)
     return;
 
-  if (AnonRecords.find(CTy) == AnonRecords.end()) {
-    AnonRecords[CTy] = ParentTy;
-    return;
-  }
+  auto [It, Inserted] = AnonRecords.try_emplace(CTy, ParentTy);
 
   // Two or more typedef's may point to the same anon record.
   // If this is the case, set the typedef DIType to be nullptr
   // to indicate the duplication case.
-  DIDerivedType *CurrTy = AnonRecords[CTy];
-  if (CurrTy == ParentTy)
-    return;
-  AnonRecords[CTy] = nullptr;
+  if (!Inserted && It->second != ParentTy)
+    It->second = nullptr;
 }
 
 void SBFAbstractMemberAccess::CheckDerivedType(DIDerivedType *ParentTy,
@@ -312,7 +306,7 @@ static uint32_t calcArraySize(const DICompositeType *CTy, uint32_t StartDim) {
     if (auto *Element = dyn_cast_or_null<DINode>(Elements[I]))
       if (Element->getTag() == dwarf::DW_TAG_subrange_type) {
         const DISubrange *SR = cast<DISubrange>(Element);
-        auto *CI = SR->getCount().dyn_cast<ConstantInt *>();
+        auto *CI = dyn_cast<ConstantInt *>(SR->getCount());
         DimSize *= CI->getSExtValue();
       }
   }
@@ -425,7 +419,7 @@ void SBFAbstractMemberAccess::replaceWithGEP(std::vector<CallInst *> &CallList,
     IdxList.push_back(Call->getArgOperand(GEPIndex));
 
     auto *GEP = GetElementPtrInst::CreateInBounds(
-        getBaseElementType(Call), Call->getArgOperand(0), IdxList, "", Call);
+        getBaseElementType(Call), Call->getArgOperand(0), IdxList, "", Call->getIterator());
     Call->replaceAllUsesWith(GEP);
     Call->eraseFromParent();
   }
@@ -1083,9 +1077,9 @@ bool SBFAbstractMemberAccess::transformGEPChain(CallInst *Call,
     // Load the global variable which represents the returned field info.
     LoadInst *LDInst;
     if (IsInt32Ret)
-      LDInst = new LoadInst(Type::getInt32Ty(BB->getContext()), GV, "", Call);
+      LDInst = new LoadInst(Type::getInt32Ty(BB->getContext()), GV, "", Call->getIterator());
     else
-      LDInst = new LoadInst(Type::getInt64Ty(BB->getContext()), GV, "", Call);
+      LDInst = new LoadInst(Type::getInt64Ty(BB->getContext()), GV, "", Call->getIterator());
 
     Instruction *PassThroughInst =
         SBFCoreSharedInfo::insertPassThrough(M, BB, LDInst, Call);
@@ -1105,21 +1099,23 @@ bool SBFAbstractMemberAccess::transformGEPChain(CallInst *Call,
   // The original Call inst is removed.
 
   // Load the global variable.
-  auto *LDInst = new LoadInst(Type::getInt64Ty(BB->getContext()), GV, "", Call);
+  auto *LDInst = new LoadInst(Type::getInt64Ty(BB->getContext()), GV, "", Call->getIterator());
 
   // Generate a BitCast
   auto *BCInst =
-      new BitCastInst(Base, PointerType::getUnqual(BB->getContext()));
-  BCInst->insertBefore(Call);
+      new BitCastInst(
+          Base, PointerType::get(BB->getContext(),
+                                 Base->getType()->getPointerAddressSpace()));
+  BCInst->insertBefore(Call->getIterator());
 
   // Generate a GetElementPtr
   auto *GEP = GetElementPtrInst::Create(Type::getInt8Ty(BB->getContext()),
                                         BCInst, LDInst);
-  GEP->insertBefore(Call);
+  GEP->insertBefore(Call->getIterator());
 
   // Generate a BitCast
   auto *BCInst2 = new BitCastInst(GEP, Call->getType());
-  BCInst2->insertBefore(Call);
+  BCInst2->insertBefore(Call->getIterator());
 
   // For the following code,
   //    Block0:

llvm/lib/Target/SBF/SBFAsmPrinter.cpp

@@ -14,14 +14,12 @@
 #include "SBF.h"
 #include "SBFInstrInfo.h"
 #include "SBFMCInstLower.h"
-#include "SBFTargetMachine.h"
 #include "BTFDebug.h"
 #include "MCTargetDesc/SBFInstPrinter.h"
 #include "MCTargetDesc/SBFMCTargetDesc.h"
 #include "TargetInfo/SBFTargetInfo.h"
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/CodeGen/MachineConstantPool.h"
-#include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/IR/Module.h"
@@ -70,7 +68,7 @@ bool SBFAsmPrinter::doInitialization(Module &M) {
   if (MAI->doesSupportDebugInformation() && !M.debug_compile_units().empty() &&
       SBFEnableBTFEmission) {
     BTF = new BTFX::BTFDebug(this);
-    DebugHandlers.push_back(std::unique_ptr<BTFX::BTFDebug>(BTF));
+    Handlers.push_back(std::unique_ptr<BTFX::BTFDebug>(BTF));
   }
 
   return false;