Merge branch 'main' into hgh/libcxx/clean-up_saturation_arithmetic_tests

Author: Zingam

libcxx/test/std/utilities/meta/meta.rel/is_virtual_base_of.pass.cpp

@@ -9,7 +9,7 @@
 // UNSUPPORTED: c++03, c++11, c++14, c++17, c++20, c++23
 
 // These compilers don't support __builtin_is_virtual_base_of yet.
-// UNSUPPORTED: clang-18, clang-19, gcc-14, apple-clang-16
+// UNSUPPORTED: clang-18, clang-19, gcc-14, apple-clang-16, apple-clang-17
 
 // <type_traits>
 

llvm/include/llvm/CodeGen/AntiDepBreaker.h

@@ -56,7 +56,7 @@ class AntiDepBreaker {
 
   /// Update DBG_VALUE or DBG_PHI if dependency breaker is updating
   /// other machine instruction to use NewReg.
-  void UpdateDbgValue(MachineInstr &MI, unsigned OldReg, unsigned NewReg) {
+  void UpdateDbgValue(MachineInstr &MI, MCRegister OldReg, MCRegister NewReg) {
     if (MI.isDebugValue()) {
       if (MI.getDebugOperand(0).isReg() &&
           MI.getDebugOperand(0).getReg() == OldReg)
@@ -73,7 +73,7 @@ class AntiDepBreaker {
   /// Update all DBG_VALUE instructions that may be affected by the dependency
   /// breaker's update of ParentMI to use NewReg.
   void UpdateDbgValues(const DbgValueVector &DbgValues, MachineInstr *ParentMI,
-                       unsigned OldReg, unsigned NewReg) {
+                       MCRegister OldReg, MCRegister NewReg) {
     // The following code is dependent on the order in which the DbgValues are
     // constructed in ScheduleDAGInstrs::buildSchedGraph.
     MachineInstr *PrevDbgMI = nullptr;

llvm/include/llvm/CodeGen/DebugHandlerBase.h

@@ -30,7 +30,7 @@ class MachineModuleInfo;
 /// Represents the location at which a variable is stored.
 struct DbgVariableLocation {
   /// Base register.
-  unsigned Register;
+  MCRegister Register;
 
   /// Chain of offsetted loads necessary to load the value if it lives in
   /// memory. Every load except for the last is pointer-sized.

llvm/include/llvm/MC/MCExpr.h

@@ -249,16 +249,6 @@ class MCSymbolRefExpr : public MCExpr {
 
     VK_COFF_IMGREL32, // symbol@imgrel (image-relative)
 
-    VK_Hexagon_LO16,
-    VK_Hexagon_HI16,
-    VK_Hexagon_GPREL,
-    VK_Hexagon_GD_GOT,
-    VK_Hexagon_LD_GOT,
-    VK_Hexagon_GD_PLT,
-    VK_Hexagon_LD_PLT,
-    VK_Hexagon_IE,
-    VK_Hexagon_IE_GOT,
-
     VK_WASM_TYPEINDEX, // Reference to a symbol's type (signature)
     VK_WASM_TLSREL,    // Memory address relative to __tls_base
     VK_WASM_MBREL,     // Memory address relative to __memory_base
@@ -310,6 +300,10 @@ class MCSymbolRefExpr : public MCExpr {
 
   static const MCSymbolRefExpr *create(const MCSymbol *Symbol, VariantKind Kind,
                                        MCContext &Ctx, SMLoc Loc = SMLoc());
+  static const MCSymbolRefExpr *create(const MCSymbol *Symbol, uint16_t Kind,
+                                       MCContext &Ctx, SMLoc Loc = SMLoc()) {
+    return MCSymbolRefExpr::create(Symbol, VariantKind(Kind), Ctx, Loc);
+  }
 
   /// @}
   /// \name Accessors
@@ -577,7 +571,9 @@ class MCTargetExpr : public MCExpr {
   virtual void visitUsedExpr(MCStreamer& Streamer) const = 0;
   virtual MCFragment *findAssociatedFragment() const = 0;
 
-  virtual void fixELFSymbolsInTLSFixups(MCAssembler &) const = 0;
+  // Deprecated way to set the type of referenced ELF symbols to STT_TLS when
+  // the derived MCELFObjectTargetWriter::getRelocType does not update symbols.
+  virtual void fixELFSymbolsInTLSFixups(MCAssembler &) const {}
 
   static bool classof(const MCExpr *E) {
     return E->getKind() == MCExpr::Target;

llvm/include/llvm/Transforms/Utils/Cloning.h

@@ -244,25 +244,6 @@ DISubprogram *CollectDebugInfoForCloning(const Function &F,
                                          CloneFunctionChangeType Changes,
                                          DebugInfoFinder &DIFinder);
 
-/// Based on \p Changes and \p DIFinder return debug info that needs to be
-/// identity mapped during Metadata cloning.
-///
-/// NOTE: Such \a MetadataSetTy can be used by \a CloneFunction* to directly
-/// specify metadata that should be identity mapped (and hence not cloned). The
-/// metadata will be identity mapped in \a ValueToValueMapTy on first use. There
-/// are several reasons for doing it this way rather than eagerly identity
-/// mapping metadata nodes in a \a ValueMap:
-/// 1. Mapping metadata is not cheap, particularly because of tracking.
-/// 2. When cloning a Function we identity map lots of global module-level
-///    metadata to avoid cloning it, while only a fraction of it is actually
-///    used by the function. Mapping on first use is a lot faster for modules
-///    with meaningful amount of debug info.
-/// 3. Eagerly identity mapping metadata makes it harder to cache module-level
-///    data (e.g. a set of metadata nodes in a \a DICompileUnit).
-MetadataSetTy FindDebugInfoToIdentityMap(CloneFunctionChangeType Changes,
-                                         DebugInfoFinder &DIFinder,
-                                         DISubprogram *SPClonedWithinModule);
-
 /// This class captures the data input to the InlineFunction call, and records
 /// the auxiliary results produced by it.
 class InlineFunctionInfo {

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

@@ -1361,7 +1361,7 @@ void CodeViewDebug::calculateRanges(
     }
 
     // We can only handle a register or an offseted load of a register.
-    if (Location->Register == 0 || Location->LoadChain.size() > 1)
+    if (!Location->Register || Location->LoadChain.size() > 1)
       continue;
 
     // Codeview can only express byte-aligned offsets, ensure that we have a

llvm/lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp

@@ -39,7 +39,7 @@ DbgVariableLocation::extractFromMachineInstruction(
     return std::nullopt;
   if (!Instruction.getDebugOperand(0).isReg())
     return std::nullopt;
-  Location.Register = Instruction.getDebugOperand(0).getReg();
+  Location.Register = Instruction.getDebugOperand(0).getReg().asMCReg();
   Location.FragmentInfo.reset();
   // We only handle expressions generated by DIExpression::appendOffset,
   // which doesn't require a full stack machine.

llvm/lib/MC/MCWinCOFFStreamer.cpp

@@ -82,10 +82,6 @@ class MCCOFFSectionNumberTargetExpr final : public MCTargetExpr {
   MCFragment *findAssociatedFragment() const override {
     return SectionSymbol.getFragment();
   }
-
-  void fixELFSymbolsInTLSFixups(MCAssembler &) const override {
-    llvm_unreachable("Not supported for ELF");
-  }
 };
 
 /// MCExpr that represents the offset to a symbol from the beginning of its
@@ -123,10 +119,6 @@ class MCCOFFSectionOffsetTargetExpr final : public MCTargetExpr {
   MCFragment *findAssociatedFragment() const override {
     return Symbol.getFragment();
   }
-
-  void fixELFSymbolsInTLSFixups(MCAssembler &) const override {
-    llvm_unreachable("Not supported for ELF");
-  }
 };
 
 MCWinCOFFStreamer::MCWinCOFFStreamer(MCContext &Context,

llvm/lib/Target/AArch64/MCTargetDesc/AArch64ELFObjectWriter.cpp

@@ -126,6 +126,19 @@ unsigned AArch64ELFObjectWriter::getRelocType(MCContext &Ctx,
           Target.getSymB()->getKind() == MCSymbolRefExpr::VK_None) &&
          "Should only be expression-level modifiers here");
 
+  switch (SymLoc) {
+  case AArch64MCExpr::VK_DTPREL:
+  case AArch64MCExpr::VK_GOTTPREL:
+  case AArch64MCExpr::VK_TPREL:
+  case AArch64MCExpr::VK_TLSDESC:
+  case AArch64MCExpr::VK_TLSDESC_AUTH:
+    if (auto *S = Target.getSymA())
+      cast<MCSymbolELF>(S->getSymbol()).setType(ELF::STT_TLS);
+    break;
+  default:
+    break;
+  }
+
   if (IsPCRel) {
     switch (Kind) {
     case FK_Data_1:

llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCExpr.cpp

@@ -120,50 +120,6 @@ bool AArch64MCExpr::evaluateAsRelocatableImpl(MCValue &Res,
   return true;
 }
 
-static void fixELFSymbolsInTLSFixupsImpl(const MCExpr *Expr, MCAssembler &Asm) {
-  switch (Expr->getKind()) {
-  case MCExpr::Target:
-    llvm_unreachable("Can't handle nested target expression");
-    break;
-  case MCExpr::Constant:
-    break;
-
-  case MCExpr::Binary: {
-    const MCBinaryExpr *BE = cast<MCBinaryExpr>(Expr);
-    fixELFSymbolsInTLSFixupsImpl(BE->getLHS(), Asm);
-    fixELFSymbolsInTLSFixupsImpl(BE->getRHS(), Asm);
-    break;
-  }
-
-  case MCExpr::SymbolRef: {
-    // We're known to be under a TLS fixup, so any symbol should be
-    // modified. There should be only one.
-    const MCSymbolRefExpr &SymRef = *cast<MCSymbolRefExpr>(Expr);
-    cast<MCSymbolELF>(SymRef.getSymbol()).setType(ELF::STT_TLS);
-    break;
-  }
-
-  case MCExpr::Unary:
-    fixELFSymbolsInTLSFixupsImpl(cast<MCUnaryExpr>(Expr)->getSubExpr(), Asm);
-    break;
-  }
-}
-
-void AArch64MCExpr::fixELFSymbolsInTLSFixups(MCAssembler &Asm) const {
-  switch (getSymbolLoc(Kind)) {
-  default:
-    return;
-  case VK_DTPREL:
-  case VK_GOTTPREL:
-  case VK_TPREL:
-  case VK_TLSDESC:
-  case VK_TLSDESC_AUTH:
-    break;
-  }
-
-  fixELFSymbolsInTLSFixupsImpl(getSubExpr(), Asm);
-}
-
 const AArch64AuthMCExpr *AArch64AuthMCExpr::create(const MCExpr *Expr,
                                                    uint16_t Discriminator,
                                                    AArch64PACKey::ID Key,