Merge branch 'main' into hgh/libcxx/P2255R2-A_type_trait_to_detect_reference_binding_to_temporary

Author: H-G-Hristov

llvm/lib/ProfileData/InstrProfWriter.cpp

@@ -230,15 +230,16 @@ void InstrProfWriter::overlapRecord(NamedInstrProfRecord &&Other,
   auto Name = Other.Name;
   auto Hash = Other.Hash;
   Other.accumulateCounts(FuncLevelOverlap.Test);
-  if (!FunctionData.contains(Name)) {
+  auto It = FunctionData.find(Name);
+  if (It == FunctionData.end()) {
     Overlap.addOneUnique(FuncLevelOverlap.Test);
     return;
   }
   if (FuncLevelOverlap.Test.CountSum < 1.0f) {
     Overlap.Overlap.NumEntries += 1;
     return;
   }
-  auto &ProfileDataMap = FunctionData[Name];
+  auto &ProfileDataMap = It->second;
   bool NewFunc;
   ProfilingData::iterator Where;
   std::tie(Where, NewFunc) =

llvm/lib/Target/AMDGPU/AMDGPURegBankLegalizeRules.cpp

@@ -314,18 +314,20 @@ RegBankLegalizeRules::getRulesForOpc(MachineInstr &MI) const {
       Opc == AMDGPU::G_INTRINSIC_W_SIDE_EFFECTS ||
       Opc == AMDGPU::G_INTRINSIC_CONVERGENT_W_SIDE_EFFECTS) {
     unsigned IntrID = cast<GIntrinsic>(MI).getIntrinsicID();
-    if (!IRulesAlias.contains(IntrID)) {
+    auto IRAIt = IRulesAlias.find(IntrID);
+    if (IRAIt == IRulesAlias.end()) {
       LLVM_DEBUG(dbgs() << "MI: "; MI.dump(););
       llvm_unreachable("No rules defined for intrinsic opcode");
     }
-    return IRules.at(IRulesAlias.at(IntrID));
+    return IRules.at(IRAIt->second);
   }
 
-  if (!GRulesAlias.contains(Opc)) {
+  auto GRAIt = GRulesAlias.find(Opc);
+  if (GRAIt == GRulesAlias.end()) {
     LLVM_DEBUG(dbgs() << "MI: "; MI.dump(););
     llvm_unreachable("No rules defined for generic opcode");
   }
-  return GRules.at(GRulesAlias.at(Opc));
+  return GRules.at(GRAIt->second);
 }
 
 // Syntactic sugar wrapper for predicate lambda that enables '&&', '||' and '!'.

llvm/lib/Target/PowerPC/MCTargetDesc/PPCELFStreamer.cpp

@@ -217,10 +217,11 @@ std::optional<bool> llvm::isPartOfGOTToPCRelPair(const MCInst &Inst,
   return (Inst.getOpcode() == PPC::PLDpc);
 }
 
-MCELFStreamer *llvm::createPPCELFStreamer(
-    MCContext &Context, std::unique_ptr<MCAsmBackend> MAB,
-    std::unique_ptr<MCObjectWriter> OW,
-    std::unique_ptr<MCCodeEmitter> Emitter) {
-  return new PPCELFStreamer(Context, std::move(MAB), std::move(OW),
+MCStreamer *
+llvm::createPPCELFStreamer(const Triple &T, MCContext &C,
+                           std::unique_ptr<MCAsmBackend> &&MAB,
+                           std::unique_ptr<MCObjectWriter> &&OW,
+                           std::unique_ptr<MCCodeEmitter> &&Emitter) {
+  return new PPCELFStreamer(C, std::move(MAB), std::move(OW),
                             std::move(Emitter));
 }

llvm/lib/Target/PowerPC/MCTargetDesc/PPCELFStreamer.h

@@ -50,10 +50,10 @@ class PPCELFStreamer : public MCELFStreamer {
 std::optional<bool> isPartOfGOTToPCRelPair(const MCInst &Inst,
                                            const MCSubtargetInfo &STI);
 
-MCELFStreamer *createPPCELFStreamer(MCContext &Context,
-                                    std::unique_ptr<MCAsmBackend> MAB,
-                                    std::unique_ptr<MCObjectWriter> OW,
-                                    std::unique_ptr<MCCodeEmitter> Emitter);
+MCStreamer *createPPCELFStreamer(const Triple &, MCContext &,
+                                 std::unique_ptr<MCAsmBackend> &&MAB,
+                                 std::unique_ptr<MCObjectWriter> &&OW,
+                                 std::unique_ptr<MCCodeEmitter> &&Emitter);
 } // end namespace llvm
 
 #endif // LLVM_LIB_TARGET_PPC_MCELFSTREAMER_PPCELFSTREAMER_H

llvm/lib/Target/PowerPC/MCTargetDesc/PPCMCTargetDesc.cpp

@@ -199,24 +199,6 @@ static MCAsmInfo *createPPCMCAsmInfo(const MCRegisterInfo &MRI,
   return MAI;
 }
 
-static MCStreamer *
-createPPCELFStreamer(const Triple &T, MCContext &Context,
-                     std::unique_ptr<MCAsmBackend> &&MAB,
-                     std::unique_ptr<MCObjectWriter> &&OW,
-                     std::unique_ptr<MCCodeEmitter> &&Emitter) {
-  return createPPCELFStreamer(Context, std::move(MAB), std::move(OW),
-                              std::move(Emitter));
-}
-
-static MCStreamer *
-createPPCXCOFFStreamer(const Triple &T, MCContext &Context,
-                       std::unique_ptr<MCAsmBackend> &&MAB,
-                       std::unique_ptr<MCObjectWriter> &&OW,
-                       std::unique_ptr<MCCodeEmitter> &&Emitter) {
-  return createPPCXCOFFStreamer(Context, std::move(MAB), std::move(OW),
-                                std::move(Emitter));
-}
-
 namespace {
 
 class PPCTargetAsmStreamer : public PPCTargetStreamer {

llvm/lib/Target/PowerPC/MCTargetDesc/PPCXCOFFStreamer.cpp

@@ -64,11 +64,11 @@ void PPCXCOFFStreamer::emitInstruction(const MCInst &Inst,
   emitPrefixedInstruction(Inst, STI);
 }
 
-MCXCOFFStreamer *
-llvm::createPPCXCOFFStreamer(MCContext &Context,
-                             std::unique_ptr<MCAsmBackend> MAB,
-                             std::unique_ptr<MCObjectWriter> OW,
-                             std::unique_ptr<MCCodeEmitter> Emitter) {
-  return new PPCXCOFFStreamer(Context, std::move(MAB), std::move(OW),
+MCStreamer *
+llvm::createPPCXCOFFStreamer(const Triple &, MCContext &C,
+                             std::unique_ptr<MCAsmBackend> &&MAB,
+                             std::unique_ptr<MCObjectWriter> &&OW,
+                             std::unique_ptr<MCCodeEmitter> &&Emitter) {
+  return new PPCXCOFFStreamer(C, std::move(MAB), std::move(OW),
                               std::move(Emitter));
 }

llvm/lib/Target/PowerPC/MCTargetDesc/PPCXCOFFStreamer.h

@@ -29,10 +29,10 @@ class PPCXCOFFStreamer : public MCXCOFFStreamer {
   void emitPrefixedInstruction(const MCInst &Inst, const MCSubtargetInfo &STI);
 };
 
-MCXCOFFStreamer *createPPCXCOFFStreamer(MCContext &Context,
-                                        std::unique_ptr<MCAsmBackend> MAB,
-                                        std::unique_ptr<MCObjectWriter> OW,
-                                        std::unique_ptr<MCCodeEmitter> Emitter);
+MCStreamer *createPPCXCOFFStreamer(const Triple &, MCContext &,
+                                   std::unique_ptr<MCAsmBackend> &&MAB,
+                                   std::unique_ptr<MCObjectWriter> &&OW,
+                                   std::unique_ptr<MCCodeEmitter> &&Emitter);
 } // end namespace llvm
 
 #endif // LLVM_LIB_TARGET_PPC_MCXCOFFSTREAMER_PPCXCOFFSTREAMER_H