merge main into amd-staging (llvm#3715)

Author: z1_cciauto

clang/lib/CodeGen/Targets/RISCV.cpp

@@ -955,7 +955,6 @@ void RISCVABIInfo::createCoercedStore(llvm::Value *Val, Address Dst,
       cast<llvm::FixedVectorType>(EltTy), Val, uint64_t(0));
   auto *I = CGF.Builder.CreateStore(Coerced, Dst, DestIsVolatile);
   CGF.addInstToCurrentSourceAtom(I, Val);
-  return;
 }
 
 namespace {

clang/lib/Driver/Driver.cpp

@@ -4691,7 +4691,6 @@ void Driver::BuildDriverManagedModuleBuildActions(
     Compilation &C, llvm::opt::DerivedArgList &Args, const InputList &Inputs,
     ActionList &Actions) const {
   Diags.Report(diag::remark_performing_driver_managed_module_build);
-  return;
 }
 
 /// Returns the canonical name for the offloading architecture when using a HIP

clang/lib/Driver/ToolChains/HLSL.cpp

@@ -215,7 +215,6 @@ void getSpirvExtOperand(StringRef SpvExtensionArg, raw_ostream &out) {
     return;
   }
   out << SpvExtensionArg;
-  return;
 }
 
 SmallString<1024> getSpirvExtArg(ArrayRef<std::string> SpvExtensionArgs) {

clang/unittests/Analysis/FlowSensitive/FormulaTest.cpp

@@ -22,8 +22,6 @@ using namespace dataflow;
 using ::llvm::Failed;
 using ::llvm::HasValue;
 using ::llvm::Succeeded;
-using ::testing::ElementsAre;
-using ::testing::IsEmpty;
 
 class SerializeFormulaTest : public ::testing::Test {
 protected:

llvm/include/llvm/IR/ConstantRange.h

@@ -381,6 +381,7 @@ class [[nodiscard]] ConstantRange {
   /// strictly smaller than the current type.  The returned range will
   /// correspond to the possible range of values if the source range had been
   /// truncated to the specified type with wrap type \p NoWrapKind.
+  /// Note that the result of trunc nuw is exact.
   LLVM_ABI ConstantRange truncate(uint32_t BitWidth,
                                   unsigned NoWrapKind = 0) const;
 

llvm/include/llvm/MC/MCAsmBackend.h

@@ -166,12 +166,8 @@ class LLVM_ABI MCAsmBackend {
   // Return false to use default handling. Otherwise, set `Size` to the number
   // of padding bytes.
   virtual bool relaxAlign(MCFragment &F, unsigned &Size) { return false; }
-  virtual bool relaxDwarfLineAddr(MCFragment &, bool &WasRelaxed) const {
-    return false;
-  }
-  virtual bool relaxDwarfCFA(MCFragment &, bool &WasRelaxed) const {
-    return false;
-  }
+  virtual bool relaxDwarfLineAddr(MCFragment &) const { return false; }
+  virtual bool relaxDwarfCFA(MCFragment &) const { return false; }
 
   // Defined by linker relaxation targets to possibly emit LEB128 relocations
   // and set Value at the relocated location.

llvm/include/llvm/MC/MCAssembler.h

@@ -112,15 +112,11 @@ class MCAssembler {
 
   /// Perform relaxation on a single fragment.
   bool relaxFragment(MCFragment &F);
-  bool relaxInstruction(MCFragment &F);
-  bool relaxLEB(MCFragment &F);
-  bool relaxBoundaryAlign(MCBoundaryAlignFragment &BF);
-  bool relaxDwarfLineAddr(MCFragment &F);
-  bool relaxDwarfCallFrameFragment(MCFragment &F);
-  bool relaxCVInlineLineTable(MCCVInlineLineTableFragment &DF);
-  bool relaxCVDefRange(MCCVDefRangeFragment &DF);
-  bool relaxFill(MCFillFragment &F);
-  bool relaxOrg(MCOrgFragment &F);
+  void relaxInstruction(MCFragment &F);
+  void relaxLEB(MCFragment &F);
+  void relaxBoundaryAlign(MCBoundaryAlignFragment &BF);
+  void relaxDwarfLineAddr(MCFragment &F);
+  void relaxDwarfCallFrameFragment(MCFragment &F);
 
 public:
   /// Construct a new assembler instance.

llvm/include/llvm/MC/MCSection.h

@@ -307,7 +307,6 @@ class MCFillFragment : public MCFragment {
   uint64_t Value;
   /// The number of bytes to insert.
   const MCExpr &NumValues;
-  uint64_t Size = 0;
 
   /// Source location of the directive that this fragment was created for.
   SMLoc Loc;
@@ -321,8 +320,6 @@ class MCFillFragment : public MCFragment {
   uint64_t getValue() const { return Value; }
   uint8_t getValueSize() const { return ValueSize; }
   const MCExpr &getNumValues() const { return NumValues; }
-  uint64_t getSize() const { return Size; }
-  void setSize(uint64_t Value) { Size = Value; }
 
   SMLoc getLoc() const { return Loc; }
 
@@ -371,16 +368,12 @@ class MCOrgFragment : public MCFragment {
   /// Source location of the directive that this fragment was created for.
   SMLoc Loc;
 
-  uint64_t Size = 0;
-
 public:
   MCOrgFragment(const MCExpr &Offset, int8_t Value, SMLoc Loc)
       : MCFragment(FT_Org), Value(Value), Offset(&Offset), Loc(Loc) {}
 
   const MCExpr &getOffset() const { return *Offset; }
   uint8_t getValue() const { return Value; }
-  uint64_t getSize() const { return Size; }
-  void setSize(uint64_t Value) { Size = Value; }
 
   SMLoc getLoc() const { return Loc; }
 

llvm/include/llvm/Transforms/Utils/LoopUtils.h

@@ -371,6 +371,9 @@ LLVM_ABI bool canSinkOrHoistInst(Instruction &I, AAResults *AA,
 /// Returns the llvm.vector.reduce intrinsic that corresponds to the recurrence
 /// kind.
 LLVM_ABI constexpr Intrinsic::ID getReductionIntrinsicID(RecurKind RK);
+/// Returns the llvm.vector.reduce min/max intrinsic that corresponds to the
+/// intrinsic op.
+LLVM_ABI Intrinsic::ID getMinMaxReductionIntrinsicID(Intrinsic::ID IID);
 
 /// Returns the arithmetic instruction opcode used when expanding a reduction.
 LLVM_ABI unsigned getArithmeticReductionInstruction(Intrinsic::ID RdxID);

llvm/lib/MC/MCAssembler.cpp

@@ -203,7 +203,7 @@ uint64_t MCAssembler::computeFragmentSize(const MCFragment &F) const {
   case MCFragment::FT_CVDefRange:
     return F.getSize();
   case MCFragment::FT_Fill: {
-    auto &FF = cast<MCFillFragment>(F);
+    auto &FF = static_cast<const MCFillFragment &>(F);
     int64_t NumValues = 0;
     if (!FF.getNumValues().evaluateKnownAbsolute(NumValues, *this)) {
       recordError(FF.getLoc(), "expected assembly-time absolute expression");
@@ -748,22 +748,22 @@ bool MCAssembler::fixupNeedsRelaxation(const MCFragment &F,
                                                    Resolved);
 }
 
-bool MCAssembler::relaxInstruction(MCFragment &F) {
+void MCAssembler::relaxInstruction(MCFragment &F) {
   assert(getEmitterPtr() &&
          "Expected CodeEmitter defined for relaxInstruction");
   // If this inst doesn't ever need relaxation, ignore it. This occurs when we
   // are intentionally pushing out inst fragments, or because we relaxed a
   // previous instruction to one that doesn't need relaxation.
   if (!getBackend().mayNeedRelaxation(F.getOpcode(), F.getOperands(),
                                       *F.getSubtargetInfo()))
-    return false;
+    return;
 
   bool DoRelax = false;
   for (const MCFixup &Fixup : F.getVarFixups())
     if ((DoRelax = fixupNeedsRelaxation(F, Fixup)))
       break;
   if (!DoRelax)
-    return false;
+    return;
 
   ++stats::RelaxedInstructions;
 
@@ -779,12 +779,10 @@ bool MCAssembler::relaxInstruction(MCFragment &F) {
   getEmitter().encodeInstruction(Relaxed, Data, Fixups, *F.getSubtargetInfo());
   F.setVarContents(Data);
   F.setVarFixups(Fixups);
-  return true;
 }
 
-bool MCAssembler::relaxLEB(MCFragment &F) {
-  const unsigned OldSize = F.getVarSize();
-  unsigned PadTo = OldSize;
+void MCAssembler::relaxLEB(MCFragment &F) {
+  unsigned PadTo = F.getVarSize();
   int64_t Value;
   F.clearVarFixups();
   // Use evaluateKnownAbsolute for Mach-O as a hack: .subsections_via_symbols
@@ -818,7 +816,6 @@ bool MCAssembler::relaxLEB(MCFragment &F) {
   else
     Size = encodeULEB128(Value, Data, PadTo);
   F.setVarContents({reinterpret_cast<char *>(Data), Size});
-  return OldSize != Size;
 }
 
 /// Check if the branch crosses the boundary.
@@ -858,11 +855,11 @@ static bool needPadding(uint64_t StartAddr, uint64_t Size,
          isAgainstBoundary(StartAddr, Size, BoundaryAlignment);
 }
 
-bool MCAssembler::relaxBoundaryAlign(MCBoundaryAlignFragment &BF) {
+void MCAssembler::relaxBoundaryAlign(MCBoundaryAlignFragment &BF) {
   // BoundaryAlignFragment that doesn't need to align any fragment should not be
   // relaxed.
   if (!BF.getLastFragment())
-    return false;
+    return;
 
   uint64_t AlignedOffset = getFragmentOffset(BF);
   uint64_t AlignedSize = 0;
@@ -877,18 +874,15 @@ bool MCAssembler::relaxBoundaryAlign(MCBoundaryAlignFragment &BF) {
                          ? offsetToAlignment(AlignedOffset, BoundaryAlignment)
                          : 0U;
   if (NewSize == BF.getSize())
-    return false;
+    return;
   BF.setSize(NewSize);
-  return true;
 }
 
-bool MCAssembler::relaxDwarfLineAddr(MCFragment &F) {
-  bool WasRelaxed;
-  if (getBackend().relaxDwarfLineAddr(F, WasRelaxed))
-    return WasRelaxed;
+void MCAssembler::relaxDwarfLineAddr(MCFragment &F) {
+  if (getBackend().relaxDwarfLineAddr(F))
+    return;
 
   MCContext &Context = getContext();
-  auto OldSize = F.getVarSize();
   int64_t AddrDelta;
   bool Abs = F.getDwarfAddrDelta().evaluateKnownAbsolute(AddrDelta, *this);
   assert(Abs && "We created a line delta with an invalid expression");
@@ -898,13 +892,11 @@ bool MCAssembler::relaxDwarfLineAddr(MCFragment &F) {
                           F.getDwarfLineDelta(), AddrDelta, Data);
   F.setVarContents(Data);
   F.clearVarFixups();
-  return OldSize != Data.size();
 }
 
-bool MCAssembler::relaxDwarfCallFrameFragment(MCFragment &F) {
-  bool WasRelaxed;
-  if (getBackend().relaxDwarfCFA(F, WasRelaxed))
-    return WasRelaxed;
+void MCAssembler::relaxDwarfCallFrameFragment(MCFragment &F) {
+  if (getBackend().relaxDwarfCFA(F))
+    return;
 
   MCContext &Context = getContext();
   int64_t Value;
@@ -913,69 +905,49 @@ bool MCAssembler::relaxDwarfCallFrameFragment(MCFragment &F) {
     reportError(F.getDwarfAddrDelta().getLoc(),
                 "invalid CFI advance_loc expression");
     F.setDwarfAddrDelta(MCConstantExpr::create(0, Context));
-    return false;
+    return;
   }
 
-  auto OldSize = F.getVarContents().size();
   SmallVector<char, 8> Data;
   MCDwarfFrameEmitter::encodeAdvanceLoc(Context, Value, Data);
   F.setVarContents(Data);
   F.clearVarFixups();
-  return OldSize != Data.size();
-}
-
-bool MCAssembler::relaxCVInlineLineTable(MCCVInlineLineTableFragment &F) {
-  unsigned OldSize = F.getVarContents().size();
-  getContext().getCVContext().encodeInlineLineTable(*this, F);
-  return OldSize != F.getVarContents().size();
-}
-
-bool MCAssembler::relaxCVDefRange(MCCVDefRangeFragment &F) {
-  unsigned OldSize = F.getVarContents().size();
-  getContext().getCVContext().encodeDefRange(*this, F);
-  return OldSize != F.getVarContents().size();
-}
-
-bool MCAssembler::relaxFill(MCFillFragment &F) {
-  uint64_t Size = computeFragmentSize(F);
-  if (F.getSize() == Size)
-    return false;
-  F.setSize(Size);
-  return true;
-}
-
-bool MCAssembler::relaxOrg(MCOrgFragment &F) {
-  uint64_t Size = computeFragmentSize(F);
-  if (F.getSize() == Size)
-    return false;
-  F.setSize(Size);
-  return true;
 }
 
 bool MCAssembler::relaxFragment(MCFragment &F) {
-  switch(F.getKind()) {
+  auto Size = computeFragmentSize(F);
+  switch (F.getKind()) {
   default:
     return false;
   case MCFragment::FT_Relaxable:
     assert(!getRelaxAll() && "Did not expect a FT_Relaxable in RelaxAll mode");
-    return relaxInstruction(F);
+    relaxInstruction(F);
+    break;
   case MCFragment::FT_LEB:
-    return relaxLEB(F);
+    relaxLEB(F);
+    break;
   case MCFragment::FT_Dwarf:
-    return relaxDwarfLineAddr(F);
+    relaxDwarfLineAddr(F);
+    break;
   case MCFragment::FT_DwarfFrame:
-    return relaxDwarfCallFrameFragment(F);
+    relaxDwarfCallFrameFragment(F);
+    break;
   case MCFragment::FT_BoundaryAlign:
-    return relaxBoundaryAlign(cast<MCBoundaryAlignFragment>(F));
+    relaxBoundaryAlign(static_cast<MCBoundaryAlignFragment &>(F));
+    break;
   case MCFragment::FT_CVInlineLines:
-    return relaxCVInlineLineTable(cast<MCCVInlineLineTableFragment>(F));
+    getContext().getCVContext().encodeInlineLineTable(
+        *this, static_cast<MCCVInlineLineTableFragment &>(F));
+    break;
   case MCFragment::FT_CVDefRange:
-    return relaxCVDefRange(cast<MCCVDefRangeFragment>(F));
+    getContext().getCVContext().encodeDefRange(
+        *this, static_cast<MCCVDefRangeFragment &>(F));
+    break;
   case MCFragment::FT_Fill:
-    return relaxFill(cast<MCFillFragment>(F));
   case MCFragment::FT_Org:
-    return relaxOrg(static_cast<MCOrgFragment &>(F));
+    return F.getNext()->Offset - F.Offset != Size;
   }
+  return computeFragmentSize(F) != Size;
 }
 
 void MCAssembler::layoutSection(MCSection &Sec) {
@@ -1024,7 +996,7 @@ unsigned MCAssembler::relaxOnce(unsigned FirstStable) {
     for (;;) {
       bool Changed = false;
       for (MCFragment &F : Sec)
-        if (relaxFragment(F))
+        if (F.getKind() != MCFragment::FT_Data && relaxFragment(F))
           Changed = true;
 
       if (!Changed)