[AsmPrinter] Remove hidden flag -print-schedule.

[andreadb]

Summary

This patch removes hidden codegen flag -print-schedule effectively reverting the logic originally committed as r300311 (https://llvm.org/viewvc/llvm-project?view=revision&revision=300311).

Flag -print-schedule was originally introduced by r300311 to address PR32216 (https://bugs.llvm.org/show_bug.cgi?id=32216). That bug was about adding "Better testing of schedule model instruction latencies/throughputs".

These days, we can use llvm-mca to test scheduling models. So there is no longer a need for flag -print-schedule in LLVM. The main use case for PR32216 is addressed by llvm-mca.
Flag -print-schedule is mainly used for debugging purposes, and it is only actually used by x86 specific tests. We already have extensive (latency and throughput) tests under "test/tools/llvm-mca" for X86 processor models. That means, most (if not all) existing -print-schedule tests for X86 are redundant.

When flag -print-schedule was first added to LLVM, several files had to be modified; a few APIs gained new arguments (see for example method MCAsmStreamer::EmitInstruction), and MCSubtargetInfo/TargetSubtargetInfo gained a couple of getSchedInfoStr() methods.

Method getSchedInfoStr() had to originally work for both MCInst and MachineInstr. The original implmentation of getSchedInfoStr() introduced a subtle layering violation (reported as PR37160 and then fixed/worked-around by r330615).
In retrospect, that new API could have been designed more optimally. We can always query MCSchedModel to get the latency and throughput. More importantly, the "sched-info" string should not have been generated by the subtarget.
Note, r317782 fixed an issue where "print-schedule" didn't work very well in the presence of inline assembly. That commit is also reverted by this change.

In conclusion: I think that we can safely remove the -print-schedule flag. It was previously very useful despite the above issues because there was no better alternative. Future tests for machine schedulers can use llvm-mca as tool.

Apologies for the large patch; most of the difference is because several tests have been removed. The rest of the diff is a clean-up, and lines have been removed.
I didn't remove the avx512 tests mainly because I am not entirely sure if we have extensive coverage for those in llvm-mca. For now, I have simply regenerated those using update_llc.py (after having removed flag -print-schedule).

Please let me know what you think.

Thanks in advance,
Andrea

[RKSimon]

avx512vpopcntdq-schedule.ll can be deleted - its fully covered in llvm-mca tests

[RKSimon]

avx512-shuffle-schedule.ll is covered by llvm-mca tests - I don't think it gives us much in additional codegen test coverage, we can maybe keep it around as avx512-shuffle.ll ?

avx512-schedule.ll - this isn't fully covered by llvm-mca tests, it also has some tests that don't look like they belong there (_mm512_set_epi32, stack folding tests etc.)

@craig.topper what do you think?

[craig.topper]

How much of avx512-schedule.ll isn't covered by llvm-mca? The test itself seems to be a lot of copy and pastes from other files. I don't know if there's any unique content in it.

[RKSimon]

In D57244#1372388, @craig.topper wrote:

How much of avx512-schedule.ll isn't covered by llvm-mca? The test itself seems to be a lot of copy and pastes from other files. I don't know if there's any unique content in it.

I'll try to go through the file and audit it, I think its mainly avx512dq instructions that aren't covered by llvm-mca tests. And I'll move the non-schedule tests into somewhere more suitable.

[RKSimon]

I've gone through avx512-schedule.ll - the tests are duplicates from various other avx512 test files, sometimes renamed, to add schedule test coverage - imo the file can be deleted.

I've done a first pass of adding the llvm-mca tests at rL352273, we need to go through and do a more thorough pass at some point to ensure we have full ISA/schedule-model coverage but I don't think there's anything stopping us getting rid of the -schedule.ll files at this point.

[andreadb]

Patch updated.

Removed avx512 schedule tests (thanks Simon!).

[RKSimon]

This makes sense to me - tbh I'm not sure if we gain anything from keeping -print-schedule any more - does anyone have any further comments?

test/CodeGen/X86/mul-constant-i32.ll

9

Please add common check-prefixes to collapse this more (same for mul-constant-i64.ll).

[RKSimon]

Looks like there's no objections, so LGTM!

include/llvm/CodeGen/AsmPrinter.h

public:
   /// default, this is equal to CurrentFnSym.
   MCSymbol *CurrentFnSymForSize = nullptr;
 
   /// Map global GOT equivalent MCSymbols to GlobalVariables and keep track of
   /// its number of uses by other globals.
   using GOTEquivUsePair = std::pair<const GlobalVariable *, unsigned>;
   MapVector<const MCSymbol *, GOTEquivUsePair> GlobalGOTEquivs;
 
-  /// Enable print [latency:throughput] in output.
-  bool EnablePrintSchedInfo = false;
-
 private:
   MCSymbol *CurrentFnBegin = nullptr;
   MCSymbol *CurrentFnEnd = nullptr;
   MCSymbol *CurExceptionSym = nullptr;
 
   // The garbage collection metadata printer table.
   void *GCMetadataPrinters = nullptr; // Really a DenseMap.
 

include/llvm/CodeGen/TargetSubtargetInfo.h

public:
   /// True if the subtarget should run MachineScheduler after aggressive
   /// coalescing.
   ///
   /// This currently replaces the SelectionDAG scheduler with the "source" order
   /// scheduler (though see below for an option to turn this off and use the
   /// TargetLowering preference). It does not yet disable the postRA scheduler.
   virtual bool enableMachineScheduler() const;
 
-  /// Support printing of [latency:throughput] comment in output .S file.
-  virtual bool supportPrintSchedInfo() const { return false; }
-
   /// True if the machine scheduler should disable the TLI preference
   /// for preRA scheduling with the source level scheduler.
   virtual bool enableMachineSchedDefaultSched() const { return true; }
 
   /// True if the subtarget should enable joining global copies.
   ///
   /// By default this is enabled if the machine scheduler is enabled, but
   /// can be overridden.
virtual std::unique_ptr<PBQPRAConstraint> getCustomPBQPConstraints() const {
     return nullptr;
   }
 
   /// Enable tracking of subregister liveness in register allocator.
   /// Please use MachineRegisterInfo::subRegLivenessEnabled() instead where
   /// possible.
   virtual bool enableSubRegLiveness() const { return false; }
 
-  /// Returns string representation of scheduler comment
-  std::string getSchedInfoStr(const MachineInstr &MI) const;
-  std::string getSchedInfoStr(MCInst const &MCI) const override;
-
   /// This is called after a .mir file was loaded.
   virtual void mirFileLoaded(MachineFunction &MF) const;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_CODEGEN_TARGETSUBTARGETINFO_H

include/llvm/MC/MCObjectStreamer.h

public:
   virtual void EmitLabel(MCSymbol *Symbol, SMLoc Loc, MCFragment *F);
   void EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) override;
   void EmitValueImpl(const MCExpr *Value, unsigned Size,
                      SMLoc Loc = SMLoc()) override;
   void EmitULEB128Value(const MCExpr *Value) override;
   void EmitSLEB128Value(const MCExpr *Value) override;
   void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override;
   void ChangeSection(MCSection *Section, const MCExpr *Subsection) override;
-  void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI,
-                       bool = false) override;
+  void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI) override;
 
   /// Emit an instruction to a special fragment, because this instruction
   /// can change its size during relaxation.
   virtual void EmitInstToFragment(const MCInst &Inst, const MCSubtargetInfo &);
 
   void EmitBundleAlignMode(unsigned AlignPow2) override;
   void EmitBundleLock(bool AlignToEnd) override;
   void EmitBundleUnlock() override;

include/llvm/MC/MCParser/MCAsmParser.h

 protected: // Can only create subclasses.
   MCAsmParser();
 
   SmallVector<MCPendingError, 0> PendingErrors;
 
   /// Flag tracking whether any errors have been encountered.
   bool HadError = false;
 
-  /// Enable print [latency:throughput] in output file.
-  bool EnablePrintSchedInfo = false;
-
   bool ShowParsedOperands = false;
 
 public:
   MCAsmParser(const MCAsmParser &) = delete;
   MCAsmParser &operator=(const MCAsmParser &) = delete;
   virtual ~MCAsmParser();
 
   virtual void addDirectiveHandler(StringRef Directive,
public:
   void setTargetParser(MCTargetAsmParser &P);
 
   virtual unsigned getAssemblerDialect() { return 0;}
   virtual void setAssemblerDialect(unsigned i) { }
 
   bool getShowParsedOperands() const { return ShowParsedOperands; }
   void setShowParsedOperands(bool Value) { ShowParsedOperands = Value; }
 
-  void setEnablePrintSchedInfo(bool Value) { EnablePrintSchedInfo = Value; }
-  bool shouldPrintSchedInfo() const { return EnablePrintSchedInfo; }
-
   /// Run the parser on the input source buffer.
   virtual bool Run(bool NoInitialTextSection, bool NoFinalize = false) = 0;
 
   virtual void setParsingInlineAsm(bool V) = 0;
   virtual bool isParsingInlineAsm() = 0;
 
   /// Parse MS-style inline assembly.
   virtual bool parseMSInlineAsm(

include/llvm/MC/MCStreamer.h

virtual bool EmitRelocDirective(const MCExpr &Offset, StringRef Name,
                                   const MCSubtargetInfo &STI) {
     return true;
   }
 
   virtual void EmitAddrsig() {}
   virtual void EmitAddrsigSym(const MCSymbol *Sym) {}
 
   /// Emit the given \p Instruction into the current section.
-  /// PrintSchedInfo == true then schedul comment should be added to output
-  virtual void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI,
-                               bool PrintSchedInfo = false);
+  virtual void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI);
 
   /// Set the bundle alignment mode from now on in the section.
   /// The argument is the power of 2 to which the alignment is set. The
   /// value 0 means turn the bundle alignment off.
   virtual void EmitBundleAlignMode(unsigned AlignPow2);
 
   /// The following instructions are a bundle-locked group.
   ///

include/llvm/MC/MCSubtargetInfo.h

resolveVariantSchedClass(unsigned SchedClass, const MCInst *MI,
     return 0;
   }
 
   /// Check whether the CPU string is valid.
   bool isCPUStringValid(StringRef CPU) const {
     auto Found = std::lower_bound(ProcDesc.begin(), ProcDesc.end(), CPU);
     return Found != ProcDesc.end() && StringRef(Found->Key) == CPU;
   }
-
-  /// Returns string representation of scheduler comment
-  virtual std::string getSchedInfoStr(MCInst const &MCI) const {
-    return {};
-  }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_MC_MCSUBTARGETINFO_H

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

 #include "llvm/CodeGen/MachineOperand.h"
 #include "llvm/CodeGen/MachineOptimizationRemarkEmitter.h"
 #include "llvm/CodeGen/StackMaps.h"
 #include "llvm/CodeGen/TargetFrameLowering.h"
 #include "llvm/CodeGen/TargetInstrInfo.h"
 #include "llvm/CodeGen/TargetLowering.h"
 #include "llvm/CodeGen/TargetOpcodes.h"
 #include "llvm/CodeGen/TargetRegisterInfo.h"
-#include "llvm/CodeGen/TargetSubtargetInfo.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Comdat.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"

 static const char *const CFGuardName = "Control Flow Guard";
 static const char *const CFGuardDescription = "Control Flow Guard Tables";
 static const char *const CodeViewLineTablesGroupName = "linetables";
 static const char *const CodeViewLineTablesGroupDescription =
   "CodeView Line Tables";
 
 STATISTIC(EmittedInsts, "Number of machine instrs printed");
 
-static cl::opt<bool>
-    PrintSchedule("print-schedule", cl::Hidden, cl::init(false),
-                  cl::desc("Print 'sched: [latency:throughput]' in .s output"));
-
 char AsmPrinter::ID = 0;
 
 using gcp_map_type = DenseMap<GCStrategy *, std::unique_ptr<GCMetadataPrinter>>;
 
 static gcp_map_type &getGCMap(void *&P) {
   if (!P)
     P = new gcp_map_type();
   return *(gcp_map_type*)P;
void AsmPrinter::EmitFunctionEntryLabel() {
   if (CurrentFnSym->isDefined())
     report_fatal_error("'" + Twine(CurrentFnSym->getName()) +
                        "' label emitted multiple times to assembly file");
 
   return OutStreamer->EmitLabel(CurrentFnSym);
 }
 
 /// emitComments - Pretty-print comments for instructions.
-/// It returns true iff the sched comment was emitted.
-///   Otherwise it returns false.
-static bool emitComments(const MachineInstr &MI, raw_ostream &CommentOS,
-                         AsmPrinter *AP) {
+static void emitComments(const MachineInstr &MI, raw_ostream &CommentOS) {
   const MachineFunction *MF = MI.getMF();
   const TargetInstrInfo *TII = MF->getSubtarget().getInstrInfo();
 
   // Check for spills and reloads
   int FI;
 
   const MachineFrameInfo &MFI = MF->getFrameInfo();
-  bool Commented = false;
 
   auto getSize =
       [&MFI](const SmallVectorImpl<const MachineMemOperand *> &Accesses) {
         unsigned Size = 0;
         for (auto A : Accesses)
           if (MFI.isSpillSlotObjectIndex(
                   cast<FixedStackPseudoSourceValue>(A->getPseudoValue())
                       ->getFrameIndex()))
             Size += A->getSize();
         return Size;
       };
 
   // We assume a single instruction only has a spill or reload, not
   // both.
   const MachineMemOperand *MMO;
   SmallVector<const MachineMemOperand *, 2> Accesses;
   if (TII->isLoadFromStackSlotPostFE(MI, FI)) {
     if (MFI.isSpillSlotObjectIndex(FI)) {
       MMO = *MI.memoperands_begin();
-      CommentOS << MMO->getSize() << "-byte Reload";
-      Commented = true;
+      CommentOS << MMO->getSize() << "-byte Reload\n";
     }
   } else if (TII->hasLoadFromStackSlot(MI, Accesses)) {
-    if (auto Size = getSize(Accesses)) {
-      CommentOS << Size << "-byte Folded Reload";
-      Commented = true;
-    }
+    if (auto Size = getSize(Accesses))
+      CommentOS << Size << "-byte Folded Reload\n";
   } else if (TII->isStoreToStackSlotPostFE(MI, FI)) {
     if (MFI.isSpillSlotObjectIndex(FI)) {
       MMO = *MI.memoperands_begin();
-      CommentOS << MMO->getSize() << "-byte Spill";
-      Commented = true;
+      CommentOS << MMO->getSize() << "-byte Spill\n";
     }
   } else if (TII->hasStoreToStackSlot(MI, Accesses)) {
-    if (auto Size = getSize(Accesses)) {
-      CommentOS << Size << "-byte Folded Spill";
-      Commented = true;
-    }
+    if (auto Size = getSize(Accesses))
+      CommentOS << Size << "-byte Folded Spill\n";
   }
 
   // Check for spill-induced copies
-  if (MI.getAsmPrinterFlag(MachineInstr::ReloadReuse)) {
-    Commented = true;
-    CommentOS << " Reload Reuse";
-  }
-
-  if (Commented) {
-    if (AP->EnablePrintSchedInfo) {
-      // If any comment was added above and we need sched info comment then add
-      // this new comment just after the above comment w/o "\n" between them.
-      CommentOS << " " << MF->getSubtarget().getSchedInfoStr(MI) << "\n";
-      return true;
-    }
-    CommentOS << "\n";
-  }
-  return false;
+  if (MI.getAsmPrinterFlag(MachineInstr::ReloadReuse))
+    CommentOS << " Reload Reuse\n";
 }
 
 /// emitImplicitDef - This method emits the specified machine instruction
 /// that is an implicit def.
 void AsmPrinter::emitImplicitDef(const MachineInstr *MI) const {
   unsigned RegNo = MI->getOperand(0).getReg();
 
   SmallString<128> Str;
for (auto &MI : MBB) {
         for (const HandlerInfo &HI : Handlers) {
           NamedRegionTimer T(HI.TimerName, HI.TimerDescription,
                              HI.TimerGroupName, HI.TimerGroupDescription,
                              TimePassesIsEnabled);
           HI.Handler->beginInstruction(&MI);
         }
       }
 
-      if (isVerbose() && emitComments(MI, OutStreamer->GetCommentOS(), this)) {
-        MachineInstr *MIP = const_cast<MachineInstr *>(&MI);
-        MIP->setAsmPrinterFlag(MachineInstr::NoSchedComment);
-      }
+      if (isVerbose())
+        emitComments(MI, OutStreamer->GetCommentOS());
 
       switch (MI.getOpcode()) {
       case TargetOpcode::CFI_INSTRUCTION:
         emitCFIInstruction(MI);
         break;
       case TargetOpcode::LOCAL_ESCAPE:
         emitFrameAlloc(MI);
         break;
void AsmPrinter::SetupMachineFunction(MachineFunction &MF) {
   if (needFuncLabelsForEHOrDebugInfo(MF, MMI) || NeedsLocalForSize ||
       MF.getTarget().Options.EmitStackSizeSection) {
     CurrentFnBegin = createTempSymbol("func_begin");
     if (NeedsLocalForSize)
       CurrentFnSymForSize = CurrentFnBegin;
   }
 
   ORE = &getAnalysis<MachineOptimizationRemarkEmitterPass>().getORE();
-
-  const TargetSubtargetInfo &STI = MF.getSubtarget();
-  EnablePrintSchedInfo = PrintSchedule.getNumOccurrences()
-                             ? PrintSchedule
-                             : STI.supportPrintSchedInfo();
 }
 
 namespace {
 
 // Keep track the alignment, constpool entries per Section.
   struct SectionCPs {
     MCSection *S;
     unsigned Alignment;

lib/CodeGen/AsmPrinter/AsmPrinterInlineAsm.cpp

 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/TargetInstrInfo.h"
 #include "llvm/CodeGen/TargetRegisterInfo.h"
-#include "llvm/CodeGen/TargetSubtargetInfo.h"
+//#include "llvm/CodeGen/TargetSubtargetInfo.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/InlineAsm.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCParser/MCTargetAsmParser.h"
 #include "llvm/MC/MCStreamer.h"
void AsmPrinter::EmitInlineAsm(StringRef Str, const MCSubtargetInfo &STI,
   std::unique_ptr<MCInstrInfo> MII(TM.getTarget().createMCInstrInfo());
   std::unique_ptr<MCTargetAsmParser> TAP(TM.getTarget().createMCAsmParser(
       STI, *Parser, *MII, MCOptions));
   if (!TAP)
     report_fatal_error("Inline asm not supported by this streamer because"
                        " we don't have an asm parser for this target\n");
   Parser->setAssemblerDialect(Dialect);
   Parser->setTargetParser(*TAP.get());
-  Parser->setEnablePrintSchedInfo(EnablePrintSchedInfo);
   // Enable lexing Masm binary and hex integer literals in intel inline
   // assembly.
   if (Dialect == InlineAsm::AD_Intel)
     Parser->getLexer().setLexMasmIntegers(true);
   if (MF) {
     const TargetRegisterInfo *TRI = MF->getSubtarget().getRegisterInfo();
     TAP->SetFrameRegister(TRI->getFrameRegister(*MF));
   }

lib/CodeGen/MachineCombiner.cpp

for (auto P : Patterns) {
       unsigned OldInstCount = DelInstrs.size();
       // Found pattern, but did not generate alternative sequence.
       // This can happen e.g. when an immediate could not be materialized
       // in a single instruction.
       if (!NewInstCount)
         continue;
 
       LLVM_DEBUG(if (dump_intrs) {
-        dbgs() << "\tFor the Pattern (" << (int)P << ") these instructions could be removed\n";
-        for (auto const *InstrPtr : DelInstrs) {
-          dbgs() << "\t\t" << STI->getSchedInfoStr(*InstrPtr) << ": ";
+        dbgs() << "\tFor the Pattern (" << (int)P
+               << ") these instructions could be removed\n";
+        for (auto const *InstrPtr : DelInstrs)
           InstrPtr->print(dbgs(), false, false, false, TII);
-        }
         dbgs() << "\tThese instructions could replace the removed ones\n";
-        for (auto const *InstrPtr : InsInstrs) {
-          dbgs() << "\t\t" << STI->getSchedInfoStr(*InstrPtr) << ": ";
+        for (auto const *InstrPtr : InsInstrs)
           InstrPtr->print(dbgs(), false, false, false, TII);
-        }
       });
 
       bool SubstituteAlways = false;
       if (ML && TII->isThroughputPattern(P))
         SubstituteAlways = true;
 
       if (IncrementalUpdate) {
         // Update depths since the last incremental update.

lib/CodeGen/TargetSubtargetInfo.cpp

 //===- TargetSubtargetInfo.cpp - General Target Information ----------------==//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 /// \file This file describes the general parts of a Subtarget.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/CodeGen/TargetSubtargetInfo.h"
-#include "llvm/ADT/Optional.h"
-#include "llvm/CodeGen/MachineInstr.h"
-#include "llvm/CodeGen/TargetInstrInfo.h"
-#include "llvm/CodeGen/TargetSchedule.h"
-#include "llvm/MC/MCInst.h"
-#include "llvm/Support/Format.h"
-#include "llvm/Support/raw_ostream.h"
-#include <string>
 
 using namespace llvm;
 
 TargetSubtargetInfo::TargetSubtargetInfo(
     const Triple &TT, StringRef CPU, StringRef FS,
     ArrayRef<SubtargetFeatureKV> PF, ArrayRef<SubtargetFeatureKV> PD,
     const SubtargetInfoKV *ProcSched, const MCWriteProcResEntry *WPR,
     const MCWriteLatencyEntry *WL, const MCReadAdvanceEntry *RA,

 bool TargetSubtargetInfo::enablePostRAScheduler() const {
   return getSchedModel().PostRAScheduler;
 }
 
 bool TargetSubtargetInfo::useAA() const {
   return false;
 }
 
-static std::string createSchedInfoStr(unsigned Latency, double RThroughput) {
-  static const char *SchedPrefix = " sched: [";
-  std::string Comment;
-  raw_string_ostream CS(Comment);
-  if (RThroughput != 0.0)
-    CS << SchedPrefix << Latency << format(":%2.2f", RThroughput)
-       << "]";
-  else
-    CS << SchedPrefix << Latency << ":?]";
-  CS.flush();
-  return Comment;
-}
-
-/// Returns string representation of scheduler comment
-std::string TargetSubtargetInfo::getSchedInfoStr(const MachineInstr &MI) const {
-  if (MI.isPseudo() || MI.isTerminator())
-    return std::string();
-  // We don't cache TSchedModel because it depends on TargetInstrInfo
-  // that could be changed during the compilation
-  TargetSchedModel TSchedModel;
-  TSchedModel.init(this);
-  unsigned Latency = TSchedModel.computeInstrLatency(&MI);
-
-  // Add extra latency due to forwarding delays.
-  const MCSchedClassDesc &SCDesc = *TSchedModel.resolveSchedClass(&MI);
-  Latency +=
-      MCSchedModel::getForwardingDelayCycles(getReadAdvanceEntries(SCDesc));
-
-  double RThroughput = TSchedModel.computeReciprocalThroughput(&MI);
-  return createSchedInfoStr(Latency, RThroughput);
-}
-
-/// Returns string representation of scheduler comment
-std::string TargetSubtargetInfo::getSchedInfoStr(MCInst const &MCI) const {
-  // We don't cache TSchedModel because it depends on TargetInstrInfo
-  // that could be changed during the compilation
-  TargetSchedModel TSchedModel;
-  TSchedModel.init(this);
-  unsigned Latency;
-  if (TSchedModel.hasInstrSchedModel()) {
-    Latency = TSchedModel.computeInstrLatency(MCI);
-    // Add extra latency due to forwarding delays.
-    const MCSchedModel &SM = *TSchedModel.getMCSchedModel();
-    unsigned SClassID = getInstrInfo()->get(MCI.getOpcode()).getSchedClass();
-    while (SM.getSchedClassDesc(SClassID)->isVariant())
-      SClassID = resolveVariantSchedClass(SClassID, &MCI, SM.ProcID);
-    const MCSchedClassDesc &SCDesc = *SM.getSchedClassDesc(SClassID);  
-    Latency +=
-        MCSchedModel::getForwardingDelayCycles(getReadAdvanceEntries(SCDesc));
-  } else if (TSchedModel.hasInstrItineraries()) {
-    auto *ItinData = TSchedModel.getInstrItineraries();
-    Latency = ItinData->getStageLatency(
-        getInstrInfo()->get(MCI.getOpcode()).getSchedClass());
-  } else
-    return std::string();
-  double RThroughput = TSchedModel.computeReciprocalThroughput(MCI);
-  return createSchedInfoStr(Latency, RThroughput);
-}
-
-void TargetSubtargetInfo::mirFileLoaded(MachineFunction &MF) const {
-}
+void TargetSubtargetInfo::mirFileLoaded(MachineFunction &MF) const { }

lib/MC/MCAsmStreamer.cpp

public:
   bool hasRawTextSupport() const override { return true; }
 
   /// Add a comment that can be emitted to the generated .s file to make the
   /// output of the compiler more readable. This only affects the MCAsmStreamer
   /// and only when verbose assembly output is enabled.
   void AddComment(const Twine &T, bool EOL = true) override;
 
   /// Add a comment showing the encoding of an instruction.
-  /// If PrintSchedInfo is true, then the comment sched:[x:y] will be added to
-  /// the output if supported by the target.
-  void AddEncodingComment(const MCInst &Inst, const MCSubtargetInfo &,
-                          bool PrintSchedInfo);
+  void AddEncodingComment(const MCInst &Inst, const MCSubtargetInfo &);
 
   /// Return a raw_ostream that comments can be written to.
   /// Unlike AddComment, you are required to terminate comments with \n if you
   /// use this method.
   raw_ostream &GetCommentOS() override {
     if (!IsVerboseAsm)
       return nulls();  // Discard comments unless in verbose asm mode.
     return CommentStream;
public:
 
   void EmitWinEHHandler(const MCSymbol *Sym, bool Unwind, bool Except,
                         SMLoc Loc) override;
   void EmitWinEHHandlerData(SMLoc Loc) override;
 
   void emitCGProfileEntry(const MCSymbolRefExpr *From,
                           const MCSymbolRefExpr *To, uint64_t Count) override;
 
-  void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI,
-                       bool PrintSchedInfo) override;
+  void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI) override;
 
   void EmitBundleAlignMode(unsigned AlignPow2) override;
   void EmitBundleLock(bool AlignToEnd) override;
   void EmitBundleUnlock() override;
 
   bool EmitRelocDirective(const MCExpr &Offset, StringRef Name,
                           const MCExpr *Expr, SMLoc Loc,
                           const MCSubtargetInfo &STI) override;
void MCAsmStreamer::emitCGProfileEntry(const MCSymbolRefExpr *From,
   From->getSymbol().print(OS, MAI);
   OS << ", ";
   To->getSymbol().print(OS, MAI);
   OS << ", " << Count;
   EmitEOL();
 }
 
 void MCAsmStreamer::AddEncodingComment(const MCInst &Inst,
-                                       const MCSubtargetInfo &STI,
-                                       bool PrintSchedInfo) {
+                                       const MCSubtargetInfo &STI) {
   raw_ostream &OS = GetCommentOS();
   SmallString<256> Code;
   SmallVector<MCFixup, 4> Fixups;
   raw_svector_ostream VecOS(Code);
 
   // If we have no code emitter, don't emit code.
   if (!getAssembler().getEmitterPtr())
     return;
if (MapEntry != uint8_t(~0U)) {
         if (uint8_t MapEntry = FixupMap[FixupBit]) {
           assert(Bit == 0 && "Encoder wrote into fixed up bit!");
           OS << char('A' + MapEntry - 1);
         } else
           OS << Bit;
       }
     }
   }
-  OS << "]";
-  // If we are not going to add fixup or schedule comments after this point
-  // then we have to end the current comment line with "\n".
-  if (Fixups.size() || !PrintSchedInfo)
-    OS << "\n";
+  OS << "]\n";
 
   for (unsigned i = 0, e = Fixups.size(); i != e; ++i) {
     MCFixup &F = Fixups[i];
     const MCFixupKindInfo &Info =
         getAssembler().getBackend().getFixupKindInfo(F.getKind());
     OS << "  fixup " << char('A' + i) << " - " << "offset: " << F.getOffset()
        << ", value: " << *F.getValue() << ", kind: " << Info.Name << "\n";
   }
 }
 
 void MCAsmStreamer::EmitInstruction(const MCInst &Inst,
-                                    const MCSubtargetInfo &STI,
-                                    bool PrintSchedInfo) {
+                                    const MCSubtargetInfo &STI) {
   assert(getCurrentSectionOnly() &&
          "Cannot emit contents before setting section!");
 
   // Show the encoding in a comment if we have a code emitter.
-  AddEncodingComment(Inst, STI, PrintSchedInfo);
+  AddEncodingComment(Inst, STI);
 
   // Show the MCInst if enabled.
   if (ShowInst) {
-    if (PrintSchedInfo)
-      GetCommentOS() << "\n";
     Inst.dump_pretty(GetCommentOS(), InstPrinter.get(), "\n ");
     GetCommentOS() << "\n";
   }
 
   if(getTargetStreamer())
     getTargetStreamer()->prettyPrintAsm(*InstPrinter, OS, Inst, STI);
   else
     InstPrinter->printInst(&Inst, OS, "", STI);
 
-  if (PrintSchedInfo) {
-    std::string SI = STI.getSchedInfoStr(Inst);
-    if (!SI.empty())
-      GetCommentOS() << SI;
-  }
-
   StringRef Comments = CommentToEmit;
   if (Comments.size() && Comments.back() != '\n')
     GetCommentOS() << "\n";
 
   EmitEOL();
 }
 
 void MCAsmStreamer::EmitBundleAlignMode(unsigned AlignPow2) {

lib/MC/MCObjectStreamer.cpp

void MCObjectStreamer::EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) {
   MCStreamer::EmitAssignment(Symbol, Value);
 }
 
 bool MCObjectStreamer::mayHaveInstructions(MCSection &Sec) const {
   return Sec.hasInstructions();
 }
 
 void MCObjectStreamer::EmitInstruction(const MCInst &Inst,
-                                       const MCSubtargetInfo &STI, bool) {
+                                       const MCSubtargetInfo &STI) {
   getAssembler().getBackend().handleCodePaddingInstructionBegin(Inst);
   EmitInstructionImpl(Inst, STI);
   getAssembler().getBackend().handleCodePaddingInstructionEnd(Inst);
 }
 
 void MCObjectStreamer::EmitInstructionImpl(const MCInst &Inst,
                                            const MCSubtargetInfo &STI) {
   MCStreamer::EmitInstruction(Inst, STI);

lib/MC/MCStreamer.cpp

case MCExpr::SymbolRef:
     break;
 
   case MCExpr::Unary:
     visitUsedExpr(*cast<MCUnaryExpr>(Expr).getSubExpr());
     break;
   }
 }
 
-void MCStreamer::EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI,
-                                 bool) {
+void MCStreamer::EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &) {
   // Scan for values.
   for (unsigned i = Inst.getNumOperands(); i--;)
     if (Inst.getOperand(i).isExpr())
       visitUsedExpr(*Inst.getOperand(i).getExpr());
 }
 
 void MCStreamer::emitAbsoluteSymbolDiff(const MCSymbol *Hi, const MCSymbol *Lo,
                                         unsigned Size) {

lib/Object/RecordStreamer.h

private:
   void markDefined(const MCSymbol &Symbol);
   void markGlobal(const MCSymbol &Symbol, MCSymbolAttr Attribute);
   void markUsed(const MCSymbol &Symbol);
   void visitUsedSymbol(const MCSymbol &Sym) override;
 
 public:
   RecordStreamer(MCContext &Context, const Module &M);
 
-  void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI,
-                       bool) override;
+  void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI) override;
   void EmitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
   void EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) override;
   bool EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
   void EmitZerofill(MCSection *Section, MCSymbol *Symbol, uint64_t Size,
                     unsigned ByteAlignment, SMLoc Loc = SMLoc()) override;
   void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                         unsigned ByteAlignment) override;
 

lib/Object/RecordStreamer.cpp

 
 RecordStreamer::const_iterator RecordStreamer::begin() {
   return Symbols.begin();
 }
 
 RecordStreamer::const_iterator RecordStreamer::end() { return Symbols.end(); }
 
 void RecordStreamer::EmitInstruction(const MCInst &Inst,
-                                     const MCSubtargetInfo &STI, bool) {
+                                     const MCSubtargetInfo &STI) {
   MCStreamer::EmitInstruction(Inst, STI);
 }
 
 void RecordStreamer::EmitLabel(MCSymbol *Symbol, SMLoc Loc) {
   MCStreamer::EmitLabel(Symbol);
   markDefined(*Symbol);
 }
 

lib/Target/AArch64/MCTargetDesc/AArch64ELFStreamer.cpp

void reset() override {
     MCELFStreamer::reset();
     LastMappingSymbols.clear();
     LastEMS = EMS_None;
   }
 
   /// This function is the one used to emit instruction data into the ELF
   /// streamer. We override it to add the appropriate mapping symbol if
   /// necessary.
-  void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI,
-                       bool) override {
+  void EmitInstruction(const MCInst &Inst,
+                       const MCSubtargetInfo &STI) override {
     EmitA64MappingSymbol();
     MCELFStreamer::EmitInstruction(Inst, STI);
   }
 
   /// Emit a 32-bit value as an instruction. This is only used for the .inst
   /// directive, EmitInstruction should be used in other cases.
   void emitInst(uint32_t Inst) {
     char Buffer[4];

lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp

if (LastMappingSymbol != LastMappingSymbols.end()) {
       return;
     }
     LastEMSInfo.reset(new ElfMappingSymbolInfo(SMLoc(), nullptr, 0));
   }
 
   /// This function is the one used to emit instruction data into the ELF
   /// streamer. We override it to add the appropriate mapping symbol if
   /// necessary.
-  void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI,
-                       bool) override {
+  void EmitInstruction(const MCInst &Inst,
+                       const MCSubtargetInfo &STI) override {
     if (IsThumb)
       EmitThumbMappingSymbol();
     else
       EmitARMMappingSymbol();
 
     MCELFStreamer::EmitInstruction(Inst, STI);
   }
 

lib/Target/Hexagon/MCTargetDesc/HexagonMCELFStreamer.h

HexagonMCELFStreamer(MCContext &Context, std::unique_ptr<MCAsmBackend> TAB,
                        std::unique_ptr<MCObjectWriter> OW,
                        std::unique_ptr<MCCodeEmitter> Emitter);
 
   HexagonMCELFStreamer(MCContext &Context, std::unique_ptr<MCAsmBackend> TAB,
                        std::unique_ptr<MCObjectWriter> OW,
                        std::unique_ptr<MCCodeEmitter> Emitter,
                        MCAssembler *Assembler);
 
-  void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI,
-                       bool) override;
+  void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI) override;
   void EmitSymbol(const MCInst &Inst);
   void HexagonMCEmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                                       unsigned ByteAlignment,
                                       unsigned AccessSize);
   void HexagonMCEmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                                  unsigned ByteAlignment, unsigned AccessSize);
 };
 
 MCStreamer *createHexagonELFStreamer(Triple const &TT, MCContext &Context,
                                      std::unique_ptr<MCAsmBackend> MAB,
                                      std::unique_ptr<MCObjectWriter> OW,
                                      std::unique_ptr<MCCodeEmitter> CE);
 
 } // end namespace llvm
 
 #endif // LLVM_LIB_TARGET_HEXAGON_MCTARGETDESC_HEXAGONMCELFSTREAMER_H

lib/Target/Hexagon/MCTargetDesc/HexagonMCELFStreamer.cpp

 HexagonMCELFStreamer::HexagonMCELFStreamer(
     MCContext &Context, std::unique_ptr<MCAsmBackend> TAB,
     std::unique_ptr<MCObjectWriter> OW, std::unique_ptr<MCCodeEmitter> Emitter,
     MCAssembler *Assembler)
     : MCELFStreamer(Context, std::move(TAB), std::move(OW), std::move(Emitter)),
       MCII(createHexagonMCInstrInfo()) {}
 
 void HexagonMCELFStreamer::EmitInstruction(const MCInst &MCB,
-                                           const MCSubtargetInfo &STI, bool) {
+                                           const MCSubtargetInfo &STI) {
   assert(MCB.getOpcode() == Hexagon::BUNDLE);
   assert(HexagonMCInstrInfo::bundleSize(MCB) <= HEXAGON_PACKET_SIZE);
   assert(HexagonMCInstrInfo::bundleSize(MCB) > 0);
 
   // At this point, MCB is a bundle
   // Iterate through the bundle and assign addends for the instructions
   for (auto const &I : HexagonMCInstrInfo::bundleInstructions(MCB)) {
     MCInst *MCI = const_cast<MCInst *>(I.getInst());

lib/Target/Mips/MCTargetDesc/MipsELFStreamer.h

public:
   MipsELFStreamer(MCContext &Context, std::unique_ptr<MCAsmBackend> MAB,
                   std::unique_ptr<MCObjectWriter> OW,
                   std::unique_ptr<MCCodeEmitter> Emitter);
 
   /// Overriding this function allows us to add arbitrary behaviour before the
   /// \p Inst is actually emitted. For example, we can inspect the operands and
   /// gather sufficient information that allows us to reason about the register
   /// usage for the translation unit.
-  void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI,
-                       bool = false) override;
+  void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI) override;
 
   /// Overriding this function allows us to record all labels that should be
   /// marked as microMIPS. Based on this data marking is done in
   /// EmitInstruction.
   void EmitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
 
   /// Overriding this function allows us to dismiss all labels that are
   /// candidates for marking as microMIPS when .section directive is processed.

lib/Target/Mips/MCTargetDesc/MipsELFStreamer.cpp

MipsELFStreamer::MipsELFStreamer(MCContext &Context,
     : MCELFStreamer(Context, std::move(MAB), std::move(OW),
                     std::move(Emitter)) {
   RegInfoRecord = new MipsRegInfoRecord(this, Context);
   MipsOptionRecords.push_back(
       std::unique_ptr<MipsRegInfoRecord>(RegInfoRecord));
 }
 
 void MipsELFStreamer::EmitInstruction(const MCInst &Inst,
-                                      const MCSubtargetInfo &STI, bool) {
+                                      const MCSubtargetInfo &STI) {
   MCELFStreamer::EmitInstruction(Inst, STI);
 
   MCContext &Context = getContext();
   const MCRegisterInfo *MCRegInfo = Context.getRegisterInfo();
 
   for (unsigned OpIndex = 0; OpIndex < Inst.getNumOperands(); ++OpIndex) {
     const MCOperand &Op = Inst.getOperand(OpIndex);
 

lib/Target/Mips/MCTargetDesc/MipsNaClELFStreamer.cpp

if (MaskAfter) {
       emitMask(SPReg, LoadStoreStackMaskReg, STI);
     }
     EmitBundleUnlock();
   }
 
 public:
   /// This function is the one used to emit instruction data into the ELF
   /// streamer.  We override it to mask dangerous instructions.
-  void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI,
-                       bool) override {
+  void EmitInstruction(const MCInst &Inst,
+                       const MCSubtargetInfo &STI) override {
     // Sandbox indirect jumps.
     if (isIndirectJump(Inst)) {
       if (PendingCall)
         report_fatal_error("Dangerous instruction in branch delay slot!");
       sandboxIndirectJump(Inst, STI);
       return;
     }
 

lib/Target/X86/AsmParser/X86AsmInstrumentation.h

public:
   void SetInitialFrameRegister(unsigned RegNo) {
     InitialFrameReg = RegNo;
   }
 
   // Tries to instrument and emit instruction.
   virtual void InstrumentAndEmitInstruction(
       const MCInst &Inst,
       SmallVectorImpl<std::unique_ptr<MCParsedAsmOperand>> &Operands,
-      MCContext &Ctx, const MCInstrInfo &MII, MCStreamer &Out,
-      bool PrintSchedInfoEnabled);
+      MCContext &Ctx, const MCInstrInfo &MII, MCStreamer &Out);
 
 protected:
   friend X86AsmInstrumentation *
   CreateX86AsmInstrumentation(const MCTargetOptions &MCOptions,
                               const MCContext &Ctx,
                               const MCSubtargetInfo *&STI);
 
   X86AsmInstrumentation(const MCSubtargetInfo *&STI);
 
   unsigned GetFrameRegGeneric(const MCContext &Ctx, MCStreamer &Out);
 
-  void EmitInstruction(MCStreamer &Out, const MCInst &Inst,
-                       bool PrintSchedInfoEnabled = false);
+  void EmitInstruction(MCStreamer &Out, const MCInst &Inst);
 
   const MCSubtargetInfo *&STI;
 
   unsigned InitialFrameReg = 0;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_LIB_TARGET_X86_ASMPARSER_X86ASMINSTRUMENTATION_H

lib/Target/X86/AsmParser/X86AsmInstrumentation.cpp

public:
   X86AddressSanitizer(const MCSubtargetInfo *&STI)
       : X86AsmInstrumentation(STI), RepPrefix(false), OrigSPOffset(0) {}
 
   ~X86AddressSanitizer() override = default;
 
   // X86AsmInstrumentation implementation:
   void InstrumentAndEmitInstruction(const MCInst &Inst, OperandVector &Operands,
                                     MCContext &Ctx, const MCInstrInfo &MII,
-                                    MCStreamer &Out,
-                                    /* unused */ bool) override {
+                                    MCStreamer &Out) override {
     InstrumentMOVS(Inst, Operands, Ctx, MII, Out);
     if (RepPrefix)
       EmitInstruction(Out, MCInstBuilder(X86::REP_PREFIX));
 
     InstrumentMOV(Inst, Operands, Ctx, MII, Out);
 
     RepPrefix = (Inst.getOpcode() == X86::REP_PREFIX);
     if (!RepPrefix)

 
 X86AsmInstrumentation::X86AsmInstrumentation(const MCSubtargetInfo *&STI)
     : STI(STI) {}
 
 X86AsmInstrumentation::~X86AsmInstrumentation() = default;
 
 void X86AsmInstrumentation::InstrumentAndEmitInstruction(
     const MCInst &Inst, OperandVector &Operands, MCContext &Ctx,
-    const MCInstrInfo &MII, MCStreamer &Out, bool PrintSchedInfoEnabled) {
-  EmitInstruction(Out, Inst, PrintSchedInfoEnabled);
+    const MCInstrInfo &MII, MCStreamer &Out) {
+  EmitInstruction(Out, Inst);
 }
 
-void X86AsmInstrumentation::EmitInstruction(MCStreamer &Out, const MCInst &Inst,
-                                            bool PrintSchedInfoEnabled) {
-  Out.EmitInstruction(Inst, *STI, PrintSchedInfoEnabled);
+void X86AsmInstrumentation::EmitInstruction(MCStreamer &Out, const MCInst &Inst) {
+  Out.EmitInstruction(Inst, *STI);
 }
 
 unsigned X86AsmInstrumentation::GetFrameRegGeneric(const MCContext &Ctx,
                                                    MCStreamer &Out) {
   if (!Out.getNumFrameInfos()) // No active dwarf frame
     return X86::NoRegister;
   const MCDwarfFrameInfo &Frame = Out.getDwarfFrameInfos().back();
   if (Frame.End) // Active dwarf frame is closed

lib/Target/X86/AsmParser/X86AsmParser.cpp

bool X86AsmParser::validateInstruction(MCInst &Inst, const OperandVector &Ops) {
   return false;
 }
 
 static const char *getSubtargetFeatureName(uint64_t Val);
 
 void X86AsmParser::EmitInstruction(MCInst &Inst, OperandVector &Operands,
                                    MCStreamer &Out) {
   Instrumentation->InstrumentAndEmitInstruction(
-      Inst, Operands, getContext(), MII, Out,
-      getParser().shouldPrintSchedInfo());
+      Inst, Operands, getContext(), MII, Out);
 }
 
 bool X86AsmParser::MatchAndEmitInstruction(SMLoc IDLoc, unsigned &Opcode,
                                            OperandVector &Operands,
                                            MCStreamer &Out, uint64_t &ErrorInfo,
                                            bool MatchingInlineAsm) {
   if (isParsingIntelSyntax())
     return MatchAndEmitIntelInstruction(IDLoc, Opcode, Operands, Out, ErrorInfo,

lib/Target/X86/InstPrinter/X86InstComments.cpp

while (i != e && (int)ShuffleMask[i] != SM_SentinelZero &&
         OS << "u";
       else
         OS << ShuffleMask[i] % ShuffleMask.size();
       ++i;
     }
     OS << ']';
     --i; // For loop increments element #.
   }
+  OS << '\n';
 
   // We successfully added a comment to this instruction.
   return true;
 }

lib/Target/X86/MCTargetDesc/X86BaseInfo.h

namespace X86 {
   /// The constants to describe instr prefixes if there are
   enum IPREFIXES {
     IP_NO_PREFIX = 0,
     IP_HAS_OP_SIZE = 1,
     IP_HAS_AD_SIZE = 2,
     IP_HAS_REPEAT_NE = 4,
     IP_HAS_REPEAT = 8,
     IP_HAS_LOCK = 16,
-    NO_SCHED_INFO = 32, // Don't add sched comment to the current instr because
-                        // it was already added
-    IP_HAS_NOTRACK = 64
+    IP_HAS_NOTRACK = 32
   };
 } // end namespace X86;
 
 /// X86II - This namespace holds all of the target specific flags that
 /// instruction info tracks.
 ///
 namespace X86II {
   /// Target Operand Flag enum.

lib/Target/X86/X86MCInstLower.cpp

void X86AsmPrinter::StackMapShadowTracker::emitShadowPadding(
   if (InShadow && CurrentShadowSize < RequiredShadowSize) {
     InShadow = false;
     EmitNops(OutStreamer, RequiredShadowSize - CurrentShadowSize,
              MF->getSubtarget<X86Subtarget>().is64Bit(), STI);
   }
 }
 
 void X86AsmPrinter::EmitAndCountInstruction(MCInst &Inst) {
-  OutStreamer->EmitInstruction(Inst, getSubtargetInfo(),
-                               EnablePrintSchedInfo &&
-                                   !(Inst.getFlags() & X86::NO_SCHED_INFO));
+  OutStreamer->EmitInstruction(Inst, getSubtargetInfo());
   SMShadowTracker.count(Inst, getSubtargetInfo(), CodeEmitter.get());
 }
 
 X86MCInstLower::X86MCInstLower(const MachineFunction &mf,
                                X86AsmPrinter &asmprinter)
     : Ctx(mf.getContext()), MF(mf), TM(mf.getTarget()), MAI(*TM.getMCAsmInfo()),
       AsmPrinter(asmprinter) {}
 
assert(MI->getNumOperands() >= 6 &&
            "We should always have at least 6 operands!");
 
     const MachineOperand &MaskOp = MI->getOperand(MaskIdx);
     if (auto *C = getConstantFromPool(*MI, MaskOp)) {
       unsigned Width = getRegisterWidth(MI->getDesc().OpInfo[0]);
       SmallVector<int, 64> Mask;
       DecodePSHUFBMask(C, Width, Mask);
       if (!Mask.empty())
-        OutStreamer->AddComment(getShuffleComment(MI, SrcIdx, SrcIdx, Mask),
-                                !EnablePrintSchedInfo);
+        OutStreamer->AddComment(getShuffleComment(MI, SrcIdx, SrcIdx, Mask));
     }
     break;
   }
 
   case X86::VPERMILPSrm:
   case X86::VPERMILPSYrm:
   case X86::VPERMILPSZ128rm:
   case X86::VPERMILPSZ128rmk:
assert(MI->getNumOperands() >= 6 &&
            "We should always have at least 6 operands!");
 
     const MachineOperand &MaskOp = MI->getOperand(MaskIdx);
     if (auto *C = getConstantFromPool(*MI, MaskOp)) {
       unsigned Width = getRegisterWidth(MI->getDesc().OpInfo[0]);
       SmallVector<int, 16> Mask;
       DecodeVPERMILPMask(C, ElSize, Width, Mask);
       if (!Mask.empty())
-        OutStreamer->AddComment(getShuffleComment(MI, SrcIdx, SrcIdx, Mask),
-                                !EnablePrintSchedInfo);
+        OutStreamer->AddComment(getShuffleComment(MI, SrcIdx, SrcIdx, Mask));
     }
     break;
   }
 
   case X86::VPERMIL2PDrm:
   case X86::VPERMIL2PSrm:
   case X86::VPERMIL2PDYrm:
   case X86::VPERMIL2PSYrm: {
case X86::VPERMIL2PSYrm: {
     }
 
     const MachineOperand &MaskOp = MI->getOperand(6);
     if (auto *C = getConstantFromPool(*MI, MaskOp)) {
       unsigned Width = getRegisterWidth(MI->getDesc().OpInfo[0]);
       SmallVector<int, 16> Mask;
       DecodeVPERMIL2PMask(C, (unsigned)CtrlOp.getImm(), ElSize, Width, Mask);
       if (!Mask.empty())
-        OutStreamer->AddComment(getShuffleComment(MI, 1, 2, Mask),
-                                !EnablePrintSchedInfo);
+        OutStreamer->AddComment(getShuffleComment(MI, 1, 2, Mask));
     }
     break;
   }
 
   case X86::VPPERMrrm: {
     if (!OutStreamer->isVerboseAsm())
       break;
     assert(MI->getNumOperands() >= 7 &&
            "We should always have at least 7 operands!");
 
     const MachineOperand &MaskOp = MI->getOperand(6);
     if (auto *C = getConstantFromPool(*MI, MaskOp)) {
       unsigned Width = getRegisterWidth(MI->getDesc().OpInfo[0]);
       SmallVector<int, 16> Mask;
       DecodeVPPERMMask(C, Width, Mask);
       if (!Mask.empty())
-        OutStreamer->AddComment(getShuffleComment(MI, 1, 2, Mask),
-                                !EnablePrintSchedInfo);
+        OutStreamer->AddComment(getShuffleComment(MI, 1, 2, Mask));
     }
     break;
   }
 
   case X86::MMX_MOVQ64rm: {
     if (!OutStreamer->isVerboseAsm())
       break;
     if (MI->getNumOperands() <= 4)
       break;
     if (auto *C = getConstantFromPool(*MI, MI->getOperand(4))) {
       std::string Comment;
       raw_string_ostream CS(Comment);
       const MachineOperand &DstOp = MI->getOperand(0);
       CS << X86ATTInstPrinter::getRegisterName(DstOp.getReg()) << " = ";
       if (auto *CF = dyn_cast<ConstantFP>(C)) {
         CS << "0x" << CF->getValueAPF().bitcastToAPInt().toString(16, false);
-        OutStreamer->AddComment(CS.str(), !EnablePrintSchedInfo);
+        OutStreamer->AddComment(CS.str());
       }
     }
     break;
   }
 
 #define MOV_CASE(Prefix, Suffix)                                               \
   case X86::Prefix##MOVAPD##Suffix##rm:                                        \
   case X86::Prefix##MOVAPS##Suffix##rm:                                        \
if (auto *C = getConstantFromPool(*MI, MI->getOperand(4))) {
                      CDS->getElementType()->isFloatTy() ||
                      CDS->getElementType()->isDoubleTy())
               printConstant(CDS->getElementAsAPFloat(i), CS);
             else
               CS << "?";
           }
         }
         CS << "]";
-        OutStreamer->AddComment(CS.str(), !EnablePrintSchedInfo);
+        OutStreamer->AddComment(CS.str());
       } else if (auto *CV = dyn_cast<ConstantVector>(C)) {
         CS << "<";
         for (int l = 0; l != NumLanes; ++l) {
           for (int i = 0, NumOperands = CV->getNumOperands(); i < NumOperands;
                ++i) {
             if (i != 0 || l != 0)
               CS << ",";
             printConstant(CV->getOperand(i), CS);
           }
         }
         CS << ">";
-        OutStreamer->AddComment(CS.str(), !EnablePrintSchedInfo);
+        OutStreamer->AddComment(CS.str());
       }
     }
     break;
   case X86::MOVDDUPrm:
   case X86::VMOVDDUPrm:
   case X86::VMOVDDUPZ128rm:
   case X86::VBROADCASTSSrm:
   case X86::VBROADCASTSSYrm:
if (auto *C = getConstantFromPool(*MI, MI->getOperand(4))) {
       CS << X86ATTInstPrinter::getRegisterName(DstOp.getReg()) << " = ";
       CS << "[";
       for (int i = 0; i != NumElts; ++i) {
         if (i != 0)
           CS << ",";
         printConstant(C, CS);
       }
       CS << "]";
-      OutStreamer->AddComment(CS.str(), !EnablePrintSchedInfo);
+      OutStreamer->AddComment(CS.str());
     }
   }
 
   MCInst TmpInst;
   MCInstLowering.Lower(MI, TmpInst);
-  if (MI->getAsmPrinterFlag(MachineInstr::NoSchedComment))
-    TmpInst.setFlags(TmpInst.getFlags() | X86::NO_SCHED_INFO);
 
   // Stackmap shadows cannot include branch targets, so we can count the bytes
   // in a call towards the shadow, but must ensure that the no thread returns
   // in to the stackmap shadow.  The only way to achieve this is if the call
   // is at the end of the shadow.
   if (MI->isCall()) {
     // Count then size of the call towards the shadow
     SMShadowTracker.count(TmpInst, getSubtargetInfo(), CodeEmitter.get());

lib/Target/X86/X86Subtarget.h

public:
   /// lowering to an actual indirect jump.
   bool enableIndirectBrExpand() const override {
     return useRetpolineIndirectBranches();
   }
 
   /// Enable the MachineScheduler pass for all X86 subtargets.
   bool enableMachineScheduler() const override { return true; }
 
-  // TODO: Update the regression tests and return true.
-  bool supportPrintSchedInfo() const override { return false; }
-
   bool enableEarlyIfConversion() const override;
 
   AntiDepBreakMode getAntiDepBreakMode() const override {
     return TargetSubtargetInfo::ANTIDEP_CRITICAL;
   }
 
   bool enableAdvancedRASplitCost() const override { return true; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_LIB_TARGET_X86_X86SUBTARGET_H

test/CodeGen/X86/avx512vpopcntdq-schedule.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
-; RUN: llc < %s -mtriple=x86_64-unknown-unknown -print-schedule -mcpu=x86-64 -mattr=+avx512vpopcntdq | FileCheck %s --check-prefix=GENERIC
-; RUN: llc < %s -mtriple=x86_64-unknown-unknown -print-schedule -mcpu=icelake-client | FileCheck %s --check-prefix=ICELAKE
-; RUN: llc < %s -mtriple=x86_64-unknown-unknown -print-schedule -mcpu=icelake-server | FileCheck %s --check-prefix=ICELAKE
+; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mattr=+avx512vpopcntdq | FileCheck %s --check-prefix=GENERIC
+; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=icelake-client | FileCheck %s --check-prefix=ICELAKE
+; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=icelake-server | FileCheck %s --check-prefix=ICELAKE
 
 define void @test_vpopcntd(<16 x i32> %a0, <16 x i32> %a1, <16 x i32> *%a2, i16 %a3) {
 ; GENERIC-LABEL: test_vpopcntd:
 ; GENERIC:       # %bb.0:
-; GENERIC-NEXT:    kmovw %esi, %k1 # sched: [1:0.33]
+; GENERIC-NEXT:    kmovw %esi, %k1
 ; GENERIC-NEXT:    #APP
-; GENERIC-NEXT:    vpopcntd %zmm1, %zmm0 # sched: [1:0.50]
-; GENERIC-NEXT:    vpopcntd %zmm1, %zmm0 {%k1} # sched: [1:0.50]
-; GENERIC-NEXT:    vpopcntd %zmm1, %zmm0 {%k1} {z} # sched: [1:0.50]
-; GENERIC-NEXT:    vpopcntd (%rdi), %zmm0 # sched: [8:0.50]
-; GENERIC-NEXT:    vpopcntd (%rdi), %zmm0 {%k1} # sched: [8:0.50]
-; GENERIC-NEXT:    vpopcntd (%rdi), %zmm0 {%k1} {z} # sched: [8:0.50]
-; GENERIC-NEXT:    vpopcntd (%rdi){1to16}, %zmm0 # sched: [8:0.50]
-; GENERIC-NEXT:    vpopcntd (%rdi){1to16}, %zmm0 {%k1} # sched: [8:0.50]
-; GENERIC-NEXT:    vpopcntd (%rdi){1to16}, %zmm0 {%k1} {z} # sched: [8:0.50]
+; GENERIC-NEXT:    vpopcntd %zmm1, %zmm0
+; GENERIC-NEXT:    vpopcntd %zmm1, %zmm0 {%k1}
+; GENERIC-NEXT:    vpopcntd %zmm1, %zmm0 {%k1} {z}
+; GENERIC-NEXT:    vpopcntd (%rdi), %zmm0
+; GENERIC-NEXT:    vpopcntd (%rdi), %zmm0 {%k1}
+; GENERIC-NEXT:    vpopcntd (%rdi), %zmm0 {%k1} {z}
+; GENERIC-NEXT:    vpopcntd (%rdi){1to16}, %zmm0
+; GENERIC-NEXT:    vpopcntd (%rdi){1to16}, %zmm0 {%k1}
+; GENERIC-NEXT:    vpopcntd (%rdi){1to16}, %zmm0 {%k1} {z}
 ; GENERIC-NEXT:    #NO_APP
-; GENERIC-NEXT:    vzeroupper # sched: [1:1.00]
-; GENERIC-NEXT:    retq # sched: [1:1.00]
+; GENERIC-NEXT:    vzeroupper
+; GENERIC-NEXT:    retq
 ;
 ; ICELAKE-LABEL: test_vpopcntd:
 ; ICELAKE:       # %bb.0:
-; ICELAKE-NEXT:    kmovd %esi, %k1 # sched: [1:1.00]
+; ICELAKE-NEXT:    kmovd %esi, %k1
 ; ICELAKE-NEXT:    #APP
-; ICELAKE-NEXT:    vpopcntd %zmm1, %zmm0 # sched: [1:1.00]
-; ICELAKE-NEXT:    vpopcntd %zmm1, %zmm0 {%k1} # sched: [1:1.00]
-; ICELAKE-NEXT:    vpopcntd %zmm1, %zmm0 {%k1} {z} # sched: [1:1.00]
-; ICELAKE-NEXT:    vpopcntd (%rdi), %zmm0 # sched: [8:1.00]
-; ICELAKE-NEXT:    vpopcntd (%rdi), %zmm0 {%k1} # sched: [8:1.00]
-; ICELAKE-NEXT:    vpopcntd (%rdi), %zmm0 {%k1} {z} # sched: [8:1.00]
-; ICELAKE-NEXT:    vpopcntd (%rdi){1to16}, %zmm0 # sched: [8:1.00]
-; ICELAKE-NEXT:    vpopcntd (%rdi){1to16}, %zmm0 {%k1} # sched: [8:1.00]
-; ICELAKE-NEXT:    vpopcntd (%rdi){1to16}, %zmm0 {%k1} {z} # sched: [8:1.00]
+; ICELAKE-NEXT:    vpopcntd %zmm1, %zmm0
+; ICELAKE-NEXT:    vpopcntd %zmm1, %zmm0 {%k1}
+; ICELAKE-NEXT:    vpopcntd %zmm1, %zmm0 {%k1} {z}
+; ICELAKE-NEXT:    vpopcntd (%rdi), %zmm0
+; ICELAKE-NEXT:    vpopcntd (%rdi), %zmm0 {%k1}
+; ICELAKE-NEXT:    vpopcntd (%rdi), %zmm0 {%k1} {z}
+; ICELAKE-NEXT:    vpopcntd (%rdi){1to16}, %zmm0
+; ICELAKE-NEXT:    vpopcntd (%rdi){1to16}, %zmm0 {%k1}
+; ICELAKE-NEXT:    vpopcntd (%rdi){1to16}, %zmm0 {%k1} {z}
 ; ICELAKE-NEXT:    #NO_APP
-; ICELAKE-NEXT:    vzeroupper # sched: [0:0.67]
-; ICELAKE-NEXT:    retq # sched: [7:1.00]
+; ICELAKE-NEXT:    vzeroupper
+; ICELAKE-NEXT:    retq
   tail call void asm "vpopcntd $1, $0 \0A\09 vpopcntd $1, $0 {$3} \0A\09 vpopcntd $1, $0 {$3} {z} \0A\09 vpopcntd $2, $0 \0A\09 vpopcntd $2, $0 {$3} \0A\09 vpopcntd $2, $0 {$3} {z} \0A\09 vpopcntd $2{1to16}, $0 \0A\09 vpopcntd $2{1to16}, $0 {$3} \0A\09 vpopcntd $2{1to16}, $0 {$3} {z}", "v,v,*m,^Yk"(<16 x i32> %a0, <16 x i32> %a1, <16 x i32> *%a2, i16 %a3) nounwind
   ret void
 }
 
 define void @test_vpopcntq(<8 x i64> %a0, <8 x i64> %a1, <8 x i64> *%a2, i8 %a3) {
 ; GENERIC-LABEL: test_vpopcntq:
 ; GENERIC:       # %bb.0:
-; GENERIC-NEXT:    kmovw %esi, %k1 # sched: [1:0.33]
+; GENERIC-NEXT:    kmovw %esi, %k1
 ; GENERIC-NEXT:    #APP
-; GENERIC-NEXT:    vpopcntq %zmm1, %zmm0 # sched: [1:0.50]
-; GENERIC-NEXT:    vpopcntq %zmm1, %zmm0 {%k1} # sched: [1:0.50]
-; GENERIC-NEXT:    vpopcntq %zmm1, %zmm0 {%k1} {z} # sched: [1:0.50]
-; GENERIC-NEXT:    vpopcntq (%rdi), %zmm0 # sched: [8:0.50]
-; GENERIC-NEXT:    vpopcntq (%rdi), %zmm0 {%k1} # sched: [8:0.50]
-; GENERIC-NEXT:    vpopcntq (%rdi), %zmm0 {%k1} {z} # sched: [8:0.50]
-; GENERIC-NEXT:    vpopcntq (%rdi){1to8}, %zmm0 # sched: [8:0.50]
-; GENERIC-NEXT:    vpopcntq (%rdi){1to8}, %zmm0 {%k1} # sched: [8:0.50]
-; GENERIC-NEXT:    vpopcntq (%rdi){1to8}, %zmm0 {%k1} {z} # sched: [8:0.50]
+; GENERIC-NEXT:    vpopcntq %zmm1, %zmm0
+; GENERIC-NEXT:    vpopcntq %zmm1, %zmm0 {%k1}
+; GENERIC-NEXT:    vpopcntq %zmm1, %zmm0 {%k1} {z}
+; GENERIC-NEXT:    vpopcntq (%rdi), %zmm0
+; GENERIC-NEXT:    vpopcntq (%rdi), %zmm0 {%k1}
+; GENERIC-NEXT:    vpopcntq (%rdi), %zmm0 {%k1} {z}
+; GENERIC-NEXT:    vpopcntq (%rdi){1to8}, %zmm0
+; GENERIC-NEXT:    vpopcntq (%rdi){1to8}, %zmm0 {%k1}
+; GENERIC-NEXT:    vpopcntq (%rdi){1to8}, %zmm0 {%k1} {z}
 ; GENERIC-NEXT:    #NO_APP
-; GENERIC-NEXT:    vzeroupper # sched: [1:1.00]
-; GENERIC-NEXT:    retq # sched: [1:1.00]
+; GENERIC-NEXT:    vzeroupper
+; GENERIC-NEXT:    retq
 ;
 ; ICELAKE-LABEL: test_vpopcntq:
 ; ICELAKE:       # %bb.0:
-; ICELAKE-NEXT:    kmovd %esi, %k1 # sched: [1:1.00]
+; ICELAKE-NEXT:    kmovd %esi, %k1
 ; ICELAKE-NEXT:    #APP
-; ICELAKE-NEXT:    vpopcntq %zmm1, %zmm0 # sched: [1:1.00]
-; ICELAKE-NEXT:    vpopcntq %zmm1, %zmm0 {%k1} # sched: [1:1.00]
-; ICELAKE-NEXT:    vpopcntq %zmm1, %zmm0 {%k1} {z} # sched: [1:1.00]
-; ICELAKE-NEXT:    vpopcntq (%rdi), %zmm0 # sched: [8:1.00]
-; ICELAKE-NEXT:    vpopcntq (%rdi), %zmm0 {%k1} # sched: [8:1.00]
-; ICELAKE-NEXT:    vpopcntq (%rdi), %zmm0 {%k1} {z} # sched: [8:1.00]
-; ICELAKE-NEXT:    vpopcntq (%rdi){1to8}, %zmm0 # sched: [8:1.00]
-; ICELAKE-NEXT:    vpopcntq (%rdi){1to8}, %zmm0 {%k1} # sched: [8:1.00]
-; ICELAKE-NEXT:    vpopcntq (%rdi){1to8}, %zmm0 {%k1} {z} # sched: [8:1.00]
+; ICELAKE-NEXT:    vpopcntq %zmm1, %zmm0
+; ICELAKE-NEXT:    vpopcntq %zmm1, %zmm0 {%k1}
+; ICELAKE-NEXT:    vpopcntq %zmm1, %zmm0 {%k1} {z}
+; ICELAKE-NEXT:    vpopcntq (%rdi), %zmm0
+; ICELAKE-NEXT:    vpopcntq (%rdi), %zmm0 {%k1}
+; ICELAKE-NEXT:    vpopcntq (%rdi), %zmm0 {%k1} {z}
+; ICELAKE-NEXT:    vpopcntq (%rdi){1to8}, %zmm0
+; ICELAKE-NEXT:    vpopcntq (%rdi){1to8}, %zmm0 {%k1}
+; ICELAKE-NEXT:    vpopcntq (%rdi){1to8}, %zmm0 {%k1} {z}
 ; ICELAKE-NEXT:    #NO_APP
-; ICELAKE-NEXT:    vzeroupper # sched: [0:0.67]
-; ICELAKE-NEXT:    retq # sched: [7:1.00]
+; ICELAKE-NEXT:    vzeroupper
+; ICELAKE-NEXT:    retq
   tail call void asm "vpopcntq $1, $0 \0A\09 vpopcntq $1, $0 {$3} \0A\09 vpopcntq $1, $0 {$3} {z} \0A\09 vpopcntq $2, $0 \0A\09 vpopcntq $2, $0 {$3} \0A\09 vpopcntq $2, $0 {$3} {z} \0A\09 vpopcntq $2{1to8}, $0 \0A\09 vpopcntq $2{1to8}, $0 {$3} \0A\09 vpopcntq $2{1to8}, $0 {$3} {z}", "v,v,*m,^Yk"(<8 x i64> %a0, <8 x i64> %a1, <8 x i64> *%a2, i8 %a3) nounwind
   ret void
 }

test/CodeGen/X86/mul-constant-i32.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc < %s -mtriple=i686-unknown | FileCheck %s --check-prefix=X86
-; RUN: llc < %s -mtriple=x86_64-unknown -print-schedule=true -mcpu=haswell| FileCheck %s --check-prefix=X64-HSW
-; RUN: llc < %s -mtriple=x86_64-unknown -print-schedule=true -mcpu=btver2| FileCheck %s --check-prefix=X64-JAG
+; RUN: llc < %s -mtriple=x86_64-unknown -mcpu=haswell | FileCheck %s --check-prefix=X64-HSW
+; RUN: llc < %s -mtriple=x86_64-unknown -mcpu=btver2 | FileCheck %s --check-prefix=X64-JAG
 ; RUN: llc < %s -mtriple=i686-unknown -mul-constant-optimization=false | FileCheck %s --check-prefix=X86-NOOPT
-; RUN: llc < %s -mtriple=x86_64-unknown -mul-constant-optimization=false -print-schedule=true -mcpu=haswell| FileCheck %s --check-prefix=HSW-NOOPT
-; RUN: llc < %s -mtriple=x86_64-unknown -mul-constant-optimization=false -print-schedule=true -mcpu=btver2| FileCheck %s --check-prefix=JAG-NOOPT
-; RUN: llc < %s -mtriple=x86_64-unknown -print-schedule=true -mcpu=slm| FileCheck %s --check-prefix=X64-SLM
-; RUN: llc < %s -mtriple=x86_64-unknown -mul-constant-optimization=false -print-schedule=true -mcpu=slm| FileCheck %s --check-prefix=SLM-NOOPT
+; RUN: llc < %s -mtriple=x86_64-unknown -mul-constant-optimization=false -mcpu=haswell | FileCheck %s --check-prefix=HSW-NOOPT
+; RUN: llc < %s -mtriple=x86_64-unknown -mul-constant-optimization=false -mcpu=btver2 | FileCheck %s --check-prefix=JAG-NOOPT
+; RUN: llc < %s -mtriple=x86_64-unknown -mcpu=slm | FileCheck %s --check-prefix=X64-SLM
+; RUN: llc < %s -mtriple=x86_64-unknown -mul-constant-optimization=false -mcpu=slm | FileCheck %s --check-prefix=SLM-NOOPT
 
 define i32 @test_mul_by_1(i32 %x) {
 ; X86-LABEL: test_mul_by_1:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_1:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    movl %edi, %eax # sched: [1:0.25]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    movl %edi, %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_1:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    movl %edi, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    movl %edi, %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_1:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_1:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    movl %edi, %eax # sched: [1:0.25]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    movl %edi, %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_1:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    movl %edi, %eax # sched: [1:0.50]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    movl %edi, %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_1:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    movl %edi, %eax # sched: [1:0.50]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    movl %edi, %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_1:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    movl %edi, %eax # sched: [1:0.50]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    movl %edi, %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 1
   ret i32 %mul
 }
 
 define i32 @test_mul_by_2(i32 %x) {
 ; X86-LABEL: test_mul_by_2:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    addl %eax, %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_2:
 ; X64-HSW:       # %bb.0:
 ; X64-HSW-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-HSW-NEXT:    leal (%rdi,%rdi), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leal (%rdi,%rdi), %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_2:
 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-JAG-NEXT:    leal (%rdi,%rdi), %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leal (%rdi,%rdi), %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_2:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    addl %eax, %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_2:
 ; HSW-NOOPT:       # %bb.0:
 ; HSW-NOOPT-NEXT:    # kill: def $edi killed $edi def $rdi
-; HSW-NOOPT-NEXT:    leal (%rdi,%rdi), %eax # sched: [1:0.50]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    leal (%rdi,%rdi), %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_2:
 ; JAG-NOOPT:       # %bb.0:
 ; JAG-NOOPT-NEXT:    # kill: def $edi killed $edi def $rdi
-; JAG-NOOPT-NEXT:    leal (%rdi,%rdi), %eax # sched: [1:0.50]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    leal (%rdi,%rdi), %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_2:
 ; X64-SLM:       # %bb.0:
 ; X64-SLM-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-SLM-NEXT:    leal (%rdi,%rdi), %eax # sched: [1:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    leal (%rdi,%rdi), %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_2:
 ; SLM-NOOPT:       # %bb.0:
 ; SLM-NOOPT-NEXT:    # kill: def $edi killed $edi def $rdi
-; SLM-NOOPT-NEXT:    leal (%rdi,%rdi), %eax # sched: [1:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    leal (%rdi,%rdi), %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 2
   ret i32 %mul
 }
 
 define i32 @test_mul_by_3(i32 %x) {
 ; X86-LABEL: test_mul_by_3:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal (%eax,%eax,2), %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_3:
 ; X64-HSW:       # %bb.0:
 ; X64-HSW-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-HSW-NEXT:    leal (%rdi,%rdi,2), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leal (%rdi,%rdi,2), %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_3:
 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-JAG-NEXT:    leal (%rdi,%rdi,2), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leal (%rdi,%rdi,2), %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_3:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $3, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_3:
 ; HSW-NOOPT:       # %bb.0:
 ; HSW-NOOPT-NEXT:    # kill: def $edi killed $edi def $rdi
-; HSW-NOOPT-NEXT:    leal (%rdi,%rdi,2), %eax # sched: [1:0.50]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    leal (%rdi,%rdi,2), %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_3:
 ; JAG-NOOPT:       # %bb.0:
 ; JAG-NOOPT-NEXT:    # kill: def $edi killed $edi def $rdi
-; JAG-NOOPT-NEXT:    leal (%rdi,%rdi,2), %eax # sched: [2:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    leal (%rdi,%rdi,2), %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_3:
 ; X64-SLM:       # %bb.0:
 ; X64-SLM-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-SLM-NEXT:    leal (%rdi,%rdi,2), %eax # sched: [1:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    leal (%rdi,%rdi,2), %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_3:
 ; SLM-NOOPT:       # %bb.0:
 ; SLM-NOOPT-NEXT:    # kill: def $edi killed $edi def $rdi
-; SLM-NOOPT-NEXT:    leal (%rdi,%rdi,2), %eax # sched: [1:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    leal (%rdi,%rdi,2), %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 3
   ret i32 %mul
 }
 
 define i32 @test_mul_by_4(i32 %x) {
 ; X86-LABEL: test_mul_by_4:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    shll $2, %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_4:
 ; X64-HSW:       # %bb.0:
 ; X64-HSW-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-HSW-NEXT:    leal (,%rdi,4), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leal (,%rdi,4), %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_4:
 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-JAG-NEXT:    leal (,%rdi,4), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leal (,%rdi,4), %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_4:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    shll $2, %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_4:
 ; HSW-NOOPT:       # %bb.0:
 ; HSW-NOOPT-NEXT:    # kill: def $edi killed $edi def $rdi
-; HSW-NOOPT-NEXT:    leal (,%rdi,4), %eax # sched: [1:0.50]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    leal (,%rdi,4), %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_4:
 ; JAG-NOOPT:       # %bb.0:
 ; JAG-NOOPT-NEXT:    # kill: def $edi killed $edi def $rdi
-; JAG-NOOPT-NEXT:    leal (,%rdi,4), %eax # sched: [2:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    leal (,%rdi,4), %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_4:
 ; X64-SLM:       # %bb.0:
 ; X64-SLM-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-SLM-NEXT:    leal (,%rdi,4), %eax # sched: [1:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    leal (,%rdi,4), %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_4:
 ; SLM-NOOPT:       # %bb.0:
 ; SLM-NOOPT-NEXT:    # kill: def $edi killed $edi def $rdi
-; SLM-NOOPT-NEXT:    leal (,%rdi,4), %eax # sched: [1:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    leal (,%rdi,4), %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 4
   ret i32 %mul
 }
 
 define i32 @test_mul_by_5(i32 %x) {
 ; X86-LABEL: test_mul_by_5:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal (%eax,%eax,4), %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_5:
 ; X64-HSW:       # %bb.0:
 ; X64-HSW-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-HSW-NEXT:    leal (%rdi,%rdi,4), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leal (%rdi,%rdi,4), %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_5:
 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-JAG-NEXT:    leal (%rdi,%rdi,4), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leal (%rdi,%rdi,4), %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_5:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $5, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_5:
 ; HSW-NOOPT:       # %bb.0:
 ; HSW-NOOPT-NEXT:    # kill: def $edi killed $edi def $rdi
-; HSW-NOOPT-NEXT:    leal (%rdi,%rdi,4), %eax # sched: [1:0.50]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    leal (%rdi,%rdi,4), %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_5:
 ; JAG-NOOPT:       # %bb.0:
 ; JAG-NOOPT-NEXT:    # kill: def $edi killed $edi def $rdi
-; JAG-NOOPT-NEXT:    leal (%rdi,%rdi,4), %eax # sched: [2:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    leal (%rdi,%rdi,4), %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_5:
 ; X64-SLM:       # %bb.0:
 ; X64-SLM-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-SLM-NEXT:    leal (%rdi,%rdi,4), %eax # sched: [1:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    leal (%rdi,%rdi,4), %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_5:
 ; SLM-NOOPT:       # %bb.0:
 ; SLM-NOOPT-NEXT:    # kill: def $edi killed $edi def $rdi
-; SLM-NOOPT-NEXT:    leal (%rdi,%rdi,4), %eax # sched: [1:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    leal (%rdi,%rdi,4), %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 5
   ret i32 %mul
 }
 
 define i32 @test_mul_by_6(i32 %x) {
 ; X86-LABEL: test_mul_by_6:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    addl %eax, %eax
 ; X86-NEXT:    leal (%eax,%eax,2), %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_6:
 ; X64-HSW:       # %bb.0:
 ; X64-HSW-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-HSW-NEXT:    addl %edi, %edi # sched: [1:0.25]
-; X64-HSW-NEXT:    leal (%rdi,%rdi,2), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    addl %edi, %edi
+; X64-HSW-NEXT:    leal (%rdi,%rdi,2), %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_6:
 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-JAG-NEXT:    addl %edi, %edi # sched: [1:0.50]
-; X64-JAG-NEXT:    leal (%rdi,%rdi,2), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    addl %edi, %edi
+; X64-JAG-NEXT:    leal (%rdi,%rdi,2), %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_6:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $6, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_6:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imull $6, %edi, %eax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imull $6, %edi, %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_6:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imull $6, %edi, %eax # sched: [3:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imull $6, %edi, %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_6:
 ; X64-SLM:       # %bb.0:
 ; X64-SLM-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-SLM-NEXT:    addl %edi, %edi # sched: [1:0.50]
-; X64-SLM-NEXT:    leal (%rdi,%rdi,2), %eax # sched: [1:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    addl %edi, %edi
+; X64-SLM-NEXT:    leal (%rdi,%rdi,2), %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_6:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imull $6, %edi, %eax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imull $6, %edi, %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 6
   ret i32 %mul
 }
 
 define i32 @test_mul_by_7(i32 %x) {
 ; X86-LABEL: test_mul_by_7:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %ecx
 ; X86-NEXT:    leal (,%ecx,8), %eax
 ; X86-NEXT:    subl %ecx, %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_7:
 ; X64-HSW:       # %bb.0:
 ; X64-HSW-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-HSW-NEXT:    leal (,%rdi,8), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    subl %edi, %eax # sched: [1:0.25]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leal (,%rdi,8), %eax
+; X64-HSW-NEXT:    subl %edi, %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_7:
 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-JAG-NEXT:    leal (,%rdi,8), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    subl %edi, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leal (,%rdi,8), %eax
+; X64-JAG-NEXT:    subl %edi, %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_7:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $7, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_7:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imull $7, %edi, %eax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imull $7, %edi, %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_7:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imull $7, %edi, %eax # sched: [3:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imull $7, %edi, %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_7:
 ; X64-SLM:       # %bb.0:
 ; X64-SLM-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-SLM-NEXT:    leal (,%rdi,8), %eax # sched: [1:1.00]
-; X64-SLM-NEXT:    subl %edi, %eax # sched: [1:0.50]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    leal (,%rdi,8), %eax
+; X64-SLM-NEXT:    subl %edi, %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_7:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imull $7, %edi, %eax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imull $7, %edi, %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 7
   ret i32 %mul
 }
 
 define i32 @test_mul_by_8(i32 %x) {
 ; X86-LABEL: test_mul_by_8:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    shll $3, %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_8:
 ; X64-HSW:       # %bb.0:
 ; X64-HSW-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-HSW-NEXT:    leal (,%rdi,8), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leal (,%rdi,8), %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_8:
 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-JAG-NEXT:    leal (,%rdi,8), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leal (,%rdi,8), %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_8:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    shll $3, %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_8:
 ; HSW-NOOPT:       # %bb.0:
 ; HSW-NOOPT-NEXT:    # kill: def $edi killed $edi def $rdi
-; HSW-NOOPT-NEXT:    leal (,%rdi,8), %eax # sched: [1:0.50]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    leal (,%rdi,8), %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_8:
 ; JAG-NOOPT:       # %bb.0:
 ; JAG-NOOPT-NEXT:    # kill: def $edi killed $edi def $rdi
-; JAG-NOOPT-NEXT:    leal (,%rdi,8), %eax # sched: [2:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    leal (,%rdi,8), %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_8:
 ; X64-SLM:       # %bb.0:
 ; X64-SLM-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-SLM-NEXT:    leal (,%rdi,8), %eax # sched: [1:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    leal (,%rdi,8), %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_8:
 ; SLM-NOOPT:       # %bb.0:
 ; SLM-NOOPT-NEXT:    # kill: def $edi killed $edi def $rdi
-; SLM-NOOPT-NEXT:    leal (,%rdi,8), %eax # sched: [1:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    leal (,%rdi,8), %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 8
   ret i32 %mul
 }
 
 define i32 @test_mul_by_9(i32 %x) {
 ; X86-LABEL: test_mul_by_9:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal (%eax,%eax,8), %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_9:
 ; X64-HSW:       # %bb.0:
 ; X64-HSW-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-HSW-NEXT:    leal (%rdi,%rdi,8), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leal (%rdi,%rdi,8), %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_9:
 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-JAG-NEXT:    leal (%rdi,%rdi,8), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leal (%rdi,%rdi,8), %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_9:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $9, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_9:
 ; HSW-NOOPT:       # %bb.0:
 ; HSW-NOOPT-NEXT:    # kill: def $edi killed $edi def $rdi
-; HSW-NOOPT-NEXT:    leal (%rdi,%rdi,8), %eax # sched: [1:0.50]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    leal (%rdi,%rdi,8), %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_9:
 ; JAG-NOOPT:       # %bb.0:
 ; JAG-NOOPT-NEXT:    # kill: def $edi killed $edi def $rdi
-; JAG-NOOPT-NEXT:    leal (%rdi,%rdi,8), %eax # sched: [2:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    leal (%rdi,%rdi,8), %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_9:
 ; X64-SLM:       # %bb.0:
 ; X64-SLM-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-SLM-NEXT:    leal (%rdi,%rdi,8), %eax # sched: [1:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    leal (%rdi,%rdi,8), %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_9:
 ; SLM-NOOPT:       # %bb.0:
 ; SLM-NOOPT-NEXT:    # kill: def $edi killed $edi def $rdi
-; SLM-NOOPT-NEXT:    leal (%rdi,%rdi,8), %eax # sched: [1:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    leal (%rdi,%rdi,8), %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 9
   ret i32 %mul
 }
 
 define i32 @test_mul_by_10(i32 %x) {
 ; X86-LABEL: test_mul_by_10:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    addl %eax, %eax
 ; X86-NEXT:    leal (%eax,%eax,4), %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_10:
 ; X64-HSW:       # %bb.0:
 ; X64-HSW-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-HSW-NEXT:    addl %edi, %edi # sched: [1:0.25]
-; X64-HSW-NEXT:    leal (%rdi,%rdi,4), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    addl %edi, %edi
+; X64-HSW-NEXT:    leal (%rdi,%rdi,4), %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_10:
 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-JAG-NEXT:    addl %edi, %edi # sched: [1:0.50]
-; X64-JAG-NEXT:    leal (%rdi,%rdi,4), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    addl %edi, %edi
+; X64-JAG-NEXT:    leal (%rdi,%rdi,4), %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_10:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $10, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_10:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imull $10, %edi, %eax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imull $10, %edi, %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_10:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imull $10, %edi, %eax # sched: [3:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imull $10, %edi, %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_10:
 ; X64-SLM:       # %bb.0:
 ; X64-SLM-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-SLM-NEXT:    addl %edi, %edi # sched: [1:0.50]
-; X64-SLM-NEXT:    leal (%rdi,%rdi,4), %eax # sched: [1:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    addl %edi, %edi
+; X64-SLM-NEXT:    leal (%rdi,%rdi,4), %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_10:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imull $10, %edi, %eax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imull $10, %edi, %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 10
   ret i32 %mul
 }
 
 define i32 @test_mul_by_11(i32 %x) {
 ; X86-LABEL: test_mul_by_11:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal (%eax,%eax,4), %ecx
 ; X86-NEXT:    leal (%eax,%ecx,2), %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_11:
 ; X64-HSW:       # %bb.0:
 ; X64-HSW-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-HSW-NEXT:    leal (%rdi,%rdi,4), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    leal (%rdi,%rax,2), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leal (%rdi,%rdi,4), %eax
+; X64-HSW-NEXT:    leal (%rdi,%rax,2), %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_11:
 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-JAG-NEXT:    leal (%rdi,%rdi,4), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    leal (%rdi,%rax,2), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leal (%rdi,%rdi,4), %eax
+; X64-JAG-NEXT:    leal (%rdi,%rax,2), %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_11:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $11, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_11:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imull $11, %edi, %eax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imull $11, %edi, %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_11:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imull $11, %edi, %eax # sched: [3:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imull $11, %edi, %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_11:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    imull $11, %edi, %eax # sched: [3:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    imull $11, %edi, %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_11:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imull $11, %edi, %eax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imull $11, %edi, %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 11
   ret i32 %mul
 }
 
 define i32 @test_mul_by_12(i32 %x) {
 ; X86-LABEL: test_mul_by_12:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    shll $2, %eax
 ; X86-NEXT:    leal (%eax,%eax,2), %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_12:
 ; X64-HSW:       # %bb.0:
 ; X64-HSW-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-HSW-NEXT:    shll $2, %edi # sched: [1:0.50]
-; X64-HSW-NEXT:    leal (%rdi,%rdi,2), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    shll $2, %edi
+; X64-HSW-NEXT:    leal (%rdi,%rdi,2), %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_12:
 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-JAG-NEXT:    shll $2, %edi # sched: [1:0.50]
-; X64-JAG-NEXT:    leal (%rdi,%rdi,2), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    shll $2, %edi
+; X64-JAG-NEXT:    leal (%rdi,%rdi,2), %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_12:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $12, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_12:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imull $12, %edi, %eax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imull $12, %edi, %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_12:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imull $12, %edi, %eax # sched: [3:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imull $12, %edi, %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_12:
 ; X64-SLM:       # %bb.0:
 ; X64-SLM-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-SLM-NEXT:    shll $2, %edi # sched: [1:1.00]
-; X64-SLM-NEXT:    leal (%rdi,%rdi,2), %eax # sched: [1:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    shll $2, %edi
+; X64-SLM-NEXT:    leal (%rdi,%rdi,2), %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_12:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imull $12, %edi, %eax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imull $12, %edi, %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 12
   ret i32 %mul
 }
 
 define i32 @test_mul_by_13(i32 %x) {
 ; X86-LABEL: test_mul_by_13:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal (%eax,%eax,2), %ecx
 ; X86-NEXT:    leal (%eax,%ecx,4), %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_13:
 ; X64-HSW:       # %bb.0:
 ; X64-HSW-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-HSW-NEXT:    leal (%rdi,%rdi,2), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    leal (%rdi,%rax,4), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leal (%rdi,%rdi,2), %eax
+; X64-HSW-NEXT:    leal (%rdi,%rax,4), %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_13:
 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-JAG-NEXT:    leal (%rdi,%rdi,2), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    leal (%rdi,%rax,4), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leal (%rdi,%rdi,2), %eax
+; X64-JAG-NEXT:    leal (%rdi,%rax,4), %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_13:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $13, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_13:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imull $13, %edi, %eax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imull $13, %edi, %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_13:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imull $13, %edi, %eax # sched: [3:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imull $13, %edi, %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_13:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    imull $13, %edi, %eax # sched: [3:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    imull $13, %edi, %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_13:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imull $13, %edi, %eax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imull $13, %edi, %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 13
   ret i32 %mul
 }
 
 define i32 @test_mul_by_14(i32 %x) {
 ; X86-LABEL: test_mul_by_14:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %ecx
 ; X86-NEXT:    movl %ecx, %eax
 ; X86-NEXT:    shll $4, %eax
 ; X86-NEXT:    subl %ecx, %eax
 ; X86-NEXT:    subl %ecx, %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_14:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    movl %edi, %eax # sched: [1:0.25]
-; X64-HSW-NEXT:    shll $4, %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    subl %edi, %eax # sched: [1:0.25]
-; X64-HSW-NEXT:    subl %edi, %eax # sched: [1:0.25]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    movl %edi, %eax
+; X64-HSW-NEXT:    shll $4, %eax
+; X64-HSW-NEXT:    subl %edi, %eax
+; X64-HSW-NEXT:    subl %edi, %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_14:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    movl %edi, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    shll $4, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    subl %edi, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    subl %edi, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    movl %edi, %eax
+; X64-JAG-NEXT:    shll $4, %eax
+; X64-JAG-NEXT:    subl %edi, %eax
+; X64-JAG-NEXT:    subl %edi, %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_14:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $14, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_14:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imull $14, %edi, %eax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imull $14, %edi, %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_14:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imull $14, %edi, %eax # sched: [3:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imull $14, %edi, %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_14:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    movl %edi, %eax # sched: [1:0.50]
-; X64-SLM-NEXT:    shll $4, %eax # sched: [1:1.00]
-; X64-SLM-NEXT:    subl %edi, %eax # sched: [1:0.50]
-; X64-SLM-NEXT:    subl %edi, %eax # sched: [1:0.50]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    movl %edi, %eax
+; X64-SLM-NEXT:    shll $4, %eax
+; X64-SLM-NEXT:    subl %edi, %eax
+; X64-SLM-NEXT:    subl %edi, %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_14:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imull $14, %edi, %eax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imull $14, %edi, %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 14
   ret i32 %mul
 }
 
 define i32 @test_mul_by_15(i32 %x) {
 ; X86-LABEL: test_mul_by_15:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal (%eax,%eax,4), %eax
 ; X86-NEXT:    leal (%eax,%eax,2), %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_15:
 ; X64-HSW:       # %bb.0:
 ; X64-HSW-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-HSW-NEXT:    leal (%rdi,%rdi,4), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    leal (%rax,%rax,2), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leal (%rdi,%rdi,4), %eax
+; X64-HSW-NEXT:    leal (%rax,%rax,2), %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_15:
 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-JAG-NEXT:    leal (%rdi,%rdi,4), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    leal (%rax,%rax,2), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leal (%rdi,%rdi,4), %eax
+; X64-JAG-NEXT:    leal (%rax,%rax,2), %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_15:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $15, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_15:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imull $15, %edi, %eax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imull $15, %edi, %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_15:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imull $15, %edi, %eax # sched: [3:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imull $15, %edi, %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_15:
 ; X64-SLM:       # %bb.0:
 ; X64-SLM-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-SLM-NEXT:    leal (%rdi,%rdi,4), %eax # sched: [1:1.00]
-; X64-SLM-NEXT:    leal (%rax,%rax,2), %eax # sched: [1:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    leal (%rdi,%rdi,4), %eax
+; X64-SLM-NEXT:    leal (%rax,%rax,2), %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_15:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imull $15, %edi, %eax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imull $15, %edi, %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 15
   ret i32 %mul
 }
 
 define i32 @test_mul_by_16(i32 %x) {
 ; X86-LABEL: test_mul_by_16:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    shll $4, %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_16:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    movl %edi, %eax # sched: [1:0.25]
-; X64-HSW-NEXT:    shll $4, %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    movl %edi, %eax
+; X64-HSW-NEXT:    shll $4, %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_16:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    movl %edi, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    shll $4, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    movl %edi, %eax
+; X64-JAG-NEXT:    shll $4, %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_16:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    shll $4, %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_16:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    movl %edi, %eax # sched: [1:0.25]
-; HSW-NOOPT-NEXT:    shll $4, %eax # sched: [1:0.50]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    movl %edi, %eax
+; HSW-NOOPT-NEXT:    shll $4, %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_16:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    movl %edi, %eax # sched: [1:0.50]
-; JAG-NOOPT-NEXT:    shll $4, %eax # sched: [1:0.50]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    movl %edi, %eax
+; JAG-NOOPT-NEXT:    shll $4, %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_16:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    movl %edi, %eax # sched: [1:0.50]
-; X64-SLM-NEXT:    shll $4, %eax # sched: [1:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    movl %edi, %eax
+; X64-SLM-NEXT:    shll $4, %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_16:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    movl %edi, %eax # sched: [1:0.50]
-; SLM-NOOPT-NEXT:    shll $4, %eax # sched: [1:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    movl %edi, %eax
+; SLM-NOOPT-NEXT:    shll $4, %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 16
   ret i32 %mul
 }
 
 define i32 @test_mul_by_17(i32 %x) {
 ; X86-LABEL: test_mul_by_17:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %ecx
 ; X86-NEXT:    movl %ecx, %eax
 ; X86-NEXT:    shll $4, %eax
 ; X86-NEXT:    addl %ecx, %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_17:
 ; X64-HSW:       # %bb.0:
 ; X64-HSW-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-HSW-NEXT:    movl %edi, %eax # sched: [1:0.25]
-; X64-HSW-NEXT:    shll $4, %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    leal (%rax,%rdi), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    movl %edi, %eax
+; X64-HSW-NEXT:    shll $4, %eax
+; X64-HSW-NEXT:    leal (%rax,%rdi), %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_17:
 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-JAG-NEXT:    movl %edi, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    shll $4, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    leal (%rax,%rdi), %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    movl %edi, %eax
+; X64-JAG-NEXT:    shll $4, %eax
+; X64-JAG-NEXT:    leal (%rax,%rdi), %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_17:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $17, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_17:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imull $17, %edi, %eax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imull $17, %edi, %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_17:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imull $17, %edi, %eax # sched: [3:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imull $17, %edi, %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_17:
 ; X64-SLM:       # %bb.0:
 ; X64-SLM-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-SLM-NEXT:    movl %edi, %eax # sched: [1:0.50]
-; X64-SLM-NEXT:    shll $4, %eax # sched: [1:1.00]
-; X64-SLM-NEXT:    leal (%rax,%rdi), %eax # sched: [1:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    movl %edi, %eax
+; X64-SLM-NEXT:    shll $4, %eax
+; X64-SLM-NEXT:    leal (%rax,%rdi), %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_17:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imull $17, %edi, %eax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imull $17, %edi, %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 17
   ret i32 %mul
 }
 
 define i32 @test_mul_by_18(i32 %x) {
 ; X86-LABEL: test_mul_by_18:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    addl %eax, %eax
 ; X86-NEXT:    leal (%eax,%eax,8), %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_18:
 ; X64-HSW:       # %bb.0:
 ; X64-HSW-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-HSW-NEXT:    addl %edi, %edi # sched: [1:0.25]
-; X64-HSW-NEXT:    leal (%rdi,%rdi,8), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    addl %edi, %edi
+; X64-HSW-NEXT:    leal (%rdi,%rdi,8), %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_18:
 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-JAG-NEXT:    addl %edi, %edi # sched: [1:0.50]
-; X64-JAG-NEXT:    leal (%rdi,%rdi,8), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    addl %edi, %edi
+; X64-JAG-NEXT:    leal (%rdi,%rdi,8), %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_18:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $18, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_18:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imull $18, %edi, %eax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imull $18, %edi, %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_18:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imull $18, %edi, %eax # sched: [3:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imull $18, %edi, %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_18:
 ; X64-SLM:       # %bb.0:
 ; X64-SLM-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-SLM-NEXT:    addl %edi, %edi # sched: [1:0.50]
-; X64-SLM-NEXT:    leal (%rdi,%rdi,8), %eax # sched: [1:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    addl %edi, %edi
+; X64-SLM-NEXT:    leal (%rdi,%rdi,8), %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_18:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imull $18, %edi, %eax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imull $18, %edi, %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 18
   ret i32 %mul
 }
 
 define i32 @test_mul_by_19(i32 %x) {
 ; X86-LABEL: test_mul_by_19:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal (%eax,%eax,8), %ecx
 ; X86-NEXT:    leal (%eax,%ecx,2), %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_19:
 ; X64-HSW:       # %bb.0:
 ; X64-HSW-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-HSW-NEXT:    leal (%rdi,%rdi,8), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    leal (%rdi,%rax,2), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leal (%rdi,%rdi,8), %eax
+; X64-HSW-NEXT:    leal (%rdi,%rax,2), %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_19:
 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-JAG-NEXT:    leal (%rdi,%rdi,8), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    leal (%rdi,%rax,2), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leal (%rdi,%rdi,8), %eax
+; X64-JAG-NEXT:    leal (%rdi,%rax,2), %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_19:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $19, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_19:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imull $19, %edi, %eax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imull $19, %edi, %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_19:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imull $19, %edi, %eax # sched: [3:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imull $19, %edi, %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_19:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    imull $19, %edi, %eax # sched: [3:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    imull $19, %edi, %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_19:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imull $19, %edi, %eax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imull $19, %edi, %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 19
   ret i32 %mul
 }
 
 define i32 @test_mul_by_20(i32 %x) {
 ; X86-LABEL: test_mul_by_20:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    shll $2, %eax
 ; X86-NEXT:    leal (%eax,%eax,4), %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_20:
 ; X64-HSW:       # %bb.0:
 ; X64-HSW-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-HSW-NEXT:    shll $2, %edi # sched: [1:0.50]
-; X64-HSW-NEXT:    leal (%rdi,%rdi,4), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    shll $2, %edi
+; X64-HSW-NEXT:    leal (%rdi,%rdi,4), %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_20:
 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-JAG-NEXT:    shll $2, %edi # sched: [1:0.50]
-; X64-JAG-NEXT:    leal (%rdi,%rdi,4), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    shll $2, %edi
+; X64-JAG-NEXT:    leal (%rdi,%rdi,4), %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_20:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $20, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_20:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imull $20, %edi, %eax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imull $20, %edi, %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_20:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imull $20, %edi, %eax # sched: [3:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imull $20, %edi, %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_20:
 ; X64-SLM:       # %bb.0:
 ; X64-SLM-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-SLM-NEXT:    shll $2, %edi # sched: [1:1.00]
-; X64-SLM-NEXT:    leal (%rdi,%rdi,4), %eax # sched: [1:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    shll $2, %edi
+; X64-SLM-NEXT:    leal (%rdi,%rdi,4), %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_20:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imull $20, %edi, %eax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imull $20, %edi, %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 20
   ret i32 %mul
 }
 
 define i32 @test_mul_by_21(i32 %x) {
 ; X86-LABEL: test_mul_by_21:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal (%eax,%eax,4), %ecx
 ; X86-NEXT:    leal (%eax,%ecx,4), %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_21:
 ; X64-HSW:       # %bb.0:
 ; X64-HSW-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-HSW-NEXT:    leal (%rdi,%rdi,4), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    leal (%rdi,%rax,4), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leal (%rdi,%rdi,4), %eax
+; X64-HSW-NEXT:    leal (%rdi,%rax,4), %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_21:
 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-JAG-NEXT:    leal (%rdi,%rdi,4), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    leal (%rdi,%rax,4), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leal (%rdi,%rdi,4), %eax
+; X64-JAG-NEXT:    leal (%rdi,%rax,4), %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_21:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $21, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_21:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imull $21, %edi, %eax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imull $21, %edi, %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_21:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imull $21, %edi, %eax # sched: [3:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imull $21, %edi, %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_21:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    imull $21, %edi, %eax # sched: [3:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    imull $21, %edi, %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_21:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imull $21, %edi, %eax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imull $21, %edi, %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 21
   ret i32 %mul
 }
 
 define i32 @test_mul_by_22(i32 %x) {
 ; X86-LABEL: test_mul_by_22:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %ecx
 ; X86-NEXT:    leal (%ecx,%ecx,4), %eax
 ; X86-NEXT:    leal (%ecx,%eax,4), %eax
 ; X86-NEXT:    addl %ecx, %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_22:
 ; X64-HSW:       # %bb.0:
 ; X64-HSW-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-HSW-NEXT:    leal (%rdi,%rdi,4), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    leal (%rdi,%rax,4), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    addl %edi, %eax # sched: [1:0.25]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leal (%rdi,%rdi,4), %eax
+; X64-HSW-NEXT:    leal (%rdi,%rax,4), %eax
+; X64-HSW-NEXT:    addl %edi, %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_22:
 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-JAG-NEXT:    leal (%rdi,%rdi,4), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    leal (%rdi,%rax,4), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    addl %edi, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leal (%rdi,%rdi,4), %eax
+; X64-JAG-NEXT:    leal (%rdi,%rax,4), %eax
+; X64-JAG-NEXT:    addl %edi, %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_22:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $22, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_22:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imull $22, %edi, %eax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imull $22, %edi, %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_22:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imull $22, %edi, %eax # sched: [3:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imull $22, %edi, %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_22:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    imull $22, %edi, %eax # sched: [3:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    imull $22, %edi, %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_22:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imull $22, %edi, %eax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imull $22, %edi, %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 22
   ret i32 %mul
 }
 
 define i32 @test_mul_by_23(i32 %x) {
 ; X86-LABEL: test_mul_by_23:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %ecx
 ; X86-NEXT:    leal (%ecx,%ecx,2), %eax
 ; X86-NEXT:    shll $3, %eax
 ; X86-NEXT:    subl %ecx, %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_23:
 ; X64-HSW:       # %bb.0:
 ; X64-HSW-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-HSW-NEXT:    leal (%rdi,%rdi,2), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    shll $3, %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    subl %edi, %eax # sched: [1:0.25]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leal (%rdi,%rdi,2), %eax
+; X64-HSW-NEXT:    shll $3, %eax
+; X64-HSW-NEXT:    subl %edi, %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_23:
 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-JAG-NEXT:    leal (%rdi,%rdi,2), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    shll $3, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    subl %edi, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leal (%rdi,%rdi,2), %eax
+; X64-JAG-NEXT:    shll $3, %eax
+; X64-JAG-NEXT:    subl %edi, %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_23:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $23, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_23:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imull $23, %edi, %eax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imull $23, %edi, %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_23:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imull $23, %edi, %eax # sched: [3:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imull $23, %edi, %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_23:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    imull $23, %edi, %eax # sched: [3:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    imull $23, %edi, %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_23:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imull $23, %edi, %eax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imull $23, %edi, %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 23
   ret i32 %mul
 }
 
 define i32 @test_mul_by_24(i32 %x) {
 ; X86-LABEL: test_mul_by_24:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    shll $3, %eax
 ; X86-NEXT:    leal (%eax,%eax,2), %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_24:
 ; X64-HSW:       # %bb.0:
 ; X64-HSW-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-HSW-NEXT:    shll $3, %edi # sched: [1:0.50]
-; X64-HSW-NEXT:    leal (%rdi,%rdi,2), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    shll $3, %edi
+; X64-HSW-NEXT:    leal (%rdi,%rdi,2), %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_24:
 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-JAG-NEXT:    shll $3, %edi # sched: [1:0.50]
-; X64-JAG-NEXT:    leal (%rdi,%rdi,2), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    shll $3, %edi
+; X64-JAG-NEXT:    leal (%rdi,%rdi,2), %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_24:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $24, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_24:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imull $24, %edi, %eax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imull $24, %edi, %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_24:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imull $24, %edi, %eax # sched: [3:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imull $24, %edi, %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_24:
 ; X64-SLM:       # %bb.0:
 ; X64-SLM-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-SLM-NEXT:    shll $3, %edi # sched: [1:1.00]
-; X64-SLM-NEXT:    leal (%rdi,%rdi,2), %eax # sched: [1:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    shll $3, %edi
+; X64-SLM-NEXT:    leal (%rdi,%rdi,2), %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_24:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imull $24, %edi, %eax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imull $24, %edi, %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 24
   ret i32 %mul
 }
 
 define i32 @test_mul_by_25(i32 %x) {
 ; X86-LABEL: test_mul_by_25:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal (%eax,%eax,4), %eax
 ; X86-NEXT:    leal (%eax,%eax,4), %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_25:
 ; X64-HSW:       # %bb.0:
 ; X64-HSW-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-HSW-NEXT:    leal (%rdi,%rdi,4), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    leal (%rax,%rax,4), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leal (%rdi,%rdi,4), %eax
+; X64-HSW-NEXT:    leal (%rax,%rax,4), %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_25:
 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-JAG-NEXT:    leal (%rdi,%rdi,4), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    leal (%rax,%rax,4), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leal (%rdi,%rdi,4), %eax
+; X64-JAG-NEXT:    leal (%rax,%rax,4), %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_25:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $25, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_25:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imull $25, %edi, %eax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imull $25, %edi, %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_25:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imull $25, %edi, %eax # sched: [3:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imull $25, %edi, %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_25:
 ; X64-SLM:       # %bb.0:
 ; X64-SLM-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-SLM-NEXT:    leal (%rdi,%rdi,4), %eax # sched: [1:1.00]
-; X64-SLM-NEXT:    leal (%rax,%rax,4), %eax # sched: [1:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    leal (%rdi,%rdi,4), %eax
+; X64-SLM-NEXT:    leal (%rax,%rax,4), %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_25:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imull $25, %edi, %eax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imull $25, %edi, %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 25
   ret i32 %mul
 }
 
 define i32 @test_mul_by_26(i32 %x) {
 ; X86-LABEL: test_mul_by_26:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %ecx
 ; X86-NEXT:    leal (%ecx,%ecx,4), %eax
 ; X86-NEXT:    leal (%eax,%eax,4), %eax
 ; X86-NEXT:    addl %ecx, %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_26:
 ; X64-HSW:       # %bb.0:
 ; X64-HSW-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-HSW-NEXT:    leal (%rdi,%rdi,4), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    leal (%rax,%rax,4), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    addl %edi, %eax # sched: [1:0.25]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leal (%rdi,%rdi,4), %eax
+; X64-HSW-NEXT:    leal (%rax,%rax,4), %eax
+; X64-HSW-NEXT:    addl %edi, %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_26:
 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-JAG-NEXT:    leal (%rdi,%rdi,4), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    leal (%rax,%rax,4), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    addl %edi, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leal (%rdi,%rdi,4), %eax
+; X64-JAG-NEXT:    leal (%rax,%rax,4), %eax
+; X64-JAG-NEXT:    addl %edi, %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_26:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $26, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_26:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imull $26, %edi, %eax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imull $26, %edi, %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_26:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imull $26, %edi, %eax # sched: [3:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imull $26, %edi, %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_26:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    imull $26, %edi, %eax # sched: [3:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    imull $26, %edi, %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_26:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imull $26, %edi, %eax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imull $26, %edi, %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 26
   ret i32 %mul
 }
 
 define i32 @test_mul_by_27(i32 %x) {
 ; X86-LABEL: test_mul_by_27:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal (%eax,%eax,8), %eax
 ; X86-NEXT:    leal (%eax,%eax,2), %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_27:
 ; X64-HSW:       # %bb.0:
 ; X64-HSW-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-HSW-NEXT:    leal (%rdi,%rdi,8), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    leal (%rax,%rax,2), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leal (%rdi,%rdi,8), %eax
+; X64-HSW-NEXT:    leal (%rax,%rax,2), %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_27:
 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-JAG-NEXT:    leal (%rdi,%rdi,8), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    leal (%rax,%rax,2), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leal (%rdi,%rdi,8), %eax
+; X64-JAG-NEXT:    leal (%rax,%rax,2), %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_27:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $27, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_27:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imull $27, %edi, %eax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imull $27, %edi, %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_27:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imull $27, %edi, %eax # sched: [3:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imull $27, %edi, %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_27:
 ; X64-SLM:       # %bb.0:
 ; X64-SLM-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-SLM-NEXT:    leal (%rdi,%rdi,8), %eax # sched: [1:1.00]
-; X64-SLM-NEXT:    leal (%rax,%rax,2), %eax # sched: [1:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    leal (%rdi,%rdi,8), %eax
+; X64-SLM-NEXT:    leal (%rax,%rax,2), %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_27:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imull $27, %edi, %eax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imull $27, %edi, %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 27
   ret i32 %mul
 }
 
 define i32 @test_mul_by_28(i32 %x) {
 ; X86-LABEL: test_mul_by_28:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %ecx
 ; X86-NEXT:    leal (%ecx,%ecx,8), %eax
 ; X86-NEXT:    leal (%eax,%eax,2), %eax
 ; X86-NEXT:    addl %ecx, %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_28:
 ; X64-HSW:       # %bb.0:
 ; X64-HSW-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-HSW-NEXT:    leal (%rdi,%rdi,8), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    leal (%rax,%rax,2), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    addl %edi, %eax # sched: [1:0.25]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leal (%rdi,%rdi,8), %eax
+; X64-HSW-NEXT:    leal (%rax,%rax,2), %eax
+; X64-HSW-NEXT:    addl %edi, %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_28:
 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-JAG-NEXT:    leal (%rdi,%rdi,8), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    leal (%rax,%rax,2), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    addl %edi, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leal (%rdi,%rdi,8), %eax
+; X64-JAG-NEXT:    leal (%rax,%rax,2), %eax
+; X64-JAG-NEXT:    addl %edi, %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_28:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $28, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_28:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imull $28, %edi, %eax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imull $28, %edi, %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_28:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imull $28, %edi, %eax # sched: [3:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imull $28, %edi, %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_28:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    imull $28, %edi, %eax # sched: [3:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    imull $28, %edi, %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_28:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imull $28, %edi, %eax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imull $28, %edi, %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 28
   ret i32 %mul
 }
 
 define i32 @test_mul_by_29(i32 %x) {
 ; X86-LABEL: test_mul_by_29:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %ecx
 ; X86-NEXT:    leal (%ecx,%ecx,8), %eax
 ; X86-NEXT:    leal (%eax,%eax,2), %eax
 ; X86-NEXT:    addl %ecx, %eax
 ; X86-NEXT:    addl %ecx, %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_29:
 ; X64-HSW:       # %bb.0:
 ; X64-HSW-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-HSW-NEXT:    leal (%rdi,%rdi,8), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    leal (%rax,%rax,2), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    addl %edi, %eax # sched: [1:0.25]
-; X64-HSW-NEXT:    addl %edi, %eax # sched: [1:0.25]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leal (%rdi,%rdi,8), %eax
+; X64-HSW-NEXT:    leal (%rax,%rax,2), %eax
+; X64-HSW-NEXT:    addl %edi, %eax
+; X64-HSW-NEXT:    addl %edi, %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_29:
 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-JAG-NEXT:    leal (%rdi,%rdi,8), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    leal (%rax,%rax,2), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    addl %edi, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    addl %edi, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leal (%rdi,%rdi,8), %eax
+; X64-JAG-NEXT:    leal (%rax,%rax,2), %eax
+; X64-JAG-NEXT:    addl %edi, %eax
+; X64-JAG-NEXT:    addl %edi, %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_29:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $29, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_29:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imull $29, %edi, %eax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imull $29, %edi, %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_29:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imull $29, %edi, %eax # sched: [3:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imull $29, %edi, %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_29:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    imull $29, %edi, %eax # sched: [3:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    imull $29, %edi, %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_29:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imull $29, %edi, %eax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imull $29, %edi, %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 29
   ret i32 %mul
 }
 
 define i32 @test_mul_by_30(i32 %x) {
 ; X86-LABEL: test_mul_by_30:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %ecx
 ; X86-NEXT:    movl %ecx, %eax
 ; X86-NEXT:    shll $5, %eax
 ; X86-NEXT:    subl %ecx, %eax
 ; X86-NEXT:    subl %ecx, %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_30:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    movl %edi, %eax # sched: [1:0.25]
-; X64-HSW-NEXT:    shll $5, %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    subl %edi, %eax # sched: [1:0.25]
-; X64-HSW-NEXT:    subl %edi, %eax # sched: [1:0.25]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    movl %edi, %eax
+; X64-HSW-NEXT:    shll $5, %eax
+; X64-HSW-NEXT:    subl %edi, %eax
+; X64-HSW-NEXT:    subl %edi, %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_30:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    movl %edi, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    shll $5, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    subl %edi, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    subl %edi, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    movl %edi, %eax
+; X64-JAG-NEXT:    shll $5, %eax
+; X64-JAG-NEXT:    subl %edi, %eax
+; X64-JAG-NEXT:    subl %edi, %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_30:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $30, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_30:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imull $30, %edi, %eax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imull $30, %edi, %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_30:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imull $30, %edi, %eax # sched: [3:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imull $30, %edi, %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_30:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    movl %edi, %eax # sched: [1:0.50]
-; X64-SLM-NEXT:    shll $5, %eax # sched: [1:1.00]
-; X64-SLM-NEXT:    subl %edi, %eax # sched: [1:0.50]
-; X64-SLM-NEXT:    subl %edi, %eax # sched: [1:0.50]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    movl %edi, %eax
+; X64-SLM-NEXT:    shll $5, %eax
+; X64-SLM-NEXT:    subl %edi, %eax
+; X64-SLM-NEXT:    subl %edi, %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_30:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imull $30, %edi, %eax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imull $30, %edi, %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 30
   ret i32 %mul
 }
 
 define i32 @test_mul_by_31(i32 %x) {
 ; X86-LABEL: test_mul_by_31:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %ecx
 ; X86-NEXT:    movl %ecx, %eax
 ; X86-NEXT:    shll $5, %eax
 ; X86-NEXT:    subl %ecx, %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_31:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    movl %edi, %eax # sched: [1:0.25]
-; X64-HSW-NEXT:    shll $5, %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    subl %edi, %eax # sched: [1:0.25]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    movl %edi, %eax
+; X64-HSW-NEXT:    shll $5, %eax
+; X64-HSW-NEXT:    subl %edi, %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_31:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    movl %edi, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    shll $5, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    subl %edi, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    movl %edi, %eax
+; X64-JAG-NEXT:    shll $5, %eax
+; X64-JAG-NEXT:    subl %edi, %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_31:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $31, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_31:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imull $31, %edi, %eax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imull $31, %edi, %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_31:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imull $31, %edi, %eax # sched: [3:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imull $31, %edi, %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_31:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    movl %edi, %eax # sched: [1:0.50]
-; X64-SLM-NEXT:    shll $5, %eax # sched: [1:1.00]
-; X64-SLM-NEXT:    subl %edi, %eax # sched: [1:0.50]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    movl %edi, %eax
+; X64-SLM-NEXT:    shll $5, %eax
+; X64-SLM-NEXT:    subl %edi, %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_31:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imull $31, %edi, %eax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imull $31, %edi, %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 31
   ret i32 %mul
 }
 
 define i32 @test_mul_by_32(i32 %x) {
 ; X86-LABEL: test_mul_by_32:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    shll $5, %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_32:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    movl %edi, %eax # sched: [1:0.25]
-; X64-HSW-NEXT:    shll $5, %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    movl %edi, %eax
+; X64-HSW-NEXT:    shll $5, %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_32:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    movl %edi, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    shll $5, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    movl %edi, %eax
+; X64-JAG-NEXT:    shll $5, %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_32:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    shll $5, %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_32:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    movl %edi, %eax # sched: [1:0.25]
-; HSW-NOOPT-NEXT:    shll $5, %eax # sched: [1:0.50]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    movl %edi, %eax
+; HSW-NOOPT-NEXT:    shll $5, %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_32:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    movl %edi, %eax # sched: [1:0.50]
-; JAG-NOOPT-NEXT:    shll $5, %eax # sched: [1:0.50]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    movl %edi, %eax
+; JAG-NOOPT-NEXT:    shll $5, %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_32:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    movl %edi, %eax # sched: [1:0.50]
-; X64-SLM-NEXT:    shll $5, %eax # sched: [1:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    movl %edi, %eax
+; X64-SLM-NEXT:    shll $5, %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_32:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    movl %edi, %eax # sched: [1:0.50]
-; SLM-NOOPT-NEXT:    shll $5, %eax # sched: [1:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    movl %edi, %eax
+; SLM-NOOPT-NEXT:    shll $5, %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 32
   ret i32 %mul
 }
 
 define i32 @test_mul_by_37(i32 %x) {
 ; X86-LABEL: test_mul_by_37:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal (%eax,%eax,8), %ecx
 ; X86-NEXT:    leal (%eax,%ecx,4), %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_37:
 ; X64-HSW:       # %bb.0:
 ; X64-HSW-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-HSW-NEXT:    leal (%rdi,%rdi,8), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    leal (%rdi,%rax,4), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leal (%rdi,%rdi,8), %eax
+; X64-HSW-NEXT:    leal (%rdi,%rax,4), %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_37:
 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-JAG-NEXT:    leal (%rdi,%rdi,8), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    leal (%rdi,%rax,4), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leal (%rdi,%rdi,8), %eax
+; X64-JAG-NEXT:    leal (%rdi,%rax,4), %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_37:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $37, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_37:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imull $37, %edi, %eax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imull $37, %edi, %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_37:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imull $37, %edi, %eax # sched: [3:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imull $37, %edi, %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_37:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    imull $37, %edi, %eax # sched: [3:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    imull $37, %edi, %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_37:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imull $37, %edi, %eax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imull $37, %edi, %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 37
   ret i32 %mul
 }
 
 define i32 @test_mul_by_41(i32 %x) {
 ; X86-LABEL: test_mul_by_41:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal (%eax,%eax,4), %ecx
 ; X86-NEXT:    leal (%eax,%ecx,8), %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_41:
 ; X64-HSW:       # %bb.0:
 ; X64-HSW-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-HSW-NEXT:    leal (%rdi,%rdi,4), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    leal (%rdi,%rax,8), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leal (%rdi,%rdi,4), %eax
+; X64-HSW-NEXT:    leal (%rdi,%rax,8), %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_41:
 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-JAG-NEXT:    leal (%rdi,%rdi,4), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    leal (%rdi,%rax,8), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leal (%rdi,%rdi,4), %eax
+; X64-JAG-NEXT:    leal (%rdi,%rax,8), %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_41:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $41, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_41:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imull $41, %edi, %eax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imull $41, %edi, %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_41:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imull $41, %edi, %eax # sched: [3:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imull $41, %edi, %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_41:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    imull $41, %edi, %eax # sched: [3:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    imull $41, %edi, %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_41:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imull $41, %edi, %eax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imull $41, %edi, %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 41
   ret i32 %mul
 }
 
 define i32 @test_mul_by_62(i32 %x) {
 ; X86-LABEL: test_mul_by_62:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %ecx
 ; X86-NEXT:    movl %ecx, %eax
 ; X86-NEXT:    shll $6, %eax
 ; X86-NEXT:    subl %ecx, %eax
 ; X86-NEXT:    subl %ecx, %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_62:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    movl %edi, %eax # sched: [1:0.25]
-; X64-HSW-NEXT:    shll $6, %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    subl %edi, %eax # sched: [1:0.25]
-; X64-HSW-NEXT:    subl %edi, %eax # sched: [1:0.25]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    movl %edi, %eax
+; X64-HSW-NEXT:    shll $6, %eax
+; X64-HSW-NEXT:    subl %edi, %eax
+; X64-HSW-NEXT:    subl %edi, %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_62:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    movl %edi, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    shll $6, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    subl %edi, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    subl %edi, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    movl %edi, %eax
+; X64-JAG-NEXT:    shll $6, %eax
+; X64-JAG-NEXT:    subl %edi, %eax
+; X64-JAG-NEXT:    subl %edi, %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_62:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $62, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_62:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imull $62, %edi, %eax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imull $62, %edi, %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_62:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imull $62, %edi, %eax # sched: [3:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imull $62, %edi, %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_62:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    movl %edi, %eax # sched: [1:0.50]
-; X64-SLM-NEXT:    shll $6, %eax # sched: [1:1.00]
-; X64-SLM-NEXT:    subl %edi, %eax # sched: [1:0.50]
-; X64-SLM-NEXT:    subl %edi, %eax # sched: [1:0.50]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    movl %edi, %eax
+; X64-SLM-NEXT:    shll $6, %eax
+; X64-SLM-NEXT:    subl %edi, %eax
+; X64-SLM-NEXT:    subl %edi, %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_62:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imull $62, %edi, %eax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imull $62, %edi, %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 62
   ret i32 %mul
 }
 
 define i32 @test_mul_by_66(i32 %x) {
 ; X86-LABEL: test_mul_by_66:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    movl %eax, %ecx
 ; X86-NEXT:    shll $6, %ecx
 ; X86-NEXT:    leal (%ecx,%eax,2), %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_66:
 ; X64-HSW:       # %bb.0:
 ; X64-HSW-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-HSW-NEXT:    movl %edi, %eax # sched: [1:0.25]
-; X64-HSW-NEXT:    shll $6, %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    leal (%rax,%rdi,2), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    movl %edi, %eax
+; X64-HSW-NEXT:    shll $6, %eax
+; X64-HSW-NEXT:    leal (%rax,%rdi,2), %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_66:
 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-JAG-NEXT:    movl %edi, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    shll $6, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    leal (%rax,%rdi,2), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    movl %edi, %eax
+; X64-JAG-NEXT:    shll $6, %eax
+; X64-JAG-NEXT:    leal (%rax,%rdi,2), %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_66:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $66, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_66:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imull $66, %edi, %eax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imull $66, %edi, %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_66:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imull $66, %edi, %eax # sched: [3:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imull $66, %edi, %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_66:
 ; X64-SLM:       # %bb.0:
 ; X64-SLM-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-SLM-NEXT:    movl %edi, %eax # sched: [1:0.50]
-; X64-SLM-NEXT:    shll $6, %eax # sched: [1:1.00]
-; X64-SLM-NEXT:    leal (%rax,%rdi), %eax # sched: [1:1.00]
-; X64-SLM-NEXT:    addl %edi, %eax # sched: [1:0.50]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    movl %edi, %eax
+; X64-SLM-NEXT:    shll $6, %eax
+; X64-SLM-NEXT:    leal (%rax,%rdi), %eax
+; X64-SLM-NEXT:    addl %edi, %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_66:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imull $66, %edi, %eax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imull $66, %edi, %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 66
   ret i32 %mul
 }
 
 define i32 @test_mul_by_73(i32 %x) {
 ; X86-LABEL: test_mul_by_73:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal (%eax,%eax,8), %ecx
 ; X86-NEXT:    leal (%eax,%ecx,8), %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_73:
 ; X64-HSW:       # %bb.0:
 ; X64-HSW-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-HSW-NEXT:    leal (%rdi,%rdi,8), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    leal (%rdi,%rax,8), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leal (%rdi,%rdi,8), %eax
+; X64-HSW-NEXT:    leal (%rdi,%rax,8), %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_73:
 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-JAG-NEXT:    leal (%rdi,%rdi,8), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    leal (%rdi,%rax,8), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leal (%rdi,%rdi,8), %eax
+; X64-JAG-NEXT:    leal (%rdi,%rax,8), %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_73:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $73, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_73:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imull $73, %edi, %eax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imull $73, %edi, %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_73:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imull $73, %edi, %eax # sched: [3:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imull $73, %edi, %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_73:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    imull $73, %edi, %eax # sched: [3:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    imull $73, %edi, %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_73:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imull $73, %edi, %eax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imull $73, %edi, %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 73
   ret i32 %mul
 }
 
 define i32 @test_mul_by_520(i32 %x) {
 ; X86-LABEL: test_mul_by_520:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    movl %eax, %ecx
 ; X86-NEXT:    shll $9, %ecx
 ; X86-NEXT:    leal (%ecx,%eax,8), %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_520:
 ; X64-HSW:       # %bb.0:
 ; X64-HSW-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-HSW-NEXT:    movl %edi, %eax # sched: [1:0.25]
-; X64-HSW-NEXT:    shll $9, %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    leal (%rax,%rdi,8), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    movl %edi, %eax
+; X64-HSW-NEXT:    shll $9, %eax
+; X64-HSW-NEXT:    leal (%rax,%rdi,8), %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_520:
 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-JAG-NEXT:    movl %edi, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    shll $9, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    leal (%rax,%rdi,8), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    movl %edi, %eax
+; X64-JAG-NEXT:    shll $9, %eax
+; X64-JAG-NEXT:    leal (%rax,%rdi,8), %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_520:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $520, {{[0-9]+}}(%esp), %eax # imm = 0x208
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_520:
 ; HSW-NOOPT:       # %bb.0:
 ; HSW-NOOPT-NEXT:    imull $520, %edi, %eax # imm = 0x208
-; HSW-NOOPT-NEXT:    # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_520:
 ; JAG-NOOPT:       # %bb.0:
 ; JAG-NOOPT-NEXT:    imull $520, %edi, %eax # imm = 0x208
-; JAG-NOOPT-NEXT:    # sched: [3:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_520:
 ; X64-SLM:       # %bb.0:
 ; X64-SLM-NEXT:    imull $520, %edi, %eax # imm = 0x208
-; X64-SLM-NEXT:    # sched: [3:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_520:
 ; SLM-NOOPT:       # %bb.0:
 ; SLM-NOOPT-NEXT:    imull $520, %edi, %eax # imm = 0x208
-; SLM-NOOPT-NEXT:    # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 520
   ret i32 %mul
 }
 
 define i32 @test_mul_by_neg10(i32 %x) {
 ; X86-LABEL: test_mul_by_neg10:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    addl %eax, %eax
 ; X86-NEXT:    leal (%eax,%eax,4), %eax
 ; X86-NEXT:    negl %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_neg10:
 ; X64-HSW:       # %bb.0:
 ; X64-HSW-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-HSW-NEXT:    addl %edi, %edi # sched: [1:0.25]
-; X64-HSW-NEXT:    leal (%rdi,%rdi,4), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    negl %eax # sched: [1:0.25]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    addl %edi, %edi
+; X64-HSW-NEXT:    leal (%rdi,%rdi,4), %eax
+; X64-HSW-NEXT:    negl %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_neg10:
 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-JAG-NEXT:    addl %edi, %edi # sched: [1:0.50]
-; X64-JAG-NEXT:    leal (%rdi,%rdi,4), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    negl %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    addl %edi, %edi
+; X64-JAG-NEXT:    leal (%rdi,%rdi,4), %eax
+; X64-JAG-NEXT:    negl %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_neg10:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $-10, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_neg10:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imull $-10, %edi, %eax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imull $-10, %edi, %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_neg10:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imull $-10, %edi, %eax # sched: [3:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imull $-10, %edi, %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_neg10:
 ; X64-SLM:       # %bb.0:
 ; X64-SLM-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-SLM-NEXT:    addl %edi, %edi # sched: [1:0.50]
-; X64-SLM-NEXT:    leal (%rdi,%rdi,4), %eax # sched: [1:1.00]
-; X64-SLM-NEXT:    negl %eax # sched: [1:0.50]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    addl %edi, %edi
+; X64-SLM-NEXT:    leal (%rdi,%rdi,4), %eax
+; X64-SLM-NEXT:    negl %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_neg10:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imull $-10, %edi, %eax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imull $-10, %edi, %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, -10
   ret i32 %mul
 }
 
 define i32 @test_mul_by_neg36(i32 %x) {
 ; X86-LABEL: test_mul_by_neg36:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    shll $2, %eax
 ; X86-NEXT:    leal (%eax,%eax,8), %eax
 ; X86-NEXT:    negl %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_neg36:
 ; X64-HSW:       # %bb.0:
 ; X64-HSW-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-HSW-NEXT:    shll $2, %edi # sched: [1:0.50]
-; X64-HSW-NEXT:    leal (%rdi,%rdi,8), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    negl %eax # sched: [1:0.25]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    shll $2, %edi
+; X64-HSW-NEXT:    leal (%rdi,%rdi,8), %eax
+; X64-HSW-NEXT:    negl %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_neg36:
 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-JAG-NEXT:    shll $2, %edi # sched: [1:0.50]
-; X64-JAG-NEXT:    leal (%rdi,%rdi,8), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    negl %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    shll $2, %edi
+; X64-JAG-NEXT:    leal (%rdi,%rdi,8), %eax
+; X64-JAG-NEXT:    negl %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_neg36:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $-36, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_neg36:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imull $-36, %edi, %eax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imull $-36, %edi, %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_neg36:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imull $-36, %edi, %eax # sched: [3:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imull $-36, %edi, %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_neg36:
 ; X64-SLM:       # %bb.0:
 ; X64-SLM-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-SLM-NEXT:    shll $2, %edi # sched: [1:1.00]
-; X64-SLM-NEXT:    leal (%rdi,%rdi,8), %eax # sched: [1:1.00]
-; X64-SLM-NEXT:    negl %eax # sched: [1:0.50]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    shll $2, %edi
+; X64-SLM-NEXT:    leal (%rdi,%rdi,8), %eax
+; X64-SLM-NEXT:    negl %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_neg36:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imull $-36, %edi, %eax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imull $-36, %edi, %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, -36
   ret i32 %mul
 }
 
 ; (x*9+42)*(x*5+2)
 define i32 @test_mul_spec(i32 %x) nounwind {
 ; X86-LABEL: test_mul_spec:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal 42(%eax,%eax,8), %ecx
 ; X86-NEXT:    leal 2(%eax,%eax,4), %eax
 ; X86-NEXT:    imull %ecx, %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_spec:
 ; X64-HSW:       # %bb.0:
 ; X64-HSW-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-HSW-NEXT:    leal (%rdi,%rdi,8), %ecx # sched: [1:0.50]
-; X64-HSW-NEXT:    addl $42, %ecx # sched: [1:0.25]
-; X64-HSW-NEXT:    leal (%rdi,%rdi,4), %eax # sched: [1:0.50]
-; X64-HSW-NEXT:    addl $2, %eax # sched: [1:0.25]
-; X64-HSW-NEXT:    imull %ecx, %eax # sched: [3:1.00]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leal (%rdi,%rdi,8), %ecx
+; X64-HSW-NEXT:    addl $42, %ecx
+; X64-HSW-NEXT:    leal (%rdi,%rdi,4), %eax
+; X64-HSW-NEXT:    addl $2, %eax
+; X64-HSW-NEXT:    imull %ecx, %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_spec:
 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-JAG-NEXT:    leal 42(%rdi,%rdi,8), %ecx # sched: [2:1.00]
-; X64-JAG-NEXT:    leal 2(%rdi,%rdi,4), %eax # sched: [2:1.00]
-; X64-JAG-NEXT:    imull %ecx, %eax # sched: [3:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leal 42(%rdi,%rdi,8), %ecx
+; X64-JAG-NEXT:    leal 2(%rdi,%rdi,4), %eax
+; X64-JAG-NEXT:    imull %ecx, %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_spec:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    leal 42(%eax,%eax,8), %ecx
 ; X86-NOOPT-NEXT:    leal 2(%eax,%eax,4), %eax
 ; X86-NOOPT-NEXT:    imull %ecx, %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_spec:
 ; HSW-NOOPT:       # %bb.0:
 ; HSW-NOOPT-NEXT:    # kill: def $edi killed $edi def $rdi
-; HSW-NOOPT-NEXT:    leal (%rdi,%rdi,8), %ecx # sched: [1:0.50]
-; HSW-NOOPT-NEXT:    addl $42, %ecx # sched: [1:0.25]
-; HSW-NOOPT-NEXT:    leal (%rdi,%rdi,4), %eax # sched: [1:0.50]
-; HSW-NOOPT-NEXT:    addl $2, %eax # sched: [1:0.25]
-; HSW-NOOPT-NEXT:    imull %ecx, %eax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    leal (%rdi,%rdi,8), %ecx
+; HSW-NOOPT-NEXT:    addl $42, %ecx
+; HSW-NOOPT-NEXT:    leal (%rdi,%rdi,4), %eax
+; HSW-NOOPT-NEXT:    addl $2, %eax
+; HSW-NOOPT-NEXT:    imull %ecx, %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_spec:
 ; JAG-NOOPT:       # %bb.0:
 ; JAG-NOOPT-NEXT:    # kill: def $edi killed $edi def $rdi
-; JAG-NOOPT-NEXT:    leal 42(%rdi,%rdi,8), %ecx # sched: [2:1.00]
-; JAG-NOOPT-NEXT:    leal 2(%rdi,%rdi,4), %eax # sched: [2:1.00]
-; JAG-NOOPT-NEXT:    imull %ecx, %eax # sched: [3:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    leal 42(%rdi,%rdi,8), %ecx
+; JAG-NOOPT-NEXT:    leal 2(%rdi,%rdi,4), %eax
+; JAG-NOOPT-NEXT:    imull %ecx, %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_spec:
 ; X64-SLM:       # %bb.0:
 ; X64-SLM-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-SLM-NEXT:    leal 42(%rdi,%rdi,8), %ecx # sched: [1:1.00]
-; X64-SLM-NEXT:    leal 2(%rdi,%rdi,4), %eax # sched: [1:1.00]
-; X64-SLM-NEXT:    imull %ecx, %eax # sched: [3:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    leal 42(%rdi,%rdi,8), %ecx
+; X64-SLM-NEXT:    leal 2(%rdi,%rdi,4), %eax
+; X64-SLM-NEXT:    imull %ecx, %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_spec:
 ; SLM-NOOPT:       # %bb.0:
 ; SLM-NOOPT-NEXT:    # kill: def $edi killed $edi def $rdi
-; SLM-NOOPT-NEXT:    leal 42(%rdi,%rdi,8), %ecx # sched: [1:1.00]
-; SLM-NOOPT-NEXT:    leal 2(%rdi,%rdi,4), %eax # sched: [1:1.00]
-; SLM-NOOPT-NEXT:    imull %ecx, %eax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    leal 42(%rdi,%rdi,8), %ecx
+; SLM-NOOPT-NEXT:    leal 2(%rdi,%rdi,4), %eax
+; SLM-NOOPT-NEXT:    imull %ecx, %eax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i32 %x, 9
   %add = add nsw i32 %mul, 42
   %mul2 = mul nsw i32 %x, 5
   %add2 = add nsw i32 %mul2, 2
   %mul3 = mul nsw i32 %add, %add2
   ret i32 %mul3
 }
 
 ; This makes sure we are able to fold the negate generated by the mul expansion
 ; into the next instruction.
 ; FIXME: We make this work.
 define i32 @mul_neg_fold(i32 %a, i32 %b) {
 ; X86-LABEL: mul_neg_fold:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %ecx
 ; X86-NEXT:    leal (%ecx,%ecx,8), %ecx
 ; X86-NEXT:    subl %ecx, %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: mul_neg_fold:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    movl %esi, %eax # sched: [1:0.25]
+; X64-HSW-NEXT:    movl %esi, %eax
 ; X64-HSW-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-HSW-NEXT:    leal (%rdi,%rdi,8), %ecx # sched: [1:0.50]
-; X64-HSW-NEXT:    subl %ecx, %eax # sched: [1:0.25]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leal (%rdi,%rdi,8), %ecx
+; X64-HSW-NEXT:    subl %ecx, %eax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: mul_neg_fold:
 ; X64-JAG:       # %bb.0:
 ; X64-JAG-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-JAG-NEXT:    leal (%rdi,%rdi,8), %ecx # sched: [2:1.00]
-; X64-JAG-NEXT:    movl %esi, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    subl %ecx, %eax # sched: [1:0.50]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leal (%rdi,%rdi,8), %ecx
+; X64-JAG-NEXT:    movl %esi, %eax
+; X64-JAG-NEXT:    subl %ecx, %eax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: mul_neg_fold:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    imull $-9, {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    addl {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: mul_neg_fold:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imull $-9, %edi, %eax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    addl %esi, %eax # sched: [1:0.25]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imull $-9, %edi, %eax
+; HSW-NOOPT-NEXT:    addl %esi, %eax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: mul_neg_fold:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imull $-9, %edi, %eax # sched: [3:1.00]
-; JAG-NOOPT-NEXT:    addl %esi, %eax # sched: [1:0.50]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imull $-9, %edi, %eax
+; JAG-NOOPT-NEXT:    addl %esi, %eax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: mul_neg_fold:
 ; X64-SLM:       # %bb.0:
 ; X64-SLM-NEXT:    # kill: def $edi killed $edi def $rdi
-; X64-SLM-NEXT:    movl %esi, %eax # sched: [1:0.50]
-; X64-SLM-NEXT:    leal (%rdi,%rdi,8), %ecx # sched: [1:1.00]
-; X64-SLM-NEXT:    subl %ecx, %eax # sched: [1:0.50]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    movl %esi, %eax
+; X64-SLM-NEXT:    leal (%rdi,%rdi,8), %ecx
+; X64-SLM-NEXT:    subl %ecx, %eax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: mul_neg_fold:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imull $-9, %edi, %eax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    addl %esi, %eax # sched: [1:0.50]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imull $-9, %edi, %eax
+; SLM-NOOPT-NEXT:    addl %esi, %eax
+; SLM-NOOPT-NEXT:    retq
   %c = mul i32 %a, -9
   %d = add i32 %b, %c
   ret i32 %d
 }

test/CodeGen/X86/mul-constant-i64.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc < %s -mtriple=i686-unknown | FileCheck %s --check-prefix=X86
-; RUN: llc < %s -mtriple=x86_64-unknown -print-schedule=true -mcpu=haswell| FileCheck %s --check-prefix=X64-HSW
-; RUN: llc < %s -mtriple=x86_64-unknown -print-schedule=true -mcpu=btver2| FileCheck %s --check-prefix=X64-JAG
+; RUN: llc < %s -mtriple=x86_64-unknown -mcpu=haswell | FileCheck %s --check-prefix=X64-HSW
+; RUN: llc < %s -mtriple=x86_64-unknown -mcpu=btver2 | FileCheck %s --check-prefix=X64-JAG
 ; RUN: llc < %s -mtriple=i686-unknown -mul-constant-optimization=false | FileCheck %s --check-prefix=X86-NOOPT
-; RUN: llc < %s -mtriple=x86_64-unknown -mul-constant-optimization=false -print-schedule=true -mcpu=haswell| FileCheck %s --check-prefix=HSW-NOOPT
-; RUN: llc < %s -mtriple=x86_64-unknown -mul-constant-optimization=false -print-schedule=true -mcpu=btver2| FileCheck %s --check-prefix=JAG-NOOPT
-; RUN: llc < %s -mtriple=x86_64-unknown -print-schedule=true -mcpu=slm| FileCheck %s --check-prefix=X64-SLM
-; RUN: llc < %s -mtriple=x86_64-unknown -mul-constant-optimization=false -print-schedule=true -mcpu=slm| FileCheck %s --check-prefix=SLM-NOOPT
+; RUN: llc < %s -mtriple=x86_64-unknown -mul-constant-optimization=false -mcpu=haswell | FileCheck %s --check-prefix=HSW-NOOPT
+; RUN: llc < %s -mtriple=x86_64-unknown -mul-constant-optimization=false -mcpu=btver2 | FileCheck %s --check-prefix=JAG-NOOPT
+; RUN: llc < %s -mtriple=x86_64-unknown -mcpu=slm | FileCheck %s --check-prefix=X64-SLM
+; RUN: llc < %s -mtriple=x86_64-unknown -mul-constant-optimization=false -mcpu=slm | FileCheck %s --check-prefix=SLM-NOOPT
 
 define i64 @test_mul_by_1(i64 %x) nounwind {
 ; X86-LABEL: test_mul_by_1:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %edx
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_1:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    movq %rdi, %rax # sched: [1:0.25]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    movq %rdi, %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_1:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    movq %rdi, %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    movq %rdi, %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_1:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    movl {{[0-9]+}}(%esp), %edx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_1:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    movq %rdi, %rax # sched: [1:0.25]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    movq %rdi, %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_1:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    movq %rdi, %rax # sched: [1:0.50]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    movq %rdi, %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_1:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    movq %rdi, %rax # sched: [1:0.50]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    movq %rdi, %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_1:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    movq %rdi, %rax # sched: [1:0.50]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    movq %rdi, %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 1
   ret i64 %mul
 }
 
 define i64 @test_mul_by_2(i64 %x) {
 ; X86-LABEL: test_mul_by_2:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %edx
 ; X86-NEXT:    shldl $1, %eax, %edx
 ; X86-NEXT:    addl %eax, %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_2:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    leaq (%rdi,%rdi), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leaq (%rdi,%rdi), %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_2:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    leaq (%rdi,%rdi), %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leaq (%rdi,%rdi), %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_2:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    movl {{[0-9]+}}(%esp), %edx
 ; X86-NOOPT-NEXT:    shldl $1, %eax, %edx
 ; X86-NOOPT-NEXT:    addl %eax, %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_2:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    leaq (%rdi,%rdi), %rax # sched: [1:0.50]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    leaq (%rdi,%rdi), %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_2:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    leaq (%rdi,%rdi), %rax # sched: [1:0.50]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    leaq (%rdi,%rdi), %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_2:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    leaq (%rdi,%rdi), %rax # sched: [1:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    leaq (%rdi,%rdi), %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_2:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    leaq (%rdi,%rdi), %rax # sched: [1:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    leaq (%rdi,%rdi), %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 2
   ret i64 %mul
 }
 
 define i64 @test_mul_by_3(i64 %x) {
 ; X86-LABEL: test_mul_by_3:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal (%eax,%eax,2), %ecx
 ; X86-NEXT:    movl $3, %eax
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NEXT:    addl %ecx, %edx
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_3:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    leaq (%rdi,%rdi,2), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leaq (%rdi,%rdi,2), %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_3:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    leaq (%rdi,%rdi,2), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leaq (%rdi,%rdi,2), %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_3:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl $3, %eax
 ; X86-NOOPT-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NOOPT-NEXT:    imull $3, {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    addl %ecx, %edx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_3:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    leaq (%rdi,%rdi,2), %rax # sched: [1:0.50]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    leaq (%rdi,%rdi,2), %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_3:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    leaq (%rdi,%rdi,2), %rax # sched: [2:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    leaq (%rdi,%rdi,2), %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_3:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    leaq (%rdi,%rdi,2), %rax # sched: [1:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    leaq (%rdi,%rdi,2), %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_3:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    leaq (%rdi,%rdi,2), %rax # sched: [1:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    leaq (%rdi,%rdi,2), %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 3
   ret i64 %mul
 }
 
 define i64 @test_mul_by_4(i64 %x) {
 ; X86-LABEL: test_mul_by_4:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %edx
 ; X86-NEXT:    shldl $2, %eax, %edx
 ; X86-NEXT:    shll $2, %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_4:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    leaq (,%rdi,4), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leaq (,%rdi,4), %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_4:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    leaq (,%rdi,4), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leaq (,%rdi,4), %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_4:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    movl {{[0-9]+}}(%esp), %edx
 ; X86-NOOPT-NEXT:    shldl $2, %eax, %edx
 ; X86-NOOPT-NEXT:    shll $2, %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_4:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    leaq (,%rdi,4), %rax # sched: [1:0.50]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    leaq (,%rdi,4), %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_4:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    leaq (,%rdi,4), %rax # sched: [2:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    leaq (,%rdi,4), %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_4:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    leaq (,%rdi,4), %rax # sched: [1:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    leaq (,%rdi,4), %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_4:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    leaq (,%rdi,4), %rax # sched: [1:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    leaq (,%rdi,4), %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 4
   ret i64 %mul
 }
 
 define i64 @test_mul_by_5(i64 %x) {
 ; X86-LABEL: test_mul_by_5:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal (%eax,%eax,4), %ecx
 ; X86-NEXT:    movl $5, %eax
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NEXT:    addl %ecx, %edx
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_5:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    leaq (%rdi,%rdi,4), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leaq (%rdi,%rdi,4), %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_5:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    leaq (%rdi,%rdi,4), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leaq (%rdi,%rdi,4), %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_5:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl $5, %eax
 ; X86-NOOPT-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NOOPT-NEXT:    imull $5, {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    addl %ecx, %edx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_5:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    leaq (%rdi,%rdi,4), %rax # sched: [1:0.50]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    leaq (%rdi,%rdi,4), %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_5:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    leaq (%rdi,%rdi,4), %rax # sched: [2:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    leaq (%rdi,%rdi,4), %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_5:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    leaq (%rdi,%rdi,4), %rax # sched: [1:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    leaq (%rdi,%rdi,4), %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_5:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    leaq (%rdi,%rdi,4), %rax # sched: [1:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    leaq (%rdi,%rdi,4), %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 5
   ret i64 %mul
 }
 
 define i64 @test_mul_by_6(i64 %x) {
 ; X86-LABEL: test_mul_by_6:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal (%eax,%eax,2), %ecx
 ; X86-NEXT:    movl $6, %eax
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NEXT:    leal (%edx,%ecx,2), %edx
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_6:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    addq %rdi, %rdi # sched: [1:0.25]
-; X64-HSW-NEXT:    leaq (%rdi,%rdi,2), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    addq %rdi, %rdi
+; X64-HSW-NEXT:    leaq (%rdi,%rdi,2), %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_6:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    addq %rdi, %rdi # sched: [1:0.50]
-; X64-JAG-NEXT:    leaq (%rdi,%rdi,2), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    addq %rdi, %rdi
+; X64-JAG-NEXT:    leaq (%rdi,%rdi,2), %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_6:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl $6, %eax
 ; X86-NOOPT-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NOOPT-NEXT:    imull $6, {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    addl %ecx, %edx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_6:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imulq $6, %rdi, %rax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imulq $6, %rdi, %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_6:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imulq $6, %rdi, %rax # sched: [6:4.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imulq $6, %rdi, %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_6:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    addq %rdi, %rdi # sched: [1:0.50]
-; X64-SLM-NEXT:    leaq (%rdi,%rdi,2), %rax # sched: [1:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    addq %rdi, %rdi
+; X64-SLM-NEXT:    leaq (%rdi,%rdi,2), %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_6:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imulq $6, %rdi, %rax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imulq $6, %rdi, %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 6
   ret i64 %mul
 }
 
 define i64 @test_mul_by_7(i64 %x) {
 ; X86-LABEL: test_mul_by_7:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal (,%eax,8), %ecx
 ; X86-NEXT:    subl %eax, %ecx
 ; X86-NEXT:    movl $7, %eax
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NEXT:    addl %ecx, %edx
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_7:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    leaq (,%rdi,8), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    subq %rdi, %rax # sched: [1:0.25]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leaq (,%rdi,8), %rax
+; X64-HSW-NEXT:    subq %rdi, %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_7:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    leaq (,%rdi,8), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    subq %rdi, %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leaq (,%rdi,8), %rax
+; X64-JAG-NEXT:    subq %rdi, %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_7:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl $7, %eax
 ; X86-NOOPT-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NOOPT-NEXT:    imull $7, {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    addl %ecx, %edx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_7:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imulq $7, %rdi, %rax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imulq $7, %rdi, %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_7:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imulq $7, %rdi, %rax # sched: [6:4.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imulq $7, %rdi, %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_7:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    leaq (,%rdi,8), %rax # sched: [1:1.00]
-; X64-SLM-NEXT:    subq %rdi, %rax # sched: [1:0.50]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    leaq (,%rdi,8), %rax
+; X64-SLM-NEXT:    subq %rdi, %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_7:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imulq $7, %rdi, %rax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imulq $7, %rdi, %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 7
   ret i64 %mul
 }
 
 define i64 @test_mul_by_8(i64 %x) {
 ; X86-LABEL: test_mul_by_8:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %edx
 ; X86-NEXT:    shldl $3, %eax, %edx
 ; X86-NEXT:    shll $3, %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_8:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    leaq (,%rdi,8), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leaq (,%rdi,8), %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_8:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    leaq (,%rdi,8), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leaq (,%rdi,8), %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_8:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    movl {{[0-9]+}}(%esp), %edx
 ; X86-NOOPT-NEXT:    shldl $3, %eax, %edx
 ; X86-NOOPT-NEXT:    shll $3, %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_8:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    leaq (,%rdi,8), %rax # sched: [1:0.50]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    leaq (,%rdi,8), %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_8:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    leaq (,%rdi,8), %rax # sched: [2:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    leaq (,%rdi,8), %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_8:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    leaq (,%rdi,8), %rax # sched: [1:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    leaq (,%rdi,8), %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_8:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    leaq (,%rdi,8), %rax # sched: [1:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    leaq (,%rdi,8), %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 8
   ret i64 %mul
 }
 
 define i64 @test_mul_by_9(i64 %x) {
 ; X86-LABEL: test_mul_by_9:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal (%eax,%eax,8), %ecx
 ; X86-NEXT:    movl $9, %eax
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NEXT:    addl %ecx, %edx
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_9:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    leaq (%rdi,%rdi,8), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leaq (%rdi,%rdi,8), %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_9:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    leaq (%rdi,%rdi,8), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leaq (%rdi,%rdi,8), %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_9:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl $9, %eax
 ; X86-NOOPT-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NOOPT-NEXT:    imull $9, {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    addl %ecx, %edx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_9:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    leaq (%rdi,%rdi,8), %rax # sched: [1:0.50]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    leaq (%rdi,%rdi,8), %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_9:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    leaq (%rdi,%rdi,8), %rax # sched: [2:1.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    leaq (%rdi,%rdi,8), %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_9:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    leaq (%rdi,%rdi,8), %rax # sched: [1:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    leaq (%rdi,%rdi,8), %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_9:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    leaq (%rdi,%rdi,8), %rax # sched: [1:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    leaq (%rdi,%rdi,8), %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 9
   ret i64 %mul
 }
 
 define i64 @test_mul_by_10(i64 %x) {
 ; X86-LABEL: test_mul_by_10:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal (%eax,%eax,4), %ecx
 ; X86-NEXT:    movl $10, %eax
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NEXT:    leal (%edx,%ecx,2), %edx
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_10:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    addq %rdi, %rdi # sched: [1:0.25]
-; X64-HSW-NEXT:    leaq (%rdi,%rdi,4), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    addq %rdi, %rdi
+; X64-HSW-NEXT:    leaq (%rdi,%rdi,4), %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_10:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    addq %rdi, %rdi # sched: [1:0.50]
-; X64-JAG-NEXT:    leaq (%rdi,%rdi,4), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    addq %rdi, %rdi
+; X64-JAG-NEXT:    leaq (%rdi,%rdi,4), %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_10:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl $10, %eax
 ; X86-NOOPT-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NOOPT-NEXT:    imull $10, {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    addl %ecx, %edx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_10:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imulq $10, %rdi, %rax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imulq $10, %rdi, %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_10:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imulq $10, %rdi, %rax # sched: [6:4.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imulq $10, %rdi, %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_10:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    addq %rdi, %rdi # sched: [1:0.50]
-; X64-SLM-NEXT:    leaq (%rdi,%rdi,4), %rax # sched: [1:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    addq %rdi, %rdi
+; X64-SLM-NEXT:    leaq (%rdi,%rdi,4), %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_10:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imulq $10, %rdi, %rax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imulq $10, %rdi, %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 10
   ret i64 %mul
 }
 
 define i64 @test_mul_by_11(i64 %x) {
 ; X86-LABEL: test_mul_by_11:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal (%eax,%eax,4), %ecx
 ; X86-NEXT:    leal (%eax,%ecx,2), %ecx
 ; X86-NEXT:    movl $11, %eax
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NEXT:    addl %ecx, %edx
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_11:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    leaq (%rdi,%rdi,4), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    leaq (%rdi,%rax,2), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leaq (%rdi,%rdi,4), %rax
+; X64-HSW-NEXT:    leaq (%rdi,%rax,2), %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_11:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    leaq (%rdi,%rdi,4), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    leaq (%rdi,%rax,2), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leaq (%rdi,%rdi,4), %rax
+; X64-JAG-NEXT:    leaq (%rdi,%rax,2), %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_11:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl $11, %eax
 ; X86-NOOPT-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NOOPT-NEXT:    imull $11, {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    addl %ecx, %edx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_11:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imulq $11, %rdi, %rax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imulq $11, %rdi, %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_11:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imulq $11, %rdi, %rax # sched: [6:4.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imulq $11, %rdi, %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_11:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    imulq $11, %rdi, %rax # sched: [3:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    imulq $11, %rdi, %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_11:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imulq $11, %rdi, %rax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imulq $11, %rdi, %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 11
   ret i64 %mul
 }
 
 define i64 @test_mul_by_12(i64 %x) {
 ; X86-LABEL: test_mul_by_12:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal (%eax,%eax,2), %ecx
 ; X86-NEXT:    movl $12, %eax
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NEXT:    leal (%edx,%ecx,4), %edx
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_12:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    shlq $2, %rdi # sched: [1:0.50]
-; X64-HSW-NEXT:    leaq (%rdi,%rdi,2), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    shlq $2, %rdi
+; X64-HSW-NEXT:    leaq (%rdi,%rdi,2), %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_12:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    shlq $2, %rdi # sched: [1:0.50]
-; X64-JAG-NEXT:    leaq (%rdi,%rdi,2), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    shlq $2, %rdi
+; X64-JAG-NEXT:    leaq (%rdi,%rdi,2), %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_12:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl $12, %eax
 ; X86-NOOPT-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NOOPT-NEXT:    imull $12, {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    addl %ecx, %edx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_12:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imulq $12, %rdi, %rax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imulq $12, %rdi, %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_12:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imulq $12, %rdi, %rax # sched: [6:4.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imulq $12, %rdi, %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_12:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    shlq $2, %rdi # sched: [1:1.00]
-; X64-SLM-NEXT:    leaq (%rdi,%rdi,2), %rax # sched: [1:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    shlq $2, %rdi
+; X64-SLM-NEXT:    leaq (%rdi,%rdi,2), %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_12:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imulq $12, %rdi, %rax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imulq $12, %rdi, %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 12
   ret i64 %mul
 }
 
 define i64 @test_mul_by_13(i64 %x) {
 ; X86-LABEL: test_mul_by_13:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal (%eax,%eax,2), %ecx
 ; X86-NEXT:    leal (%eax,%ecx,4), %ecx
 ; X86-NEXT:    movl $13, %eax
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NEXT:    addl %ecx, %edx
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_13:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    leaq (%rdi,%rdi,2), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    leaq (%rdi,%rax,4), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leaq (%rdi,%rdi,2), %rax
+; X64-HSW-NEXT:    leaq (%rdi,%rax,4), %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_13:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    leaq (%rdi,%rdi,2), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    leaq (%rdi,%rax,4), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leaq (%rdi,%rdi,2), %rax
+; X64-JAG-NEXT:    leaq (%rdi,%rax,4), %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_13:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl $13, %eax
 ; X86-NOOPT-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NOOPT-NEXT:    imull $13, {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    addl %ecx, %edx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_13:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imulq $13, %rdi, %rax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imulq $13, %rdi, %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_13:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imulq $13, %rdi, %rax # sched: [6:4.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imulq $13, %rdi, %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_13:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    imulq $13, %rdi, %rax # sched: [3:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    imulq $13, %rdi, %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_13:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imulq $13, %rdi, %rax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imulq $13, %rdi, %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 13
   ret i64 %mul
 }
 
 define i64 @test_mul_by_14(i64 %x) {
 ; X86-LABEL: test_mul_by_14:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    movl %eax, %ecx
 ; X86-NEXT:    shll $4, %ecx
 ; X86-NEXT:    subl %eax, %ecx
 ; X86-NEXT:    subl %eax, %ecx
 ; X86-NEXT:    movl $14, %eax
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NEXT:    addl %ecx, %edx
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_14:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    movq %rdi, %rax # sched: [1:0.25]
-; X64-HSW-NEXT:    shlq $4, %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    subq %rdi, %rax # sched: [1:0.25]
-; X64-HSW-NEXT:    subq %rdi, %rax # sched: [1:0.25]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    movq %rdi, %rax
+; X64-HSW-NEXT:    shlq $4, %rax
+; X64-HSW-NEXT:    subq %rdi, %rax
+; X64-HSW-NEXT:    subq %rdi, %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_14:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    movq %rdi, %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    shlq $4, %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    subq %rdi, %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    subq %rdi, %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    movq %rdi, %rax
+; X64-JAG-NEXT:    shlq $4, %rax
+; X64-JAG-NEXT:    subq %rdi, %rax
+; X64-JAG-NEXT:    subq %rdi, %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_14:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl $14, %eax
 ; X86-NOOPT-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NOOPT-NEXT:    imull $14, {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    addl %ecx, %edx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_14:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imulq $14, %rdi, %rax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imulq $14, %rdi, %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_14:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imulq $14, %rdi, %rax # sched: [6:4.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imulq $14, %rdi, %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_14:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    movq %rdi, %rax # sched: [1:0.50]
-; X64-SLM-NEXT:    shlq $4, %rax # sched: [1:1.00]
-; X64-SLM-NEXT:    subq %rdi, %rax # sched: [1:0.50]
-; X64-SLM-NEXT:    subq %rdi, %rax # sched: [1:0.50]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    movq %rdi, %rax
+; X64-SLM-NEXT:    shlq $4, %rax
+; X64-SLM-NEXT:    subq %rdi, %rax
+; X64-SLM-NEXT:    subq %rdi, %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_14:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imulq $14, %rdi, %rax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imulq $14, %rdi, %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 14
   ret i64 %mul
 }
 
 define i64 @test_mul_by_15(i64 %x) {
 ; X86-LABEL: test_mul_by_15:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %ecx
 ; X86-NEXT:    movl $15, %eax
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NEXT:    leal (%ecx,%ecx,4), %ecx
 ; X86-NEXT:    leal (%ecx,%ecx,2), %ecx
 ; X86-NEXT:    addl %ecx, %edx
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_15:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    leaq (%rdi,%rdi,4), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    leaq (%rax,%rax,2), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leaq (%rdi,%rdi,4), %rax
+; X64-HSW-NEXT:    leaq (%rax,%rax,2), %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_15:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    leaq (%rdi,%rdi,4), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    leaq (%rax,%rax,2), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leaq (%rdi,%rdi,4), %rax
+; X64-JAG-NEXT:    leaq (%rax,%rax,2), %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_15:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl $15, %eax
 ; X86-NOOPT-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NOOPT-NEXT:    imull $15, {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    addl %ecx, %edx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_15:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imulq $15, %rdi, %rax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imulq $15, %rdi, %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_15:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imulq $15, %rdi, %rax # sched: [6:4.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imulq $15, %rdi, %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_15:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    leaq (%rdi,%rdi,4), %rax # sched: [1:1.00]
-; X64-SLM-NEXT:    leaq (%rax,%rax,2), %rax # sched: [1:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    leaq (%rdi,%rdi,4), %rax
+; X64-SLM-NEXT:    leaq (%rax,%rax,2), %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_15:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imulq $15, %rdi, %rax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imulq $15, %rdi, %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 15
   ret i64 %mul
 }
 
 define i64 @test_mul_by_16(i64 %x) {
 ; X86-LABEL: test_mul_by_16:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %edx
 ; X86-NEXT:    shldl $4, %eax, %edx
 ; X86-NEXT:    shll $4, %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_16:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    movq %rdi, %rax # sched: [1:0.25]
-; X64-HSW-NEXT:    shlq $4, %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    movq %rdi, %rax
+; X64-HSW-NEXT:    shlq $4, %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_16:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    movq %rdi, %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    shlq $4, %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    movq %rdi, %rax
+; X64-JAG-NEXT:    shlq $4, %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_16:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    movl {{[0-9]+}}(%esp), %edx
 ; X86-NOOPT-NEXT:    shldl $4, %eax, %edx
 ; X86-NOOPT-NEXT:    shll $4, %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_16:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    movq %rdi, %rax # sched: [1:0.25]
-; HSW-NOOPT-NEXT:    shlq $4, %rax # sched: [1:0.50]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    movq %rdi, %rax
+; HSW-NOOPT-NEXT:    shlq $4, %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_16:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    movq %rdi, %rax # sched: [1:0.50]
-; JAG-NOOPT-NEXT:    shlq $4, %rax # sched: [1:0.50]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    movq %rdi, %rax
+; JAG-NOOPT-NEXT:    shlq $4, %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_16:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    movq %rdi, %rax # sched: [1:0.50]
-; X64-SLM-NEXT:    shlq $4, %rax # sched: [1:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    movq %rdi, %rax
+; X64-SLM-NEXT:    shlq $4, %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_16:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    movq %rdi, %rax # sched: [1:0.50]
-; SLM-NOOPT-NEXT:    shlq $4, %rax # sched: [1:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    movq %rdi, %rax
+; SLM-NOOPT-NEXT:    shlq $4, %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 16
   ret i64 %mul
 }
 
 define i64 @test_mul_by_17(i64 %x) {
 ; X86-LABEL: test_mul_by_17:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    movl %eax, %ecx
 ; X86-NEXT:    shll $4, %ecx
 ; X86-NEXT:    addl %eax, %ecx
 ; X86-NEXT:    movl $17, %eax
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NEXT:    addl %ecx, %edx
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_17:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    movq %rdi, %rax # sched: [1:0.25]
-; X64-HSW-NEXT:    shlq $4, %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    leaq (%rax,%rdi), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    movq %rdi, %rax
+; X64-HSW-NEXT:    shlq $4, %rax
+; X64-HSW-NEXT:    leaq (%rax,%rdi), %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_17:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    movq %rdi, %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    shlq $4, %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    leaq (%rax,%rdi), %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    movq %rdi, %rax
+; X64-JAG-NEXT:    shlq $4, %rax
+; X64-JAG-NEXT:    leaq (%rax,%rdi), %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_17:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl $17, %eax
 ; X86-NOOPT-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NOOPT-NEXT:    imull $17, {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    addl %ecx, %edx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_17:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imulq $17, %rdi, %rax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imulq $17, %rdi, %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_17:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imulq $17, %rdi, %rax # sched: [6:4.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imulq $17, %rdi, %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_17:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    movq %rdi, %rax # sched: [1:0.50]
-; X64-SLM-NEXT:    shlq $4, %rax # sched: [1:1.00]
-; X64-SLM-NEXT:    addq %rdi, %rax # sched: [1:0.50]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    movq %rdi, %rax
+; X64-SLM-NEXT:    shlq $4, %rax
+; X64-SLM-NEXT:    addq %rdi, %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_17:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imulq $17, %rdi, %rax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imulq $17, %rdi, %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 17
   ret i64 %mul
 }
 
 define i64 @test_mul_by_18(i64 %x) {
 ; X86-LABEL: test_mul_by_18:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal (%eax,%eax,8), %ecx
 ; X86-NEXT:    movl $18, %eax
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NEXT:    leal (%edx,%ecx,2), %edx
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_18:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    addq %rdi, %rdi # sched: [1:0.25]
-; X64-HSW-NEXT:    leaq (%rdi,%rdi,8), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    addq %rdi, %rdi
+; X64-HSW-NEXT:    leaq (%rdi,%rdi,8), %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_18:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    addq %rdi, %rdi # sched: [1:0.50]
-; X64-JAG-NEXT:    leaq (%rdi,%rdi,8), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    addq %rdi, %rdi
+; X64-JAG-NEXT:    leaq (%rdi,%rdi,8), %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_18:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl $18, %eax
 ; X86-NOOPT-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NOOPT-NEXT:    imull $18, {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    addl %ecx, %edx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_18:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imulq $18, %rdi, %rax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imulq $18, %rdi, %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_18:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imulq $18, %rdi, %rax # sched: [6:4.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imulq $18, %rdi, %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_18:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    addq %rdi, %rdi # sched: [1:0.50]
-; X64-SLM-NEXT:    leaq (%rdi,%rdi,8), %rax # sched: [1:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    addq %rdi, %rdi
+; X64-SLM-NEXT:    leaq (%rdi,%rdi,8), %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_18:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imulq $18, %rdi, %rax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imulq $18, %rdi, %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 18
   ret i64 %mul
 }
 
 define i64 @test_mul_by_19(i64 %x) {
 ; X86-LABEL: test_mul_by_19:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal (%eax,%eax,8), %ecx
 ; X86-NEXT:    leal (%eax,%ecx,2), %ecx
 ; X86-NEXT:    movl $19, %eax
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NEXT:    addl %ecx, %edx
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_19:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    leaq (%rdi,%rdi,8), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    leaq (%rdi,%rax,2), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leaq (%rdi,%rdi,8), %rax
+; X64-HSW-NEXT:    leaq (%rdi,%rax,2), %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_19:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    leaq (%rdi,%rdi,8), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    leaq (%rdi,%rax,2), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leaq (%rdi,%rdi,8), %rax
+; X64-JAG-NEXT:    leaq (%rdi,%rax,2), %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_19:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl $19, %eax
 ; X86-NOOPT-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NOOPT-NEXT:    imull $19, {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    addl %ecx, %edx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_19:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imulq $19, %rdi, %rax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imulq $19, %rdi, %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_19:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imulq $19, %rdi, %rax # sched: [6:4.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imulq $19, %rdi, %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_19:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    imulq $19, %rdi, %rax # sched: [3:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    imulq $19, %rdi, %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_19:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imulq $19, %rdi, %rax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imulq $19, %rdi, %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 19
   ret i64 %mul
 }
 
 define i64 @test_mul_by_20(i64 %x) {
 ; X86-LABEL: test_mul_by_20:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal (%eax,%eax,4), %ecx
 ; X86-NEXT:    movl $20, %eax
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NEXT:    leal (%edx,%ecx,4), %edx
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_20:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    shlq $2, %rdi # sched: [1:0.50]
-; X64-HSW-NEXT:    leaq (%rdi,%rdi,4), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    shlq $2, %rdi
+; X64-HSW-NEXT:    leaq (%rdi,%rdi,4), %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_20:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    shlq $2, %rdi # sched: [1:0.50]
-; X64-JAG-NEXT:    leaq (%rdi,%rdi,4), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    shlq $2, %rdi
+; X64-JAG-NEXT:    leaq (%rdi,%rdi,4), %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_20:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl $20, %eax
 ; X86-NOOPT-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NOOPT-NEXT:    imull $20, {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    addl %ecx, %edx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_20:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imulq $20, %rdi, %rax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imulq $20, %rdi, %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_20:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imulq $20, %rdi, %rax # sched: [6:4.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imulq $20, %rdi, %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_20:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    shlq $2, %rdi # sched: [1:1.00]
-; X64-SLM-NEXT:    leaq (%rdi,%rdi,4), %rax # sched: [1:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    shlq $2, %rdi
+; X64-SLM-NEXT:    leaq (%rdi,%rdi,4), %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_20:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imulq $20, %rdi, %rax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imulq $20, %rdi, %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 20
   ret i64 %mul
 }
 
 define i64 @test_mul_by_21(i64 %x) {
 ; X86-LABEL: test_mul_by_21:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal (%eax,%eax,4), %ecx
 ; X86-NEXT:    leal (%eax,%ecx,4), %ecx
 ; X86-NEXT:    movl $21, %eax
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NEXT:    addl %ecx, %edx
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_21:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    leaq (%rdi,%rdi,4), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    leaq (%rdi,%rax,4), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leaq (%rdi,%rdi,4), %rax
+; X64-HSW-NEXT:    leaq (%rdi,%rax,4), %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_21:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    leaq (%rdi,%rdi,4), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    leaq (%rdi,%rax,4), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leaq (%rdi,%rdi,4), %rax
+; X64-JAG-NEXT:    leaq (%rdi,%rax,4), %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_21:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl $21, %eax
 ; X86-NOOPT-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NOOPT-NEXT:    imull $21, {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    addl %ecx, %edx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_21:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imulq $21, %rdi, %rax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imulq $21, %rdi, %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_21:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imulq $21, %rdi, %rax # sched: [6:4.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imulq $21, %rdi, %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_21:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    imulq $21, %rdi, %rax # sched: [3:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    imulq $21, %rdi, %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_21:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imulq $21, %rdi, %rax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imulq $21, %rdi, %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 21
   ret i64 %mul
 }
 
 define i64 @test_mul_by_22(i64 %x) {
 ; X86-LABEL: test_mul_by_22:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal (%eax,%eax,4), %ecx
 ; X86-NEXT:    leal (%eax,%ecx,4), %ecx
 ; X86-NEXT:    addl %eax, %ecx
 ; X86-NEXT:    movl $22, %eax
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NEXT:    addl %ecx, %edx
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_22:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    leaq (%rdi,%rdi,4), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    leaq (%rdi,%rax,4), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    addq %rdi, %rax # sched: [1:0.25]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leaq (%rdi,%rdi,4), %rax
+; X64-HSW-NEXT:    leaq (%rdi,%rax,4), %rax
+; X64-HSW-NEXT:    addq %rdi, %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_22:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    leaq (%rdi,%rdi,4), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    leaq (%rdi,%rax,4), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    addq %rdi, %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leaq (%rdi,%rdi,4), %rax
+; X64-JAG-NEXT:    leaq (%rdi,%rax,4), %rax
+; X64-JAG-NEXT:    addq %rdi, %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_22:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl $22, %eax
 ; X86-NOOPT-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NOOPT-NEXT:    imull $22, {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    addl %ecx, %edx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_22:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imulq $22, %rdi, %rax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imulq $22, %rdi, %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_22:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imulq $22, %rdi, %rax # sched: [6:4.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imulq $22, %rdi, %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_22:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    imulq $22, %rdi, %rax # sched: [3:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    imulq $22, %rdi, %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_22:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imulq $22, %rdi, %rax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imulq $22, %rdi, %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 22
   ret i64 %mul
 }
 
 define i64 @test_mul_by_23(i64 %x) {
 ; X86-LABEL: test_mul_by_23:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal (%eax,%eax,2), %ecx
 ; X86-NEXT:    shll $3, %ecx
 ; X86-NEXT:    subl %eax, %ecx
 ; X86-NEXT:    movl $23, %eax
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NEXT:    addl %ecx, %edx
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_23:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    leaq (%rdi,%rdi,2), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    shlq $3, %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    subq %rdi, %rax # sched: [1:0.25]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leaq (%rdi,%rdi,2), %rax
+; X64-HSW-NEXT:    shlq $3, %rax
+; X64-HSW-NEXT:    subq %rdi, %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_23:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    leaq (%rdi,%rdi,2), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    shlq $3, %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    subq %rdi, %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leaq (%rdi,%rdi,2), %rax
+; X64-JAG-NEXT:    shlq $3, %rax
+; X64-JAG-NEXT:    subq %rdi, %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_23:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl $23, %eax
 ; X86-NOOPT-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NOOPT-NEXT:    imull $23, {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    addl %ecx, %edx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_23:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imulq $23, %rdi, %rax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imulq $23, %rdi, %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_23:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imulq $23, %rdi, %rax # sched: [6:4.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imulq $23, %rdi, %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_23:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    imulq $23, %rdi, %rax # sched: [3:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    imulq $23, %rdi, %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_23:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imulq $23, %rdi, %rax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imulq $23, %rdi, %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 23
   ret i64 %mul
 }
 
 define i64 @test_mul_by_24(i64 %x) {
 ; X86-LABEL: test_mul_by_24:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal (%eax,%eax,2), %ecx
 ; X86-NEXT:    movl $24, %eax
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NEXT:    leal (%edx,%ecx,8), %edx
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_24:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    shlq $3, %rdi # sched: [1:0.50]
-; X64-HSW-NEXT:    leaq (%rdi,%rdi,2), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    shlq $3, %rdi
+; X64-HSW-NEXT:    leaq (%rdi,%rdi,2), %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_24:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    shlq $3, %rdi # sched: [1:0.50]
-; X64-JAG-NEXT:    leaq (%rdi,%rdi,2), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    shlq $3, %rdi
+; X64-JAG-NEXT:    leaq (%rdi,%rdi,2), %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_24:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl $24, %eax
 ; X86-NOOPT-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NOOPT-NEXT:    imull $24, {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    addl %ecx, %edx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_24:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imulq $24, %rdi, %rax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imulq $24, %rdi, %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_24:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imulq $24, %rdi, %rax # sched: [6:4.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imulq $24, %rdi, %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_24:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    shlq $3, %rdi # sched: [1:1.00]
-; X64-SLM-NEXT:    leaq (%rdi,%rdi,2), %rax # sched: [1:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    shlq $3, %rdi
+; X64-SLM-NEXT:    leaq (%rdi,%rdi,2), %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_24:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imulq $24, %rdi, %rax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imulq $24, %rdi, %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 24
   ret i64 %mul
 }
 
 define i64 @test_mul_by_25(i64 %x) {
 ; X86-LABEL: test_mul_by_25:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %ecx
 ; X86-NEXT:    movl $25, %eax
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NEXT:    leal (%ecx,%ecx,4), %ecx
 ; X86-NEXT:    leal (%ecx,%ecx,4), %ecx
 ; X86-NEXT:    addl %ecx, %edx
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_25:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    leaq (%rdi,%rdi,4), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    leaq (%rax,%rax,4), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leaq (%rdi,%rdi,4), %rax
+; X64-HSW-NEXT:    leaq (%rax,%rax,4), %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_25:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    leaq (%rdi,%rdi,4), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    leaq (%rax,%rax,4), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leaq (%rdi,%rdi,4), %rax
+; X64-JAG-NEXT:    leaq (%rax,%rax,4), %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_25:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl $25, %eax
 ; X86-NOOPT-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NOOPT-NEXT:    imull $25, {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    addl %ecx, %edx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_25:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imulq $25, %rdi, %rax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imulq $25, %rdi, %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_25:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imulq $25, %rdi, %rax # sched: [6:4.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imulq $25, %rdi, %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_25:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    leaq (%rdi,%rdi,4), %rax # sched: [1:1.00]
-; X64-SLM-NEXT:    leaq (%rax,%rax,4), %rax # sched: [1:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    leaq (%rdi,%rdi,4), %rax
+; X64-SLM-NEXT:    leaq (%rax,%rax,4), %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_25:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imulq $25, %rdi, %rax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imulq $25, %rdi, %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 25
   ret i64 %mul
 }
 
 define i64 @test_mul_by_26(i64 %x) {
 ; X86-LABEL: test_mul_by_26:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal (%eax,%eax,4), %ecx
 ; X86-NEXT:    leal (%ecx,%ecx,4), %ecx
 ; X86-NEXT:    addl %eax, %ecx
 ; X86-NEXT:    movl $26, %eax
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NEXT:    addl %ecx, %edx
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_26:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    leaq (%rdi,%rdi,4), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    leaq (%rax,%rax,4), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    addq %rdi, %rax # sched: [1:0.25]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leaq (%rdi,%rdi,4), %rax
+; X64-HSW-NEXT:    leaq (%rax,%rax,4), %rax
+; X64-HSW-NEXT:    addq %rdi, %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_26:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    leaq (%rdi,%rdi,4), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    leaq (%rax,%rax,4), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    addq %rdi, %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leaq (%rdi,%rdi,4), %rax
+; X64-JAG-NEXT:    leaq (%rax,%rax,4), %rax
+; X64-JAG-NEXT:    addq %rdi, %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_26:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl $26, %eax
 ; X86-NOOPT-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NOOPT-NEXT:    imull $26, {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    addl %ecx, %edx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_26:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imulq $26, %rdi, %rax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imulq $26, %rdi, %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_26:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imulq $26, %rdi, %rax # sched: [6:4.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imulq $26, %rdi, %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_26:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    imulq $26, %rdi, %rax # sched: [3:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    imulq $26, %rdi, %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_26:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imulq $26, %rdi, %rax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imulq $26, %rdi, %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 26
   ret i64 %mul
 }
 
 define i64 @test_mul_by_27(i64 %x) {
 ; X86-LABEL: test_mul_by_27:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %ecx
 ; X86-NEXT:    movl $27, %eax
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NEXT:    leal (%ecx,%ecx,8), %ecx
 ; X86-NEXT:    leal (%ecx,%ecx,2), %ecx
 ; X86-NEXT:    addl %ecx, %edx
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_27:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    leaq (%rdi,%rdi,8), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    leaq (%rax,%rax,2), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leaq (%rdi,%rdi,8), %rax
+; X64-HSW-NEXT:    leaq (%rax,%rax,2), %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_27:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    leaq (%rdi,%rdi,8), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    leaq (%rax,%rax,2), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leaq (%rdi,%rdi,8), %rax
+; X64-JAG-NEXT:    leaq (%rax,%rax,2), %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_27:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl $27, %eax
 ; X86-NOOPT-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NOOPT-NEXT:    imull $27, {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    addl %ecx, %edx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_27:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imulq $27, %rdi, %rax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imulq $27, %rdi, %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_27:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imulq $27, %rdi, %rax # sched: [6:4.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imulq $27, %rdi, %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_27:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    leaq (%rdi,%rdi,8), %rax # sched: [1:1.00]
-; X64-SLM-NEXT:    leaq (%rax,%rax,2), %rax # sched: [1:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    leaq (%rdi,%rdi,8), %rax
+; X64-SLM-NEXT:    leaq (%rax,%rax,2), %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_27:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imulq $27, %rdi, %rax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imulq $27, %rdi, %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 27
   ret i64 %mul
 }
 
 define i64 @test_mul_by_28(i64 %x) {
 ; X86-LABEL: test_mul_by_28:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal (%eax,%eax,8), %ecx
 ; X86-NEXT:    leal (%ecx,%ecx,2), %ecx
 ; X86-NEXT:    addl %eax, %ecx
 ; X86-NEXT:    movl $28, %eax
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NEXT:    addl %ecx, %edx
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_28:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    leaq (%rdi,%rdi,8), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    leaq (%rax,%rax,2), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    addq %rdi, %rax # sched: [1:0.25]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leaq (%rdi,%rdi,8), %rax
+; X64-HSW-NEXT:    leaq (%rax,%rax,2), %rax
+; X64-HSW-NEXT:    addq %rdi, %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_28:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    leaq (%rdi,%rdi,8), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    leaq (%rax,%rax,2), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    addq %rdi, %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leaq (%rdi,%rdi,8), %rax
+; X64-JAG-NEXT:    leaq (%rax,%rax,2), %rax
+; X64-JAG-NEXT:    addq %rdi, %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_28:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl $28, %eax
 ; X86-NOOPT-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NOOPT-NEXT:    imull $28, {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    addl %ecx, %edx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_28:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imulq $28, %rdi, %rax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imulq $28, %rdi, %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_28:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imulq $28, %rdi, %rax # sched: [6:4.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imulq $28, %rdi, %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_28:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    imulq $28, %rdi, %rax # sched: [3:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    imulq $28, %rdi, %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_28:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imulq $28, %rdi, %rax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imulq $28, %rdi, %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 28
   ret i64 %mul
 }
 
 define i64 @test_mul_by_29(i64 %x) {
 ; X86-LABEL: test_mul_by_29:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal (%eax,%eax,8), %ecx
 ; X86-NEXT:    leal (%ecx,%ecx,2), %ecx
 ; X86-NEXT:    addl %eax, %ecx
 ; X86-NEXT:    addl %eax, %ecx
 ; X86-NEXT:    movl $29, %eax
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NEXT:    addl %ecx, %edx
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_29:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    leaq (%rdi,%rdi,8), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    leaq (%rax,%rax,2), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    addq %rdi, %rax # sched: [1:0.25]
-; X64-HSW-NEXT:    addq %rdi, %rax # sched: [1:0.25]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leaq (%rdi,%rdi,8), %rax
+; X64-HSW-NEXT:    leaq (%rax,%rax,2), %rax
+; X64-HSW-NEXT:    addq %rdi, %rax
+; X64-HSW-NEXT:    addq %rdi, %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_29:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    leaq (%rdi,%rdi,8), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    leaq (%rax,%rax,2), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    addq %rdi, %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    addq %rdi, %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leaq (%rdi,%rdi,8), %rax
+; X64-JAG-NEXT:    leaq (%rax,%rax,2), %rax
+; X64-JAG-NEXT:    addq %rdi, %rax
+; X64-JAG-NEXT:    addq %rdi, %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_29:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl $29, %eax
 ; X86-NOOPT-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NOOPT-NEXT:    imull $29, {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    addl %ecx, %edx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_29:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imulq $29, %rdi, %rax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imulq $29, %rdi, %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_29:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imulq $29, %rdi, %rax # sched: [6:4.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imulq $29, %rdi, %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_29:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    imulq $29, %rdi, %rax # sched: [3:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    imulq $29, %rdi, %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_29:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imulq $29, %rdi, %rax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imulq $29, %rdi, %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 29
   ret i64 %mul
 }
 
 define i64 @test_mul_by_30(i64 %x) {
 ; X86-LABEL: test_mul_by_30:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    movl %eax, %ecx
 ; X86-NEXT:    shll $5, %ecx
 ; X86-NEXT:    subl %eax, %ecx
 ; X86-NEXT:    subl %eax, %ecx
 ; X86-NEXT:    movl $30, %eax
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NEXT:    addl %ecx, %edx
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_30:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    movq %rdi, %rax # sched: [1:0.25]
-; X64-HSW-NEXT:    shlq $5, %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    subq %rdi, %rax # sched: [1:0.25]
-; X64-HSW-NEXT:    subq %rdi, %rax # sched: [1:0.25]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    movq %rdi, %rax
+; X64-HSW-NEXT:    shlq $5, %rax
+; X64-HSW-NEXT:    subq %rdi, %rax
+; X64-HSW-NEXT:    subq %rdi, %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_30:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    movq %rdi, %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    shlq $5, %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    subq %rdi, %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    subq %rdi, %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    movq %rdi, %rax
+; X64-JAG-NEXT:    shlq $5, %rax
+; X64-JAG-NEXT:    subq %rdi, %rax
+; X64-JAG-NEXT:    subq %rdi, %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_30:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl $30, %eax
 ; X86-NOOPT-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NOOPT-NEXT:    imull $30, {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    addl %ecx, %edx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_30:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imulq $30, %rdi, %rax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imulq $30, %rdi, %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_30:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imulq $30, %rdi, %rax # sched: [6:4.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imulq $30, %rdi, %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_30:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    movq %rdi, %rax # sched: [1:0.50]
-; X64-SLM-NEXT:    shlq $5, %rax # sched: [1:1.00]
-; X64-SLM-NEXT:    subq %rdi, %rax # sched: [1:0.50]
-; X64-SLM-NEXT:    subq %rdi, %rax # sched: [1:0.50]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    movq %rdi, %rax
+; X64-SLM-NEXT:    shlq $5, %rax
+; X64-SLM-NEXT:    subq %rdi, %rax
+; X64-SLM-NEXT:    subq %rdi, %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_30:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imulq $30, %rdi, %rax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imulq $30, %rdi, %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 30
   ret i64 %mul
 }
 
 define i64 @test_mul_by_31(i64 %x) {
 ; X86-LABEL: test_mul_by_31:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    movl %eax, %ecx
 ; X86-NEXT:    shll $5, %ecx
 ; X86-NEXT:    subl %eax, %ecx
 ; X86-NEXT:    movl $31, %eax
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NEXT:    addl %ecx, %edx
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_31:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    movq %rdi, %rax # sched: [1:0.25]
-; X64-HSW-NEXT:    shlq $5, %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    subq %rdi, %rax # sched: [1:0.25]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    movq %rdi, %rax
+; X64-HSW-NEXT:    shlq $5, %rax
+; X64-HSW-NEXT:    subq %rdi, %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_31:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    movq %rdi, %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    shlq $5, %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    subq %rdi, %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    movq %rdi, %rax
+; X64-JAG-NEXT:    shlq $5, %rax
+; X64-JAG-NEXT:    subq %rdi, %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_31:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl $31, %eax
 ; X86-NOOPT-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NOOPT-NEXT:    imull $31, {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    addl %ecx, %edx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_31:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imulq $31, %rdi, %rax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imulq $31, %rdi, %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_31:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imulq $31, %rdi, %rax # sched: [6:4.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imulq $31, %rdi, %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_31:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    movq %rdi, %rax # sched: [1:0.50]
-; X64-SLM-NEXT:    shlq $5, %rax # sched: [1:1.00]
-; X64-SLM-NEXT:    subq %rdi, %rax # sched: [1:0.50]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    movq %rdi, %rax
+; X64-SLM-NEXT:    shlq $5, %rax
+; X64-SLM-NEXT:    subq %rdi, %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_31:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imulq $31, %rdi, %rax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imulq $31, %rdi, %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 31
   ret i64 %mul
 }
 
 define i64 @test_mul_by_32(i64 %x) {
 ; X86-LABEL: test_mul_by_32:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %edx
 ; X86-NEXT:    shldl $5, %eax, %edx
 ; X86-NEXT:    shll $5, %eax
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_32:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    movq %rdi, %rax # sched: [1:0.25]
-; X64-HSW-NEXT:    shlq $5, %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    movq %rdi, %rax
+; X64-HSW-NEXT:    shlq $5, %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_32:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    movq %rdi, %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    shlq $5, %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    movq %rdi, %rax
+; X64-JAG-NEXT:    shlq $5, %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_32:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NOOPT-NEXT:    movl {{[0-9]+}}(%esp), %edx
 ; X86-NOOPT-NEXT:    shldl $5, %eax, %edx
 ; X86-NOOPT-NEXT:    shll $5, %eax
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_32:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    movq %rdi, %rax # sched: [1:0.25]
-; HSW-NOOPT-NEXT:    shlq $5, %rax # sched: [1:0.50]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    movq %rdi, %rax
+; HSW-NOOPT-NEXT:    shlq $5, %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_32:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    movq %rdi, %rax # sched: [1:0.50]
-; JAG-NOOPT-NEXT:    shlq $5, %rax # sched: [1:0.50]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    movq %rdi, %rax
+; JAG-NOOPT-NEXT:    shlq $5, %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_32:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    movq %rdi, %rax # sched: [1:0.50]
-; X64-SLM-NEXT:    shlq $5, %rax # sched: [1:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    movq %rdi, %rax
+; X64-SLM-NEXT:    shlq $5, %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_32:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    movq %rdi, %rax # sched: [1:0.50]
-; SLM-NOOPT-NEXT:    shlq $5, %rax # sched: [1:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    movq %rdi, %rax
+; SLM-NOOPT-NEXT:    shlq $5, %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 32
   ret i64 %mul
 }
 
 define i64 @test_mul_by_37(i64 %x) {
 ; X86-LABEL: test_mul_by_37:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal (%eax,%eax,8), %ecx
 ; X86-NEXT:    leal (%eax,%ecx,4), %ecx
 ; X86-NEXT:    movl $37, %eax
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NEXT:    addl %ecx, %edx
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_37:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    leaq (%rdi,%rdi,8), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    leaq (%rdi,%rax,4), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leaq (%rdi,%rdi,8), %rax
+; X64-HSW-NEXT:    leaq (%rdi,%rax,4), %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_37:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    leaq (%rdi,%rdi,8), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    leaq (%rdi,%rax,4), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leaq (%rdi,%rdi,8), %rax
+; X64-JAG-NEXT:    leaq (%rdi,%rax,4), %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_37:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl $37, %eax
 ; X86-NOOPT-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NOOPT-NEXT:    imull $37, {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    addl %ecx, %edx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_37:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imulq $37, %rdi, %rax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imulq $37, %rdi, %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_37:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imulq $37, %rdi, %rax # sched: [6:4.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imulq $37, %rdi, %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_37:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    imulq $37, %rdi, %rax # sched: [3:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    imulq $37, %rdi, %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_37:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imulq $37, %rdi, %rax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imulq $37, %rdi, %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 37
   ret i64 %mul
 }
 
 define i64 @test_mul_by_41(i64 %x) {
 ; X86-LABEL: test_mul_by_41:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal (%eax,%eax,4), %ecx
 ; X86-NEXT:    leal (%eax,%ecx,8), %ecx
 ; X86-NEXT:    movl $41, %eax
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NEXT:    addl %ecx, %edx
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_41:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    leaq (%rdi,%rdi,4), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    leaq (%rdi,%rax,8), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leaq (%rdi,%rdi,4), %rax
+; X64-HSW-NEXT:    leaq (%rdi,%rax,8), %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_41:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    leaq (%rdi,%rdi,4), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    leaq (%rdi,%rax,8), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leaq (%rdi,%rdi,4), %rax
+; X64-JAG-NEXT:    leaq (%rdi,%rax,8), %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_41:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl $41, %eax
 ; X86-NOOPT-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NOOPT-NEXT:    imull $41, {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    addl %ecx, %edx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_41:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imulq $41, %rdi, %rax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imulq $41, %rdi, %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_41:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imulq $41, %rdi, %rax # sched: [6:4.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imulq $41, %rdi, %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_41:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    imulq $41, %rdi, %rax # sched: [3:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    imulq $41, %rdi, %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_41:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imulq $41, %rdi, %rax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imulq $41, %rdi, %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 41
   ret i64 %mul
 }
 
 define i64 @test_mul_by_62(i64 %x) {
 ; X86-LABEL: test_mul_by_62:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    movl %eax, %ecx
 ; X86-NEXT:    shll $6, %ecx
 ; X86-NEXT:    subl %eax, %ecx
 ; X86-NEXT:    subl %eax, %ecx
 ; X86-NEXT:    movl $62, %eax
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NEXT:    addl %ecx, %edx
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_62:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    movq %rdi, %rax # sched: [1:0.25]
-; X64-HSW-NEXT:    shlq $6, %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    subq %rdi, %rax # sched: [1:0.25]
-; X64-HSW-NEXT:    subq %rdi, %rax # sched: [1:0.25]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    movq %rdi, %rax
+; X64-HSW-NEXT:    shlq $6, %rax
+; X64-HSW-NEXT:    subq %rdi, %rax
+; X64-HSW-NEXT:    subq %rdi, %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_62:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    movq %rdi, %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    shlq $6, %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    subq %rdi, %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    subq %rdi, %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    movq %rdi, %rax
+; X64-JAG-NEXT:    shlq $6, %rax
+; X64-JAG-NEXT:    subq %rdi, %rax
+; X64-JAG-NEXT:    subq %rdi, %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_62:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl $62, %eax
 ; X86-NOOPT-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NOOPT-NEXT:    imull $62, {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    addl %ecx, %edx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_62:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imulq $62, %rdi, %rax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imulq $62, %rdi, %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_62:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imulq $62, %rdi, %rax # sched: [6:4.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imulq $62, %rdi, %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_62:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    movq %rdi, %rax # sched: [1:0.50]
-; X64-SLM-NEXT:    shlq $6, %rax # sched: [1:1.00]
-; X64-SLM-NEXT:    subq %rdi, %rax # sched: [1:0.50]
-; X64-SLM-NEXT:    subq %rdi, %rax # sched: [1:0.50]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    movq %rdi, %rax
+; X64-SLM-NEXT:    shlq $6, %rax
+; X64-SLM-NEXT:    subq %rdi, %rax
+; X64-SLM-NEXT:    subq %rdi, %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_62:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imulq $62, %rdi, %rax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imulq $62, %rdi, %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 62
   ret i64 %mul
 }
 
 define i64 @test_mul_by_66(i64 %x) {
 ; X86-LABEL: test_mul_by_66:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    movl %eax, %ecx
 ; X86-NEXT:    shll $6, %ecx
 ; X86-NEXT:    leal (%ecx,%eax,2), %ecx
 ; X86-NEXT:    movl $66, %eax
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NEXT:    addl %ecx, %edx
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_66:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    movq %rdi, %rax # sched: [1:0.25]
-; X64-HSW-NEXT:    shlq $6, %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    leaq (%rax,%rdi,2), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    movq %rdi, %rax
+; X64-HSW-NEXT:    shlq $6, %rax
+; X64-HSW-NEXT:    leaq (%rax,%rdi,2), %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_66:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    movq %rdi, %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    shlq $6, %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    leaq (%rax,%rdi,2), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    movq %rdi, %rax
+; X64-JAG-NEXT:    shlq $6, %rax
+; X64-JAG-NEXT:    leaq (%rax,%rdi,2), %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_66:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl $66, %eax
 ; X86-NOOPT-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NOOPT-NEXT:    imull $66, {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    addl %ecx, %edx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_66:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imulq $66, %rdi, %rax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imulq $66, %rdi, %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_66:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imulq $66, %rdi, %rax # sched: [6:4.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imulq $66, %rdi, %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_66:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    movq %rdi, %rax # sched: [1:0.50]
-; X64-SLM-NEXT:    shlq $6, %rax # sched: [1:1.00]
-; X64-SLM-NEXT:    addq %rdi, %rax # sched: [1:0.50]
-; X64-SLM-NEXT:    addq %rdi, %rax # sched: [1:0.50]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    movq %rdi, %rax
+; X64-SLM-NEXT:    shlq $6, %rax
+; X64-SLM-NEXT:    addq %rdi, %rax
+; X64-SLM-NEXT:    addq %rdi, %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_66:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imulq $66, %rdi, %rax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imulq $66, %rdi, %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 66
   ret i64 %mul
 }
 
 define i64 @test_mul_by_73(i64 %x) {
 ; X86-LABEL: test_mul_by_73:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    leal (%eax,%eax,8), %ecx
 ; X86-NEXT:    leal (%eax,%ecx,8), %ecx
 ; X86-NEXT:    movl $73, %eax
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NEXT:    addl %ecx, %edx
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_73:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    leaq (%rdi,%rdi,8), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    leaq (%rdi,%rax,8), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leaq (%rdi,%rdi,8), %rax
+; X64-HSW-NEXT:    leaq (%rdi,%rax,8), %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_73:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    leaq (%rdi,%rdi,8), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    leaq (%rdi,%rax,8), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leaq (%rdi,%rdi,8), %rax
+; X64-JAG-NEXT:    leaq (%rdi,%rax,8), %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_73:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl $73, %eax
 ; X86-NOOPT-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NOOPT-NEXT:    imull $73, {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    addl %ecx, %edx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_73:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imulq $73, %rdi, %rax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imulq $73, %rdi, %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_73:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imulq $73, %rdi, %rax # sched: [6:4.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imulq $73, %rdi, %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_73:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    imulq $73, %rdi, %rax # sched: [3:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    imulq $73, %rdi, %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_73:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imulq $73, %rdi, %rax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imulq $73, %rdi, %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 73
   ret i64 %mul
 }
 
 define i64 @test_mul_by_520(i64 %x) {
 ; X86-LABEL: test_mul_by_520:
 ; X86:       # %bb.0:
 ; X86-NEXT:    movl {{[0-9]+}}(%esp), %eax
 ; X86-NEXT:    movl %eax, %ecx
 ; X86-NEXT:    shll $9, %ecx
 ; X86-NEXT:    leal (%ecx,%eax,8), %ecx
 ; X86-NEXT:    movl $520, %eax # imm = 0x208
 ; X86-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NEXT:    addl %ecx, %edx
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_520:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    movq %rdi, %rax # sched: [1:0.25]
-; X64-HSW-NEXT:    shlq $9, %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    leaq (%rax,%rdi,8), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    movq %rdi, %rax
+; X64-HSW-NEXT:    shlq $9, %rax
+; X64-HSW-NEXT:    leaq (%rax,%rdi,8), %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_520:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    movq %rdi, %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    shlq $9, %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    leaq (%rax,%rdi,8), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    movq %rdi, %rax
+; X64-JAG-NEXT:    shlq $9, %rax
+; X64-JAG-NEXT:    leaq (%rax,%rdi,8), %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_520:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl $520, %eax # imm = 0x208
 ; X86-NOOPT-NEXT:    mull {{[0-9]+}}(%esp)
 ; X86-NOOPT-NEXT:    imull $520, {{[0-9]+}}(%esp), %ecx # imm = 0x208
 ; X86-NOOPT-NEXT:    addl %ecx, %edx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_520:
 ; HSW-NOOPT:       # %bb.0:
 ; HSW-NOOPT-NEXT:    imulq $520, %rdi, %rax # imm = 0x208
-; HSW-NOOPT-NEXT:    # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_520:
 ; JAG-NOOPT:       # %bb.0:
 ; JAG-NOOPT-NEXT:    imulq $520, %rdi, %rax # imm = 0x208
-; JAG-NOOPT-NEXT:    # sched: [6:4.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_520:
 ; X64-SLM:       # %bb.0:
 ; X64-SLM-NEXT:    imulq $520, %rdi, %rax # imm = 0x208
-; X64-SLM-NEXT:    # sched: [3:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_520:
 ; SLM-NOOPT:       # %bb.0:
 ; SLM-NOOPT-NEXT:    imulq $520, %rdi, %rax # imm = 0x208
-; SLM-NOOPT-NEXT:    # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 520
   ret i64 %mul
 }
 
 define i64 @test_mul_by_neg10(i64 %x) {
 ; X86-LABEL: test_mul_by_neg10:
 ; X86:       # %bb.0:
 ; X86-NEXT:    pushl %esi

 ; X86-NEXT:    leal (%esi,%esi,4), %ecx
 ; X86-NEXT:    subl %ecx, %edx
 ; X86-NEXT:    popl %esi
 ; X86-NEXT:    .cfi_def_cfa_offset 4
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_neg10:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    addq %rdi, %rdi # sched: [1:0.25]
-; X64-HSW-NEXT:    leaq (%rdi,%rdi,4), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    negq %rax # sched: [1:0.25]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    addq %rdi, %rdi
+; X64-HSW-NEXT:    leaq (%rdi,%rdi,4), %rax
+; X64-HSW-NEXT:    negq %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_neg10:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    addq %rdi, %rdi # sched: [1:0.50]
-; X64-JAG-NEXT:    leaq (%rdi,%rdi,4), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    negq %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    addq %rdi, %rdi
+; X64-JAG-NEXT:    leaq (%rdi,%rdi,4), %rax
+; X64-JAG-NEXT:    negq %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_neg10:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    movl $-10, %edx
 ; X86-NOOPT-NEXT:    movl %ecx, %eax
 ; X86-NOOPT-NEXT:    mull %edx
 ; X86-NOOPT-NEXT:    subl %ecx, %edx
 ; X86-NOOPT-NEXT:    imull $-10, {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    addl %ecx, %edx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_neg10:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imulq $-10, %rdi, %rax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imulq $-10, %rdi, %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_neg10:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imulq $-10, %rdi, %rax # sched: [6:4.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imulq $-10, %rdi, %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_neg10:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    addq %rdi, %rdi # sched: [1:0.50]
-; X64-SLM-NEXT:    leaq (%rdi,%rdi,4), %rax # sched: [1:1.00]
-; X64-SLM-NEXT:    negq %rax # sched: [1:0.50]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    addq %rdi, %rdi
+; X64-SLM-NEXT:    leaq (%rdi,%rdi,4), %rax
+; X64-SLM-NEXT:    negq %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_neg10:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imulq $-10, %rdi, %rax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imulq $-10, %rdi, %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, -10
   ret i64 %mul
 }
 
 define i64 @test_mul_by_neg36(i64 %x) {
 ; X86-LABEL: test_mul_by_neg36:
 ; X86:       # %bb.0:
 ; X86-NEXT:    pushl %esi

 ; X86-NEXT:    leal (%esi,%esi,8), %ecx
 ; X86-NEXT:    subl %ecx, %edx
 ; X86-NEXT:    popl %esi
 ; X86-NEXT:    .cfi_def_cfa_offset 4
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_by_neg36:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    shlq $2, %rdi # sched: [1:0.50]
-; X64-HSW-NEXT:    leaq (%rdi,%rdi,8), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    negq %rax # sched: [1:0.25]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    shlq $2, %rdi
+; X64-HSW-NEXT:    leaq (%rdi,%rdi,8), %rax
+; X64-HSW-NEXT:    negq %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_by_neg36:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    shlq $2, %rdi # sched: [1:0.50]
-; X64-JAG-NEXT:    leaq (%rdi,%rdi,8), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    negq %rax # sched: [1:0.50]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    shlq $2, %rdi
+; X64-JAG-NEXT:    leaq (%rdi,%rdi,8), %rax
+; X64-JAG-NEXT:    negq %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_by_neg36:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    movl {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    movl $-36, %edx
 ; X86-NOOPT-NEXT:    movl %ecx, %eax
 ; X86-NOOPT-NEXT:    mull %edx
 ; X86-NOOPT-NEXT:    subl %ecx, %edx
 ; X86-NOOPT-NEXT:    imull $-36, {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    addl %ecx, %edx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_by_neg36:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    imulq $-36, %rdi, %rax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    imulq $-36, %rdi, %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_by_neg36:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    imulq $-36, %rdi, %rax # sched: [6:4.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    imulq $-36, %rdi, %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_by_neg36:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    shlq $2, %rdi # sched: [1:1.00]
-; X64-SLM-NEXT:    leaq (%rdi,%rdi,8), %rax # sched: [1:1.00]
-; X64-SLM-NEXT:    negq %rax # sched: [1:0.50]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    shlq $2, %rdi
+; X64-SLM-NEXT:    leaq (%rdi,%rdi,8), %rax
+; X64-SLM-NEXT:    negq %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_by_neg36:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    imulq $-36, %rdi, %rax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    imulq $-36, %rdi, %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, -36
   ret i64 %mul
 }
 
 ; (x*9+42)*(x*5+2)
 define i64 @test_mul_spec(i64 %x) nounwind {
 ; X86-LABEL: test_mul_spec:
 ; X86:       # %bb.0:

 ; X86-NEXT:    addl %ecx, %edx
 ; X86-NEXT:    popl %esi
 ; X86-NEXT:    popl %edi
 ; X86-NEXT:    popl %ebx
 ; X86-NEXT:    retl
 ;
 ; X64-HSW-LABEL: test_mul_spec:
 ; X64-HSW:       # %bb.0:
-; X64-HSW-NEXT:    leaq (%rdi,%rdi,8), %rcx # sched: [1:0.50]
-; X64-HSW-NEXT:    addq $42, %rcx # sched: [1:0.25]
-; X64-HSW-NEXT:    leaq (%rdi,%rdi,4), %rax # sched: [1:0.50]
-; X64-HSW-NEXT:    addq $2, %rax # sched: [1:0.25]
-; X64-HSW-NEXT:    imulq %rcx, %rax # sched: [3:1.00]
-; X64-HSW-NEXT:    retq # sched: [7:1.00]
+; X64-HSW-NEXT:    leaq (%rdi,%rdi,8), %rcx
+; X64-HSW-NEXT:    addq $42, %rcx
+; X64-HSW-NEXT:    leaq (%rdi,%rdi,4), %rax
+; X64-HSW-NEXT:    addq $2, %rax
+; X64-HSW-NEXT:    imulq %rcx, %rax
+; X64-HSW-NEXT:    retq
 ;
 ; X64-JAG-LABEL: test_mul_spec:
 ; X64-JAG:       # %bb.0:
-; X64-JAG-NEXT:    leaq 42(%rdi,%rdi,8), %rcx # sched: [2:1.00]
-; X64-JAG-NEXT:    leaq 2(%rdi,%rdi,4), %rax # sched: [2:1.00]
-; X64-JAG-NEXT:    imulq %rcx, %rax # sched: [6:4.00]
-; X64-JAG-NEXT:    retq # sched: [4:1.00]
+; X64-JAG-NEXT:    leaq 42(%rdi,%rdi,8), %rcx
+; X64-JAG-NEXT:    leaq 2(%rdi,%rdi,4), %rax
+; X64-JAG-NEXT:    imulq %rcx, %rax
+; X64-JAG-NEXT:    retq
 ;
 ; X86-NOOPT-LABEL: test_mul_spec:
 ; X86-NOOPT:       # %bb.0:
 ; X86-NOOPT-NEXT:    pushl %ebx
 ; X86-NOOPT-NEXT:    pushl %edi
 ; X86-NOOPT-NEXT:    pushl %esi
 ; X86-NOOPT-NEXT:    movl {{[0-9]+}}(%esp), %ecx
 ; X86-NOOPT-NEXT:    movl {{[0-9]+}}(%esp), %edi

 ; X86-NOOPT-NEXT:    addl %ecx, %edx
 ; X86-NOOPT-NEXT:    popl %esi
 ; X86-NOOPT-NEXT:    popl %edi
 ; X86-NOOPT-NEXT:    popl %ebx
 ; X86-NOOPT-NEXT:    retl
 ;
 ; HSW-NOOPT-LABEL: test_mul_spec:
 ; HSW-NOOPT:       # %bb.0:
-; HSW-NOOPT-NEXT:    leaq (%rdi,%rdi,8), %rcx # sched: [1:0.50]
-; HSW-NOOPT-NEXT:    addq $42, %rcx # sched: [1:0.25]
-; HSW-NOOPT-NEXT:    leaq (%rdi,%rdi,4), %rax # sched: [1:0.50]
-; HSW-NOOPT-NEXT:    addq $2, %rax # sched: [1:0.25]
-; HSW-NOOPT-NEXT:    imulq %rcx, %rax # sched: [3:1.00]
-; HSW-NOOPT-NEXT:    retq # sched: [7:1.00]
+; HSW-NOOPT-NEXT:    leaq (%rdi,%rdi,8), %rcx
+; HSW-NOOPT-NEXT:    addq $42, %rcx
+; HSW-NOOPT-NEXT:    leaq (%rdi,%rdi,4), %rax
+; HSW-NOOPT-NEXT:    addq $2, %rax
+; HSW-NOOPT-NEXT:    imulq %rcx, %rax
+; HSW-NOOPT-NEXT:    retq
 ;
 ; JAG-NOOPT-LABEL: test_mul_spec:
 ; JAG-NOOPT:       # %bb.0:
-; JAG-NOOPT-NEXT:    leaq 42(%rdi,%rdi,8), %rcx # sched: [2:1.00]
-; JAG-NOOPT-NEXT:    leaq 2(%rdi,%rdi,4), %rax # sched: [2:1.00]
-; JAG-NOOPT-NEXT:    imulq %rcx, %rax # sched: [6:4.00]
-; JAG-NOOPT-NEXT:    retq # sched: [4:1.00]
+; JAG-NOOPT-NEXT:    leaq 42(%rdi,%rdi,8), %rcx
+; JAG-NOOPT-NEXT:    leaq 2(%rdi,%rdi,4), %rax
+; JAG-NOOPT-NEXT:    imulq %rcx, %rax
+; JAG-NOOPT-NEXT:    retq
 ;
 ; X64-SLM-LABEL: test_mul_spec:
 ; X64-SLM:       # %bb.0:
-; X64-SLM-NEXT:    leaq 42(%rdi,%rdi,8), %rcx # sched: [1:1.00]
-; X64-SLM-NEXT:    leaq 2(%rdi,%rdi,4), %rax # sched: [1:1.00]
-; X64-SLM-NEXT:    imulq %rcx, %rax # sched: [3:1.00]
-; X64-SLM-NEXT:    retq # sched: [4:1.00]
+; X64-SLM-NEXT:    leaq 42(%rdi,%rdi,8), %rcx
+; X64-SLM-NEXT:    leaq 2(%rdi,%rdi,4), %rax
+; X64-SLM-NEXT:    imulq %rcx, %rax
+; X64-SLM-NEXT:    retq
 ;
 ; SLM-NOOPT-LABEL: test_mul_spec:
 ; SLM-NOOPT:       # %bb.0:
-; SLM-NOOPT-NEXT:    leaq 42(%rdi,%rdi,8), %rcx # sched: [1:1.00]
-; SLM-NOOPT-NEXT:    leaq 2(%rdi,%rdi,4), %rax # sched: [1:1.00]
-; SLM-NOOPT-NEXT:    imulq %rcx, %rax # sched: [3:1.00]
-; SLM-NOOPT-NEXT:    retq # sched: [4:1.00]
+; SLM-NOOPT-NEXT:    leaq 42(%rdi,%rdi,8), %rcx
+; SLM-NOOPT-NEXT:    leaq 2(%rdi,%rdi,4), %rax
+; SLM-NOOPT-NEXT:    imulq %rcx, %rax
+; SLM-NOOPT-NEXT:    retq
   %mul = mul nsw i64 %x, 9
   %add = add nsw i64 %mul, 42
   %mul2 = mul nsw i64 %x, 5
   %add2 = add nsw i64 %mul2, 2
   %mul3 = mul nsw i64 %add, %add2
   ret i64 %mul3
 }

test/CodeGen/X86/recip-fastmath.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=+sse2     | FileCheck %s --check-prefix=CHECK --check-prefix=SSE --check-prefix=SSE-RECIP
 ; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=+avx      | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX-RECIP
 ; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=+avx,+fma | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=FMA-RECIP
-; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=bdver2 -print-schedule      | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=BDVER2
-; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=btver2 -print-schedule      | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=BTVER2
-; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=sandybridge -print-schedule | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=SANDY
-; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=haswell -print-schedule     | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=HASWELL
+; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=bdver2 | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=BDVER2
+; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=btver2 | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=BTVER2
+; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=sandybridge | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=SANDY
+; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=haswell | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=HASWELL
 ; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=haswell -mattr=-fma | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=HASWELL-NO-FMA
-; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=knl -print-schedule | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX512 --check-prefix=KNL
-; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=skx -print-schedule | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX512 --check-prefix=SKX
+; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=knl | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX512 --check-prefix=KNL
+; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=skx | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX512 --check-prefix=SKX
 
 ; If the target's divss/divps instructions are substantially
 ; slower than rcpss/rcpps with a Newton-Raphson refinement,
 ; we should generate the estimate sequence.
 
 ; See PR21385 ( http://llvm.org/bugs/show_bug.cgi?id=21385 )
 ; for details about the accuracy, speed, and implementation
 ; differences of x86 reciprocal estimates.
 
 define float @f32_no_estimate(float %x) #0 {
 ; SSE-LABEL: f32_no_estimate:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    movss {{.*#+}} xmm1 = mem[0],zero,zero,zero
 ; SSE-NEXT:    divss %xmm0, %xmm1
 ; SSE-NEXT:    movaps %xmm1, %xmm0
 ; SSE-NEXT:    retq
 ;
-; AVX-RECIP-LABEL: f32_no_estimate:
-; AVX-RECIP:       # %bb.0:
-; AVX-RECIP-NEXT:    vmovss {{.*#+}} xmm1 = mem[0],zero,zero,zero
-; AVX-RECIP-NEXT:    vdivss %xmm0, %xmm1, %xmm0
-; AVX-RECIP-NEXT:    retq
-;
-; FMA-RECIP-LABEL: f32_no_estimate:
-; FMA-RECIP:       # %bb.0:
-; FMA-RECIP-NEXT:    vmovss {{.*#+}} xmm1 = mem[0],zero,zero,zero
-; FMA-RECIP-NEXT:    vdivss %xmm0, %xmm1, %xmm0
-; FMA-RECIP-NEXT:    retq
-;
-; BDVER2-LABEL: f32_no_estimate:
-; BDVER2:       # %bb.0:
-; BDVER2-NEXT:    vmovss {{.*#+}} xmm1 = mem[0],zero,zero,zero sched: [5:0.50]
-; BDVER2-NEXT:    vdivss %xmm0, %xmm1, %xmm0 # sched: [9:9.50]
-; BDVER2-NEXT:    retq # sched: [5:1.00]
-;
-; BTVER2-LABEL: f32_no_estimate:
-; BTVER2:       # %bb.0:
-; BTVER2-NEXT:    vmovss {{.*#+}} xmm1 = mem[0],zero,zero,zero sched: [5:1.00]
-; BTVER2-NEXT:    vdivss %xmm0, %xmm1, %xmm0 # sched: [19:19.00]
-; BTVER2-NEXT:    retq # sched: [4:1.00]
-;
-; SANDY-LABEL: f32_no_estimate:
-; SANDY:       # %bb.0:
-; SANDY-NEXT:    vmovss {{.*#+}} xmm1 = mem[0],zero,zero,zero sched: [6:0.50]
-; SANDY-NEXT:    vdivss %xmm0, %xmm1, %xmm0 # sched: [14:14.00]
-; SANDY-NEXT:    retq # sched: [1:1.00]
-;
-; HASWELL-LABEL: f32_no_estimate:
-; HASWELL:       # %bb.0:
-; HASWELL-NEXT:    vmovss {{.*#+}} xmm1 = mem[0],zero,zero,zero sched: [5:0.50]
-; HASWELL-NEXT:    vdivss %xmm0, %xmm1, %xmm0 # sched: [13:7.00]
-; HASWELL-NEXT:    retq # sched: [7:1.00]
-;
-; HASWELL-NO-FMA-LABEL: f32_no_estimate:
-; HASWELL-NO-FMA:       # %bb.0:
-; HASWELL-NO-FMA-NEXT:    vmovss {{.*#+}} xmm1 = mem[0],zero,zero,zero
-; HASWELL-NO-FMA-NEXT:    vdivss %xmm0, %xmm1, %xmm0
-; HASWELL-NO-FMA-NEXT:    retq
-;
-; KNL-LABEL: f32_no_estimate:
-; KNL:       # %bb.0:
-; KNL-NEXT:    vmovss {{.*#+}} xmm1 = mem[0],zero,zero,zero sched: [5:0.50]
-; KNL-NEXT:    vdivss %xmm0, %xmm1, %xmm0 # sched: [13:7.00]
-; KNL-NEXT:    retq # sched: [7:1.00]
-;
-; SKX-LABEL: f32_no_estimate:
-; SKX:       # %bb.0:
-; SKX-NEXT:    vmovss {{.*#+}} xmm1 = mem[0],zero,zero,zero sched: [5:0.50]
-; SKX-NEXT:    vdivss %xmm0, %xmm1, %xmm0 # sched: [11:3.00]
-; SKX-NEXT:    retq # sched: [7:1.00]
+; AVX-LABEL: f32_no_estimate:
+; AVX:       # %bb.0:
+; AVX-NEXT:    vmovss {{.*#+}} xmm1 = mem[0],zero,zero,zero
+; AVX-NEXT:    vdivss %xmm0, %xmm1, %xmm0
+; AVX-NEXT:    retq
   %div = fdiv fast float 1.0, %x
   ret float %div
 }
 
 define float @f32_one_step(float %x) #1 {
 ; SSE-LABEL: f32_one_step:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    rcpss %xmm0, %xmm2

 ; FMA-RECIP:       # %bb.0:
 ; FMA-RECIP-NEXT:    vrcpss %xmm0, %xmm0, %xmm1
 ; FMA-RECIP-NEXT:    vfnmadd213ss {{.*#+}} xmm0 = -(xmm1 * xmm0) + mem
 ; FMA-RECIP-NEXT:    vfmadd132ss {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1
 ; FMA-RECIP-NEXT:    retq
 ;
 ; BDVER2-LABEL: f32_one_step:
 ; BDVER2:       # %bb.0:
-; BDVER2-NEXT:    vrcpss %xmm0, %xmm0, %xmm1 # sched: [5:1.00]
-; BDVER2-NEXT:    vfnmaddss {{.*}}(%rip), %xmm1, %xmm0, %xmm0 # sched: [10:0.50]
-; BDVER2-NEXT:    vfmaddss %xmm1, %xmm0, %xmm1, %xmm0 # sched: [5:0.50]
-; BDVER2-NEXT:    retq # sched: [5:1.00]
+; BDVER2-NEXT:    vrcpss %xmm0, %xmm0, %xmm1
+; BDVER2-NEXT:    vfnmaddss {{.*}}(%rip), %xmm1, %xmm0, %xmm0
+; BDVER2-NEXT:    vfmaddss %xmm1, %xmm0, %xmm1, %xmm0
+; BDVER2-NEXT:    retq
 ;
 ; BTVER2-LABEL: f32_one_step:
 ; BTVER2:       # %bb.0:
-; BTVER2-NEXT:    vmovss {{.*#+}} xmm2 = mem[0],zero,zero,zero sched: [5:1.00]
-; BTVER2-NEXT:    vrcpss %xmm0, %xmm0, %xmm1 # sched: [2:1.00]
-; BTVER2-NEXT:    vmulss %xmm1, %xmm0, %xmm0 # sched: [2:1.00]
-; BTVER2-NEXT:    vsubss %xmm0, %xmm2, %xmm0 # sched: [3:1.00]
-; BTVER2-NEXT:    vmulss %xmm0, %xmm1, %xmm0 # sched: [2:1.00]
-; BTVER2-NEXT:    vaddss %xmm0, %xmm1, %xmm0 # sched: [3:1.00]
-; BTVER2-NEXT:    retq # sched: [4:1.00]
+; BTVER2-NEXT:    vmovss {{.*#+}} xmm2 = mem[0],zero,zero,zero
+; BTVER2-NEXT:    vrcpss %xmm0, %xmm0, %xmm1
+; BTVER2-NEXT:    vmulss %xmm1, %xmm0, %xmm0
+; BTVER2-NEXT:    vsubss %xmm0, %xmm2, %xmm0
+; BTVER2-NEXT:    vmulss %xmm0, %xmm1, %xmm0
+; BTVER2-NEXT:    vaddss %xmm0, %xmm1, %xmm0
+; BTVER2-NEXT:    retq
 ;
 ; SANDY-LABEL: f32_one_step:
 ; SANDY:       # %bb.0:
-; SANDY-NEXT:    vrcpss %xmm0, %xmm0, %xmm1 # sched: [5:1.00]
-; SANDY-NEXT:    vmulss %xmm1, %xmm0, %xmm0 # sched: [5:1.00]
-; SANDY-NEXT:    vmovss {{.*#+}} xmm2 = mem[0],zero,zero,zero sched: [6:0.50]
-; SANDY-NEXT:    vsubss %xmm0, %xmm2, %xmm0 # sched: [3:1.00]
-; SANDY-NEXT:    vmulss %xmm0, %xmm1, %xmm0 # sched: [5:1.00]
-; SANDY-NEXT:    vaddss %xmm0, %xmm1, %xmm0 # sched: [3:1.00]
-; SANDY-NEXT:    retq # sched: [1:1.00]
+; SANDY-NEXT:    vrcpss %xmm0, %xmm0, %xmm1
+; SANDY-NEXT:    vmulss %xmm1, %xmm0, %xmm0
+; SANDY-NEXT:    vmovss {{.*#+}} xmm2 = mem[0],zero,zero,zero
+; SANDY-NEXT:    vsubss %xmm0, %xmm2, %xmm0
+; SANDY-NEXT:    vmulss %xmm0, %xmm1, %xmm0
+; SANDY-NEXT:    vaddss %xmm0, %xmm1, %xmm0
+; SANDY-NEXT:    retq
 ;
 ; HASWELL-LABEL: f32_one_step:
 ; HASWELL:       # %bb.0:
-; HASWELL-NEXT:    vrcpss %xmm0, %xmm0, %xmm1 # sched: [5:1.00]
-; HASWELL-NEXT:    vfnmadd213ss {{.*#+}} xmm0 = -(xmm1 * xmm0) + mem sched: [10:0.50]
-; HASWELL-NEXT:    vfmadd132ss {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1 sched: [5:0.50]
-; HASWELL-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NEXT:    vrcpss %xmm0, %xmm0, %xmm1
+; HASWELL-NEXT:    vfnmadd213ss {{.*#+}} xmm0 = -(xmm1 * xmm0) + mem
+; HASWELL-NEXT:    vfmadd132ss {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1
+; HASWELL-NEXT:    retq
 ;
 ; HASWELL-NO-FMA-LABEL: f32_one_step:
 ; HASWELL-NO-FMA:       # %bb.0:
 ; HASWELL-NO-FMA-NEXT:    vrcpss %xmm0, %xmm0, %xmm1
 ; HASWELL-NO-FMA-NEXT:    vmulss %xmm1, %xmm0, %xmm0
 ; HASWELL-NO-FMA-NEXT:    vmovss {{.*#+}} xmm2 = mem[0],zero,zero,zero
 ; HASWELL-NO-FMA-NEXT:    vsubss %xmm0, %xmm2, %xmm0
 ; HASWELL-NO-FMA-NEXT:    vmulss %xmm0, %xmm1, %xmm0
 ; HASWELL-NO-FMA-NEXT:    vaddss %xmm0, %xmm1, %xmm0
 ; HASWELL-NO-FMA-NEXT:    retq
 ;
-; KNL-LABEL: f32_one_step:
-; KNL:       # %bb.0:
-; KNL-NEXT:    vrcpss %xmm0, %xmm0, %xmm1 # sched: [5:1.00]
-; KNL-NEXT:    vfnmadd213ss {{.*#+}} xmm0 = -(xmm1 * xmm0) + mem sched: [10:0.50]
-; KNL-NEXT:    vfmadd132ss {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1 sched: [5:0.50]
-; KNL-NEXT:    retq # sched: [7:1.00]
-;
-; SKX-LABEL: f32_one_step:
-; SKX:       # %bb.0:
-; SKX-NEXT:    vrcpss %xmm0, %xmm0, %xmm1 # sched: [4:1.00]
-; SKX-NEXT:    vfnmadd213ss {{.*#+}} xmm0 = -(xmm1 * xmm0) + mem sched: [9:0.50]
-; SKX-NEXT:    vfmadd132ss {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1 sched: [4:0.50]
-; SKX-NEXT:    retq # sched: [7:1.00]
+; AVX512-LABEL: f32_one_step:
+; AVX512:       # %bb.0:
+; AVX512-NEXT:    vrcpss %xmm0, %xmm0, %xmm1
+; AVX512-NEXT:    vfnmadd213ss {{.*#+}} xmm0 = -(xmm1 * xmm0) + mem
+; AVX512-NEXT:    vfmadd132ss {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1
+; AVX512-NEXT:    retq
   %div = fdiv fast float 1.0, %x
   ret float %div
 }
 
 define float @f32_two_step(float %x) #2 {
 ; SSE-LABEL: f32_two_step:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    rcpss %xmm0, %xmm2

 ; FMA-RECIP-NEXT:    vfnmadd213ss {{.*#+}} xmm3 = -(xmm0 * xmm3) + xmm2
 ; FMA-RECIP-NEXT:    vfmadd132ss {{.*#+}} xmm3 = (xmm3 * xmm1) + xmm1
 ; FMA-RECIP-NEXT:    vfnmadd213ss {{.*#+}} xmm0 = -(xmm3 * xmm0) + xmm2
 ; FMA-RECIP-NEXT:    vfmadd132ss {{.*#+}} xmm0 = (xmm0 * xmm3) + xmm3
 ; FMA-RECIP-NEXT:    retq
 ;
 ; BDVER2-LABEL: f32_two_step:
 ; BDVER2:       # %bb.0:
-; BDVER2-NEXT:    vrcpss %xmm0, %xmm0, %xmm1 # sched: [5:1.00]
-; BDVER2-NEXT:    vmovss {{.*#+}} xmm2 = mem[0],zero,zero,zero sched: [5:0.50]
-; BDVER2-NEXT:    vfnmaddss %xmm2, %xmm1, %xmm0, %xmm3 # sched: [5:0.50]
-; BDVER2-NEXT:    vfmaddss %xmm1, %xmm3, %xmm1, %xmm1 # sched: [5:0.50]
-; BDVER2-NEXT:    vfnmaddss %xmm2, %xmm1, %xmm0, %xmm0 # sched: [5:0.50]
-; BDVER2-NEXT:    vfmaddss %xmm1, %xmm0, %xmm1, %xmm0 # sched: [5:0.50]
-; BDVER2-NEXT:    retq # sched: [5:1.00]
+; BDVER2-NEXT:    vrcpss %xmm0, %xmm0, %xmm1
+; BDVER2-NEXT:    vmovss {{.*#+}} xmm2 = mem[0],zero,zero,zero
+; BDVER2-NEXT:    vfnmaddss %xmm2, %xmm1, %xmm0, %xmm3
+; BDVER2-NEXT:    vfmaddss %xmm1, %xmm3, %xmm1, %xmm1
+; BDVER2-NEXT:    vfnmaddss %xmm2, %xmm1, %xmm0, %xmm0
+; BDVER2-NEXT:    vfmaddss %xmm1, %xmm0, %xmm1, %xmm0
+; BDVER2-NEXT:    retq
 ;
 ; BTVER2-LABEL: f32_two_step:
 ; BTVER2:       # %bb.0:
-; BTVER2-NEXT:    vmovss {{.*#+}} xmm3 = mem[0],zero,zero,zero sched: [5:1.00]
-; BTVER2-NEXT:    vrcpss %xmm0, %xmm0, %xmm1 # sched: [2:1.00]
-; BTVER2-NEXT:    vmulss %xmm1, %xmm0, %xmm2 # sched: [2:1.00]
-; BTVER2-NEXT:    vsubss %xmm2, %xmm3, %xmm2 # sched: [3:1.00]
-; BTVER2-NEXT:    vmulss %xmm2, %xmm1, %xmm2 # sched: [2:1.00]
-; BTVER2-NEXT:    vaddss %xmm2, %xmm1, %xmm1 # sched: [3:1.00]
-; BTVER2-NEXT:    vmulss %xmm1, %xmm0, %xmm0 # sched: [2:1.00]
-; BTVER2-NEXT:    vsubss %xmm0, %xmm3, %xmm0 # sched: [3:1.00]
-; BTVER2-NEXT:    vmulss %xmm0, %xmm1, %xmm0 # sched: [2:1.00]
-; BTVER2-NEXT:    vaddss %xmm0, %xmm1, %xmm0 # sched: [3:1.00]
-; BTVER2-NEXT:    retq # sched: [4:1.00]
+; BTVER2-NEXT:    vmovss {{.*#+}} xmm3 = mem[0],zero,zero,zero
+; BTVER2-NEXT:    vrcpss %xmm0, %xmm0, %xmm1
+; BTVER2-NEXT:    vmulss %xmm1, %xmm0, %xmm2
+; BTVER2-NEXT:    vsubss %xmm2, %xmm3, %xmm2
+; BTVER2-NEXT:    vmulss %xmm2, %xmm1, %xmm2
+; BTVER2-NEXT:    vaddss %xmm2, %xmm1, %xmm1
+; BTVER2-NEXT:    vmulss %xmm1, %xmm0, %xmm0
+; BTVER2-NEXT:    vsubss %xmm0, %xmm3, %xmm0
+; BTVER2-NEXT:    vmulss %xmm0, %xmm1, %xmm0
+; BTVER2-NEXT:    vaddss %xmm0, %xmm1, %xmm0
+; BTVER2-NEXT:    retq
 ;
 ; SANDY-LABEL: f32_two_step:
 ; SANDY:       # %bb.0:
-; SANDY-NEXT:    vrcpss %xmm0, %xmm0, %xmm1 # sched: [5:1.00]
-; SANDY-NEXT:    vmulss %xmm1, %xmm0, %xmm2 # sched: [5:1.00]
-; SANDY-NEXT:    vmovss {{.*#+}} xmm3 = mem[0],zero,zero,zero sched: [6:0.50]
-; SANDY-NEXT:    vsubss %xmm2, %xmm3, %xmm2 # sched: [3:1.00]
-; SANDY-NEXT:    vmulss %xmm2, %xmm1, %xmm2 # sched: [5:1.00]
-; SANDY-NEXT:    vaddss %xmm2, %xmm1, %xmm1 # sched: [3:1.00]
-; SANDY-NEXT:    vmulss %xmm1, %xmm0, %xmm0 # sched: [5:1.00]
-; SANDY-NEXT:    vsubss %xmm0, %xmm3, %xmm0 # sched: [3:1.00]
-; SANDY-NEXT:    vmulss %xmm0, %xmm1, %xmm0 # sched: [5:1.00]
-; SANDY-NEXT:    vaddss %xmm0, %xmm1, %xmm0 # sched: [3:1.00]
-; SANDY-NEXT:    retq # sched: [1:1.00]
+; SANDY-NEXT:    vrcpss %xmm0, %xmm0, %xmm1
+; SANDY-NEXT:    vmulss %xmm1, %xmm0, %xmm2
+; SANDY-NEXT:    vmovss {{.*#+}} xmm3 = mem[0],zero,zero,zero
+; SANDY-NEXT:    vsubss %xmm2, %xmm3, %xmm2
+; SANDY-NEXT:    vmulss %xmm2, %xmm1, %xmm2
+; SANDY-NEXT:    vaddss %xmm2, %xmm1, %xmm1
+; SANDY-NEXT:    vmulss %xmm1, %xmm0, %xmm0
+; SANDY-NEXT:    vsubss %xmm0, %xmm3, %xmm0
+; SANDY-NEXT:    vmulss %xmm0, %xmm1, %xmm0
+; SANDY-NEXT:    vaddss %xmm0, %xmm1, %xmm0
+; SANDY-NEXT:    retq
 ;
 ; HASWELL-LABEL: f32_two_step:
 ; HASWELL:       # %bb.0:
-; HASWELL-NEXT:    vrcpss %xmm0, %xmm0, %xmm1 # sched: [5:1.00]
-; HASWELL-NEXT:    vmovss {{.*#+}} xmm2 = mem[0],zero,zero,zero sched: [5:0.50]
-; HASWELL-NEXT:    vmovaps %xmm1, %xmm3 # sched: [1:1.00]
-; HASWELL-NEXT:    vfnmadd213ss {{.*#+}} xmm3 = -(xmm0 * xmm3) + xmm2 sched: [5:0.50]
-; HASWELL-NEXT:    vfmadd132ss {{.*#+}} xmm3 = (xmm3 * xmm1) + xmm1 sched: [5:0.50]
-; HASWELL-NEXT:    vfnmadd213ss {{.*#+}} xmm0 = -(xmm3 * xmm0) + xmm2 sched: [5:0.50]
-; HASWELL-NEXT:    vfmadd132ss {{.*#+}} xmm0 = (xmm0 * xmm3) + xmm3 sched: [5:0.50]
-; HASWELL-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NEXT:    vrcpss %xmm0, %xmm0, %xmm1
+; HASWELL-NEXT:    vmovss {{.*#+}} xmm2 = mem[0],zero,zero,zero
+; HASWELL-NEXT:    vmovaps %xmm1, %xmm3
+; HASWELL-NEXT:    vfnmadd213ss {{.*#+}} xmm3 = -(xmm0 * xmm3) + xmm2
+; HASWELL-NEXT:    vfmadd132ss {{.*#+}} xmm3 = (xmm3 * xmm1) + xmm1
+; HASWELL-NEXT:    vfnmadd213ss {{.*#+}} xmm0 = -(xmm3 * xmm0) + xmm2
+; HASWELL-NEXT:    vfmadd132ss {{.*#+}} xmm0 = (xmm0 * xmm3) + xmm3
+; HASWELL-NEXT:    retq
 ;
 ; HASWELL-NO-FMA-LABEL: f32_two_step:
 ; HASWELL-NO-FMA:       # %bb.0:
 ; HASWELL-NO-FMA-NEXT:    vrcpss %xmm0, %xmm0, %xmm1
 ; HASWELL-NO-FMA-NEXT:    vmulss %xmm1, %xmm0, %xmm2
 ; HASWELL-NO-FMA-NEXT:    vmovss {{.*#+}} xmm3 = mem[0],zero,zero,zero
 ; HASWELL-NO-FMA-NEXT:    vsubss %xmm2, %xmm3, %xmm2
 ; HASWELL-NO-FMA-NEXT:    vmulss %xmm2, %xmm1, %xmm2
 ; HASWELL-NO-FMA-NEXT:    vaddss %xmm2, %xmm1, %xmm1
 ; HASWELL-NO-FMA-NEXT:    vmulss %xmm1, %xmm0, %xmm0
 ; HASWELL-NO-FMA-NEXT:    vsubss %xmm0, %xmm3, %xmm0
 ; HASWELL-NO-FMA-NEXT:    vmulss %xmm0, %xmm1, %xmm0
 ; HASWELL-NO-FMA-NEXT:    vaddss %xmm0, %xmm1, %xmm0
 ; HASWELL-NO-FMA-NEXT:    retq
 ;
-; KNL-LABEL: f32_two_step:
-; KNL:       # %bb.0:
-; KNL-NEXT:    vrcpss %xmm0, %xmm0, %xmm1 # sched: [5:1.00]
-; KNL-NEXT:    vmovss {{.*#+}} xmm2 = mem[0],zero,zero,zero sched: [5:0.50]
-; KNL-NEXT:    vmovaps %xmm1, %xmm3 # sched: [1:1.00]
-; KNL-NEXT:    vfnmadd213ss {{.*#+}} xmm3 = -(xmm0 * xmm3) + xmm2 sched: [5:0.50]
-; KNL-NEXT:    vfmadd132ss {{.*#+}} xmm3 = (xmm3 * xmm1) + xmm1 sched: [5:0.50]
-; KNL-NEXT:    vfnmadd213ss {{.*#+}} xmm0 = -(xmm3 * xmm0) + xmm2 sched: [5:0.50]
-; KNL-NEXT:    vfmadd132ss {{.*#+}} xmm0 = (xmm0 * xmm3) + xmm3 sched: [5:0.50]
-; KNL-NEXT:    retq # sched: [7:1.00]
-;
-; SKX-LABEL: f32_two_step:
-; SKX:       # %bb.0:
-; SKX-NEXT:    vrcpss %xmm0, %xmm0, %xmm1 # sched: [4:1.00]
-; SKX-NEXT:    vmovss {{.*#+}} xmm2 = mem[0],zero,zero,zero sched: [5:0.50]
-; SKX-NEXT:    vmovaps %xmm1, %xmm3 # sched: [1:0.33]
-; SKX-NEXT:    vfnmadd213ss {{.*#+}} xmm3 = -(xmm0 * xmm3) + xmm2 sched: [4:0.50]
-; SKX-NEXT:    vfmadd132ss {{.*#+}} xmm3 = (xmm3 * xmm1) + xmm1 sched: [4:0.50]
-; SKX-NEXT:    vfnmadd213ss {{.*#+}} xmm0 = -(xmm3 * xmm0) + xmm2 sched: [4:0.50]
-; SKX-NEXT:    vfmadd132ss {{.*#+}} xmm0 = (xmm0 * xmm3) + xmm3 sched: [4:0.50]
-; SKX-NEXT:    retq # sched: [7:1.00]
+; AVX512-LABEL: f32_two_step:
+; AVX512:       # %bb.0:
+; AVX512-NEXT:    vrcpss %xmm0, %xmm0, %xmm1
+; AVX512-NEXT:    vmovss {{.*#+}} xmm2 = mem[0],zero,zero,zero
+; AVX512-NEXT:    vmovaps %xmm1, %xmm3
+; AVX512-NEXT:    vfnmadd213ss {{.*#+}} xmm3 = -(xmm0 * xmm3) + xmm2
+; AVX512-NEXT:    vfmadd132ss {{.*#+}} xmm3 = (xmm3 * xmm1) + xmm1
+; AVX512-NEXT:    vfnmadd213ss {{.*#+}} xmm0 = -(xmm3 * xmm0) + xmm2
+; AVX512-NEXT:    vfmadd132ss {{.*#+}} xmm0 = (xmm0 * xmm3) + xmm3
+; AVX512-NEXT:    retq
   %div = fdiv fast float 1.0, %x
   ret float %div
 }
 
 define <4 x float> @v4f32_no_estimate(<4 x float> %x) #0 {
 ; SSE-LABEL: v4f32_no_estimate:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    movaps {{.*#+}} xmm1 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]

 ; FMA-RECIP-LABEL: v4f32_no_estimate:
 ; FMA-RECIP:       # %bb.0:
 ; FMA-RECIP-NEXT:    vmovaps {{.*#+}} xmm1 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]
 ; FMA-RECIP-NEXT:    vdivps %xmm0, %xmm1, %xmm0
 ; FMA-RECIP-NEXT:    retq
 ;
 ; BDVER2-LABEL: v4f32_no_estimate:
 ; BDVER2:       # %bb.0:
-; BDVER2-NEXT:    vmovaps {{.*#+}} xmm1 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [5:0.50]
-; BDVER2-NEXT:    vdivps %xmm0, %xmm1, %xmm0 # sched: [9:9.50]
-; BDVER2-NEXT:    retq # sched: [5:1.00]
+; BDVER2-NEXT:    vmovaps {{.*#+}} xmm1 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; BDVER2-NEXT:    vdivps %xmm0, %xmm1, %xmm0
+; BDVER2-NEXT:    retq
 ;
 ; BTVER2-LABEL: v4f32_no_estimate:
 ; BTVER2:       # %bb.0:
-; BTVER2-NEXT:    vmovaps {{.*#+}} xmm1 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [5:1.00]
-; BTVER2-NEXT:    vdivps %xmm0, %xmm1, %xmm0 # sched: [19:19.00]
-; BTVER2-NEXT:    retq # sched: [4:1.00]
+; BTVER2-NEXT:    vmovaps {{.*#+}} xmm1 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; BTVER2-NEXT:    vdivps %xmm0, %xmm1, %xmm0
+; BTVER2-NEXT:    retq
 ;
 ; SANDY-LABEL: v4f32_no_estimate:
 ; SANDY:       # %bb.0:
-; SANDY-NEXT:    vmovaps {{.*#+}} xmm1 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [6:0.50]
-; SANDY-NEXT:    vdivps %xmm0, %xmm1, %xmm0 # sched: [14:14.00]
-; SANDY-NEXT:    retq # sched: [1:1.00]
+; SANDY-NEXT:    vmovaps {{.*#+}} xmm1 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; SANDY-NEXT:    vdivps %xmm0, %xmm1, %xmm0
+; SANDY-NEXT:    retq
 ;
 ; HASWELL-LABEL: v4f32_no_estimate:
 ; HASWELL:       # %bb.0:
-; HASWELL-NEXT:    vbroadcastss {{.*#+}} xmm1 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [6:0.50]
-; HASWELL-NEXT:    vdivps %xmm0, %xmm1, %xmm0 # sched: [13:7.00]
-; HASWELL-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NEXT:    vbroadcastss {{.*#+}} xmm1 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; HASWELL-NEXT:    vdivps %xmm0, %xmm1, %xmm0
+; HASWELL-NEXT:    retq
 ;
 ; HASWELL-NO-FMA-LABEL: v4f32_no_estimate:
 ; HASWELL-NO-FMA:       # %bb.0:
 ; HASWELL-NO-FMA-NEXT:    vbroadcastss {{.*#+}} xmm1 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]
 ; HASWELL-NO-FMA-NEXT:    vdivps %xmm0, %xmm1, %xmm0
 ; HASWELL-NO-FMA-NEXT:    retq
 ;
-; KNL-LABEL: v4f32_no_estimate:
-; KNL:       # %bb.0:
-; KNL-NEXT:    vbroadcastss {{.*#+}} xmm1 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [6:0.50]
-; KNL-NEXT:    vdivps %xmm0, %xmm1, %xmm0 # sched: [13:7.00]
-; KNL-NEXT:    retq # sched: [7:1.00]
-;
-; SKX-LABEL: v4f32_no_estimate:
-; SKX:       # %bb.0:
-; SKX-NEXT:    vbroadcastss {{.*#+}} xmm1 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [6:0.50]
-; SKX-NEXT:    vdivps %xmm0, %xmm1, %xmm0 # sched: [11:3.00]
-; SKX-NEXT:    retq # sched: [7:1.00]
+; AVX512-LABEL: v4f32_no_estimate:
+; AVX512:       # %bb.0:
+; AVX512-NEXT:    vbroadcastss {{.*#+}} xmm1 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; AVX512-NEXT:    vdivps %xmm0, %xmm1, %xmm0
+; AVX512-NEXT:    retq
   %div = fdiv fast <4 x float> <float 1.0, float 1.0, float 1.0, float 1.0>, %x
   ret <4 x float> %div
 }
 
 define <4 x float> @v4f32_one_step(<4 x float> %x) #1 {
 ; SSE-LABEL: v4f32_one_step:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    rcpps %xmm0, %xmm2

 ; FMA-RECIP:       # %bb.0:
 ; FMA-RECIP-NEXT:    vrcpps %xmm0, %xmm1
 ; FMA-RECIP-NEXT:    vfnmadd213ps {{.*#+}} xmm0 = -(xmm1 * xmm0) + mem
 ; FMA-RECIP-NEXT:    vfmadd132ps {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1
 ; FMA-RECIP-NEXT:    retq
 ;
 ; BDVER2-LABEL: v4f32_one_step:
 ; BDVER2:       # %bb.0:
-; BDVER2-NEXT:    vrcpps %xmm0, %xmm1 # sched: [5:1.00]
-; BDVER2-NEXT:    vfnmaddps {{.*}}(%rip), %xmm1, %xmm0, %xmm0 # sched: [10:0.50]
-; BDVER2-NEXT:    vfmaddps %xmm1, %xmm0, %xmm1, %xmm0 # sched: [5:0.50]
-; BDVER2-NEXT:    retq # sched: [5:1.00]
+; BDVER2-NEXT:    vrcpps %xmm0, %xmm1
+; BDVER2-NEXT:    vfnmaddps {{.*}}(%rip), %xmm1, %xmm0, %xmm0
+; BDVER2-NEXT:    vfmaddps %xmm1, %xmm0, %xmm1, %xmm0
+; BDVER2-NEXT:    retq
 ;
 ; BTVER2-LABEL: v4f32_one_step:
 ; BTVER2:       # %bb.0:
-; BTVER2-NEXT:    vmovaps {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [5:1.00]
-; BTVER2-NEXT:    vrcpps %xmm0, %xmm1 # sched: [2:1.00]
-; BTVER2-NEXT:    vmulps %xmm1, %xmm0, %xmm0 # sched: [2:1.00]
-; BTVER2-NEXT:    vsubps %xmm0, %xmm2, %xmm0 # sched: [3:1.00]
-; BTVER2-NEXT:    vmulps %xmm0, %xmm1, %xmm0 # sched: [2:1.00]
-; BTVER2-NEXT:    vaddps %xmm0, %xmm1, %xmm0 # sched: [3:1.00]
-; BTVER2-NEXT:    retq # sched: [4:1.00]
+; BTVER2-NEXT:    vmovaps {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; BTVER2-NEXT:    vrcpps %xmm0, %xmm1
+; BTVER2-NEXT:    vmulps %xmm1, %xmm0, %xmm0
+; BTVER2-NEXT:    vsubps %xmm0, %xmm2, %xmm0
+; BTVER2-NEXT:    vmulps %xmm0, %xmm1, %xmm0
+; BTVER2-NEXT:    vaddps %xmm0, %xmm1, %xmm0
+; BTVER2-NEXT:    retq
 ;
 ; SANDY-LABEL: v4f32_one_step:
 ; SANDY:       # %bb.0:
-; SANDY-NEXT:    vrcpps %xmm0, %xmm1 # sched: [5:1.00]
-; SANDY-NEXT:    vmulps %xmm1, %xmm0, %xmm0 # sched: [5:1.00]
-; SANDY-NEXT:    vmovaps {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [6:0.50]
-; SANDY-NEXT:    vsubps %xmm0, %xmm2, %xmm0 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %xmm0, %xmm1, %xmm0 # sched: [5:1.00]
-; SANDY-NEXT:    vaddps %xmm0, %xmm1, %xmm0 # sched: [3:1.00]
-; SANDY-NEXT:    retq # sched: [1:1.00]
+; SANDY-NEXT:    vrcpps %xmm0, %xmm1
+; SANDY-NEXT:    vmulps %xmm1, %xmm0, %xmm0
+; SANDY-NEXT:    vmovaps {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; SANDY-NEXT:    vsubps %xmm0, %xmm2, %xmm0
+; SANDY-NEXT:    vmulps %xmm0, %xmm1, %xmm0
+; SANDY-NEXT:    vaddps %xmm0, %xmm1, %xmm0
+; SANDY-NEXT:    retq
 ;
 ; HASWELL-LABEL: v4f32_one_step:
 ; HASWELL:       # %bb.0:
-; HASWELL-NEXT:    vrcpps %xmm0, %xmm1 # sched: [5:1.00]
-; HASWELL-NEXT:    vbroadcastss {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [6:0.50]
-; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} xmm0 = -(xmm1 * xmm0) + xmm2 sched: [5:0.50]
-; HASWELL-NEXT:    vfmadd132ps {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1 sched: [5:0.50]
-; HASWELL-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NEXT:    vrcpps %xmm0, %xmm1
+; HASWELL-NEXT:    vbroadcastss {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} xmm0 = -(xmm1 * xmm0) + xmm2
+; HASWELL-NEXT:    vfmadd132ps {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1
+; HASWELL-NEXT:    retq
 ;
 ; HASWELL-NO-FMA-LABEL: v4f32_one_step:
 ; HASWELL-NO-FMA:       # %bb.0:
 ; HASWELL-NO-FMA-NEXT:    vrcpps %xmm0, %xmm1
 ; HASWELL-NO-FMA-NEXT:    vmulps %xmm1, %xmm0, %xmm0
 ; HASWELL-NO-FMA-NEXT:    vbroadcastss {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]
 ; HASWELL-NO-FMA-NEXT:    vsubps %xmm0, %xmm2, %xmm0
 ; HASWELL-NO-FMA-NEXT:    vmulps %xmm0, %xmm1, %xmm0
 ; HASWELL-NO-FMA-NEXT:    vaddps %xmm0, %xmm1, %xmm0
 ; HASWELL-NO-FMA-NEXT:    retq
 ;
 ; KNL-LABEL: v4f32_one_step:
 ; KNL:       # %bb.0:
-; KNL-NEXT:    vrcpps %xmm0, %xmm1 # sched: [5:1.00]
-; KNL-NEXT:    vbroadcastss {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [6:0.50]
-; KNL-NEXT:    vfnmadd213ps {{.*#+}} xmm0 = -(xmm1 * xmm0) + xmm2 sched: [5:0.50]
-; KNL-NEXT:    vfmadd132ps {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1 sched: [5:0.50]
-; KNL-NEXT:    retq # sched: [7:1.00]
+; KNL-NEXT:    vrcpps %xmm0, %xmm1
+; KNL-NEXT:    vbroadcastss {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; KNL-NEXT:    vfnmadd213ps {{.*#+}} xmm0 = -(xmm1 * xmm0) + xmm2
+; KNL-NEXT:    vfmadd132ps {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1
+; KNL-NEXT:    retq
 ;
 ; SKX-LABEL: v4f32_one_step:
 ; SKX:       # %bb.0:
-; SKX-NEXT:    vrcpps %xmm0, %xmm1 # sched: [4:1.00]
-; SKX-NEXT:    vfnmadd213ps {{.*#+}} xmm0 = -(xmm1 * xmm0) + mem sched: [10:0.50]
-; SKX-NEXT:    vfmadd132ps {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1 sched: [4:0.50]
-; SKX-NEXT:    retq # sched: [7:1.00]
+; SKX-NEXT:    vrcpps %xmm0, %xmm1
+; SKX-NEXT:    vfnmadd213ps {{.*#+}} xmm0 = -(xmm1 * xmm0) + mem
+; SKX-NEXT:    vfmadd132ps {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1
+; SKX-NEXT:    retq
   %div = fdiv fast <4 x float> <float 1.0, float 1.0, float 1.0, float 1.0>, %x
   ret <4 x float> %div
 }
 
 define <4 x float> @v4f32_two_step(<4 x float> %x) #2 {
 ; SSE-LABEL: v4f32_two_step:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    rcpps %xmm0, %xmm2

 ; FMA-RECIP-NEXT:    vfnmadd213ps {{.*#+}} xmm3 = -(xmm0 * xmm3) + xmm2
 ; FMA-RECIP-NEXT:    vfmadd132ps {{.*#+}} xmm3 = (xmm3 * xmm1) + xmm1
 ; FMA-RECIP-NEXT:    vfnmadd213ps {{.*#+}} xmm0 = -(xmm3 * xmm0) + xmm2
 ; FMA-RECIP-NEXT:    vfmadd132ps {{.*#+}} xmm0 = (xmm0 * xmm3) + xmm3
 ; FMA-RECIP-NEXT:    retq
 ;
 ; BDVER2-LABEL: v4f32_two_step:
 ; BDVER2:       # %bb.0:
-; BDVER2-NEXT:    vrcpps %xmm0, %xmm1 # sched: [5:1.00]
-; BDVER2-NEXT:    vmovaps {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [5:0.50]
-; BDVER2-NEXT:    vfnmaddps %xmm2, %xmm1, %xmm0, %xmm3 # sched: [5:0.50]
-; BDVER2-NEXT:    vfmaddps %xmm1, %xmm3, %xmm1, %xmm1 # sched: [5:0.50]
-; BDVER2-NEXT:    vfnmaddps %xmm2, %xmm1, %xmm0, %xmm0 # sched: [5:0.50]
-; BDVER2-NEXT:    vfmaddps %xmm1, %xmm0, %xmm1, %xmm0 # sched: [5:0.50]
-; BDVER2-NEXT:    retq # sched: [5:1.00]
+; BDVER2-NEXT:    vrcpps %xmm0, %xmm1
+; BDVER2-NEXT:    vmovaps {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; BDVER2-NEXT:    vfnmaddps %xmm2, %xmm1, %xmm0, %xmm3
+; BDVER2-NEXT:    vfmaddps %xmm1, %xmm3, %xmm1, %xmm1
+; BDVER2-NEXT:    vfnmaddps %xmm2, %xmm1, %xmm0, %xmm0
+; BDVER2-NEXT:    vfmaddps %xmm1, %xmm0, %xmm1, %xmm0
+; BDVER2-NEXT:    retq
 ;
 ; BTVER2-LABEL: v4f32_two_step:
 ; BTVER2:       # %bb.0:
-; BTVER2-NEXT:    vmovaps {{.*#+}} xmm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [5:1.00]
-; BTVER2-NEXT:    vrcpps %xmm0, %xmm1 # sched: [2:1.00]
-; BTVER2-NEXT:    vmulps %xmm1, %xmm0, %xmm2 # sched: [2:1.00]
-; BTVER2-NEXT:    vsubps %xmm2, %xmm3, %xmm2 # sched: [3:1.00]
-; BTVER2-NEXT:    vmulps %xmm2, %xmm1, %xmm2 # sched: [2:1.00]
-; BTVER2-NEXT:    vaddps %xmm2, %xmm1, %xmm1 # sched: [3:1.00]
-; BTVER2-NEXT:    vmulps %xmm1, %xmm0, %xmm0 # sched: [2:1.00]
-; BTVER2-NEXT:    vsubps %xmm0, %xmm3, %xmm0 # sched: [3:1.00]
-; BTVER2-NEXT:    vmulps %xmm0, %xmm1, %xmm0 # sched: [2:1.00]
-; BTVER2-NEXT:    vaddps %xmm0, %xmm1, %xmm0 # sched: [3:1.00]
-; BTVER2-NEXT:    retq # sched: [4:1.00]
+; BTVER2-NEXT:    vmovaps {{.*#+}} xmm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; BTVER2-NEXT:    vrcpps %xmm0, %xmm1
+; BTVER2-NEXT:    vmulps %xmm1, %xmm0, %xmm2
+; BTVER2-NEXT:    vsubps %xmm2, %xmm3, %xmm2
+; BTVER2-NEXT:    vmulps %xmm2, %xmm1, %xmm2
+; BTVER2-NEXT:    vaddps %xmm2, %xmm1, %xmm1
+; BTVER2-NEXT:    vmulps %xmm1, %xmm0, %xmm0
+; BTVER2-NEXT:    vsubps %xmm0, %xmm3, %xmm0
+; BTVER2-NEXT:    vmulps %xmm0, %xmm1, %xmm0
+; BTVER2-NEXT:    vaddps %xmm0, %xmm1, %xmm0
+; BTVER2-NEXT:    retq
 ;
 ; SANDY-LABEL: v4f32_two_step:
 ; SANDY:       # %bb.0:
-; SANDY-NEXT:    vrcpps %xmm0, %xmm1 # sched: [5:1.00]
-; SANDY-NEXT:    vmulps %xmm1, %xmm0, %xmm2 # sched: [5:1.00]
-; SANDY-NEXT:    vmovaps {{.*#+}} xmm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [6:0.50]
-; SANDY-NEXT:    vsubps %xmm2, %xmm3, %xmm2 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %xmm2, %xmm1, %xmm2 # sched: [5:1.00]
-; SANDY-NEXT:    vaddps %xmm2, %xmm1, %xmm1 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %xmm1, %xmm0, %xmm0 # sched: [5:1.00]
-; SANDY-NEXT:    vsubps %xmm0, %xmm3, %xmm0 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %xmm0, %xmm1, %xmm0 # sched: [5:1.00]
-; SANDY-NEXT:    vaddps %xmm0, %xmm1, %xmm0 # sched: [3:1.00]
-; SANDY-NEXT:    retq # sched: [1:1.00]
+; SANDY-NEXT:    vrcpps %xmm0, %xmm1
+; SANDY-NEXT:    vmulps %xmm1, %xmm0, %xmm2
+; SANDY-NEXT:    vmovaps {{.*#+}} xmm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; SANDY-NEXT:    vsubps %xmm2, %xmm3, %xmm2
+; SANDY-NEXT:    vmulps %xmm2, %xmm1, %xmm2
+; SANDY-NEXT:    vaddps %xmm2, %xmm1, %xmm1
+; SANDY-NEXT:    vmulps %xmm1, %xmm0, %xmm0
+; SANDY-NEXT:    vsubps %xmm0, %xmm3, %xmm0
+; SANDY-NEXT:    vmulps %xmm0, %xmm1, %xmm0
+; SANDY-NEXT:    vaddps %xmm0, %xmm1, %xmm0
+; SANDY-NEXT:    retq
 ;
 ; HASWELL-LABEL: v4f32_two_step:
 ; HASWELL:       # %bb.0:
-; HASWELL-NEXT:    vrcpps %xmm0, %xmm1 # sched: [5:1.00]
-; HASWELL-NEXT:    vbroadcastss {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [6:0.50]
-; HASWELL-NEXT:    vmovaps %xmm1, %xmm3 # sched: [1:1.00]
-; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} xmm3 = -(xmm0 * xmm3) + xmm2 sched: [5:0.50]
-; HASWELL-NEXT:    vfmadd132ps {{.*#+}} xmm3 = (xmm3 * xmm1) + xmm1 sched: [5:0.50]
-; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} xmm0 = -(xmm3 * xmm0) + xmm2 sched: [5:0.50]
-; HASWELL-NEXT:    vfmadd132ps {{.*#+}} xmm0 = (xmm0 * xmm3) + xmm3 sched: [5:0.50]
-; HASWELL-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NEXT:    vrcpps %xmm0, %xmm1
+; HASWELL-NEXT:    vbroadcastss {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; HASWELL-NEXT:    vmovaps %xmm1, %xmm3
+; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} xmm3 = -(xmm0 * xmm3) + xmm2
+; HASWELL-NEXT:    vfmadd132ps {{.*#+}} xmm3 = (xmm3 * xmm1) + xmm1
+; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} xmm0 = -(xmm3 * xmm0) + xmm2
+; HASWELL-NEXT:    vfmadd132ps {{.*#+}} xmm0 = (xmm0 * xmm3) + xmm3
+; HASWELL-NEXT:    retq
 ;
 ; HASWELL-NO-FMA-LABEL: v4f32_two_step:
 ; HASWELL-NO-FMA:       # %bb.0:
 ; HASWELL-NO-FMA-NEXT:    vrcpps %xmm0, %xmm1
 ; HASWELL-NO-FMA-NEXT:    vmulps %xmm1, %xmm0, %xmm2
 ; HASWELL-NO-FMA-NEXT:    vbroadcastss {{.*#+}} xmm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]
 ; HASWELL-NO-FMA-NEXT:    vsubps %xmm2, %xmm3, %xmm2
 ; HASWELL-NO-FMA-NEXT:    vmulps %xmm2, %xmm1, %xmm2
 ; HASWELL-NO-FMA-NEXT:    vaddps %xmm2, %xmm1, %xmm1
 ; HASWELL-NO-FMA-NEXT:    vmulps %xmm1, %xmm0, %xmm0
 ; HASWELL-NO-FMA-NEXT:    vsubps %xmm0, %xmm3, %xmm0
 ; HASWELL-NO-FMA-NEXT:    vmulps %xmm0, %xmm1, %xmm0
 ; HASWELL-NO-FMA-NEXT:    vaddps %xmm0, %xmm1, %xmm0
 ; HASWELL-NO-FMA-NEXT:    retq
 ;
-; KNL-LABEL: v4f32_two_step:
-; KNL:       # %bb.0:
-; KNL-NEXT:    vrcpps %xmm0, %xmm1 # sched: [5:1.00]
-; KNL-NEXT:    vbroadcastss {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [6:0.50]
-; KNL-NEXT:    vmovaps %xmm1, %xmm3 # sched: [1:1.00]
-; KNL-NEXT:    vfnmadd213ps {{.*#+}} xmm3 = -(xmm0 * xmm3) + xmm2 sched: [5:0.50]
-; KNL-NEXT:    vfmadd132ps {{.*#+}} xmm3 = (xmm3 * xmm1) + xmm1 sched: [5:0.50]
-; KNL-NEXT:    vfnmadd213ps {{.*#+}} xmm0 = -(xmm3 * xmm0) + xmm2 sched: [5:0.50]
-; KNL-NEXT:    vfmadd132ps {{.*#+}} xmm0 = (xmm0 * xmm3) + xmm3 sched: [5:0.50]
-; KNL-NEXT:    retq # sched: [7:1.00]
-;
-; SKX-LABEL: v4f32_two_step:
-; SKX:       # %bb.0:
-; SKX-NEXT:    vrcpps %xmm0, %xmm1 # sched: [4:1.00]
-; SKX-NEXT:    vbroadcastss {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [6:0.50]
-; SKX-NEXT:    vmovaps %xmm1, %xmm3 # sched: [1:0.33]
-; SKX-NEXT:    vfnmadd213ps {{.*#+}} xmm3 = -(xmm0 * xmm3) + xmm2 sched: [4:0.50]
-; SKX-NEXT:    vfmadd132ps {{.*#+}} xmm3 = (xmm3 * xmm1) + xmm1 sched: [4:0.50]
-; SKX-NEXT:    vfnmadd213ps {{.*#+}} xmm0 = -(xmm3 * xmm0) + xmm2 sched: [4:0.50]
-; SKX-NEXT:    vfmadd132ps {{.*#+}} xmm0 = (xmm0 * xmm3) + xmm3 sched: [4:0.50]
-; SKX-NEXT:    retq # sched: [7:1.00]
+; AVX512-LABEL: v4f32_two_step:
+; AVX512:       # %bb.0:
+; AVX512-NEXT:    vrcpps %xmm0, %xmm1
+; AVX512-NEXT:    vbroadcastss {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; AVX512-NEXT:    vmovaps %xmm1, %xmm3
+; AVX512-NEXT:    vfnmadd213ps {{.*#+}} xmm3 = -(xmm0 * xmm3) + xmm2
+; AVX512-NEXT:    vfmadd132ps {{.*#+}} xmm3 = (xmm3 * xmm1) + xmm1
+; AVX512-NEXT:    vfnmadd213ps {{.*#+}} xmm0 = -(xmm3 * xmm0) + xmm2
+; AVX512-NEXT:    vfmadd132ps {{.*#+}} xmm0 = (xmm0 * xmm3) + xmm3
+; AVX512-NEXT:    retq
   %div = fdiv fast <4 x float> <float 1.0, float 1.0, float 1.0, float 1.0>, %x
   ret <4 x float> %div
 }
 
 define <8 x float> @v8f32_no_estimate(<8 x float> %x) #0 {
 ; SSE-LABEL: v8f32_no_estimate:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    movaps {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]

 ; FMA-RECIP-LABEL: v8f32_no_estimate:
 ; FMA-RECIP:       # %bb.0:
 ; FMA-RECIP-NEXT:    vmovaps {{.*#+}} ymm1 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
 ; FMA-RECIP-NEXT:    vdivps %ymm0, %ymm1, %ymm0
 ; FMA-RECIP-NEXT:    retq
 ;
 ; BDVER2-LABEL: v8f32_no_estimate:
 ; BDVER2:       # %bb.0:
-; BDVER2-NEXT:    vmovaps {{.*#+}} ymm1 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [5:0.50]
-; BDVER2-NEXT:    vdivps %ymm0, %ymm1, %ymm0 # sched: [9:19.00]
-; BDVER2-NEXT:    retq # sched: [5:1.00]
+; BDVER2-NEXT:    vmovaps {{.*#+}} ymm1 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; BDVER2-NEXT:    vdivps %ymm0, %ymm1, %ymm0
+; BDVER2-NEXT:    retq
 ;
 ; BTVER2-LABEL: v8f32_no_estimate:
 ; BTVER2:       # %bb.0:
-; BTVER2-NEXT:    vmovaps {{.*#+}} ymm1 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [5:1.00]
-; BTVER2-NEXT:    vdivps %ymm0, %ymm1, %ymm0 # sched: [38:38.00]
-; BTVER2-NEXT:    retq # sched: [4:1.00]
+; BTVER2-NEXT:    vmovaps {{.*#+}} ymm1 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; BTVER2-NEXT:    vdivps %ymm0, %ymm1, %ymm0
+; BTVER2-NEXT:    retq
 ;
 ; SANDY-LABEL: v8f32_no_estimate:
 ; SANDY:       # %bb.0:
-; SANDY-NEXT:    vmovaps {{.*#+}} ymm1 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; SANDY-NEXT:    vdivps %ymm0, %ymm1, %ymm0 # sched: [29:28.00]
-; SANDY-NEXT:    retq # sched: [1:1.00]
+; SANDY-NEXT:    vmovaps {{.*#+}} ymm1 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; SANDY-NEXT:    vdivps %ymm0, %ymm1, %ymm0
+; SANDY-NEXT:    retq
 ;
 ; HASWELL-LABEL: v8f32_no_estimate:
 ; HASWELL:       # %bb.0:
-; HASWELL-NEXT:    vbroadcastss {{.*#+}} ymm1 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; HASWELL-NEXT:    vdivps %ymm0, %ymm1, %ymm0 # sched: [21:14.00]
-; HASWELL-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NEXT:    vbroadcastss {{.*#+}} ymm1 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; HASWELL-NEXT:    vdivps %ymm0, %ymm1, %ymm0
+; HASWELL-NEXT:    retq
 ;
 ; HASWELL-NO-FMA-LABEL: v8f32_no_estimate:
 ; HASWELL-NO-FMA:       # %bb.0:
 ; HASWELL-NO-FMA-NEXT:    vbroadcastss {{.*#+}} ymm1 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
 ; HASWELL-NO-FMA-NEXT:    vdivps %ymm0, %ymm1, %ymm0
 ; HASWELL-NO-FMA-NEXT:    retq
 ;
-; KNL-LABEL: v8f32_no_estimate:
-; KNL:       # %bb.0:
-; KNL-NEXT:    vbroadcastss {{.*#+}} ymm1 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; KNL-NEXT:    vdivps %ymm0, %ymm1, %ymm0 # sched: [21:14.00]
-; KNL-NEXT:    retq # sched: [7:1.00]
-;
-; SKX-LABEL: v8f32_no_estimate:
-; SKX:       # %bb.0:
-; SKX-NEXT:    vbroadcastss {{.*#+}} ymm1 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; SKX-NEXT:    vdivps %ymm0, %ymm1, %ymm0 # sched: [11:5.00]
-; SKX-NEXT:    retq # sched: [7:1.00]
+; AVX512-LABEL: v8f32_no_estimate:
+; AVX512:       # %bb.0:
+; AVX512-NEXT:    vbroadcastss {{.*#+}} ymm1 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; AVX512-NEXT:    vdivps %ymm0, %ymm1, %ymm0
+; AVX512-NEXT:    retq
   %div = fdiv fast <8 x float> <float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0>, %x
   ret <8 x float> %div
 }
 
 define <8 x float> @v8f32_one_step(<8 x float> %x) #1 {
 ; SSE-LABEL: v8f32_one_step:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    rcpps %xmm0, %xmm4

 ; FMA-RECIP:       # %bb.0:
 ; FMA-RECIP-NEXT:    vrcpps %ymm0, %ymm1
 ; FMA-RECIP-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm1 * ymm0) + mem
 ; FMA-RECIP-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm1) + ymm1
 ; FMA-RECIP-NEXT:    retq
 ;
 ; BDVER2-LABEL: v8f32_one_step:
 ; BDVER2:       # %bb.0:
-; BDVER2-NEXT:    vrcpps %ymm0, %ymm1 # sched: [5:2.00]
-; BDVER2-NEXT:    vfnmaddps {{.*}}(%rip), %ymm1, %ymm0, %ymm0 # sched: [10:1.00]
-; BDVER2-NEXT:    vfmaddps %ymm1, %ymm0, %ymm1, %ymm0 # sched: [5:0.50]
-; BDVER2-NEXT:    retq # sched: [5:1.00]
+; BDVER2-NEXT:    vrcpps %ymm0, %ymm1
+; BDVER2-NEXT:    vfnmaddps {{.*}}(%rip), %ymm1, %ymm0, %ymm0
+; BDVER2-NEXT:    vfmaddps %ymm1, %ymm0, %ymm1, %ymm0
+; BDVER2-NEXT:    retq
 ;
 ; BTVER2-LABEL: v8f32_one_step:
 ; BTVER2:       # %bb.0:
-; BTVER2-NEXT:    vmovaps {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [5:1.00]
-; BTVER2-NEXT:    vrcpps %ymm0, %ymm1 # sched: [2:2.00]
-; BTVER2-NEXT:    vmulps %ymm1, %ymm0, %ymm0 # sched: [2:2.00]
-; BTVER2-NEXT:    vsubps %ymm0, %ymm2, %ymm0 # sched: [3:2.00]
-; BTVER2-NEXT:    vmulps %ymm0, %ymm1, %ymm0 # sched: [2:2.00]
-; BTVER2-NEXT:    vaddps %ymm0, %ymm1, %ymm0 # sched: [3:2.00]
-; BTVER2-NEXT:    retq # sched: [4:1.00]
+; BTVER2-NEXT:    vmovaps {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; BTVER2-NEXT:    vrcpps %ymm0, %ymm1
+; BTVER2-NEXT:    vmulps %ymm1, %ymm0, %ymm0
+; BTVER2-NEXT:    vsubps %ymm0, %ymm2, %ymm0
+; BTVER2-NEXT:    vmulps %ymm0, %ymm1, %ymm0
+; BTVER2-NEXT:    vaddps %ymm0, %ymm1, %ymm0
+; BTVER2-NEXT:    retq
 ;
 ; SANDY-LABEL: v8f32_one_step:
 ; SANDY:       # %bb.0:
-; SANDY-NEXT:    vrcpps %ymm0, %ymm1 # sched: [7:2.00]
-; SANDY-NEXT:    vmulps %ymm1, %ymm0, %ymm0 # sched: [5:1.00]
-; SANDY-NEXT:    vmovaps {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; SANDY-NEXT:    vsubps %ymm0, %ymm2, %ymm0 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %ymm0, %ymm1, %ymm0 # sched: [5:1.00]
-; SANDY-NEXT:    vaddps %ymm0, %ymm1, %ymm0 # sched: [3:1.00]
-; SANDY-NEXT:    retq # sched: [1:1.00]
+; SANDY-NEXT:    vrcpps %ymm0, %ymm1
+; SANDY-NEXT:    vmulps %ymm1, %ymm0, %ymm0
+; SANDY-NEXT:    vmovaps {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; SANDY-NEXT:    vsubps %ymm0, %ymm2, %ymm0
+; SANDY-NEXT:    vmulps %ymm0, %ymm1, %ymm0
+; SANDY-NEXT:    vaddps %ymm0, %ymm1, %ymm0
+; SANDY-NEXT:    retq
 ;
 ; HASWELL-LABEL: v8f32_one_step:
 ; HASWELL:       # %bb.0:
-; HASWELL-NEXT:    vrcpps %ymm0, %ymm1 # sched: [11:2.00]
-; HASWELL-NEXT:    vbroadcastss {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm1 * ymm0) + ymm2 sched: [5:0.50]
-; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm1) + ymm1 sched: [5:0.50]
-; HASWELL-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NEXT:    vrcpps %ymm0, %ymm1
+; HASWELL-NEXT:    vbroadcastss {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm1 * ymm0) + ymm2
+; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm1) + ymm1
+; HASWELL-NEXT:    retq
 ;
 ; HASWELL-NO-FMA-LABEL: v8f32_one_step:
 ; HASWELL-NO-FMA:       # %bb.0:
 ; HASWELL-NO-FMA-NEXT:    vrcpps %ymm0, %ymm1
 ; HASWELL-NO-FMA-NEXT:    vmulps %ymm1, %ymm0, %ymm0
 ; HASWELL-NO-FMA-NEXT:    vbroadcastss {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
 ; HASWELL-NO-FMA-NEXT:    vsubps %ymm0, %ymm2, %ymm0
 ; HASWELL-NO-FMA-NEXT:    vmulps %ymm0, %ymm1, %ymm0
 ; HASWELL-NO-FMA-NEXT:    vaddps %ymm0, %ymm1, %ymm0
 ; HASWELL-NO-FMA-NEXT:    retq
 ;
 ; KNL-LABEL: v8f32_one_step:
 ; KNL:       # %bb.0:
-; KNL-NEXT:    vrcpps %ymm0, %ymm1 # sched: [11:2.00]
-; KNL-NEXT:    vbroadcastss {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; KNL-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm1 * ymm0) + ymm2 sched: [5:0.50]
-; KNL-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm1) + ymm1 sched: [5:0.50]
-; KNL-NEXT:    retq # sched: [7:1.00]
+; KNL-NEXT:    vrcpps %ymm0, %ymm1
+; KNL-NEXT:    vbroadcastss {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; KNL-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm1 * ymm0) + ymm2
+; KNL-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm1) + ymm1
+; KNL-NEXT:    retq
 ;
 ; SKX-LABEL: v8f32_one_step:
 ; SKX:       # %bb.0:
-; SKX-NEXT:    vrcpps %ymm0, %ymm1 # sched: [4:1.00]
-; SKX-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm1 * ymm0) + mem sched: [11:0.50]
-; SKX-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm1) + ymm1 sched: [4:0.50]
-; SKX-NEXT:    retq # sched: [7:1.00]
+; SKX-NEXT:    vrcpps %ymm0, %ymm1
+; SKX-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm1 * ymm0) + mem
+; SKX-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm1) + ymm1
+; SKX-NEXT:    retq
   %div = fdiv fast <8 x float> <float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0>, %x
   ret <8 x float> %div
 }
 
 define <8 x float> @v8f32_two_step(<8 x float> %x) #2 {
 ; SSE-LABEL: v8f32_two_step:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    movaps %xmm1, %xmm2

 ; FMA-RECIP-NEXT:    vfnmadd213ps {{.*#+}} ymm3 = -(ymm0 * ymm3) + ymm2
 ; FMA-RECIP-NEXT:    vfmadd132ps {{.*#+}} ymm3 = (ymm3 * ymm1) + ymm1
 ; FMA-RECIP-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm3 * ymm0) + ymm2
 ; FMA-RECIP-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm3) + ymm3
 ; FMA-RECIP-NEXT:    retq
 ;
 ; BDVER2-LABEL: v8f32_two_step:
 ; BDVER2:       # %bb.0:
-; BDVER2-NEXT:    vrcpps %ymm0, %ymm1 # sched: [5:2.00]
-; BDVER2-NEXT:    vmovaps {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [5:0.50]
-; BDVER2-NEXT:    vfnmaddps %ymm2, %ymm1, %ymm0, %ymm3 # sched: [5:0.50]
-; BDVER2-NEXT:    vfmaddps %ymm1, %ymm3, %ymm1, %ymm1 # sched: [5:0.50]
-; BDVER2-NEXT:    vfnmaddps %ymm2, %ymm1, %ymm0, %ymm0 # sched: [5:0.50]
-; BDVER2-NEXT:    vfmaddps %ymm1, %ymm0, %ymm1, %ymm0 # sched: [5:0.50]
-; BDVER2-NEXT:    retq # sched: [5:1.00]
+; BDVER2-NEXT:    vrcpps %ymm0, %ymm1
+; BDVER2-NEXT:    vmovaps {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; BDVER2-NEXT:    vfnmaddps %ymm2, %ymm1, %ymm0, %ymm3
+; BDVER2-NEXT:    vfmaddps %ymm1, %ymm3, %ymm1, %ymm1
+; BDVER2-NEXT:    vfnmaddps %ymm2, %ymm1, %ymm0, %ymm0
+; BDVER2-NEXT:    vfmaddps %ymm1, %ymm0, %ymm1, %ymm0
+; BDVER2-NEXT:    retq
 ;
 ; BTVER2-LABEL: v8f32_two_step:
 ; BTVER2:       # %bb.0:
-; BTVER2-NEXT:    vmovaps {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [5:1.00]
-; BTVER2-NEXT:    vrcpps %ymm0, %ymm1 # sched: [2:2.00]
-; BTVER2-NEXT:    vmulps %ymm1, %ymm0, %ymm2 # sched: [2:2.00]
-; BTVER2-NEXT:    vsubps %ymm2, %ymm3, %ymm2 # sched: [3:2.00]
-; BTVER2-NEXT:    vmulps %ymm2, %ymm1, %ymm2 # sched: [2:2.00]
-; BTVER2-NEXT:    vaddps %ymm2, %ymm1, %ymm1 # sched: [3:2.00]
-; BTVER2-NEXT:    vmulps %ymm1, %ymm0, %ymm0 # sched: [2:2.00]
-; BTVER2-NEXT:    vsubps %ymm0, %ymm3, %ymm0 # sched: [3:2.00]
-; BTVER2-NEXT:    vmulps %ymm0, %ymm1, %ymm0 # sched: [2:2.00]
-; BTVER2-NEXT:    vaddps %ymm0, %ymm1, %ymm0 # sched: [3:2.00]
-; BTVER2-NEXT:    retq # sched: [4:1.00]
+; BTVER2-NEXT:    vmovaps {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; BTVER2-NEXT:    vrcpps %ymm0, %ymm1
+; BTVER2-NEXT:    vmulps %ymm1, %ymm0, %ymm2
+; BTVER2-NEXT:    vsubps %ymm2, %ymm3, %ymm2
+; BTVER2-NEXT:    vmulps %ymm2, %ymm1, %ymm2
+; BTVER2-NEXT:    vaddps %ymm2, %ymm1, %ymm1
+; BTVER2-NEXT:    vmulps %ymm1, %ymm0, %ymm0
+; BTVER2-NEXT:    vsubps %ymm0, %ymm3, %ymm0
+; BTVER2-NEXT:    vmulps %ymm0, %ymm1, %ymm0
+; BTVER2-NEXT:    vaddps %ymm0, %ymm1, %ymm0
+; BTVER2-NEXT:    retq
 ;
 ; SANDY-LABEL: v8f32_two_step:
 ; SANDY:       # %bb.0:
-; SANDY-NEXT:    vrcpps %ymm0, %ymm1 # sched: [7:2.00]
-; SANDY-NEXT:    vmulps %ymm1, %ymm0, %ymm2 # sched: [5:1.00]
-; SANDY-NEXT:    vmovaps {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; SANDY-NEXT:    vsubps %ymm2, %ymm3, %ymm2 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %ymm2, %ymm1, %ymm2 # sched: [5:1.00]
-; SANDY-NEXT:    vaddps %ymm2, %ymm1, %ymm1 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %ymm1, %ymm0, %ymm0 # sched: [5:1.00]
-; SANDY-NEXT:    vsubps %ymm0, %ymm3, %ymm0 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %ymm0, %ymm1, %ymm0 # sched: [5:1.00]
-; SANDY-NEXT:    vaddps %ymm0, %ymm1, %ymm0 # sched: [3:1.00]
-; SANDY-NEXT:    retq # sched: [1:1.00]
+; SANDY-NEXT:    vrcpps %ymm0, %ymm1
+; SANDY-NEXT:    vmulps %ymm1, %ymm0, %ymm2
+; SANDY-NEXT:    vmovaps {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; SANDY-NEXT:    vsubps %ymm2, %ymm3, %ymm2
+; SANDY-NEXT:    vmulps %ymm2, %ymm1, %ymm2
+; SANDY-NEXT:    vaddps %ymm2, %ymm1, %ymm1
+; SANDY-NEXT:    vmulps %ymm1, %ymm0, %ymm0
+; SANDY-NEXT:    vsubps %ymm0, %ymm3, %ymm0
+; SANDY-NEXT:    vmulps %ymm0, %ymm1, %ymm0
+; SANDY-NEXT:    vaddps %ymm0, %ymm1, %ymm0
+; SANDY-NEXT:    retq
 ;
 ; HASWELL-LABEL: v8f32_two_step:
 ; HASWELL:       # %bb.0:
-; HASWELL-NEXT:    vrcpps %ymm0, %ymm1 # sched: [11:2.00]
-; HASWELL-NEXT:    vbroadcastss {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; HASWELL-NEXT:    vmovaps %ymm1, %ymm3 # sched: [1:1.00]
-; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm3 = -(ymm0 * ymm3) + ymm2 sched: [5:0.50]
-; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm3 = (ymm3 * ymm1) + ymm1 sched: [5:0.50]
-; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm3 * ymm0) + ymm2 sched: [5:0.50]
-; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm3) + ymm3 sched: [5:0.50]
-; HASWELL-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NEXT:    vrcpps %ymm0, %ymm1
+; HASWELL-NEXT:    vbroadcastss {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; HASWELL-NEXT:    vmovaps %ymm1, %ymm3
+; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm3 = -(ymm0 * ymm3) + ymm2
+; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm3 = (ymm3 * ymm1) + ymm1
+; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm3 * ymm0) + ymm2
+; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm3) + ymm3
+; HASWELL-NEXT:    retq
 ;
 ; HASWELL-NO-FMA-LABEL: v8f32_two_step:
 ; HASWELL-NO-FMA:       # %bb.0:
 ; HASWELL-NO-FMA-NEXT:    vrcpps %ymm0, %ymm1
 ; HASWELL-NO-FMA-NEXT:    vmulps %ymm1, %ymm0, %ymm2
 ; HASWELL-NO-FMA-NEXT:    vbroadcastss {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
 ; HASWELL-NO-FMA-NEXT:    vsubps %ymm2, %ymm3, %ymm2
 ; HASWELL-NO-FMA-NEXT:    vmulps %ymm2, %ymm1, %ymm2
 ; HASWELL-NO-FMA-NEXT:    vaddps %ymm2, %ymm1, %ymm1
 ; HASWELL-NO-FMA-NEXT:    vmulps %ymm1, %ymm0, %ymm0
 ; HASWELL-NO-FMA-NEXT:    vsubps %ymm0, %ymm3, %ymm0
 ; HASWELL-NO-FMA-NEXT:    vmulps %ymm0, %ymm1, %ymm0
 ; HASWELL-NO-FMA-NEXT:    vaddps %ymm0, %ymm1, %ymm0
 ; HASWELL-NO-FMA-NEXT:    retq
 ;
-; KNL-LABEL: v8f32_two_step:
-; KNL:       # %bb.0:
-; KNL-NEXT:    vrcpps %ymm0, %ymm1 # sched: [11:2.00]
-; KNL-NEXT:    vbroadcastss {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; KNL-NEXT:    vmovaps %ymm1, %ymm3 # sched: [1:1.00]
-; KNL-NEXT:    vfnmadd213ps {{.*#+}} ymm3 = -(ymm0 * ymm3) + ymm2 sched: [5:0.50]
-; KNL-NEXT:    vfmadd132ps {{.*#+}} ymm3 = (ymm3 * ymm1) + ymm1 sched: [5:0.50]
-; KNL-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm3 * ymm0) + ymm2 sched: [5:0.50]
-; KNL-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm3) + ymm3 sched: [5:0.50]
-; KNL-NEXT:    retq # sched: [7:1.00]
-;
-; SKX-LABEL: v8f32_two_step:
-; SKX:       # %bb.0:
-; SKX-NEXT:    vrcpps %ymm0, %ymm1 # sched: [4:1.00]
-; SKX-NEXT:    vbroadcastss {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; SKX-NEXT:    vmovaps %ymm1, %ymm3 # sched: [1:0.33]
-; SKX-NEXT:    vfnmadd213ps {{.*#+}} ymm3 = -(ymm0 * ymm3) + ymm2 sched: [4:0.50]
-; SKX-NEXT:    vfmadd132ps {{.*#+}} ymm3 = (ymm3 * ymm1) + ymm1 sched: [4:0.50]
-; SKX-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm3 * ymm0) + ymm2 sched: [4:0.50]
-; SKX-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm3) + ymm3 sched: [4:0.50]
-; SKX-NEXT:    retq # sched: [7:1.00]
+; AVX512-LABEL: v8f32_two_step:
+; AVX512:       # %bb.0:
+; AVX512-NEXT:    vrcpps %ymm0, %ymm1
+; AVX512-NEXT:    vbroadcastss {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; AVX512-NEXT:    vmovaps %ymm1, %ymm3
+; AVX512-NEXT:    vfnmadd213ps {{.*#+}} ymm3 = -(ymm0 * ymm3) + ymm2
+; AVX512-NEXT:    vfmadd132ps {{.*#+}} ymm3 = (ymm3 * ymm1) + ymm1
+; AVX512-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm3 * ymm0) + ymm2
+; AVX512-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm3) + ymm3
+; AVX512-NEXT:    retq
   %div = fdiv fast <8 x float> <float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0>, %x
   ret <8 x float> %div
 }
 
 define <16 x float> @v16f32_no_estimate(<16 x float> %x) #0 {
 ; SSE-LABEL: v16f32_no_estimate:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    movaps {{.*#+}} xmm4 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]

 ; FMA-RECIP:       # %bb.0:
 ; FMA-RECIP-NEXT:    vmovaps {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
 ; FMA-RECIP-NEXT:    vdivps %ymm0, %ymm2, %ymm0
 ; FMA-RECIP-NEXT:    vdivps %ymm1, %ymm2, %ymm1
 ; FMA-RECIP-NEXT:    retq
 ;
 ; BDVER2-LABEL: v16f32_no_estimate:
 ; BDVER2:       # %bb.0:
-; BDVER2-NEXT:    vmovaps {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [5:0.50]
-; BDVER2-NEXT:    vdivps %ymm0, %ymm2, %ymm0 # sched: [9:19.00]
-; BDVER2-NEXT:    vdivps %ymm1, %ymm2, %ymm1 # sched: [9:19.00]
-; BDVER2-NEXT:    retq # sched: [5:1.00]
+; BDVER2-NEXT:    vmovaps {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; BDVER2-NEXT:    vdivps %ymm0, %ymm2, %ymm0
+; BDVER2-NEXT:    vdivps %ymm1, %ymm2, %ymm1
+; BDVER2-NEXT:    retq
 ;
 ; BTVER2-LABEL: v16f32_no_estimate:
 ; BTVER2:       # %bb.0:
-; BTVER2-NEXT:    vmovaps {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [5:1.00]
-; BTVER2-NEXT:    vdivps %ymm0, %ymm2, %ymm0 # sched: [38:38.00]
-; BTVER2-NEXT:    vdivps %ymm1, %ymm2, %ymm1 # sched: [38:38.00]
-; BTVER2-NEXT:    retq # sched: [4:1.00]
+; BTVER2-NEXT:    vmovaps {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; BTVER2-NEXT:    vdivps %ymm0, %ymm2, %ymm0
+; BTVER2-NEXT:    vdivps %ymm1, %ymm2, %ymm1
+; BTVER2-NEXT:    retq
 ;
 ; SANDY-LABEL: v16f32_no_estimate:
 ; SANDY:       # %bb.0:
-; SANDY-NEXT:    vmovaps {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; SANDY-NEXT:    vdivps %ymm0, %ymm2, %ymm0 # sched: [29:28.00]
-; SANDY-NEXT:    vdivps %ymm1, %ymm2, %ymm1 # sched: [29:28.00]
-; SANDY-NEXT:    retq # sched: [1:1.00]
+; SANDY-NEXT:    vmovaps {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; SANDY-NEXT:    vdivps %ymm0, %ymm2, %ymm0
+; SANDY-NEXT:    vdivps %ymm1, %ymm2, %ymm1
+; SANDY-NEXT:    retq
 ;
 ; HASWELL-LABEL: v16f32_no_estimate:
 ; HASWELL:       # %bb.0:
-; HASWELL-NEXT:    vbroadcastss {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; HASWELL-NEXT:    vdivps %ymm0, %ymm2, %ymm0 # sched: [21:14.00]
-; HASWELL-NEXT:    vdivps %ymm1, %ymm2, %ymm1 # sched: [21:14.00]
-; HASWELL-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NEXT:    vbroadcastss {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; HASWELL-NEXT:    vdivps %ymm0, %ymm2, %ymm0
+; HASWELL-NEXT:    vdivps %ymm1, %ymm2, %ymm1
+; HASWELL-NEXT:    retq
 ;
 ; HASWELL-NO-FMA-LABEL: v16f32_no_estimate:
 ; HASWELL-NO-FMA:       # %bb.0:
 ; HASWELL-NO-FMA-NEXT:    vbroadcastss {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
 ; HASWELL-NO-FMA-NEXT:    vdivps %ymm0, %ymm2, %ymm0
 ; HASWELL-NO-FMA-NEXT:    vdivps %ymm1, %ymm2, %ymm1
 ; HASWELL-NO-FMA-NEXT:    retq
 ;
-; KNL-LABEL: v16f32_no_estimate:
-; KNL:       # %bb.0:
-; KNL-NEXT:    vbroadcastss {{.*#+}} zmm1 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [10:1.00]
-; KNL-NEXT:    vdivps %zmm0, %zmm1, %zmm0 # sched: [21:14.00]
-; KNL-NEXT:    retq # sched: [7:1.00]
-;
-; SKX-LABEL: v16f32_no_estimate:
-; SKX:       # %bb.0:
-; SKX-NEXT:    vbroadcastss {{.*#+}} zmm1 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [8:0.50]
-; SKX-NEXT:    vdivps %zmm0, %zmm1, %zmm0 # sched: [18:10.00]
-; SKX-NEXT:    retq # sched: [7:1.00]
+; AVX512-LABEL: v16f32_no_estimate:
+; AVX512:       # %bb.0:
+; AVX512-NEXT:    vbroadcastss {{.*#+}} zmm1 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; AVX512-NEXT:    vdivps %zmm0, %zmm1, %zmm0
+; AVX512-NEXT:    retq
   %div = fdiv fast <16 x float> <float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0>, %x
   ret <16 x float> %div
 }
 
 define <16 x float> @v16f32_one_step(<16 x float> %x) #1 {
 ; SSE-LABEL: v16f32_one_step:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    movaps %xmm3, %xmm4

 ; FMA-RECIP-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm2) + ymm2
 ; FMA-RECIP-NEXT:    vrcpps %ymm1, %ymm2
 ; FMA-RECIP-NEXT:    vfnmadd213ps {{.*#+}} ymm1 = -(ymm2 * ymm1) + ymm3
 ; FMA-RECIP-NEXT:    vfmadd132ps {{.*#+}} ymm1 = (ymm1 * ymm2) + ymm2
 ; FMA-RECIP-NEXT:    retq
 ;
 ; BDVER2-LABEL: v16f32_one_step:
 ; BDVER2:       # %bb.0:
-; BDVER2-NEXT:    vrcpps %ymm0, %ymm2 # sched: [5:2.00]
-; BDVER2-NEXT:    vmovaps {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [5:0.50]
-; BDVER2-NEXT:    vrcpps %ymm1, %ymm4 # sched: [5:2.00]
-; BDVER2-NEXT:    vfnmaddps %ymm3, %ymm2, %ymm0, %ymm0 # sched: [5:0.50]
-; BDVER2-NEXT:    vfnmaddps %ymm3, %ymm4, %ymm1, %ymm1 # sched: [5:0.50]
-; BDVER2-NEXT:    vfmaddps %ymm2, %ymm0, %ymm2, %ymm0 # sched: [5:0.50]
-; BDVER2-NEXT:    vfmaddps %ymm4, %ymm1, %ymm4, %ymm1 # sched: [5:0.50]
-; BDVER2-NEXT:    retq # sched: [5:1.00]
+; BDVER2-NEXT:    vrcpps %ymm0, %ymm2
+; BDVER2-NEXT:    vmovaps {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; BDVER2-NEXT:    vrcpps %ymm1, %ymm4
+; BDVER2-NEXT:    vfnmaddps %ymm3, %ymm2, %ymm0, %ymm0
+; BDVER2-NEXT:    vfnmaddps %ymm3, %ymm4, %ymm1, %ymm1
+; BDVER2-NEXT:    vfmaddps %ymm2, %ymm0, %ymm2, %ymm0
+; BDVER2-NEXT:    vfmaddps %ymm4, %ymm1, %ymm4, %ymm1
+; BDVER2-NEXT:    retq
 ;
 ; BTVER2-LABEL: v16f32_one_step:
 ; BTVER2:       # %bb.0:
-; BTVER2-NEXT:    vmovaps {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [5:1.00]
-; BTVER2-NEXT:    vrcpps %ymm0, %ymm2 # sched: [2:2.00]
-; BTVER2-NEXT:    vrcpps %ymm1, %ymm4 # sched: [2:2.00]
-; BTVER2-NEXT:    vmulps %ymm2, %ymm0, %ymm0 # sched: [2:2.00]
-; BTVER2-NEXT:    vmulps %ymm4, %ymm1, %ymm1 # sched: [2:2.00]
-; BTVER2-NEXT:    vsubps %ymm0, %ymm3, %ymm0 # sched: [3:2.00]
-; BTVER2-NEXT:    vsubps %ymm1, %ymm3, %ymm1 # sched: [3:2.00]
-; BTVER2-NEXT:    vmulps %ymm0, %ymm2, %ymm0 # sched: [2:2.00]
-; BTVER2-NEXT:    vmulps %ymm1, %ymm4, %ymm1 # sched: [2:2.00]
-; BTVER2-NEXT:    vaddps %ymm0, %ymm2, %ymm0 # sched: [3:2.00]
-; BTVER2-NEXT:    vaddps %ymm1, %ymm4, %ymm1 # sched: [3:2.00]
-; BTVER2-NEXT:    retq # sched: [4:1.00]
+; BTVER2-NEXT:    vmovaps {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; BTVER2-NEXT:    vrcpps %ymm0, %ymm2
+; BTVER2-NEXT:    vrcpps %ymm1, %ymm4
+; BTVER2-NEXT:    vmulps %ymm2, %ymm0, %ymm0
+; BTVER2-NEXT:    vmulps %ymm4, %ymm1, %ymm1
+; BTVER2-NEXT:    vsubps %ymm0, %ymm3, %ymm0
+; BTVER2-NEXT:    vsubps %ymm1, %ymm3, %ymm1
+; BTVER2-NEXT:    vmulps %ymm0, %ymm2, %ymm0
+; BTVER2-NEXT:    vmulps %ymm1, %ymm4, %ymm1
+; BTVER2-NEXT:    vaddps %ymm0, %ymm2, %ymm0
+; BTVER2-NEXT:    vaddps %ymm1, %ymm4, %ymm1
+; BTVER2-NEXT:    retq
 ;
 ; SANDY-LABEL: v16f32_one_step:
 ; SANDY:       # %bb.0:
-; SANDY-NEXT:    vrcpps %ymm0, %ymm2 # sched: [7:2.00]
-; SANDY-NEXT:    vmulps %ymm2, %ymm0, %ymm0 # sched: [5:1.00]
-; SANDY-NEXT:    vmovaps {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; SANDY-NEXT:    vsubps %ymm0, %ymm3, %ymm0 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %ymm0, %ymm2, %ymm0 # sched: [5:1.00]
-; SANDY-NEXT:    vaddps %ymm0, %ymm2, %ymm0 # sched: [3:1.00]
-; SANDY-NEXT:    vrcpps %ymm1, %ymm2 # sched: [7:2.00]
-; SANDY-NEXT:    vmulps %ymm2, %ymm1, %ymm1 # sched: [5:1.00]
-; SANDY-NEXT:    vsubps %ymm1, %ymm3, %ymm1 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %ymm1, %ymm2, %ymm1 # sched: [5:1.00]
-; SANDY-NEXT:    vaddps %ymm1, %ymm2, %ymm1 # sched: [3:1.00]
-; SANDY-NEXT:    retq # sched: [1:1.00]
+; SANDY-NEXT:    vrcpps %ymm0, %ymm2
+; SANDY-NEXT:    vmulps %ymm2, %ymm0, %ymm0
+; SANDY-NEXT:    vmovaps {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; SANDY-NEXT:    vsubps %ymm0, %ymm3, %ymm0
+; SANDY-NEXT:    vmulps %ymm0, %ymm2, %ymm0
+; SANDY-NEXT:    vaddps %ymm0, %ymm2, %ymm0
+; SANDY-NEXT:    vrcpps %ymm1, %ymm2
+; SANDY-NEXT:    vmulps %ymm2, %ymm1, %ymm1
+; SANDY-NEXT:    vsubps %ymm1, %ymm3, %ymm1
+; SANDY-NEXT:    vmulps %ymm1, %ymm2, %ymm1
+; SANDY-NEXT:    vaddps %ymm1, %ymm2, %ymm1
+; SANDY-NEXT:    retq
 ;
 ; HASWELL-LABEL: v16f32_one_step:
 ; HASWELL:       # %bb.0:
-; HASWELL-NEXT:    vrcpps %ymm0, %ymm2 # sched: [11:2.00]
-; HASWELL-NEXT:    vbroadcastss {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; HASWELL-NEXT:    vrcpps %ymm1, %ymm4 # sched: [11:2.00]
-; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm2 * ymm0) + ymm3 sched: [5:0.50]
-; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm2) + ymm2 sched: [5:0.50]
-; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm1 = -(ymm4 * ymm1) + ymm3 sched: [5:0.50]
-; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm1 = (ymm1 * ymm4) + ymm4 sched: [5:0.50]
-; HASWELL-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NEXT:    vrcpps %ymm0, %ymm2
+; HASWELL-NEXT:    vbroadcastss {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; HASWELL-NEXT:    vrcpps %ymm1, %ymm4
+; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm2 * ymm0) + ymm3
+; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm2) + ymm2
+; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm1 = -(ymm4 * ymm1) + ymm3
+; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm1 = (ymm1 * ymm4) + ymm4
+; HASWELL-NEXT:    retq
 ;
 ; HASWELL-NO-FMA-LABEL: v16f32_one_step:
 ; HASWELL-NO-FMA:       # %bb.0:
 ; HASWELL-NO-FMA-NEXT:    vrcpps %ymm0, %ymm2
 ; HASWELL-NO-FMA-NEXT:    vmulps %ymm2, %ymm0, %ymm0
 ; HASWELL-NO-FMA-NEXT:    vbroadcastss {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
 ; HASWELL-NO-FMA-NEXT:    vsubps %ymm0, %ymm3, %ymm0
 ; HASWELL-NO-FMA-NEXT:    vmulps %ymm0, %ymm2, %ymm0
 ; HASWELL-NO-FMA-NEXT:    vaddps %ymm0, %ymm2, %ymm0
 ; HASWELL-NO-FMA-NEXT:    vrcpps %ymm1, %ymm2
 ; HASWELL-NO-FMA-NEXT:    vmulps %ymm2, %ymm1, %ymm1
 ; HASWELL-NO-FMA-NEXT:    vsubps %ymm1, %ymm3, %ymm1
 ; HASWELL-NO-FMA-NEXT:    vmulps %ymm1, %ymm2, %ymm1
 ; HASWELL-NO-FMA-NEXT:    vaddps %ymm1, %ymm2, %ymm1
 ; HASWELL-NO-FMA-NEXT:    retq
 ;
-; KNL-LABEL: v16f32_one_step:
-; KNL:       # %bb.0:
-; KNL-NEXT:    vrcp14ps %zmm0, %zmm1 # sched: [11:2.00]
-; KNL-NEXT:    vfnmadd213ps {{.*#+}} zmm0 = -(zmm1 * zmm0) + mem sched: [12:0.50]
-; KNL-NEXT:    vfmadd132ps {{.*#+}} zmm0 = (zmm0 * zmm1) + zmm1 sched: [5:0.50]
-; KNL-NEXT:    retq # sched: [7:1.00]
-;
-; SKX-LABEL: v16f32_one_step:
-; SKX:       # %bb.0:
-; SKX-NEXT:    vrcp14ps %zmm0, %zmm1 # sched: [4:2.00]
-; SKX-NEXT:    vfnmadd213ps {{.*#+}} zmm0 = -(zmm1 * zmm0) + mem sched: [11:0.50]
-; SKX-NEXT:    vfmadd132ps {{.*#+}} zmm0 = (zmm0 * zmm1) + zmm1 sched: [4:0.50]
-; SKX-NEXT:    retq # sched: [7:1.00]
+; AVX512-LABEL: v16f32_one_step:
+; AVX512:       # %bb.0:
+; AVX512-NEXT:    vrcp14ps %zmm0, %zmm1
+; AVX512-NEXT:    vfnmadd213ps {{.*#+}} zmm0 = -(zmm1 * zmm0) + mem
+; AVX512-NEXT:    vfmadd132ps {{.*#+}} zmm0 = (zmm0 * zmm1) + zmm1
+; AVX512-NEXT:    retq
   %div = fdiv fast <16 x float> <float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0>, %x
   ret <16 x float> %div
 }
 
 define <16 x float> @v16f32_two_step(<16 x float> %x) #2 {
 ; SSE-LABEL: v16f32_two_step:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    movaps %xmm3, %xmm4

 ; FMA-RECIP-NEXT:    vfnmadd213ps {{.*#+}} ymm4 = -(ymm1 * ymm4) + ymm3
 ; FMA-RECIP-NEXT:    vfmadd132ps {{.*#+}} ymm4 = (ymm4 * ymm2) + ymm2
 ; FMA-RECIP-NEXT:    vfnmadd213ps {{.*#+}} ymm1 = -(ymm4 * ymm1) + ymm3
 ; FMA-RECIP-NEXT:    vfmadd132ps {{.*#+}} ymm1 = (ymm1 * ymm4) + ymm4
 ; FMA-RECIP-NEXT:    retq
 ;
 ; BDVER2-LABEL: v16f32_two_step:
 ; BDVER2:       # %bb.0:
-; BDVER2-NEXT:    vrcpps %ymm0, %ymm2 # sched: [5:2.00]
-; BDVER2-NEXT:    vmovaps {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [5:0.50]
-; BDVER2-NEXT:    vfnmaddps %ymm3, %ymm2, %ymm0, %ymm4 # sched: [5:0.50]
-; BDVER2-NEXT:    vfmaddps %ymm2, %ymm4, %ymm2, %ymm2 # sched: [5:0.50]
-; BDVER2-NEXT:    vfnmaddps %ymm3, %ymm2, %ymm0, %ymm0 # sched: [5:0.50]
-; BDVER2-NEXT:    vfmaddps %ymm2, %ymm0, %ymm2, %ymm0 # sched: [5:0.50]
-; BDVER2-NEXT:    vrcpps %ymm1, %ymm2 # sched: [5:2.00]
-; BDVER2-NEXT:    vfnmaddps %ymm3, %ymm2, %ymm1, %ymm4 # sched: [5:0.50]
-; BDVER2-NEXT:    vfmaddps %ymm2, %ymm4, %ymm2, %ymm2 # sched: [5:0.50]
-; BDVER2-NEXT:    vfnmaddps %ymm3, %ymm2, %ymm1, %ymm1 # sched: [5:0.50]
-; BDVER2-NEXT:    vfmaddps %ymm2, %ymm1, %ymm2, %ymm1 # sched: [5:0.50]
-; BDVER2-NEXT:    retq # sched: [5:1.00]
+; BDVER2-NEXT:    vrcpps %ymm0, %ymm2
+; BDVER2-NEXT:    vmovaps {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; BDVER2-NEXT:    vfnmaddps %ymm3, %ymm2, %ymm0, %ymm4
+; BDVER2-NEXT:    vfmaddps %ymm2, %ymm4, %ymm2, %ymm2
+; BDVER2-NEXT:    vfnmaddps %ymm3, %ymm2, %ymm0, %ymm0
+; BDVER2-NEXT:    vfmaddps %ymm2, %ymm0, %ymm2, %ymm0
+; BDVER2-NEXT:    vrcpps %ymm1, %ymm2
+; BDVER2-NEXT:    vfnmaddps %ymm3, %ymm2, %ymm1, %ymm4
+; BDVER2-NEXT:    vfmaddps %ymm2, %ymm4, %ymm2, %ymm2
+; BDVER2-NEXT:    vfnmaddps %ymm3, %ymm2, %ymm1, %ymm1
+; BDVER2-NEXT:    vfmaddps %ymm2, %ymm1, %ymm2, %ymm1
+; BDVER2-NEXT:    retq
 ;
 ; BTVER2-LABEL: v16f32_two_step:
 ; BTVER2:       # %bb.0:
-; BTVER2-NEXT:    vmovaps {{.*#+}} ymm4 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [5:1.00]
-; BTVER2-NEXT:    vrcpps %ymm0, %ymm2 # sched: [2:2.00]
-; BTVER2-NEXT:    vmulps %ymm2, %ymm0, %ymm3 # sched: [2:2.00]
-; BTVER2-NEXT:    vsubps %ymm3, %ymm4, %ymm3 # sched: [3:2.00]
-; BTVER2-NEXT:    vmulps %ymm3, %ymm2, %ymm3 # sched: [2:2.00]
-; BTVER2-NEXT:    vaddps %ymm3, %ymm2, %ymm2 # sched: [3:2.00]
-; BTVER2-NEXT:    vmulps %ymm2, %ymm0, %ymm0 # sched: [2:2.00]
-; BTVER2-NEXT:    vsubps %ymm0, %ymm4, %ymm0 # sched: [3:2.00]
-; BTVER2-NEXT:    vmulps %ymm0, %ymm2, %ymm0 # sched: [2:2.00]
-; BTVER2-NEXT:    vaddps %ymm0, %ymm2, %ymm0 # sched: [3:2.00]
-; BTVER2-NEXT:    vrcpps %ymm1, %ymm2 # sched: [2:2.00]
-; BTVER2-NEXT:    vmulps %ymm2, %ymm1, %ymm3 # sched: [2:2.00]
-; BTVER2-NEXT:    vsubps %ymm3, %ymm4, %ymm3 # sched: [3:2.00]
-; BTVER2-NEXT:    vmulps %ymm3, %ymm2, %ymm3 # sched: [2:2.00]
-; BTVER2-NEXT:    vaddps %ymm3, %ymm2, %ymm2 # sched: [3:2.00]
-; BTVER2-NEXT:    vmulps %ymm2, %ymm1, %ymm1 # sched: [2:2.00]
-; BTVER2-NEXT:    vsubps %ymm1, %ymm4, %ymm1 # sched: [3:2.00]
-; BTVER2-NEXT:    vmulps %ymm1, %ymm2, %ymm1 # sched: [2:2.00]
-; BTVER2-NEXT:    vaddps %ymm1, %ymm2, %ymm1 # sched: [3:2.00]
-; BTVER2-NEXT:    retq # sched: [4:1.00]
+; BTVER2-NEXT:    vmovaps {{.*#+}} ymm4 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; BTVER2-NEXT:    vrcpps %ymm0, %ymm2
+; BTVER2-NEXT:    vmulps %ymm2, %ymm0, %ymm3
+; BTVER2-NEXT:    vsubps %ymm3, %ymm4, %ymm3
+; BTVER2-NEXT:    vmulps %ymm3, %ymm2, %ymm3
+; BTVER2-NEXT:    vaddps %ymm3, %ymm2, %ymm2
+; BTVER2-NEXT:    vmulps %ymm2, %ymm0, %ymm0
+; BTVER2-NEXT:    vsubps %ymm0, %ymm4, %ymm0
+; BTVER2-NEXT:    vmulps %ymm0, %ymm2, %ymm0
+; BTVER2-NEXT:    vaddps %ymm0, %ymm2, %ymm0
+; BTVER2-NEXT:    vrcpps %ymm1, %ymm2
+; BTVER2-NEXT:    vmulps %ymm2, %ymm1, %ymm3
+; BTVER2-NEXT:    vsubps %ymm3, %ymm4, %ymm3
+; BTVER2-NEXT:    vmulps %ymm3, %ymm2, %ymm3
+; BTVER2-NEXT:    vaddps %ymm3, %ymm2, %ymm2
+; BTVER2-NEXT:    vmulps %ymm2, %ymm1, %ymm1
+; BTVER2-NEXT:    vsubps %ymm1, %ymm4, %ymm1
+; BTVER2-NEXT:    vmulps %ymm1, %ymm2, %ymm1
+; BTVER2-NEXT:    vaddps %ymm1, %ymm2, %ymm1
+; BTVER2-NEXT:    retq
 ;
 ; SANDY-LABEL: v16f32_two_step:
 ; SANDY:       # %bb.0:
-; SANDY-NEXT:    vrcpps %ymm0, %ymm2 # sched: [7:2.00]
-; SANDY-NEXT:    vmulps %ymm2, %ymm0, %ymm3 # sched: [5:1.00]
-; SANDY-NEXT:    vmovaps {{.*#+}} ymm4 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; SANDY-NEXT:    vsubps %ymm3, %ymm4, %ymm3 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %ymm3, %ymm2, %ymm3 # sched: [5:1.00]
-; SANDY-NEXT:    vaddps %ymm3, %ymm2, %ymm2 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %ymm2, %ymm0, %ymm0 # sched: [5:1.00]
-; SANDY-NEXT:    vsubps %ymm0, %ymm4, %ymm0 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %ymm0, %ymm2, %ymm0 # sched: [5:1.00]
-; SANDY-NEXT:    vaddps %ymm0, %ymm2, %ymm0 # sched: [3:1.00]
-; SANDY-NEXT:    vrcpps %ymm1, %ymm2 # sched: [7:2.00]
-; SANDY-NEXT:    vmulps %ymm2, %ymm1, %ymm3 # sched: [5:1.00]
-; SANDY-NEXT:    vsubps %ymm3, %ymm4, %ymm3 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %ymm3, %ymm2, %ymm3 # sched: [5:1.00]
-; SANDY-NEXT:    vaddps %ymm3, %ymm2, %ymm2 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %ymm2, %ymm1, %ymm1 # sched: [5:1.00]
-; SANDY-NEXT:    vsubps %ymm1, %ymm4, %ymm1 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %ymm1, %ymm2, %ymm1 # sched: [5:1.00]
-; SANDY-NEXT:    vaddps %ymm1, %ymm2, %ymm1 # sched: [3:1.00]
-; SANDY-NEXT:    retq # sched: [1:1.00]
+; SANDY-NEXT:    vrcpps %ymm0, %ymm2
+; SANDY-NEXT:    vmulps %ymm2, %ymm0, %ymm3
+; SANDY-NEXT:    vmovaps {{.*#+}} ymm4 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; SANDY-NEXT:    vsubps %ymm3, %ymm4, %ymm3
+; SANDY-NEXT:    vmulps %ymm3, %ymm2, %ymm3
+; SANDY-NEXT:    vaddps %ymm3, %ymm2, %ymm2
+; SANDY-NEXT:    vmulps %ymm2, %ymm0, %ymm0
+; SANDY-NEXT:    vsubps %ymm0, %ymm4, %ymm0
+; SANDY-NEXT:    vmulps %ymm0, %ymm2, %ymm0
+; SANDY-NEXT:    vaddps %ymm0, %ymm2, %ymm0
+; SANDY-NEXT:    vrcpps %ymm1, %ymm2
+; SANDY-NEXT:    vmulps %ymm2, %ymm1, %ymm3
+; SANDY-NEXT:    vsubps %ymm3, %ymm4, %ymm3
+; SANDY-NEXT:    vmulps %ymm3, %ymm2, %ymm3
+; SANDY-NEXT:    vaddps %ymm3, %ymm2, %ymm2
+; SANDY-NEXT:    vmulps %ymm2, %ymm1, %ymm1
+; SANDY-NEXT:    vsubps %ymm1, %ymm4, %ymm1
+; SANDY-NEXT:    vmulps %ymm1, %ymm2, %ymm1
+; SANDY-NEXT:    vaddps %ymm1, %ymm2, %ymm1
+; SANDY-NEXT:    retq
 ;
 ; HASWELL-LABEL: v16f32_two_step:
 ; HASWELL:       # %bb.0:
-; HASWELL-NEXT:    vrcpps %ymm0, %ymm2 # sched: [11:2.00]
-; HASWELL-NEXT:    vbroadcastss {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; HASWELL-NEXT:    vmovaps %ymm2, %ymm4 # sched: [1:1.00]
-; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm4 = -(ymm0 * ymm4) + ymm3 sched: [5:0.50]
-; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm4 = (ymm4 * ymm2) + ymm2 sched: [5:0.50]
-; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm4 * ymm0) + ymm3 sched: [5:0.50]
-; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm4) + ymm4 sched: [5:0.50]
-; HASWELL-NEXT:    vrcpps %ymm1, %ymm2 # sched: [11:2.00]
-; HASWELL-NEXT:    vmovaps %ymm2, %ymm4 # sched: [1:1.00]
-; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm4 = -(ymm1 * ymm4) + ymm3 sched: [5:0.50]
-; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm4 = (ymm4 * ymm2) + ymm2 sched: [5:0.50]
-; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm1 = -(ymm4 * ymm1) + ymm3 sched: [5:0.50]
-; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm1 = (ymm1 * ymm4) + ymm4 sched: [5:0.50]
-; HASWELL-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NEXT:    vrcpps %ymm0, %ymm2
+; HASWELL-NEXT:    vbroadcastss {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; HASWELL-NEXT:    vmovaps %ymm2, %ymm4
+; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm4 = -(ymm0 * ymm4) + ymm3
+; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm4 = (ymm4 * ymm2) + ymm2
+; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm4 * ymm0) + ymm3
+; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm4) + ymm4
+; HASWELL-NEXT:    vrcpps %ymm1, %ymm2
+; HASWELL-NEXT:    vmovaps %ymm2, %ymm4
+; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm4 = -(ymm1 * ymm4) + ymm3
+; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm4 = (ymm4 * ymm2) + ymm2
+; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm1 = -(ymm4 * ymm1) + ymm3
+; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm1 = (ymm1 * ymm4) + ymm4
+; HASWELL-NEXT:    retq
 ;
 ; HASWELL-NO-FMA-LABEL: v16f32_two_step:
 ; HASWELL-NO-FMA:       # %bb.0:
 ; HASWELL-NO-FMA-NEXT:    vrcpps %ymm0, %ymm2
 ; HASWELL-NO-FMA-NEXT:    vmulps %ymm2, %ymm0, %ymm3
 ; HASWELL-NO-FMA-NEXT:    vbroadcastss {{.*#+}} ymm4 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
 ; HASWELL-NO-FMA-NEXT:    vsubps %ymm3, %ymm4, %ymm3
 ; HASWELL-NO-FMA-NEXT:    vmulps %ymm3, %ymm2, %ymm3
 ; HASWELL-NO-FMA-NEXT:    vaddps %ymm3, %ymm2, %ymm2
 ; HASWELL-NO-FMA-NEXT:    vmulps %ymm2, %ymm0, %ymm0
 ; HASWELL-NO-FMA-NEXT:    vsubps %ymm0, %ymm4, %ymm0
 ; HASWELL-NO-FMA-NEXT:    vmulps %ymm0, %ymm2, %ymm0
 ; HASWELL-NO-FMA-NEXT:    vaddps %ymm0, %ymm2, %ymm0
 ; HASWELL-NO-FMA-NEXT:    vrcpps %ymm1, %ymm2
 ; HASWELL-NO-FMA-NEXT:    vmulps %ymm2, %ymm1, %ymm3
 ; HASWELL-NO-FMA-NEXT:    vsubps %ymm3, %ymm4, %ymm3
 ; HASWELL-NO-FMA-NEXT:    vmulps %ymm3, %ymm2, %ymm3
 ; HASWELL-NO-FMA-NEXT:    vaddps %ymm3, %ymm2, %ymm2
 ; HASWELL-NO-FMA-NEXT:    vmulps %ymm2, %ymm1, %ymm1
 ; HASWELL-NO-FMA-NEXT:    vsubps %ymm1, %ymm4, %ymm1
 ; HASWELL-NO-FMA-NEXT:    vmulps %ymm1, %ymm2, %ymm1
 ; HASWELL-NO-FMA-NEXT:    vaddps %ymm1, %ymm2, %ymm1
 ; HASWELL-NO-FMA-NEXT:    retq
 ;
-; KNL-LABEL: v16f32_two_step:
-; KNL:       # %bb.0:
-; KNL-NEXT:    vrcp14ps %zmm0, %zmm1 # sched: [11:2.00]
-; KNL-NEXT:    vbroadcastss {{.*#+}} zmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [10:1.00]
-; KNL-NEXT:    vmovaps %zmm1, %zmm3 # sched: [1:1.00]
-; KNL-NEXT:    vfnmadd213ps {{.*#+}} zmm3 = -(zmm0 * zmm3) + zmm2 sched: [5:0.50]
-; KNL-NEXT:    vfmadd132ps {{.*#+}} zmm3 = (zmm3 * zmm1) + zmm1 sched: [5:0.50]
-; KNL-NEXT:    vfnmadd213ps {{.*#+}} zmm0 = -(zmm3 * zmm0) + zmm2 sched: [5:0.50]
-; KNL-NEXT:    vfmadd132ps {{.*#+}} zmm0 = (zmm0 * zmm3) + zmm3 sched: [5:0.50]
-; KNL-NEXT:    retq # sched: [7:1.00]
-;
-; SKX-LABEL: v16f32_two_step:
-; SKX:       # %bb.0:
-; SKX-NEXT:    vrcp14ps %zmm0, %zmm1 # sched: [4:2.00]
-; SKX-NEXT:    vbroadcastss {{.*#+}} zmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [8:0.50]
-; SKX-NEXT:    vmovaps %zmm1, %zmm3 # sched: [1:0.33]
-; SKX-NEXT:    vfnmadd213ps {{.*#+}} zmm3 = -(zmm0 * zmm3) + zmm2 sched: [4:0.50]
-; SKX-NEXT:    vfmadd132ps {{.*#+}} zmm3 = (zmm3 * zmm1) + zmm1 sched: [4:0.50]
-; SKX-NEXT:    vfnmadd213ps {{.*#+}} zmm0 = -(zmm3 * zmm0) + zmm2 sched: [4:0.50]
-; SKX-NEXT:    vfmadd132ps {{.*#+}} zmm0 = (zmm0 * zmm3) + zmm3 sched: [4:0.50]
-; SKX-NEXT:    retq # sched: [7:1.00]
+; AVX512-LABEL: v16f32_two_step:
+; AVX512:       # %bb.0:
+; AVX512-NEXT:    vrcp14ps %zmm0, %zmm1
+; AVX512-NEXT:    vbroadcastss {{.*#+}} zmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; AVX512-NEXT:    vmovaps %zmm1, %zmm3
+; AVX512-NEXT:    vfnmadd213ps {{.*#+}} zmm3 = -(zmm0 * zmm3) + zmm2
+; AVX512-NEXT:    vfmadd132ps {{.*#+}} zmm3 = (zmm3 * zmm1) + zmm1
+; AVX512-NEXT:    vfnmadd213ps {{.*#+}} zmm0 = -(zmm3 * zmm0) + zmm2
+; AVX512-NEXT:    vfmadd132ps {{.*#+}} zmm0 = (zmm0 * zmm3) + zmm3
+; AVX512-NEXT:    retq
   %div = fdiv fast <16 x float> <float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0>, %x
   ret <16 x float> %div
 }
 
 attributes #0 = { "unsafe-fp-math"="true" "reciprocal-estimates"="!divf,!vec-divf" }
 attributes #1 = { "unsafe-fp-math"="true" "reciprocal-estimates"="divf,vec-divf" }
 attributes #2 = { "unsafe-fp-math"="true" "reciprocal-estimates"="divf:2,vec-divf:2" }
 

test/CodeGen/X86/recip-fastmath2.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
-; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=+sse2 -print-schedule      | FileCheck %s --check-prefix=CHECK --check-prefix=SSE --check-prefix=SSE-RECIP
-; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=+avx -print-schedule       | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX-RECIP
-; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=+avx,+fma -print-schedule  | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=FMA-RECIP
-; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=bdver2 -print-schedule      | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=BDVER2
-; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=btver2 -print-schedule      | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=BTVER2
-; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=sandybridge -print-schedule | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=SANDY
-; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=haswell -print-schedule     | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=HASWELL
-; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=haswell -print-schedule -mattr=-fma | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=HASWELL-NO-FMA
-; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=knl -print-schedule         | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX512 --check-prefix=KNL
-; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=skx -print-schedule         | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX512 --check-prefix=SKX
+; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=+sse2      | FileCheck %s --check-prefix=CHECK --check-prefix=SSE --check-prefix=SSE-RECIP
+; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=+avx       | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX-RECIP
+; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=+avx,+fma  | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=FMA-RECIP
+; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=bdver2      | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=BDVER2
+; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=btver2      | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=BTVER2
+; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=sandybridge | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=SANDY
+; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=haswell     | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=HASWELL
+; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=haswell -mattr=-fma | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=HASWELL-NO-FMA
+; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=knl         | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX512 --check-prefix=KNL
+; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mcpu=skx         | FileCheck %s --check-prefix=CHECK --check-prefix=AVX --check-prefix=AVX512 --check-prefix=SKX
 
 ; It's the extra tests coverage for recip as discussed on D26855.
 
 define float @f32_no_step_2(float %x) #3 {
 ; SSE-LABEL: f32_no_step_2:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    rcpss %xmm0, %xmm0
 ; SSE-NEXT:    mulss {{.*}}(%rip), %xmm0
 ; SSE-NEXT:    retq
 ;
-; AVX-RECIP-LABEL: f32_no_step_2:
-; AVX-RECIP:       # %bb.0:
-; AVX-RECIP-NEXT:    vrcpss %xmm0, %xmm0, %xmm0
-; AVX-RECIP-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0
-; AVX-RECIP-NEXT:    retq
-;
-; FMA-RECIP-LABEL: f32_no_step_2:
-; FMA-RECIP:       # %bb.0:
-; FMA-RECIP-NEXT:    vrcpss %xmm0, %xmm0, %xmm0
-; FMA-RECIP-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0
-; FMA-RECIP-NEXT:    retq
-;
-; BDVER2-LABEL: f32_no_step_2:
-; BDVER2:       # %bb.0:
-; BDVER2-NEXT:    vrcpss %xmm0, %xmm0, %xmm0 # sched: [5:1.00]
-; BDVER2-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0 # sched: [10:1.00]
-; BDVER2-NEXT:    retq # sched: [5:1.00]
-;
-; BTVER2-LABEL: f32_no_step_2:
-; BTVER2:       # %bb.0:
-; BTVER2-NEXT:    vrcpss %xmm0, %xmm0, %xmm0 # sched: [2:1.00]
-; BTVER2-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0 # sched: [7:1.00]
-; BTVER2-NEXT:    retq # sched: [4:1.00]
-;
-; SANDY-LABEL: f32_no_step_2:
-; SANDY:       # %bb.0:
-; SANDY-NEXT:    vrcpss %xmm0, %xmm0, %xmm0 # sched: [5:1.00]
-; SANDY-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0 # sched: [11:1.00]
-; SANDY-NEXT:    retq # sched: [1:1.00]
-;
-; HASWELL-LABEL: f32_no_step_2:
-; HASWELL:       # %bb.0:
-; HASWELL-NEXT:    vrcpss %xmm0, %xmm0, %xmm0 # sched: [5:1.00]
-; HASWELL-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0 # sched: [10:0.50]
-; HASWELL-NEXT:    retq # sched: [7:1.00]
-;
-; HASWELL-NO-FMA-LABEL: f32_no_step_2:
-; HASWELL-NO-FMA:       # %bb.0:
-; HASWELL-NO-FMA-NEXT:    vrcpss %xmm0, %xmm0, %xmm0 # sched: [5:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0 # sched: [10:0.50]
-; HASWELL-NO-FMA-NEXT:    retq # sched: [7:1.00]
-;
-; KNL-LABEL: f32_no_step_2:
-; KNL:       # %bb.0:
-; KNL-NEXT:    vrcpss %xmm0, %xmm0, %xmm0 # sched: [5:1.00]
-; KNL-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0 # sched: [10:0.50]
-; KNL-NEXT:    retq # sched: [7:1.00]
-;
-; SKX-LABEL: f32_no_step_2:
-; SKX:       # %bb.0:
-; SKX-NEXT:    vrcpss %xmm0, %xmm0, %xmm0 # sched: [4:1.00]
-; SKX-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0 # sched: [9:0.50]
-; SKX-NEXT:    retq # sched: [7:1.00]
+; AVX-LABEL: f32_no_step_2:
+; AVX:       # %bb.0:
+; AVX-NEXT:    vrcpss %xmm0, %xmm0, %xmm0
+; AVX-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0
+; AVX-NEXT:    retq
   %div = fdiv fast float 1234.0, %x
   ret float %div
 }
 
 define float @f32_one_step_2(float %x) #1 {
 ; SSE-LABEL: f32_one_step_2:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    rcpss %xmm0, %xmm2

 ; FMA-RECIP-NEXT:    vrcpss %xmm0, %xmm0, %xmm1
 ; FMA-RECIP-NEXT:    vfnmadd213ss {{.*#+}} xmm0 = -(xmm1 * xmm0) + mem
 ; FMA-RECIP-NEXT:    vfmadd132ss {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1
 ; FMA-RECIP-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0
 ; FMA-RECIP-NEXT:    retq
 ;
 ; BDVER2-LABEL: f32_one_step_2:
 ; BDVER2:       # %bb.0:
-; BDVER2-NEXT:    vrcpss %xmm0, %xmm0, %xmm1 # sched: [5:1.00]
-; BDVER2-NEXT:    vfnmaddss {{.*}}(%rip), %xmm1, %xmm0, %xmm0 # sched: [10:0.50]
-; BDVER2-NEXT:    vfmaddss %xmm1, %xmm0, %xmm1, %xmm0 # sched: [5:0.50]
-; BDVER2-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0 # sched: [10:1.00]
-; BDVER2-NEXT:    retq # sched: [5:1.00]
+; BDVER2-NEXT:    vrcpss %xmm0, %xmm0, %xmm1
+; BDVER2-NEXT:    vfnmaddss {{.*}}(%rip), %xmm1, %xmm0, %xmm0
+; BDVER2-NEXT:    vfmaddss %xmm1, %xmm0, %xmm1, %xmm0
+; BDVER2-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0
+; BDVER2-NEXT:    retq
 ;
 ; BTVER2-LABEL: f32_one_step_2:
 ; BTVER2:       # %bb.0:
-; BTVER2-NEXT:    vmovss {{.*#+}} xmm2 = mem[0],zero,zero,zero sched: [5:1.00]
-; BTVER2-NEXT:    vrcpss %xmm0, %xmm0, %xmm1 # sched: [2:1.00]
-; BTVER2-NEXT:    vmulss %xmm1, %xmm0, %xmm0 # sched: [2:1.00]
-; BTVER2-NEXT:    vsubss %xmm0, %xmm2, %xmm0 # sched: [3:1.00]
-; BTVER2-NEXT:    vmulss %xmm0, %xmm1, %xmm0 # sched: [2:1.00]
-; BTVER2-NEXT:    vaddss %xmm0, %xmm1, %xmm0 # sched: [3:1.00]
-; BTVER2-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0 # sched: [7:1.00]
-; BTVER2-NEXT:    retq # sched: [4:1.00]
+; BTVER2-NEXT:    vmovss {{.*#+}} xmm2 = mem[0],zero,zero,zero
+; BTVER2-NEXT:    vrcpss %xmm0, %xmm0, %xmm1
+; BTVER2-NEXT:    vmulss %xmm1, %xmm0, %xmm0
+; BTVER2-NEXT:    vsubss %xmm0, %xmm2, %xmm0
+; BTVER2-NEXT:    vmulss %xmm0, %xmm1, %xmm0
+; BTVER2-NEXT:    vaddss %xmm0, %xmm1, %xmm0
+; BTVER2-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0
+; BTVER2-NEXT:    retq
 ;
 ; SANDY-LABEL: f32_one_step_2:
 ; SANDY:       # %bb.0:
-; SANDY-NEXT:    vrcpss %xmm0, %xmm0, %xmm1 # sched: [5:1.00]
-; SANDY-NEXT:    vmulss %xmm1, %xmm0, %xmm0 # sched: [5:1.00]
-; SANDY-NEXT:    vmovss {{.*#+}} xmm2 = mem[0],zero,zero,zero sched: [6:0.50]
-; SANDY-NEXT:    vsubss %xmm0, %xmm2, %xmm0 # sched: [3:1.00]
-; SANDY-NEXT:    vmulss %xmm0, %xmm1, %xmm0 # sched: [5:1.00]
-; SANDY-NEXT:    vaddss %xmm0, %xmm1, %xmm0 # sched: [3:1.00]
-; SANDY-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0 # sched: [11:1.00]
-; SANDY-NEXT:    retq # sched: [1:1.00]
+; SANDY-NEXT:    vrcpss %xmm0, %xmm0, %xmm1
+; SANDY-NEXT:    vmulss %xmm1, %xmm0, %xmm0
+; SANDY-NEXT:    vmovss {{.*#+}} xmm2 = mem[0],zero,zero,zero
+; SANDY-NEXT:    vsubss %xmm0, %xmm2, %xmm0
+; SANDY-NEXT:    vmulss %xmm0, %xmm1, %xmm0
+; SANDY-NEXT:    vaddss %xmm0, %xmm1, %xmm0
+; SANDY-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0
+; SANDY-NEXT:    retq
 ;
 ; HASWELL-LABEL: f32_one_step_2:
 ; HASWELL:       # %bb.0:
-; HASWELL-NEXT:    vrcpss %xmm0, %xmm0, %xmm1 # sched: [5:1.00]
-; HASWELL-NEXT:    vfnmadd213ss {{.*#+}} xmm0 = -(xmm1 * xmm0) + mem sched: [10:0.50]
-; HASWELL-NEXT:    vfmadd132ss {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1 sched: [5:0.50]
-; HASWELL-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0 # sched: [10:0.50]
-; HASWELL-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NEXT:    vrcpss %xmm0, %xmm0, %xmm1
+; HASWELL-NEXT:    vfnmadd213ss {{.*#+}} xmm0 = -(xmm1 * xmm0) + mem
+; HASWELL-NEXT:    vfmadd132ss {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1
+; HASWELL-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0
+; HASWELL-NEXT:    retq
 ;
 ; HASWELL-NO-FMA-LABEL: f32_one_step_2:
 ; HASWELL-NO-FMA:       # %bb.0:
-; HASWELL-NO-FMA-NEXT:    vrcpss %xmm0, %xmm0, %xmm1 # sched: [5:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulss %xmm1, %xmm0, %xmm0 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vmovss {{.*#+}} xmm2 = mem[0],zero,zero,zero sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vsubss %xmm0, %xmm2, %xmm0 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulss %xmm0, %xmm1, %xmm0 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vaddss %xmm0, %xmm1, %xmm0 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0 # sched: [10:0.50]
-; HASWELL-NO-FMA-NEXT:    retq # sched: [7:1.00]
-;
-; KNL-LABEL: f32_one_step_2:
-; KNL:       # %bb.0:
-; KNL-NEXT:    vrcpss %xmm0, %xmm0, %xmm1 # sched: [5:1.00]
-; KNL-NEXT:    vfnmadd213ss {{.*#+}} xmm0 = -(xmm1 * xmm0) + mem sched: [10:0.50]
-; KNL-NEXT:    vfmadd132ss {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1 sched: [5:0.50]
-; KNL-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0 # sched: [10:0.50]
-; KNL-NEXT:    retq # sched: [7:1.00]
-;
-; SKX-LABEL: f32_one_step_2:
-; SKX:       # %bb.0:
-; SKX-NEXT:    vrcpss %xmm0, %xmm0, %xmm1 # sched: [4:1.00]
-; SKX-NEXT:    vfnmadd213ss {{.*#+}} xmm0 = -(xmm1 * xmm0) + mem sched: [9:0.50]
-; SKX-NEXT:    vfmadd132ss {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1 sched: [4:0.50]
-; SKX-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0 # sched: [9:0.50]
-; SKX-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NO-FMA-NEXT:    vrcpss %xmm0, %xmm0, %xmm1
+; HASWELL-NO-FMA-NEXT:    vmulss %xmm1, %xmm0, %xmm0
+; HASWELL-NO-FMA-NEXT:    vmovss {{.*#+}} xmm2 = mem[0],zero,zero,zero
+; HASWELL-NO-FMA-NEXT:    vsubss %xmm0, %xmm2, %xmm0
+; HASWELL-NO-FMA-NEXT:    vmulss %xmm0, %xmm1, %xmm0
+; HASWELL-NO-FMA-NEXT:    vaddss %xmm0, %xmm1, %xmm0
+; HASWELL-NO-FMA-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0
+; HASWELL-NO-FMA-NEXT:    retq
+;
+; AVX512-LABEL: f32_one_step_2:
+; AVX512:       # %bb.0:
+; AVX512-NEXT:    vrcpss %xmm0, %xmm0, %xmm1
+; AVX512-NEXT:    vfnmadd213ss {{.*#+}} xmm0 = -(xmm1 * xmm0) + mem
+; AVX512-NEXT:    vfmadd132ss {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1
+; AVX512-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0
+; AVX512-NEXT:    retq
   %div = fdiv fast float 3456.0, %x
   ret float %div
 }
 
 define float @f32_one_step_2_divs(float %x) #1 {
 ; SSE-LABEL: f32_one_step_2_divs:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    rcpss %xmm0, %xmm1

 ; FMA-RECIP-NEXT:    vfnmadd213ss {{.*#+}} xmm0 = -(xmm1 * xmm0) + mem
 ; FMA-RECIP-NEXT:    vfmadd132ss {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1
 ; FMA-RECIP-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm1
 ; FMA-RECIP-NEXT:    vmulss %xmm0, %xmm1, %xmm0
 ; FMA-RECIP-NEXT:    retq
 ;
 ; BDVER2-LABEL: f32_one_step_2_divs:
 ; BDVER2:       # %bb.0:
-; BDVER2-NEXT:    vrcpss %xmm0, %xmm0, %xmm1 # sched: [5:1.00]
-; BDVER2-NEXT:    vfnmaddss {{.*}}(%rip), %xmm1, %xmm0, %xmm0 # sched: [10:0.50]
-; BDVER2-NEXT:    vfmaddss %xmm1, %xmm0, %xmm1, %xmm0 # sched: [5:0.50]
-; BDVER2-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm1 # sched: [10:1.00]
-; BDVER2-NEXT:    vmulss %xmm0, %xmm1, %xmm0 # sched: [5:1.00]
-; BDVER2-NEXT:    retq # sched: [5:1.00]
+; BDVER2-NEXT:    vrcpss %xmm0, %xmm0, %xmm1
+; BDVER2-NEXT:    vfnmaddss {{.*}}(%rip), %xmm1, %xmm0, %xmm0
+; BDVER2-NEXT:    vfmaddss %xmm1, %xmm0, %xmm1, %xmm0
+; BDVER2-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm1
+; BDVER2-NEXT:    vmulss %xmm0, %xmm1, %xmm0
+; BDVER2-NEXT:    retq
 ;
 ; BTVER2-LABEL: f32_one_step_2_divs:
 ; BTVER2:       # %bb.0:
-; BTVER2-NEXT:    vmovss {{.*#+}} xmm2 = mem[0],zero,zero,zero sched: [5:1.00]
-; BTVER2-NEXT:    vrcpss %xmm0, %xmm0, %xmm1 # sched: [2:1.00]
-; BTVER2-NEXT:    vmulss %xmm1, %xmm0, %xmm0 # sched: [2:1.00]
-; BTVER2-NEXT:    vsubss %xmm0, %xmm2, %xmm0 # sched: [3:1.00]
-; BTVER2-NEXT:    vmulss %xmm0, %xmm1, %xmm0 # sched: [2:1.00]
-; BTVER2-NEXT:    vaddss %xmm0, %xmm1, %xmm0 # sched: [3:1.00]
-; BTVER2-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm1 # sched: [7:1.00]
-; BTVER2-NEXT:    vmulss %xmm0, %xmm1, %xmm0 # sched: [2:1.00]
-; BTVER2-NEXT:    retq # sched: [4:1.00]
+; BTVER2-NEXT:    vmovss {{.*#+}} xmm2 = mem[0],zero,zero,zero
+; BTVER2-NEXT:    vrcpss %xmm0, %xmm0, %xmm1
+; BTVER2-NEXT:    vmulss %xmm1, %xmm0, %xmm0
+; BTVER2-NEXT:    vsubss %xmm0, %xmm2, %xmm0
+; BTVER2-NEXT:    vmulss %xmm0, %xmm1, %xmm0
+; BTVER2-NEXT:    vaddss %xmm0, %xmm1, %xmm0
+; BTVER2-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm1
+; BTVER2-NEXT:    vmulss %xmm0, %xmm1, %xmm0
+; BTVER2-NEXT:    retq
 ;
 ; SANDY-LABEL: f32_one_step_2_divs:
 ; SANDY:       # %bb.0:
-; SANDY-NEXT:    vrcpss %xmm0, %xmm0, %xmm1 # sched: [5:1.00]
-; SANDY-NEXT:    vmulss %xmm1, %xmm0, %xmm0 # sched: [5:1.00]
-; SANDY-NEXT:    vmovss {{.*#+}} xmm2 = mem[0],zero,zero,zero sched: [6:0.50]
-; SANDY-NEXT:    vsubss %xmm0, %xmm2, %xmm0 # sched: [3:1.00]
-; SANDY-NEXT:    vmulss %xmm0, %xmm1, %xmm0 # sched: [5:1.00]
-; SANDY-NEXT:    vaddss %xmm0, %xmm1, %xmm0 # sched: [3:1.00]
-; SANDY-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm1 # sched: [11:1.00]
-; SANDY-NEXT:    vmulss %xmm0, %xmm1, %xmm0 # sched: [5:1.00]
-; SANDY-NEXT:    retq # sched: [1:1.00]
+; SANDY-NEXT:    vrcpss %xmm0, %xmm0, %xmm1
+; SANDY-NEXT:    vmulss %xmm1, %xmm0, %xmm0
+; SANDY-NEXT:    vmovss {{.*#+}} xmm2 = mem[0],zero,zero,zero
+; SANDY-NEXT:    vsubss %xmm0, %xmm2, %xmm0
+; SANDY-NEXT:    vmulss %xmm0, %xmm1, %xmm0
+; SANDY-NEXT:    vaddss %xmm0, %xmm1, %xmm0
+; SANDY-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm1
+; SANDY-NEXT:    vmulss %xmm0, %xmm1, %xmm0
+; SANDY-NEXT:    retq
 ;
 ; HASWELL-LABEL: f32_one_step_2_divs:
 ; HASWELL:       # %bb.0:
-; HASWELL-NEXT:    vrcpss %xmm0, %xmm0, %xmm1 # sched: [5:1.00]
-; HASWELL-NEXT:    vfnmadd213ss {{.*#+}} xmm0 = -(xmm1 * xmm0) + mem sched: [10:0.50]
-; HASWELL-NEXT:    vfmadd132ss {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1 sched: [5:0.50]
-; HASWELL-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm1 # sched: [10:0.50]
-; HASWELL-NEXT:    vmulss %xmm0, %xmm1, %xmm0 # sched: [5:0.50]
-; HASWELL-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NEXT:    vrcpss %xmm0, %xmm0, %xmm1
+; HASWELL-NEXT:    vfnmadd213ss {{.*#+}} xmm0 = -(xmm1 * xmm0) + mem
+; HASWELL-NEXT:    vfmadd132ss {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1
+; HASWELL-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm1
+; HASWELL-NEXT:    vmulss %xmm0, %xmm1, %xmm0
+; HASWELL-NEXT:    retq
 ;
 ; HASWELL-NO-FMA-LABEL: f32_one_step_2_divs:
 ; HASWELL-NO-FMA:       # %bb.0:
-; HASWELL-NO-FMA-NEXT:    vrcpss %xmm0, %xmm0, %xmm1 # sched: [5:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulss %xmm1, %xmm0, %xmm0 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vmovss {{.*#+}} xmm2 = mem[0],zero,zero,zero sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vsubss %xmm0, %xmm2, %xmm0 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulss %xmm0, %xmm1, %xmm0 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vaddss %xmm0, %xmm1, %xmm0 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm1 # sched: [10:0.50]
-; HASWELL-NO-FMA-NEXT:    vmulss %xmm0, %xmm1, %xmm0 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    retq # sched: [7:1.00]
-;
-; KNL-LABEL: f32_one_step_2_divs:
-; KNL:       # %bb.0:
-; KNL-NEXT:    vrcpss %xmm0, %xmm0, %xmm1 # sched: [5:1.00]
-; KNL-NEXT:    vfnmadd213ss {{.*#+}} xmm0 = -(xmm1 * xmm0) + mem sched: [10:0.50]
-; KNL-NEXT:    vfmadd132ss {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1 sched: [5:0.50]
-; KNL-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm1 # sched: [10:0.50]
-; KNL-NEXT:    vmulss %xmm0, %xmm1, %xmm0 # sched: [5:0.50]
-; KNL-NEXT:    retq # sched: [7:1.00]
-;
-; SKX-LABEL: f32_one_step_2_divs:
-; SKX:       # %bb.0:
-; SKX-NEXT:    vrcpss %xmm0, %xmm0, %xmm1 # sched: [4:1.00]
-; SKX-NEXT:    vfnmadd213ss {{.*#+}} xmm0 = -(xmm1 * xmm0) + mem sched: [9:0.50]
-; SKX-NEXT:    vfmadd132ss {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1 sched: [4:0.50]
-; SKX-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm1 # sched: [9:0.50]
-; SKX-NEXT:    vmulss %xmm0, %xmm1, %xmm0 # sched: [4:0.50]
-; SKX-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NO-FMA-NEXT:    vrcpss %xmm0, %xmm0, %xmm1
+; HASWELL-NO-FMA-NEXT:    vmulss %xmm1, %xmm0, %xmm0
+; HASWELL-NO-FMA-NEXT:    vmovss {{.*#+}} xmm2 = mem[0],zero,zero,zero
+; HASWELL-NO-FMA-NEXT:    vsubss %xmm0, %xmm2, %xmm0
+; HASWELL-NO-FMA-NEXT:    vmulss %xmm0, %xmm1, %xmm0
+; HASWELL-NO-FMA-NEXT:    vaddss %xmm0, %xmm1, %xmm0
+; HASWELL-NO-FMA-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm1
+; HASWELL-NO-FMA-NEXT:    vmulss %xmm0, %xmm1, %xmm0
+; HASWELL-NO-FMA-NEXT:    retq
+;
+; AVX512-LABEL: f32_one_step_2_divs:
+; AVX512:       # %bb.0:
+; AVX512-NEXT:    vrcpss %xmm0, %xmm0, %xmm1
+; AVX512-NEXT:    vfnmadd213ss {{.*#+}} xmm0 = -(xmm1 * xmm0) + mem
+; AVX512-NEXT:    vfmadd132ss {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1
+; AVX512-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm1
+; AVX512-NEXT:    vmulss %xmm0, %xmm1, %xmm0
+; AVX512-NEXT:    retq
   %div = fdiv fast float 3456.0, %x
   %div2 = fdiv fast float %div, %x
   ret float %div2
 }
 
 define float @f32_two_step_2(float %x) #2 {
 ; SSE-LABEL: f32_two_step_2:
 ; SSE:       # %bb.0:

 ; FMA-RECIP-NEXT:    vfmadd132ss {{.*#+}} xmm3 = (xmm3 * xmm1) + xmm1
 ; FMA-RECIP-NEXT:    vfnmadd213ss {{.*#+}} xmm0 = -(xmm3 * xmm0) + xmm2
 ; FMA-RECIP-NEXT:    vfmadd132ss {{.*#+}} xmm0 = (xmm0 * xmm3) + xmm3
 ; FMA-RECIP-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0
 ; FMA-RECIP-NEXT:    retq
 ;
 ; BDVER2-LABEL: f32_two_step_2:
 ; BDVER2:       # %bb.0:
-; BDVER2-NEXT:    vrcpss %xmm0, %xmm0, %xmm1 # sched: [5:1.00]
-; BDVER2-NEXT:    vmovss {{.*#+}} xmm2 = mem[0],zero,zero,zero sched: [5:0.50]
-; BDVER2-NEXT:    vfnmaddss %xmm2, %xmm1, %xmm0, %xmm3 # sched: [5:0.50]
-; BDVER2-NEXT:    vfmaddss %xmm1, %xmm3, %xmm1, %xmm1 # sched: [5:0.50]
-; BDVER2-NEXT:    vfnmaddss %xmm2, %xmm1, %xmm0, %xmm0 # sched: [5:0.50]
-; BDVER2-NEXT:    vfmaddss %xmm1, %xmm0, %xmm1, %xmm0 # sched: [5:0.50]
-; BDVER2-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0 # sched: [10:1.00]
-; BDVER2-NEXT:    retq # sched: [5:1.00]
+; BDVER2-NEXT:    vrcpss %xmm0, %xmm0, %xmm1
+; BDVER2-NEXT:    vmovss {{.*#+}} xmm2 = mem[0],zero,zero,zero
+; BDVER2-NEXT:    vfnmaddss %xmm2, %xmm1, %xmm0, %xmm3
+; BDVER2-NEXT:    vfmaddss %xmm1, %xmm3, %xmm1, %xmm1
+; BDVER2-NEXT:    vfnmaddss %xmm2, %xmm1, %xmm0, %xmm0
+; BDVER2-NEXT:    vfmaddss %xmm1, %xmm0, %xmm1, %xmm0
+; BDVER2-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0
+; BDVER2-NEXT:    retq
 ;
 ; BTVER2-LABEL: f32_two_step_2:
 ; BTVER2:       # %bb.0:
-; BTVER2-NEXT:    vmovss {{.*#+}} xmm3 = mem[0],zero,zero,zero sched: [5:1.00]
-; BTVER2-NEXT:    vrcpss %xmm0, %xmm0, %xmm1 # sched: [2:1.00]
-; BTVER2-NEXT:    vmulss %xmm1, %xmm0, %xmm2 # sched: [2:1.00]
-; BTVER2-NEXT:    vsubss %xmm2, %xmm3, %xmm2 # sched: [3:1.00]
-; BTVER2-NEXT:    vmulss %xmm2, %xmm1, %xmm2 # sched: [2:1.00]
-; BTVER2-NEXT:    vaddss %xmm2, %xmm1, %xmm1 # sched: [3:1.00]
-; BTVER2-NEXT:    vmulss %xmm1, %xmm0, %xmm0 # sched: [2:1.00]
-; BTVER2-NEXT:    vsubss %xmm0, %xmm3, %xmm0 # sched: [3:1.00]
-; BTVER2-NEXT:    vmulss %xmm0, %xmm1, %xmm0 # sched: [2:1.00]
-; BTVER2-NEXT:    vaddss %xmm0, %xmm1, %xmm0 # sched: [3:1.00]
-; BTVER2-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0 # sched: [7:1.00]
-; BTVER2-NEXT:    retq # sched: [4:1.00]
+; BTVER2-NEXT:    vmovss {{.*#+}} xmm3 = mem[0],zero,zero,zero
+; BTVER2-NEXT:    vrcpss %xmm0, %xmm0, %xmm1
+; BTVER2-NEXT:    vmulss %xmm1, %xmm0, %xmm2
+; BTVER2-NEXT:    vsubss %xmm2, %xmm3, %xmm2
+; BTVER2-NEXT:    vmulss %xmm2, %xmm1, %xmm2
+; BTVER2-NEXT:    vaddss %xmm2, %xmm1, %xmm1
+; BTVER2-NEXT:    vmulss %xmm1, %xmm0, %xmm0
+; BTVER2-NEXT:    vsubss %xmm0, %xmm3, %xmm0
+; BTVER2-NEXT:    vmulss %xmm0, %xmm1, %xmm0
+; BTVER2-NEXT:    vaddss %xmm0, %xmm1, %xmm0
+; BTVER2-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0
+; BTVER2-NEXT:    retq
 ;
 ; SANDY-LABEL: f32_two_step_2:
 ; SANDY:       # %bb.0:
-; SANDY-NEXT:    vrcpss %xmm0, %xmm0, %xmm1 # sched: [5:1.00]
-; SANDY-NEXT:    vmulss %xmm1, %xmm0, %xmm2 # sched: [5:1.00]
-; SANDY-NEXT:    vmovss {{.*#+}} xmm3 = mem[0],zero,zero,zero sched: [6:0.50]
-; SANDY-NEXT:    vsubss %xmm2, %xmm3, %xmm2 # sched: [3:1.00]
-; SANDY-NEXT:    vmulss %xmm2, %xmm1, %xmm2 # sched: [5:1.00]
-; SANDY-NEXT:    vaddss %xmm2, %xmm1, %xmm1 # sched: [3:1.00]
-; SANDY-NEXT:    vmulss %xmm1, %xmm0, %xmm0 # sched: [5:1.00]
-; SANDY-NEXT:    vsubss %xmm0, %xmm3, %xmm0 # sched: [3:1.00]
-; SANDY-NEXT:    vmulss %xmm0, %xmm1, %xmm0 # sched: [5:1.00]
-; SANDY-NEXT:    vaddss %xmm0, %xmm1, %xmm0 # sched: [3:1.00]
-; SANDY-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0 # sched: [11:1.00]
-; SANDY-NEXT:    retq # sched: [1:1.00]
+; SANDY-NEXT:    vrcpss %xmm0, %xmm0, %xmm1
+; SANDY-NEXT:    vmulss %xmm1, %xmm0, %xmm2
+; SANDY-NEXT:    vmovss {{.*#+}} xmm3 = mem[0],zero,zero,zero
+; SANDY-NEXT:    vsubss %xmm2, %xmm3, %xmm2
+; SANDY-NEXT:    vmulss %xmm2, %xmm1, %xmm2
+; SANDY-NEXT:    vaddss %xmm2, %xmm1, %xmm1
+; SANDY-NEXT:    vmulss %xmm1, %xmm0, %xmm0
+; SANDY-NEXT:    vsubss %xmm0, %xmm3, %xmm0
+; SANDY-NEXT:    vmulss %xmm0, %xmm1, %xmm0
+; SANDY-NEXT:    vaddss %xmm0, %xmm1, %xmm0
+; SANDY-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0
+; SANDY-NEXT:    retq
 ;
 ; HASWELL-LABEL: f32_two_step_2:
 ; HASWELL:       # %bb.0:
-; HASWELL-NEXT:    vrcpss %xmm0, %xmm0, %xmm1 # sched: [5:1.00]
-; HASWELL-NEXT:    vmovss {{.*#+}} xmm2 = mem[0],zero,zero,zero sched: [5:0.50]
-; HASWELL-NEXT:    vmovaps %xmm1, %xmm3 # sched: [1:1.00]
-; HASWELL-NEXT:    vfnmadd213ss {{.*#+}} xmm3 = -(xmm0 * xmm3) + xmm2 sched: [5:0.50]
-; HASWELL-NEXT:    vfmadd132ss {{.*#+}} xmm3 = (xmm3 * xmm1) + xmm1 sched: [5:0.50]
-; HASWELL-NEXT:    vfnmadd213ss {{.*#+}} xmm0 = -(xmm3 * xmm0) + xmm2 sched: [5:0.50]
-; HASWELL-NEXT:    vfmadd132ss {{.*#+}} xmm0 = (xmm0 * xmm3) + xmm3 sched: [5:0.50]
-; HASWELL-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0 # sched: [10:0.50]
-; HASWELL-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NEXT:    vrcpss %xmm0, %xmm0, %xmm1
+; HASWELL-NEXT:    vmovss {{.*#+}} xmm2 = mem[0],zero,zero,zero
+; HASWELL-NEXT:    vmovaps %xmm1, %xmm3
+; HASWELL-NEXT:    vfnmadd213ss {{.*#+}} xmm3 = -(xmm0 * xmm3) + xmm2
+; HASWELL-NEXT:    vfmadd132ss {{.*#+}} xmm3 = (xmm3 * xmm1) + xmm1
+; HASWELL-NEXT:    vfnmadd213ss {{.*#+}} xmm0 = -(xmm3 * xmm0) + xmm2
+; HASWELL-NEXT:    vfmadd132ss {{.*#+}} xmm0 = (xmm0 * xmm3) + xmm3
+; HASWELL-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0
+; HASWELL-NEXT:    retq
 ;
 ; HASWELL-NO-FMA-LABEL: f32_two_step_2:
 ; HASWELL-NO-FMA:       # %bb.0:
-; HASWELL-NO-FMA-NEXT:    vrcpss %xmm0, %xmm0, %xmm1 # sched: [5:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulss %xmm1, %xmm0, %xmm2 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vmovss {{.*#+}} xmm3 = mem[0],zero,zero,zero sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vsubss %xmm2, %xmm3, %xmm2 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulss %xmm2, %xmm1, %xmm2 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vaddss %xmm2, %xmm1, %xmm1 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulss %xmm1, %xmm0, %xmm0 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vsubss %xmm0, %xmm3, %xmm0 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulss %xmm0, %xmm1, %xmm0 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vaddss %xmm0, %xmm1, %xmm0 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0 # sched: [10:0.50]
-; HASWELL-NO-FMA-NEXT:    retq # sched: [7:1.00]
-;
-; KNL-LABEL: f32_two_step_2:
-; KNL:       # %bb.0:
-; KNL-NEXT:    vrcpss %xmm0, %xmm0, %xmm1 # sched: [5:1.00]
-; KNL-NEXT:    vmovss {{.*#+}} xmm2 = mem[0],zero,zero,zero sched: [5:0.50]
-; KNL-NEXT:    vmovaps %xmm1, %xmm3 # sched: [1:1.00]
-; KNL-NEXT:    vfnmadd213ss {{.*#+}} xmm3 = -(xmm0 * xmm3) + xmm2 sched: [5:0.50]
-; KNL-NEXT:    vfmadd132ss {{.*#+}} xmm3 = (xmm3 * xmm1) + xmm1 sched: [5:0.50]
-; KNL-NEXT:    vfnmadd213ss {{.*#+}} xmm0 = -(xmm3 * xmm0) + xmm2 sched: [5:0.50]
-; KNL-NEXT:    vfmadd132ss {{.*#+}} xmm0 = (xmm0 * xmm3) + xmm3 sched: [5:0.50]
-; KNL-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0 # sched: [10:0.50]
-; KNL-NEXT:    retq # sched: [7:1.00]
-;
-; SKX-LABEL: f32_two_step_2:
-; SKX:       # %bb.0:
-; SKX-NEXT:    vrcpss %xmm0, %xmm0, %xmm1 # sched: [4:1.00]
-; SKX-NEXT:    vmovss {{.*#+}} xmm2 = mem[0],zero,zero,zero sched: [5:0.50]
-; SKX-NEXT:    vmovaps %xmm1, %xmm3 # sched: [1:0.33]
-; SKX-NEXT:    vfnmadd213ss {{.*#+}} xmm3 = -(xmm0 * xmm3) + xmm2 sched: [4:0.50]
-; SKX-NEXT:    vfmadd132ss {{.*#+}} xmm3 = (xmm3 * xmm1) + xmm1 sched: [4:0.50]
-; SKX-NEXT:    vfnmadd213ss {{.*#+}} xmm0 = -(xmm3 * xmm0) + xmm2 sched: [4:0.50]
-; SKX-NEXT:    vfmadd132ss {{.*#+}} xmm0 = (xmm0 * xmm3) + xmm3 sched: [4:0.50]
-; SKX-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0 # sched: [9:0.50]
-; SKX-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NO-FMA-NEXT:    vrcpss %xmm0, %xmm0, %xmm1
+; HASWELL-NO-FMA-NEXT:    vmulss %xmm1, %xmm0, %xmm2
+; HASWELL-NO-FMA-NEXT:    vmovss {{.*#+}} xmm3 = mem[0],zero,zero,zero
+; HASWELL-NO-FMA-NEXT:    vsubss %xmm2, %xmm3, %xmm2
+; HASWELL-NO-FMA-NEXT:    vmulss %xmm2, %xmm1, %xmm2
+; HASWELL-NO-FMA-NEXT:    vaddss %xmm2, %xmm1, %xmm1
+; HASWELL-NO-FMA-NEXT:    vmulss %xmm1, %xmm0, %xmm0
+; HASWELL-NO-FMA-NEXT:    vsubss %xmm0, %xmm3, %xmm0
+; HASWELL-NO-FMA-NEXT:    vmulss %xmm0, %xmm1, %xmm0
+; HASWELL-NO-FMA-NEXT:    vaddss %xmm0, %xmm1, %xmm0
+; HASWELL-NO-FMA-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0
+; HASWELL-NO-FMA-NEXT:    retq
+;
+; AVX512-LABEL: f32_two_step_2:
+; AVX512:       # %bb.0:
+; AVX512-NEXT:    vrcpss %xmm0, %xmm0, %xmm1
+; AVX512-NEXT:    vmovss {{.*#+}} xmm2 = mem[0],zero,zero,zero
+; AVX512-NEXT:    vmovaps %xmm1, %xmm3
+; AVX512-NEXT:    vfnmadd213ss {{.*#+}} xmm3 = -(xmm0 * xmm3) + xmm2
+; AVX512-NEXT:    vfmadd132ss {{.*#+}} xmm3 = (xmm3 * xmm1) + xmm1
+; AVX512-NEXT:    vfnmadd213ss {{.*#+}} xmm0 = -(xmm3 * xmm0) + xmm2
+; AVX512-NEXT:    vfmadd132ss {{.*#+}} xmm0 = (xmm0 * xmm3) + xmm3
+; AVX512-NEXT:    vmulss {{.*}}(%rip), %xmm0, %xmm0
+; AVX512-NEXT:    retq
   %div = fdiv fast float 6789.0, %x
   ret float %div
 }
 
 define <4 x float> @v4f32_one_step2(<4 x float> %x) #1 {
 ; SSE-LABEL: v4f32_one_step2:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    rcpps %xmm0, %xmm2

 ; FMA-RECIP-NEXT:    vrcpps %xmm0, %xmm1
 ; FMA-RECIP-NEXT:    vfnmadd213ps {{.*#+}} xmm0 = -(xmm1 * xmm0) + mem
 ; FMA-RECIP-NEXT:    vfmadd132ps {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1
 ; FMA-RECIP-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm0
 ; FMA-RECIP-NEXT:    retq
 ;
 ; BDVER2-LABEL: v4f32_one_step2:
 ; BDVER2:       # %bb.0:
-; BDVER2-NEXT:    vrcpps %xmm0, %xmm1 # sched: [5:1.00]
-; BDVER2-NEXT:    vfnmaddps {{.*}}(%rip), %xmm1, %xmm0, %xmm0 # sched: [10:0.50]
-; BDVER2-NEXT:    vfmaddps %xmm1, %xmm0, %xmm1, %xmm0 # sched: [5:0.50]
-; BDVER2-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm0 # sched: [10:1.00]
-; BDVER2-NEXT:    retq # sched: [5:1.00]
+; BDVER2-NEXT:    vrcpps %xmm0, %xmm1
+; BDVER2-NEXT:    vfnmaddps {{.*}}(%rip), %xmm1, %xmm0, %xmm0
+; BDVER2-NEXT:    vfmaddps %xmm1, %xmm0, %xmm1, %xmm0
+; BDVER2-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm0
+; BDVER2-NEXT:    retq
 ;
 ; BTVER2-LABEL: v4f32_one_step2:
 ; BTVER2:       # %bb.0:
-; BTVER2-NEXT:    vmovaps {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [5:1.00]
-; BTVER2-NEXT:    vrcpps %xmm0, %xmm1 # sched: [2:1.00]
-; BTVER2-NEXT:    vmulps %xmm1, %xmm0, %xmm0 # sched: [2:1.00]
-; BTVER2-NEXT:    vsubps %xmm0, %xmm2, %xmm0 # sched: [3:1.00]
-; BTVER2-NEXT:    vmulps %xmm0, %xmm1, %xmm0 # sched: [2:1.00]
-; BTVER2-NEXT:    vaddps %xmm0, %xmm1, %xmm0 # sched: [3:1.00]
-; BTVER2-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm0 # sched: [7:1.00]
-; BTVER2-NEXT:    retq # sched: [4:1.00]
+; BTVER2-NEXT:    vmovaps {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; BTVER2-NEXT:    vrcpps %xmm0, %xmm1
+; BTVER2-NEXT:    vmulps %xmm1, %xmm0, %xmm0
+; BTVER2-NEXT:    vsubps %xmm0, %xmm2, %xmm0
+; BTVER2-NEXT:    vmulps %xmm0, %xmm1, %xmm0
+; BTVER2-NEXT:    vaddps %xmm0, %xmm1, %xmm0
+; BTVER2-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm0
+; BTVER2-NEXT:    retq
 ;
 ; SANDY-LABEL: v4f32_one_step2:
 ; SANDY:       # %bb.0:
-; SANDY-NEXT:    vrcpps %xmm0, %xmm1 # sched: [5:1.00]
-; SANDY-NEXT:    vmulps %xmm1, %xmm0, %xmm0 # sched: [5:1.00]
-; SANDY-NEXT:    vmovaps {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [6:0.50]
-; SANDY-NEXT:    vsubps %xmm0, %xmm2, %xmm0 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %xmm0, %xmm1, %xmm0 # sched: [5:1.00]
-; SANDY-NEXT:    vaddps %xmm0, %xmm1, %xmm0 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm0 # sched: [11:1.00]
-; SANDY-NEXT:    retq # sched: [1:1.00]
+; SANDY-NEXT:    vrcpps %xmm0, %xmm1
+; SANDY-NEXT:    vmulps %xmm1, %xmm0, %xmm0
+; SANDY-NEXT:    vmovaps {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; SANDY-NEXT:    vsubps %xmm0, %xmm2, %xmm0
+; SANDY-NEXT:    vmulps %xmm0, %xmm1, %xmm0
+; SANDY-NEXT:    vaddps %xmm0, %xmm1, %xmm0
+; SANDY-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm0
+; SANDY-NEXT:    retq
 ;
 ; HASWELL-LABEL: v4f32_one_step2:
 ; HASWELL:       # %bb.0:
-; HASWELL-NEXT:    vrcpps %xmm0, %xmm1 # sched: [5:1.00]
-; HASWELL-NEXT:    vbroadcastss {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [6:0.50]
-; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} xmm0 = -(xmm1 * xmm0) + xmm2 sched: [5:0.50]
-; HASWELL-NEXT:    vfmadd132ps {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1 sched: [5:0.50]
-; HASWELL-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm0 # sched: [11:0.50]
-; HASWELL-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NEXT:    vrcpps %xmm0, %xmm1
+; HASWELL-NEXT:    vbroadcastss {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} xmm0 = -(xmm1 * xmm0) + xmm2
+; HASWELL-NEXT:    vfmadd132ps {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1
+; HASWELL-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm0
+; HASWELL-NEXT:    retq
 ;
 ; HASWELL-NO-FMA-LABEL: v4f32_one_step2:
 ; HASWELL-NO-FMA:       # %bb.0:
-; HASWELL-NO-FMA-NEXT:    vrcpps %xmm0, %xmm1 # sched: [5:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulps %xmm1, %xmm0, %xmm0 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vbroadcastss {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [6:0.50]
-; HASWELL-NO-FMA-NEXT:    vsubps %xmm0, %xmm2, %xmm0 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulps %xmm0, %xmm1, %xmm0 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vaddps %xmm0, %xmm1, %xmm0 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm0 # sched: [11:0.50]
-; HASWELL-NO-FMA-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NO-FMA-NEXT:    vrcpps %xmm0, %xmm1
+; HASWELL-NO-FMA-NEXT:    vmulps %xmm1, %xmm0, %xmm0
+; HASWELL-NO-FMA-NEXT:    vbroadcastss {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; HASWELL-NO-FMA-NEXT:    vsubps %xmm0, %xmm2, %xmm0
+; HASWELL-NO-FMA-NEXT:    vmulps %xmm0, %xmm1, %xmm0
+; HASWELL-NO-FMA-NEXT:    vaddps %xmm0, %xmm1, %xmm0
+; HASWELL-NO-FMA-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm0
+; HASWELL-NO-FMA-NEXT:    retq
 ;
 ; KNL-LABEL: v4f32_one_step2:
 ; KNL:       # %bb.0:
-; KNL-NEXT:    vrcpps %xmm0, %xmm1 # sched: [5:1.00]
-; KNL-NEXT:    vbroadcastss {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [6:0.50]
-; KNL-NEXT:    vfnmadd213ps {{.*#+}} xmm0 = -(xmm1 * xmm0) + xmm2 sched: [5:0.50]
-; KNL-NEXT:    vfmadd132ps {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1 sched: [5:0.50]
-; KNL-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm0 # sched: [11:0.50]
-; KNL-NEXT:    retq # sched: [7:1.00]
+; KNL-NEXT:    vrcpps %xmm0, %xmm1
+; KNL-NEXT:    vbroadcastss {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; KNL-NEXT:    vfnmadd213ps {{.*#+}} xmm0 = -(xmm1 * xmm0) + xmm2
+; KNL-NEXT:    vfmadd132ps {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1
+; KNL-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm0
+; KNL-NEXT:    retq
 ;
 ; SKX-LABEL: v4f32_one_step2:
 ; SKX:       # %bb.0:
-; SKX-NEXT:    vrcpps %xmm0, %xmm1 # sched: [4:1.00]
-; SKX-NEXT:    vfnmadd213ps {{.*#+}} xmm0 = -(xmm1 * xmm0) + mem sched: [10:0.50]
-; SKX-NEXT:    vfmadd132ps {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1 sched: [4:0.50]
-; SKX-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm0 # sched: [10:0.50]
-; SKX-NEXT:    retq # sched: [7:1.00]
+; SKX-NEXT:    vrcpps %xmm0, %xmm1
+; SKX-NEXT:    vfnmadd213ps {{.*#+}} xmm0 = -(xmm1 * xmm0) + mem
+; SKX-NEXT:    vfmadd132ps {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1
+; SKX-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm0
+; SKX-NEXT:    retq
   %div = fdiv fast <4 x float> <float 1.0, float 2.0, float 3.0, float 4.0>, %x
   ret <4 x float> %div
 }
 
 define <4 x float> @v4f32_one_step_2_divs(<4 x float> %x) #1 {
 ; SSE-LABEL: v4f32_one_step_2_divs:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    rcpps %xmm0, %xmm1

 ; FMA-RECIP-NEXT:    vfnmadd213ps {{.*#+}} xmm0 = -(xmm1 * xmm0) + mem
 ; FMA-RECIP-NEXT:    vfmadd132ps {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1
 ; FMA-RECIP-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm1
 ; FMA-RECIP-NEXT:    vmulps %xmm0, %xmm1, %xmm0
 ; FMA-RECIP-NEXT:    retq
 ;
 ; BDVER2-LABEL: v4f32_one_step_2_divs:
 ; BDVER2:       # %bb.0:
-; BDVER2-NEXT:    vrcpps %xmm0, %xmm1 # sched: [5:1.00]
-; BDVER2-NEXT:    vfnmaddps {{.*}}(%rip), %xmm1, %xmm0, %xmm0 # sched: [10:0.50]
-; BDVER2-NEXT:    vfmaddps %xmm1, %xmm0, %xmm1, %xmm0 # sched: [5:0.50]
-; BDVER2-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm1 # sched: [10:1.00]
-; BDVER2-NEXT:    vmulps %xmm0, %xmm1, %xmm0 # sched: [5:1.00]
-; BDVER2-NEXT:    retq # sched: [5:1.00]
+; BDVER2-NEXT:    vrcpps %xmm0, %xmm1
+; BDVER2-NEXT:    vfnmaddps {{.*}}(%rip), %xmm1, %xmm0, %xmm0
+; BDVER2-NEXT:    vfmaddps %xmm1, %xmm0, %xmm1, %xmm0
+; BDVER2-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm1
+; BDVER2-NEXT:    vmulps %xmm0, %xmm1, %xmm0
+; BDVER2-NEXT:    retq
 ;
 ; BTVER2-LABEL: v4f32_one_step_2_divs:
 ; BTVER2:       # %bb.0:
-; BTVER2-NEXT:    vmovaps {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [5:1.00]
-; BTVER2-NEXT:    vrcpps %xmm0, %xmm1 # sched: [2:1.00]
-; BTVER2-NEXT:    vmulps %xmm1, %xmm0, %xmm0 # sched: [2:1.00]
-; BTVER2-NEXT:    vsubps %xmm0, %xmm2, %xmm0 # sched: [3:1.00]
-; BTVER2-NEXT:    vmulps %xmm0, %xmm1, %xmm0 # sched: [2:1.00]
-; BTVER2-NEXT:    vaddps %xmm0, %xmm1, %xmm0 # sched: [3:1.00]
-; BTVER2-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm1 # sched: [7:1.00]
-; BTVER2-NEXT:    vmulps %xmm0, %xmm1, %xmm0 # sched: [2:1.00]
-; BTVER2-NEXT:    retq # sched: [4:1.00]
+; BTVER2-NEXT:    vmovaps {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; BTVER2-NEXT:    vrcpps %xmm0, %xmm1
+; BTVER2-NEXT:    vmulps %xmm1, %xmm0, %xmm0
+; BTVER2-NEXT:    vsubps %xmm0, %xmm2, %xmm0
+; BTVER2-NEXT:    vmulps %xmm0, %xmm1, %xmm0
+; BTVER2-NEXT:    vaddps %xmm0, %xmm1, %xmm0
+; BTVER2-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm1
+; BTVER2-NEXT:    vmulps %xmm0, %xmm1, %xmm0
+; BTVER2-NEXT:    retq
 ;
 ; SANDY-LABEL: v4f32_one_step_2_divs:
 ; SANDY:       # %bb.0:
-; SANDY-NEXT:    vrcpps %xmm0, %xmm1 # sched: [5:1.00]
-; SANDY-NEXT:    vmulps %xmm1, %xmm0, %xmm0 # sched: [5:1.00]
-; SANDY-NEXT:    vmovaps {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [6:0.50]
-; SANDY-NEXT:    vsubps %xmm0, %xmm2, %xmm0 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %xmm0, %xmm1, %xmm0 # sched: [5:1.00]
-; SANDY-NEXT:    vaddps %xmm0, %xmm1, %xmm0 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm1 # sched: [11:1.00]
-; SANDY-NEXT:    vmulps %xmm0, %xmm1, %xmm0 # sched: [5:1.00]
-; SANDY-NEXT:    retq # sched: [1:1.00]
+; SANDY-NEXT:    vrcpps %xmm0, %xmm1
+; SANDY-NEXT:    vmulps %xmm1, %xmm0, %xmm0
+; SANDY-NEXT:    vmovaps {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; SANDY-NEXT:    vsubps %xmm0, %xmm2, %xmm0
+; SANDY-NEXT:    vmulps %xmm0, %xmm1, %xmm0
+; SANDY-NEXT:    vaddps %xmm0, %xmm1, %xmm0
+; SANDY-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm1
+; SANDY-NEXT:    vmulps %xmm0, %xmm1, %xmm0
+; SANDY-NEXT:    retq
 ;
 ; HASWELL-LABEL: v4f32_one_step_2_divs:
 ; HASWELL:       # %bb.0:
-; HASWELL-NEXT:    vrcpps %xmm0, %xmm1 # sched: [5:1.00]
-; HASWELL-NEXT:    vbroadcastss {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [6:0.50]
-; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} xmm0 = -(xmm1 * xmm0) + xmm2 sched: [5:0.50]
-; HASWELL-NEXT:    vfmadd132ps {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1 sched: [5:0.50]
-; HASWELL-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm1 # sched: [11:0.50]
-; HASWELL-NEXT:    vmulps %xmm0, %xmm1, %xmm0 # sched: [5:0.50]
-; HASWELL-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NEXT:    vrcpps %xmm0, %xmm1
+; HASWELL-NEXT:    vbroadcastss {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} xmm0 = -(xmm1 * xmm0) + xmm2
+; HASWELL-NEXT:    vfmadd132ps {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1
+; HASWELL-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm1
+; HASWELL-NEXT:    vmulps %xmm0, %xmm1, %xmm0
+; HASWELL-NEXT:    retq
 ;
 ; HASWELL-NO-FMA-LABEL: v4f32_one_step_2_divs:
 ; HASWELL-NO-FMA:       # %bb.0:
-; HASWELL-NO-FMA-NEXT:    vrcpps %xmm0, %xmm1 # sched: [5:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulps %xmm1, %xmm0, %xmm0 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vbroadcastss {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [6:0.50]
-; HASWELL-NO-FMA-NEXT:    vsubps %xmm0, %xmm2, %xmm0 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulps %xmm0, %xmm1, %xmm0 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vaddps %xmm0, %xmm1, %xmm0 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm1 # sched: [11:0.50]
-; HASWELL-NO-FMA-NEXT:    vmulps %xmm0, %xmm1, %xmm0 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NO-FMA-NEXT:    vrcpps %xmm0, %xmm1
+; HASWELL-NO-FMA-NEXT:    vmulps %xmm1, %xmm0, %xmm0
+; HASWELL-NO-FMA-NEXT:    vbroadcastss {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; HASWELL-NO-FMA-NEXT:    vsubps %xmm0, %xmm2, %xmm0
+; HASWELL-NO-FMA-NEXT:    vmulps %xmm0, %xmm1, %xmm0
+; HASWELL-NO-FMA-NEXT:    vaddps %xmm0, %xmm1, %xmm0
+; HASWELL-NO-FMA-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm1
+; HASWELL-NO-FMA-NEXT:    vmulps %xmm0, %xmm1, %xmm0
+; HASWELL-NO-FMA-NEXT:    retq
 ;
 ; KNL-LABEL: v4f32_one_step_2_divs:
 ; KNL:       # %bb.0:
-; KNL-NEXT:    vrcpps %xmm0, %xmm1 # sched: [5:1.00]
-; KNL-NEXT:    vbroadcastss {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [6:0.50]
-; KNL-NEXT:    vfnmadd213ps {{.*#+}} xmm0 = -(xmm1 * xmm0) + xmm2 sched: [5:0.50]
-; KNL-NEXT:    vfmadd132ps {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1 sched: [5:0.50]
-; KNL-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm1 # sched: [11:0.50]
-; KNL-NEXT:    vmulps %xmm0, %xmm1, %xmm0 # sched: [5:0.50]
-; KNL-NEXT:    retq # sched: [7:1.00]
+; KNL-NEXT:    vrcpps %xmm0, %xmm1
+; KNL-NEXT:    vbroadcastss {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; KNL-NEXT:    vfnmadd213ps {{.*#+}} xmm0 = -(xmm1 * xmm0) + xmm2
+; KNL-NEXT:    vfmadd132ps {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1
+; KNL-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm1
+; KNL-NEXT:    vmulps %xmm0, %xmm1, %xmm0
+; KNL-NEXT:    retq
 ;
 ; SKX-LABEL: v4f32_one_step_2_divs:
 ; SKX:       # %bb.0:
-; SKX-NEXT:    vrcpps %xmm0, %xmm1 # sched: [4:1.00]
-; SKX-NEXT:    vfnmadd213ps {{.*#+}} xmm0 = -(xmm1 * xmm0) + mem sched: [10:0.50]
-; SKX-NEXT:    vfmadd132ps {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1 sched: [4:0.50]
-; SKX-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm1 # sched: [10:0.50]
-; SKX-NEXT:    vmulps %xmm0, %xmm1, %xmm0 # sched: [4:0.50]
-; SKX-NEXT:    retq # sched: [7:1.00]
+; SKX-NEXT:    vrcpps %xmm0, %xmm1
+; SKX-NEXT:    vfnmadd213ps {{.*#+}} xmm0 = -(xmm1 * xmm0) + mem
+; SKX-NEXT:    vfmadd132ps {{.*#+}} xmm0 = (xmm0 * xmm1) + xmm1
+; SKX-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm1
+; SKX-NEXT:    vmulps %xmm0, %xmm1, %xmm0
+; SKX-NEXT:    retq
   %div = fdiv fast <4 x float> <float 1.0, float 2.0, float 3.0, float 4.0>, %x
   %div2 = fdiv fast <4 x float> %div, %x
   ret <4 x float> %div2
 }
 
 define <4 x float> @v4f32_two_step2(<4 x float> %x) #2 {
 ; SSE-LABEL: v4f32_two_step2:
 ; SSE:       # %bb.0:

 ; FMA-RECIP-NEXT:    vfmadd132ps {{.*#+}} xmm3 = (xmm3 * xmm1) + xmm1
 ; FMA-RECIP-NEXT:    vfnmadd213ps {{.*#+}} xmm0 = -(xmm3 * xmm0) + xmm2
 ; FMA-RECIP-NEXT:    vfmadd132ps {{.*#+}} xmm0 = (xmm0 * xmm3) + xmm3
 ; FMA-RECIP-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm0
 ; FMA-RECIP-NEXT:    retq
 ;
 ; BDVER2-LABEL: v4f32_two_step2:
 ; BDVER2:       # %bb.0:
-; BDVER2-NEXT:    vrcpps %xmm0, %xmm1 # sched: [5:1.00]
-; BDVER2-NEXT:    vmovaps {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [5:0.50]
-; BDVER2-NEXT:    vfnmaddps %xmm2, %xmm1, %xmm0, %xmm3 # sched: [5:0.50]
-; BDVER2-NEXT:    vfmaddps %xmm1, %xmm3, %xmm1, %xmm1 # sched: [5:0.50]
-; BDVER2-NEXT:    vfnmaddps %xmm2, %xmm1, %xmm0, %xmm0 # sched: [5:0.50]
-; BDVER2-NEXT:    vfmaddps %xmm1, %xmm0, %xmm1, %xmm0 # sched: [5:0.50]
-; BDVER2-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm0 # sched: [10:1.00]
-; BDVER2-NEXT:    retq # sched: [5:1.00]
+; BDVER2-NEXT:    vrcpps %xmm0, %xmm1
+; BDVER2-NEXT:    vmovaps {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; BDVER2-NEXT:    vfnmaddps %xmm2, %xmm1, %xmm0, %xmm3
+; BDVER2-NEXT:    vfmaddps %xmm1, %xmm3, %xmm1, %xmm1
+; BDVER2-NEXT:    vfnmaddps %xmm2, %xmm1, %xmm0, %xmm0
+; BDVER2-NEXT:    vfmaddps %xmm1, %xmm0, %xmm1, %xmm0
+; BDVER2-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm0
+; BDVER2-NEXT:    retq
 ;
 ; BTVER2-LABEL: v4f32_two_step2:
 ; BTVER2:       # %bb.0:
-; BTVER2-NEXT:    vmovaps {{.*#+}} xmm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [5:1.00]
-; BTVER2-NEXT:    vrcpps %xmm0, %xmm1 # sched: [2:1.00]
-; BTVER2-NEXT:    vmulps %xmm1, %xmm0, %xmm2 # sched: [2:1.00]
-; BTVER2-NEXT:    vsubps %xmm2, %xmm3, %xmm2 # sched: [3:1.00]
-; BTVER2-NEXT:    vmulps %xmm2, %xmm1, %xmm2 # sched: [2:1.00]
-; BTVER2-NEXT:    vaddps %xmm2, %xmm1, %xmm1 # sched: [3:1.00]
-; BTVER2-NEXT:    vmulps %xmm1, %xmm0, %xmm0 # sched: [2:1.00]
-; BTVER2-NEXT:    vsubps %xmm0, %xmm3, %xmm0 # sched: [3:1.00]
-; BTVER2-NEXT:    vmulps %xmm0, %xmm1, %xmm0 # sched: [2:1.00]
-; BTVER2-NEXT:    vaddps %xmm0, %xmm1, %xmm0 # sched: [3:1.00]
-; BTVER2-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm0 # sched: [7:1.00]
-; BTVER2-NEXT:    retq # sched: [4:1.00]
+; BTVER2-NEXT:    vmovaps {{.*#+}} xmm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; BTVER2-NEXT:    vrcpps %xmm0, %xmm1
+; BTVER2-NEXT:    vmulps %xmm1, %xmm0, %xmm2
+; BTVER2-NEXT:    vsubps %xmm2, %xmm3, %xmm2
+; BTVER2-NEXT:    vmulps %xmm2, %xmm1, %xmm2
+; BTVER2-NEXT:    vaddps %xmm2, %xmm1, %xmm1
+; BTVER2-NEXT:    vmulps %xmm1, %xmm0, %xmm0
+; BTVER2-NEXT:    vsubps %xmm0, %xmm3, %xmm0
+; BTVER2-NEXT:    vmulps %xmm0, %xmm1, %xmm0
+; BTVER2-NEXT:    vaddps %xmm0, %xmm1, %xmm0
+; BTVER2-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm0
+; BTVER2-NEXT:    retq
 ;
 ; SANDY-LABEL: v4f32_two_step2:
 ; SANDY:       # %bb.0:
-; SANDY-NEXT:    vrcpps %xmm0, %xmm1 # sched: [5:1.00]
-; SANDY-NEXT:    vmulps %xmm1, %xmm0, %xmm2 # sched: [5:1.00]
-; SANDY-NEXT:    vmovaps {{.*#+}} xmm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [6:0.50]
-; SANDY-NEXT:    vsubps %xmm2, %xmm3, %xmm2 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %xmm2, %xmm1, %xmm2 # sched: [5:1.00]
-; SANDY-NEXT:    vaddps %xmm2, %xmm1, %xmm1 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %xmm1, %xmm0, %xmm0 # sched: [5:1.00]
-; SANDY-NEXT:    vsubps %xmm0, %xmm3, %xmm0 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %xmm0, %xmm1, %xmm0 # sched: [5:1.00]
-; SANDY-NEXT:    vaddps %xmm0, %xmm1, %xmm0 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm0 # sched: [11:1.00]
-; SANDY-NEXT:    retq # sched: [1:1.00]
+; SANDY-NEXT:    vrcpps %xmm0, %xmm1
+; SANDY-NEXT:    vmulps %xmm1, %xmm0, %xmm2
+; SANDY-NEXT:    vmovaps {{.*#+}} xmm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; SANDY-NEXT:    vsubps %xmm2, %xmm3, %xmm2
+; SANDY-NEXT:    vmulps %xmm2, %xmm1, %xmm2
+; SANDY-NEXT:    vaddps %xmm2, %xmm1, %xmm1
+; SANDY-NEXT:    vmulps %xmm1, %xmm0, %xmm0
+; SANDY-NEXT:    vsubps %xmm0, %xmm3, %xmm0
+; SANDY-NEXT:    vmulps %xmm0, %xmm1, %xmm0
+; SANDY-NEXT:    vaddps %xmm0, %xmm1, %xmm0
+; SANDY-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm0
+; SANDY-NEXT:    retq
 ;
 ; HASWELL-LABEL: v4f32_two_step2:
 ; HASWELL:       # %bb.0:
-; HASWELL-NEXT:    vrcpps %xmm0, %xmm1 # sched: [5:1.00]
-; HASWELL-NEXT:    vbroadcastss {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [6:0.50]
-; HASWELL-NEXT:    vmovaps %xmm1, %xmm3 # sched: [1:1.00]
-; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} xmm3 = -(xmm0 * xmm3) + xmm2 sched: [5:0.50]
-; HASWELL-NEXT:    vfmadd132ps {{.*#+}} xmm3 = (xmm3 * xmm1) + xmm1 sched: [5:0.50]
-; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} xmm0 = -(xmm3 * xmm0) + xmm2 sched: [5:0.50]
-; HASWELL-NEXT:    vfmadd132ps {{.*#+}} xmm0 = (xmm0 * xmm3) + xmm3 sched: [5:0.50]
-; HASWELL-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm0 # sched: [11:0.50]
-; HASWELL-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NEXT:    vrcpps %xmm0, %xmm1
+; HASWELL-NEXT:    vbroadcastss {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; HASWELL-NEXT:    vmovaps %xmm1, %xmm3
+; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} xmm3 = -(xmm0 * xmm3) + xmm2
+; HASWELL-NEXT:    vfmadd132ps {{.*#+}} xmm3 = (xmm3 * xmm1) + xmm1
+; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} xmm0 = -(xmm3 * xmm0) + xmm2
+; HASWELL-NEXT:    vfmadd132ps {{.*#+}} xmm0 = (xmm0 * xmm3) + xmm3
+; HASWELL-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm0
+; HASWELL-NEXT:    retq
 ;
 ; HASWELL-NO-FMA-LABEL: v4f32_two_step2:
 ; HASWELL-NO-FMA:       # %bb.0:
-; HASWELL-NO-FMA-NEXT:    vrcpps %xmm0, %xmm1 # sched: [5:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulps %xmm1, %xmm0, %xmm2 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vbroadcastss {{.*#+}} xmm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [6:0.50]
-; HASWELL-NO-FMA-NEXT:    vsubps %xmm2, %xmm3, %xmm2 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulps %xmm2, %xmm1, %xmm2 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vaddps %xmm2, %xmm1, %xmm1 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulps %xmm1, %xmm0, %xmm0 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vsubps %xmm0, %xmm3, %xmm0 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulps %xmm0, %xmm1, %xmm0 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vaddps %xmm0, %xmm1, %xmm0 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm0 # sched: [11:0.50]
-; HASWELL-NO-FMA-NEXT:    retq # sched: [7:1.00]
-;
-; KNL-LABEL: v4f32_two_step2:
-; KNL:       # %bb.0:
-; KNL-NEXT:    vrcpps %xmm0, %xmm1 # sched: [5:1.00]
-; KNL-NEXT:    vbroadcastss {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [6:0.50]
-; KNL-NEXT:    vmovaps %xmm1, %xmm3 # sched: [1:1.00]
-; KNL-NEXT:    vfnmadd213ps {{.*#+}} xmm3 = -(xmm0 * xmm3) + xmm2 sched: [5:0.50]
-; KNL-NEXT:    vfmadd132ps {{.*#+}} xmm3 = (xmm3 * xmm1) + xmm1 sched: [5:0.50]
-; KNL-NEXT:    vfnmadd213ps {{.*#+}} xmm0 = -(xmm3 * xmm0) + xmm2 sched: [5:0.50]
-; KNL-NEXT:    vfmadd132ps {{.*#+}} xmm0 = (xmm0 * xmm3) + xmm3 sched: [5:0.50]
-; KNL-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm0 # sched: [11:0.50]
-; KNL-NEXT:    retq # sched: [7:1.00]
-;
-; SKX-LABEL: v4f32_two_step2:
-; SKX:       # %bb.0:
-; SKX-NEXT:    vrcpps %xmm0, %xmm1 # sched: [4:1.00]
-; SKX-NEXT:    vbroadcastss {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [6:0.50]
-; SKX-NEXT:    vmovaps %xmm1, %xmm3 # sched: [1:0.33]
-; SKX-NEXT:    vfnmadd213ps {{.*#+}} xmm3 = -(xmm0 * xmm3) + xmm2 sched: [4:0.50]
-; SKX-NEXT:    vfmadd132ps {{.*#+}} xmm3 = (xmm3 * xmm1) + xmm1 sched: [4:0.50]
-; SKX-NEXT:    vfnmadd213ps {{.*#+}} xmm0 = -(xmm3 * xmm0) + xmm2 sched: [4:0.50]
-; SKX-NEXT:    vfmadd132ps {{.*#+}} xmm0 = (xmm0 * xmm3) + xmm3 sched: [4:0.50]
-; SKX-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm0 # sched: [10:0.50]
-; SKX-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NO-FMA-NEXT:    vrcpps %xmm0, %xmm1
+; HASWELL-NO-FMA-NEXT:    vmulps %xmm1, %xmm0, %xmm2
+; HASWELL-NO-FMA-NEXT:    vbroadcastss {{.*#+}} xmm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; HASWELL-NO-FMA-NEXT:    vsubps %xmm2, %xmm3, %xmm2
+; HASWELL-NO-FMA-NEXT:    vmulps %xmm2, %xmm1, %xmm2
+; HASWELL-NO-FMA-NEXT:    vaddps %xmm2, %xmm1, %xmm1
+; HASWELL-NO-FMA-NEXT:    vmulps %xmm1, %xmm0, %xmm0
+; HASWELL-NO-FMA-NEXT:    vsubps %xmm0, %xmm3, %xmm0
+; HASWELL-NO-FMA-NEXT:    vmulps %xmm0, %xmm1, %xmm0
+; HASWELL-NO-FMA-NEXT:    vaddps %xmm0, %xmm1, %xmm0
+; HASWELL-NO-FMA-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm0
+; HASWELL-NO-FMA-NEXT:    retq
+;
+; AVX512-LABEL: v4f32_two_step2:
+; AVX512:       # %bb.0:
+; AVX512-NEXT:    vrcpps %xmm0, %xmm1
+; AVX512-NEXT:    vbroadcastss {{.*#+}} xmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; AVX512-NEXT:    vmovaps %xmm1, %xmm3
+; AVX512-NEXT:    vfnmadd213ps {{.*#+}} xmm3 = -(xmm0 * xmm3) + xmm2
+; AVX512-NEXT:    vfmadd132ps {{.*#+}} xmm3 = (xmm3 * xmm1) + xmm1
+; AVX512-NEXT:    vfnmadd213ps {{.*#+}} xmm0 = -(xmm3 * xmm0) + xmm2
+; AVX512-NEXT:    vfmadd132ps {{.*#+}} xmm0 = (xmm0 * xmm3) + xmm3
+; AVX512-NEXT:    vmulps {{.*}}(%rip), %xmm0, %xmm0
+; AVX512-NEXT:    retq
   %div = fdiv fast <4 x float> <float 1.0, float 2.0, float 3.0, float 4.0>, %x
   ret <4 x float> %div
 }
 
 define <8 x float> @v8f32_one_step2(<8 x float> %x) #1 {
 ; SSE-LABEL: v8f32_one_step2:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    rcpps %xmm1, %xmm4

 ; FMA-RECIP-NEXT:    vrcpps %ymm0, %ymm1
 ; FMA-RECIP-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm1 * ymm0) + mem
 ; FMA-RECIP-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm1) + ymm1
 ; FMA-RECIP-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
 ; FMA-RECIP-NEXT:    retq
 ;
 ; BDVER2-LABEL: v8f32_one_step2:
 ; BDVER2:       # %bb.0:
-; BDVER2-NEXT:    vrcpps %ymm0, %ymm1 # sched: [5:2.00]
-; BDVER2-NEXT:    vfnmaddps {{.*}}(%rip), %ymm1, %ymm0, %ymm0 # sched: [10:1.00]
-; BDVER2-NEXT:    vfmaddps %ymm1, %ymm0, %ymm1, %ymm0 # sched: [5:0.50]
-; BDVER2-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [10:2.00]
-; BDVER2-NEXT:    retq # sched: [5:1.00]
+; BDVER2-NEXT:    vrcpps %ymm0, %ymm1
+; BDVER2-NEXT:    vfnmaddps {{.*}}(%rip), %ymm1, %ymm0, %ymm0
+; BDVER2-NEXT:    vfmaddps %ymm1, %ymm0, %ymm1, %ymm0
+; BDVER2-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
+; BDVER2-NEXT:    retq
 ;
 ; BTVER2-LABEL: v8f32_one_step2:
 ; BTVER2:       # %bb.0:
-; BTVER2-NEXT:    vmovaps {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [5:1.00]
-; BTVER2-NEXT:    vrcpps %ymm0, %ymm1 # sched: [2:2.00]
-; BTVER2-NEXT:    vmulps %ymm1, %ymm0, %ymm0 # sched: [2:2.00]
-; BTVER2-NEXT:    vsubps %ymm0, %ymm2, %ymm0 # sched: [3:2.00]
-; BTVER2-NEXT:    vmulps %ymm0, %ymm1, %ymm0 # sched: [2:2.00]
-; BTVER2-NEXT:    vaddps %ymm0, %ymm1, %ymm0 # sched: [3:2.00]
-; BTVER2-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [7:2.00]
-; BTVER2-NEXT:    retq # sched: [4:1.00]
+; BTVER2-NEXT:    vmovaps {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; BTVER2-NEXT:    vrcpps %ymm0, %ymm1
+; BTVER2-NEXT:    vmulps %ymm1, %ymm0, %ymm0
+; BTVER2-NEXT:    vsubps %ymm0, %ymm2, %ymm0
+; BTVER2-NEXT:    vmulps %ymm0, %ymm1, %ymm0
+; BTVER2-NEXT:    vaddps %ymm0, %ymm1, %ymm0
+; BTVER2-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
+; BTVER2-NEXT:    retq
 ;
 ; SANDY-LABEL: v8f32_one_step2:
 ; SANDY:       # %bb.0:
-; SANDY-NEXT:    vrcpps %ymm0, %ymm1 # sched: [7:2.00]
-; SANDY-NEXT:    vmulps %ymm1, %ymm0, %ymm0 # sched: [5:1.00]
-; SANDY-NEXT:    vmovaps {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; SANDY-NEXT:    vsubps %ymm0, %ymm2, %ymm0 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %ymm0, %ymm1, %ymm0 # sched: [5:1.00]
-; SANDY-NEXT:    vaddps %ymm0, %ymm1, %ymm0 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [12:1.00]
-; SANDY-NEXT:    retq # sched: [1:1.00]
+; SANDY-NEXT:    vrcpps %ymm0, %ymm1
+; SANDY-NEXT:    vmulps %ymm1, %ymm0, %ymm0
+; SANDY-NEXT:    vmovaps {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; SANDY-NEXT:    vsubps %ymm0, %ymm2, %ymm0
+; SANDY-NEXT:    vmulps %ymm0, %ymm1, %ymm0
+; SANDY-NEXT:    vaddps %ymm0, %ymm1, %ymm0
+; SANDY-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
+; SANDY-NEXT:    retq
 ;
 ; HASWELL-LABEL: v8f32_one_step2:
 ; HASWELL:       # %bb.0:
-; HASWELL-NEXT:    vrcpps %ymm0, %ymm1 # sched: [11:2.00]
-; HASWELL-NEXT:    vbroadcastss {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm1 * ymm0) + ymm2 sched: [5:0.50]
-; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm1) + ymm1 sched: [5:0.50]
-; HASWELL-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [12:0.50]
-; HASWELL-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NEXT:    vrcpps %ymm0, %ymm1
+; HASWELL-NEXT:    vbroadcastss {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm1 * ymm0) + ymm2
+; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm1) + ymm1
+; HASWELL-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
+; HASWELL-NEXT:    retq
 ;
 ; HASWELL-NO-FMA-LABEL: v8f32_one_step2:
 ; HASWELL-NO-FMA:       # %bb.0:
-; HASWELL-NO-FMA-NEXT:    vrcpps %ymm0, %ymm1 # sched: [11:2.00]
-; HASWELL-NO-FMA-NEXT:    vmulps %ymm1, %ymm0, %ymm0 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vbroadcastss {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; HASWELL-NO-FMA-NEXT:    vsubps %ymm0, %ymm2, %ymm0 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulps %ymm0, %ymm1, %ymm0 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vaddps %ymm0, %ymm1, %ymm0 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [12:0.50]
-; HASWELL-NO-FMA-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NO-FMA-NEXT:    vrcpps %ymm0, %ymm1
+; HASWELL-NO-FMA-NEXT:    vmulps %ymm1, %ymm0, %ymm0
+; HASWELL-NO-FMA-NEXT:    vbroadcastss {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; HASWELL-NO-FMA-NEXT:    vsubps %ymm0, %ymm2, %ymm0
+; HASWELL-NO-FMA-NEXT:    vmulps %ymm0, %ymm1, %ymm0
+; HASWELL-NO-FMA-NEXT:    vaddps %ymm0, %ymm1, %ymm0
+; HASWELL-NO-FMA-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
+; HASWELL-NO-FMA-NEXT:    retq
 ;
 ; KNL-LABEL: v8f32_one_step2:
 ; KNL:       # %bb.0:
-; KNL-NEXT:    vrcpps %ymm0, %ymm1 # sched: [11:2.00]
-; KNL-NEXT:    vbroadcastss {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; KNL-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm1 * ymm0) + ymm2 sched: [5:0.50]
-; KNL-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm1) + ymm1 sched: [5:0.50]
-; KNL-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [12:0.50]
-; KNL-NEXT:    retq # sched: [7:1.00]
+; KNL-NEXT:    vrcpps %ymm0, %ymm1
+; KNL-NEXT:    vbroadcastss {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; KNL-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm1 * ymm0) + ymm2
+; KNL-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm1) + ymm1
+; KNL-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
+; KNL-NEXT:    retq
 ;
 ; SKX-LABEL: v8f32_one_step2:
 ; SKX:       # %bb.0:
-; SKX-NEXT:    vrcpps %ymm0, %ymm1 # sched: [4:1.00]
-; SKX-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm1 * ymm0) + mem sched: [11:0.50]
-; SKX-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm1) + ymm1 sched: [4:0.50]
-; SKX-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [11:0.50]
-; SKX-NEXT:    retq # sched: [7:1.00]
+; SKX-NEXT:    vrcpps %ymm0, %ymm1
+; SKX-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm1 * ymm0) + mem
+; SKX-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm1) + ymm1
+; SKX-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
+; SKX-NEXT:    retq
   %div = fdiv fast <8 x float> <float 1.0, float 2.0, float 3.0, float 4.0, float 5.0, float 6.0, float 7.0, float 8.0>, %x
   ret <8 x float> %div
 }
 
 define <8 x float> @v8f32_one_step_2_divs(<8 x float> %x) #1 {
 ; SSE-LABEL: v8f32_one_step_2_divs:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    rcpps %xmm0, %xmm2

 ; FMA-RECIP-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm1 * ymm0) + mem
 ; FMA-RECIP-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm1) + ymm1
 ; FMA-RECIP-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm1
 ; FMA-RECIP-NEXT:    vmulps %ymm0, %ymm1, %ymm0
 ; FMA-RECIP-NEXT:    retq
 ;
 ; BDVER2-LABEL: v8f32_one_step_2_divs:
 ; BDVER2:       # %bb.0:
-; BDVER2-NEXT:    vrcpps %ymm0, %ymm1 # sched: [5:2.00]
-; BDVER2-NEXT:    vfnmaddps {{.*}}(%rip), %ymm1, %ymm0, %ymm0 # sched: [10:1.00]
-; BDVER2-NEXT:    vfmaddps %ymm1, %ymm0, %ymm1, %ymm0 # sched: [5:0.50]
-; BDVER2-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm1 # sched: [10:2.00]
-; BDVER2-NEXT:    vmulps %ymm0, %ymm1, %ymm0 # sched: [5:2.00]
-; BDVER2-NEXT:    retq # sched: [5:1.00]
+; BDVER2-NEXT:    vrcpps %ymm0, %ymm1
+; BDVER2-NEXT:    vfnmaddps {{.*}}(%rip), %ymm1, %ymm0, %ymm0
+; BDVER2-NEXT:    vfmaddps %ymm1, %ymm0, %ymm1, %ymm0
+; BDVER2-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm1
+; BDVER2-NEXT:    vmulps %ymm0, %ymm1, %ymm0
+; BDVER2-NEXT:    retq
 ;
 ; BTVER2-LABEL: v8f32_one_step_2_divs:
 ; BTVER2:       # %bb.0:
-; BTVER2-NEXT:    vmovaps {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [5:1.00]
-; BTVER2-NEXT:    vrcpps %ymm0, %ymm1 # sched: [2:2.00]
-; BTVER2-NEXT:    vmulps %ymm1, %ymm0, %ymm0 # sched: [2:2.00]
-; BTVER2-NEXT:    vsubps %ymm0, %ymm2, %ymm0 # sched: [3:2.00]
-; BTVER2-NEXT:    vmulps %ymm0, %ymm1, %ymm0 # sched: [2:2.00]
-; BTVER2-NEXT:    vaddps %ymm0, %ymm1, %ymm0 # sched: [3:2.00]
-; BTVER2-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm1 # sched: [7:2.00]
-; BTVER2-NEXT:    vmulps %ymm0, %ymm1, %ymm0 # sched: [2:2.00]
-; BTVER2-NEXT:    retq # sched: [4:1.00]
+; BTVER2-NEXT:    vmovaps {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; BTVER2-NEXT:    vrcpps %ymm0, %ymm1
+; BTVER2-NEXT:    vmulps %ymm1, %ymm0, %ymm0
+; BTVER2-NEXT:    vsubps %ymm0, %ymm2, %ymm0
+; BTVER2-NEXT:    vmulps %ymm0, %ymm1, %ymm0
+; BTVER2-NEXT:    vaddps %ymm0, %ymm1, %ymm0
+; BTVER2-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm1
+; BTVER2-NEXT:    vmulps %ymm0, %ymm1, %ymm0
+; BTVER2-NEXT:    retq
 ;
 ; SANDY-LABEL: v8f32_one_step_2_divs:
 ; SANDY:       # %bb.0:
-; SANDY-NEXT:    vrcpps %ymm0, %ymm1 # sched: [7:2.00]
-; SANDY-NEXT:    vmulps %ymm1, %ymm0, %ymm0 # sched: [5:1.00]
-; SANDY-NEXT:    vmovaps {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; SANDY-NEXT:    vsubps %ymm0, %ymm2, %ymm0 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %ymm0, %ymm1, %ymm0 # sched: [5:1.00]
-; SANDY-NEXT:    vaddps %ymm0, %ymm1, %ymm0 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm1 # sched: [12:1.00]
-; SANDY-NEXT:    vmulps %ymm0, %ymm1, %ymm0 # sched: [5:1.00]
-; SANDY-NEXT:    retq # sched: [1:1.00]
+; SANDY-NEXT:    vrcpps %ymm0, %ymm1
+; SANDY-NEXT:    vmulps %ymm1, %ymm0, %ymm0
+; SANDY-NEXT:    vmovaps {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; SANDY-NEXT:    vsubps %ymm0, %ymm2, %ymm0
+; SANDY-NEXT:    vmulps %ymm0, %ymm1, %ymm0
+; SANDY-NEXT:    vaddps %ymm0, %ymm1, %ymm0
+; SANDY-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm1
+; SANDY-NEXT:    vmulps %ymm0, %ymm1, %ymm0
+; SANDY-NEXT:    retq
 ;
 ; HASWELL-LABEL: v8f32_one_step_2_divs:
 ; HASWELL:       # %bb.0:
-; HASWELL-NEXT:    vrcpps %ymm0, %ymm1 # sched: [11:2.00]
-; HASWELL-NEXT:    vbroadcastss {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm1 * ymm0) + ymm2 sched: [5:0.50]
-; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm1) + ymm1 sched: [5:0.50]
-; HASWELL-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm1 # sched: [12:0.50]
-; HASWELL-NEXT:    vmulps %ymm0, %ymm1, %ymm0 # sched: [5:0.50]
-; HASWELL-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NEXT:    vrcpps %ymm0, %ymm1
+; HASWELL-NEXT:    vbroadcastss {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm1 * ymm0) + ymm2
+; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm1) + ymm1
+; HASWELL-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm1
+; HASWELL-NEXT:    vmulps %ymm0, %ymm1, %ymm0
+; HASWELL-NEXT:    retq
 ;
 ; HASWELL-NO-FMA-LABEL: v8f32_one_step_2_divs:
 ; HASWELL-NO-FMA:       # %bb.0:
-; HASWELL-NO-FMA-NEXT:    vrcpps %ymm0, %ymm1 # sched: [11:2.00]
-; HASWELL-NO-FMA-NEXT:    vmulps %ymm1, %ymm0, %ymm0 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vbroadcastss {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; HASWELL-NO-FMA-NEXT:    vsubps %ymm0, %ymm2, %ymm0 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulps %ymm0, %ymm1, %ymm0 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vaddps %ymm0, %ymm1, %ymm0 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm1 # sched: [12:0.50]
-; HASWELL-NO-FMA-NEXT:    vmulps %ymm0, %ymm1, %ymm0 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NO-FMA-NEXT:    vrcpps %ymm0, %ymm1
+; HASWELL-NO-FMA-NEXT:    vmulps %ymm1, %ymm0, %ymm0
+; HASWELL-NO-FMA-NEXT:    vbroadcastss {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; HASWELL-NO-FMA-NEXT:    vsubps %ymm0, %ymm2, %ymm0
+; HASWELL-NO-FMA-NEXT:    vmulps %ymm0, %ymm1, %ymm0
+; HASWELL-NO-FMA-NEXT:    vaddps %ymm0, %ymm1, %ymm0
+; HASWELL-NO-FMA-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm1
+; HASWELL-NO-FMA-NEXT:    vmulps %ymm0, %ymm1, %ymm0
+; HASWELL-NO-FMA-NEXT:    retq
 ;
 ; KNL-LABEL: v8f32_one_step_2_divs:
 ; KNL:       # %bb.0:
-; KNL-NEXT:    vrcpps %ymm0, %ymm1 # sched: [11:2.00]
-; KNL-NEXT:    vbroadcastss {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; KNL-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm1 * ymm0) + ymm2 sched: [5:0.50]
-; KNL-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm1) + ymm1 sched: [5:0.50]
-; KNL-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm1 # sched: [12:0.50]
-; KNL-NEXT:    vmulps %ymm0, %ymm1, %ymm0 # sched: [5:0.50]
-; KNL-NEXT:    retq # sched: [7:1.00]
+; KNL-NEXT:    vrcpps %ymm0, %ymm1
+; KNL-NEXT:    vbroadcastss {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; KNL-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm1 * ymm0) + ymm2
+; KNL-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm1) + ymm1
+; KNL-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm1
+; KNL-NEXT:    vmulps %ymm0, %ymm1, %ymm0
+; KNL-NEXT:    retq
 ;
 ; SKX-LABEL: v8f32_one_step_2_divs:
 ; SKX:       # %bb.0:
-; SKX-NEXT:    vrcpps %ymm0, %ymm1 # sched: [4:1.00]
-; SKX-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm1 * ymm0) + mem sched: [11:0.50]
-; SKX-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm1) + ymm1 sched: [4:0.50]
-; SKX-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm1 # sched: [11:0.50]
-; SKX-NEXT:    vmulps %ymm0, %ymm1, %ymm0 # sched: [4:0.50]
-; SKX-NEXT:    retq # sched: [7:1.00]
+; SKX-NEXT:    vrcpps %ymm0, %ymm1
+; SKX-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm1 * ymm0) + mem
+; SKX-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm1) + ymm1
+; SKX-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm1
+; SKX-NEXT:    vmulps %ymm0, %ymm1, %ymm0
+; SKX-NEXT:    retq
   %div = fdiv fast <8 x float> <float 1.0, float 2.0, float 3.0, float 4.0, float 5.0, float 6.0, float 7.0, float 8.0>, %x
   %div2 = fdiv fast <8 x float> %div, %x
   ret <8 x float> %div2
 }
 
 define <8 x float> @v8f32_two_step2(<8 x float> %x) #2 {
 ; SSE-LABEL: v8f32_two_step2:
 ; SSE:       # %bb.0:

 ; FMA-RECIP-NEXT:    vfmadd132ps {{.*#+}} ymm3 = (ymm3 * ymm1) + ymm1
 ; FMA-RECIP-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm3 * ymm0) + ymm2
 ; FMA-RECIP-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm3) + ymm3
 ; FMA-RECIP-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
 ; FMA-RECIP-NEXT:    retq
 ;
 ; BDVER2-LABEL: v8f32_two_step2:
 ; BDVER2:       # %bb.0:
-; BDVER2-NEXT:    vrcpps %ymm0, %ymm1 # sched: [5:2.00]
-; BDVER2-NEXT:    vmovaps {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [5:0.50]
-; BDVER2-NEXT:    vfnmaddps %ymm2, %ymm1, %ymm0, %ymm3 # sched: [5:0.50]
-; BDVER2-NEXT:    vfmaddps %ymm1, %ymm3, %ymm1, %ymm1 # sched: [5:0.50]
-; BDVER2-NEXT:    vfnmaddps %ymm2, %ymm1, %ymm0, %ymm0 # sched: [5:0.50]
-; BDVER2-NEXT:    vfmaddps %ymm1, %ymm0, %ymm1, %ymm0 # sched: [5:0.50]
-; BDVER2-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [10:2.00]
-; BDVER2-NEXT:    retq # sched: [5:1.00]
+; BDVER2-NEXT:    vrcpps %ymm0, %ymm1
+; BDVER2-NEXT:    vmovaps {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; BDVER2-NEXT:    vfnmaddps %ymm2, %ymm1, %ymm0, %ymm3
+; BDVER2-NEXT:    vfmaddps %ymm1, %ymm3, %ymm1, %ymm1
+; BDVER2-NEXT:    vfnmaddps %ymm2, %ymm1, %ymm0, %ymm0
+; BDVER2-NEXT:    vfmaddps %ymm1, %ymm0, %ymm1, %ymm0
+; BDVER2-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
+; BDVER2-NEXT:    retq
 ;
 ; BTVER2-LABEL: v8f32_two_step2:
 ; BTVER2:       # %bb.0:
-; BTVER2-NEXT:    vmovaps {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [5:1.00]
-; BTVER2-NEXT:    vrcpps %ymm0, %ymm1 # sched: [2:2.00]
-; BTVER2-NEXT:    vmulps %ymm1, %ymm0, %ymm2 # sched: [2:2.00]
-; BTVER2-NEXT:    vsubps %ymm2, %ymm3, %ymm2 # sched: [3:2.00]
-; BTVER2-NEXT:    vmulps %ymm2, %ymm1, %ymm2 # sched: [2:2.00]
-; BTVER2-NEXT:    vaddps %ymm2, %ymm1, %ymm1 # sched: [3:2.00]
-; BTVER2-NEXT:    vmulps %ymm1, %ymm0, %ymm0 # sched: [2:2.00]
-; BTVER2-NEXT:    vsubps %ymm0, %ymm3, %ymm0 # sched: [3:2.00]
-; BTVER2-NEXT:    vmulps %ymm0, %ymm1, %ymm0 # sched: [2:2.00]
-; BTVER2-NEXT:    vaddps %ymm0, %ymm1, %ymm0 # sched: [3:2.00]
-; BTVER2-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [7:2.00]
-; BTVER2-NEXT:    retq # sched: [4:1.00]
+; BTVER2-NEXT:    vmovaps {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; BTVER2-NEXT:    vrcpps %ymm0, %ymm1
+; BTVER2-NEXT:    vmulps %ymm1, %ymm0, %ymm2
+; BTVER2-NEXT:    vsubps %ymm2, %ymm3, %ymm2
+; BTVER2-NEXT:    vmulps %ymm2, %ymm1, %ymm2
+; BTVER2-NEXT:    vaddps %ymm2, %ymm1, %ymm1
+; BTVER2-NEXT:    vmulps %ymm1, %ymm0, %ymm0
+; BTVER2-NEXT:    vsubps %ymm0, %ymm3, %ymm0
+; BTVER2-NEXT:    vmulps %ymm0, %ymm1, %ymm0
+; BTVER2-NEXT:    vaddps %ymm0, %ymm1, %ymm0
+; BTVER2-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
+; BTVER2-NEXT:    retq
 ;
 ; SANDY-LABEL: v8f32_two_step2:
 ; SANDY:       # %bb.0:
-; SANDY-NEXT:    vrcpps %ymm0, %ymm1 # sched: [7:2.00]
-; SANDY-NEXT:    vmulps %ymm1, %ymm0, %ymm2 # sched: [5:1.00]
-; SANDY-NEXT:    vmovaps {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; SANDY-NEXT:    vsubps %ymm2, %ymm3, %ymm2 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %ymm2, %ymm1, %ymm2 # sched: [5:1.00]
-; SANDY-NEXT:    vaddps %ymm2, %ymm1, %ymm1 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %ymm1, %ymm0, %ymm0 # sched: [5:1.00]
-; SANDY-NEXT:    vsubps %ymm0, %ymm3, %ymm0 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %ymm0, %ymm1, %ymm0 # sched: [5:1.00]
-; SANDY-NEXT:    vaddps %ymm0, %ymm1, %ymm0 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [12:1.00]
-; SANDY-NEXT:    retq # sched: [1:1.00]
+; SANDY-NEXT:    vrcpps %ymm0, %ymm1
+; SANDY-NEXT:    vmulps %ymm1, %ymm0, %ymm2
+; SANDY-NEXT:    vmovaps {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; SANDY-NEXT:    vsubps %ymm2, %ymm3, %ymm2
+; SANDY-NEXT:    vmulps %ymm2, %ymm1, %ymm2
+; SANDY-NEXT:    vaddps %ymm2, %ymm1, %ymm1
+; SANDY-NEXT:    vmulps %ymm1, %ymm0, %ymm0
+; SANDY-NEXT:    vsubps %ymm0, %ymm3, %ymm0
+; SANDY-NEXT:    vmulps %ymm0, %ymm1, %ymm0
+; SANDY-NEXT:    vaddps %ymm0, %ymm1, %ymm0
+; SANDY-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
+; SANDY-NEXT:    retq
 ;
 ; HASWELL-LABEL: v8f32_two_step2:
 ; HASWELL:       # %bb.0:
-; HASWELL-NEXT:    vrcpps %ymm0, %ymm1 # sched: [11:2.00]
-; HASWELL-NEXT:    vbroadcastss {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; HASWELL-NEXT:    vmovaps %ymm1, %ymm3 # sched: [1:1.00]
-; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm3 = -(ymm0 * ymm3) + ymm2 sched: [5:0.50]
-; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm3 = (ymm3 * ymm1) + ymm1 sched: [5:0.50]
-; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm3 * ymm0) + ymm2 sched: [5:0.50]
-; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm3) + ymm3 sched: [5:0.50]
-; HASWELL-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [12:0.50]
-; HASWELL-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NEXT:    vrcpps %ymm0, %ymm1
+; HASWELL-NEXT:    vbroadcastss {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; HASWELL-NEXT:    vmovaps %ymm1, %ymm3
+; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm3 = -(ymm0 * ymm3) + ymm2
+; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm3 = (ymm3 * ymm1) + ymm1
+; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm3 * ymm0) + ymm2
+; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm3) + ymm3
+; HASWELL-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
+; HASWELL-NEXT:    retq
 ;
 ; HASWELL-NO-FMA-LABEL: v8f32_two_step2:
 ; HASWELL-NO-FMA:       # %bb.0:
-; HASWELL-NO-FMA-NEXT:    vrcpps %ymm0, %ymm1 # sched: [11:2.00]
-; HASWELL-NO-FMA-NEXT:    vmulps %ymm1, %ymm0, %ymm2 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vbroadcastss {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; HASWELL-NO-FMA-NEXT:    vsubps %ymm2, %ymm3, %ymm2 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulps %ymm2, %ymm1, %ymm2 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vaddps %ymm2, %ymm1, %ymm1 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulps %ymm1, %ymm0, %ymm0 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vsubps %ymm0, %ymm3, %ymm0 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulps %ymm0, %ymm1, %ymm0 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vaddps %ymm0, %ymm1, %ymm0 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [12:0.50]
-; HASWELL-NO-FMA-NEXT:    retq # sched: [7:1.00]
-;
-; KNL-LABEL: v8f32_two_step2:
-; KNL:       # %bb.0:
-; KNL-NEXT:    vrcpps %ymm0, %ymm1 # sched: [11:2.00]
-; KNL-NEXT:    vbroadcastss {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; KNL-NEXT:    vmovaps %ymm1, %ymm3 # sched: [1:1.00]
-; KNL-NEXT:    vfnmadd213ps {{.*#+}} ymm3 = -(ymm0 * ymm3) + ymm2 sched: [5:0.50]
-; KNL-NEXT:    vfmadd132ps {{.*#+}} ymm3 = (ymm3 * ymm1) + ymm1 sched: [5:0.50]
-; KNL-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm3 * ymm0) + ymm2 sched: [5:0.50]
-; KNL-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm3) + ymm3 sched: [5:0.50]
-; KNL-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [12:0.50]
-; KNL-NEXT:    retq # sched: [7:1.00]
-;
-; SKX-LABEL: v8f32_two_step2:
-; SKX:       # %bb.0:
-; SKX-NEXT:    vrcpps %ymm0, %ymm1 # sched: [4:1.00]
-; SKX-NEXT:    vbroadcastss {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; SKX-NEXT:    vmovaps %ymm1, %ymm3 # sched: [1:0.33]
-; SKX-NEXT:    vfnmadd213ps {{.*#+}} ymm3 = -(ymm0 * ymm3) + ymm2 sched: [4:0.50]
-; SKX-NEXT:    vfmadd132ps {{.*#+}} ymm3 = (ymm3 * ymm1) + ymm1 sched: [4:0.50]
-; SKX-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm3 * ymm0) + ymm2 sched: [4:0.50]
-; SKX-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm3) + ymm3 sched: [4:0.50]
-; SKX-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [11:0.50]
-; SKX-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NO-FMA-NEXT:    vrcpps %ymm0, %ymm1
+; HASWELL-NO-FMA-NEXT:    vmulps %ymm1, %ymm0, %ymm2
+; HASWELL-NO-FMA-NEXT:    vbroadcastss {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; HASWELL-NO-FMA-NEXT:    vsubps %ymm2, %ymm3, %ymm2
+; HASWELL-NO-FMA-NEXT:    vmulps %ymm2, %ymm1, %ymm2
+; HASWELL-NO-FMA-NEXT:    vaddps %ymm2, %ymm1, %ymm1
+; HASWELL-NO-FMA-NEXT:    vmulps %ymm1, %ymm0, %ymm0
+; HASWELL-NO-FMA-NEXT:    vsubps %ymm0, %ymm3, %ymm0
+; HASWELL-NO-FMA-NEXT:    vmulps %ymm0, %ymm1, %ymm0
+; HASWELL-NO-FMA-NEXT:    vaddps %ymm0, %ymm1, %ymm0
+; HASWELL-NO-FMA-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
+; HASWELL-NO-FMA-NEXT:    retq
+;
+; AVX512-LABEL: v8f32_two_step2:
+; AVX512:       # %bb.0:
+; AVX512-NEXT:    vrcpps %ymm0, %ymm1
+; AVX512-NEXT:    vbroadcastss {{.*#+}} ymm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; AVX512-NEXT:    vmovaps %ymm1, %ymm3
+; AVX512-NEXT:    vfnmadd213ps {{.*#+}} ymm3 = -(ymm0 * ymm3) + ymm2
+; AVX512-NEXT:    vfmadd132ps {{.*#+}} ymm3 = (ymm3 * ymm1) + ymm1
+; AVX512-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm3 * ymm0) + ymm2
+; AVX512-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm3) + ymm3
+; AVX512-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
+; AVX512-NEXT:    retq
   %div = fdiv fast <8 x float> <float 1.0, float 2.0, float 3.0, float 4.0, float 5.0, float 6.0, float 7.0, float 8.0>, %x
   ret <8 x float> %div
 }
 
 define <8 x float> @v8f32_no_step(<8 x float> %x) #3 {
 ; SSE-LABEL: v8f32_no_step:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    rcpps %xmm0, %xmm0
 ; SSE-NEXT:    rcpps %xmm1, %xmm1
 ; SSE-NEXT:    retq
 ;
-; AVX-RECIP-LABEL: v8f32_no_step:
-; AVX-RECIP:       # %bb.0:
-; AVX-RECIP-NEXT:    vrcpps %ymm0, %ymm0
-; AVX-RECIP-NEXT:    retq
-;
-; FMA-RECIP-LABEL: v8f32_no_step:
-; FMA-RECIP:       # %bb.0:
-; FMA-RECIP-NEXT:    vrcpps %ymm0, %ymm0
-; FMA-RECIP-NEXT:    retq
-;
-; BDVER2-LABEL: v8f32_no_step:
-; BDVER2:       # %bb.0:
-; BDVER2-NEXT:    vrcpps %ymm0, %ymm0 # sched: [5:2.00]
-; BDVER2-NEXT:    retq # sched: [5:1.00]
-;
-; BTVER2-LABEL: v8f32_no_step:
-; BTVER2:       # %bb.0:
-; BTVER2-NEXT:    vrcpps %ymm0, %ymm0 # sched: [2:2.00]
-; BTVER2-NEXT:    retq # sched: [4:1.00]
-;
-; SANDY-LABEL: v8f32_no_step:
-; SANDY:       # %bb.0:
-; SANDY-NEXT:    vrcpps %ymm0, %ymm0 # sched: [7:2.00]
-; SANDY-NEXT:    retq # sched: [1:1.00]
-;
-; HASWELL-LABEL: v8f32_no_step:
-; HASWELL:       # %bb.0:
-; HASWELL-NEXT:    vrcpps %ymm0, %ymm0 # sched: [11:2.00]
-; HASWELL-NEXT:    retq # sched: [7:1.00]
-;
-; HASWELL-NO-FMA-LABEL: v8f32_no_step:
-; HASWELL-NO-FMA:       # %bb.0:
-; HASWELL-NO-FMA-NEXT:    vrcpps %ymm0, %ymm0 # sched: [11:2.00]
-; HASWELL-NO-FMA-NEXT:    retq # sched: [7:1.00]
-;
-; KNL-LABEL: v8f32_no_step:
-; KNL:       # %bb.0:
-; KNL-NEXT:    vrcpps %ymm0, %ymm0 # sched: [11:2.00]
-; KNL-NEXT:    retq # sched: [7:1.00]
-;
-; SKX-LABEL: v8f32_no_step:
-; SKX:       # %bb.0:
-; SKX-NEXT:    vrcpps %ymm0, %ymm0 # sched: [4:1.00]
-; SKX-NEXT:    retq # sched: [7:1.00]
+; AVX-LABEL: v8f32_no_step:
+; AVX:       # %bb.0:
+; AVX-NEXT:    vrcpps %ymm0, %ymm0
+; AVX-NEXT:    retq
   %div = fdiv fast <8 x float> <float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0>, %x
   ret <8 x float> %div
 }
 
 define <8 x float> @v8f32_no_step2(<8 x float> %x) #3 {
 ; SSE-LABEL: v8f32_no_step2:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    rcpps %xmm1, %xmm1
 ; SSE-NEXT:    rcpps %xmm0, %xmm0
 ; SSE-NEXT:    mulps {{.*}}(%rip), %xmm0
 ; SSE-NEXT:    mulps {{.*}}(%rip), %xmm1
 ; SSE-NEXT:    retq
 ;
-; AVX-RECIP-LABEL: v8f32_no_step2:
-; AVX-RECIP:       # %bb.0:
-; AVX-RECIP-NEXT:    vrcpps %ymm0, %ymm0
-; AVX-RECIP-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
-; AVX-RECIP-NEXT:    retq
-;
-; FMA-RECIP-LABEL: v8f32_no_step2:
-; FMA-RECIP:       # %bb.0:
-; FMA-RECIP-NEXT:    vrcpps %ymm0, %ymm0
-; FMA-RECIP-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
-; FMA-RECIP-NEXT:    retq
-;
-; BDVER2-LABEL: v8f32_no_step2:
-; BDVER2:       # %bb.0:
-; BDVER2-NEXT:    vrcpps %ymm0, %ymm0 # sched: [5:2.00]
-; BDVER2-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [10:2.00]
-; BDVER2-NEXT:    retq # sched: [5:1.00]
-;
-; BTVER2-LABEL: v8f32_no_step2:
-; BTVER2:       # %bb.0:
-; BTVER2-NEXT:    vrcpps %ymm0, %ymm0 # sched: [2:2.00]
-; BTVER2-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [7:2.00]
-; BTVER2-NEXT:    retq # sched: [4:1.00]
-;
-; SANDY-LABEL: v8f32_no_step2:
-; SANDY:       # %bb.0:
-; SANDY-NEXT:    vrcpps %ymm0, %ymm0 # sched: [7:2.00]
-; SANDY-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [12:1.00]
-; SANDY-NEXT:    retq # sched: [1:1.00]
-;
-; HASWELL-LABEL: v8f32_no_step2:
-; HASWELL:       # %bb.0:
-; HASWELL-NEXT:    vrcpps %ymm0, %ymm0 # sched: [11:2.00]
-; HASWELL-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [12:0.50]
-; HASWELL-NEXT:    retq # sched: [7:1.00]
-;
-; HASWELL-NO-FMA-LABEL: v8f32_no_step2:
-; HASWELL-NO-FMA:       # %bb.0:
-; HASWELL-NO-FMA-NEXT:    vrcpps %ymm0, %ymm0 # sched: [11:2.00]
-; HASWELL-NO-FMA-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [12:0.50]
-; HASWELL-NO-FMA-NEXT:    retq # sched: [7:1.00]
-;
-; KNL-LABEL: v8f32_no_step2:
-; KNL:       # %bb.0:
-; KNL-NEXT:    vrcpps %ymm0, %ymm0 # sched: [11:2.00]
-; KNL-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [12:0.50]
-; KNL-NEXT:    retq # sched: [7:1.00]
-;
-; SKX-LABEL: v8f32_no_step2:
-; SKX:       # %bb.0:
-; SKX-NEXT:    vrcpps %ymm0, %ymm0 # sched: [4:1.00]
-; SKX-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [11:0.50]
-; SKX-NEXT:    retq # sched: [7:1.00]
+; AVX-LABEL: v8f32_no_step2:
+; AVX:       # %bb.0:
+; AVX-NEXT:    vrcpps %ymm0, %ymm0
+; AVX-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
+; AVX-NEXT:    retq
   %div = fdiv fast <8 x float> <float 1.0, float 2.0, float 3.0, float 4.0, float 5.0, float 6.0, float 7.0, float 8.0>, %x
   ret <8 x float> %div
 }
 
 define <16 x float> @v16f32_one_step2(<16 x float> %x) #1 {
 ; SSE-LABEL: v16f32_one_step2:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    movaps %xmm3, %xmm4

 ; FMA-RECIP-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm2 * ymm0) + ymm3
 ; FMA-RECIP-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm2) + ymm2
 ; FMA-RECIP-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
 ; FMA-RECIP-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm1
 ; FMA-RECIP-NEXT:    retq
 ;
 ; BDVER2-LABEL: v16f32_one_step2:
 ; BDVER2:       # %bb.0:
-; BDVER2-NEXT:    vrcpps %ymm1, %ymm2 # sched: [5:2.00]
-; BDVER2-NEXT:    vmovaps {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [5:0.50]
-; BDVER2-NEXT:    vrcpps %ymm0, %ymm4 # sched: [5:2.00]
-; BDVER2-NEXT:    vfnmaddps %ymm3, %ymm2, %ymm1, %ymm1 # sched: [5:0.50]
-; BDVER2-NEXT:    vfnmaddps %ymm3, %ymm4, %ymm0, %ymm0 # sched: [5:0.50]
-; BDVER2-NEXT:    vfmaddps %ymm2, %ymm1, %ymm2, %ymm1 # sched: [5:0.50]
-; BDVER2-NEXT:    vfmaddps %ymm4, %ymm0, %ymm4, %ymm0 # sched: [5:0.50]
-; BDVER2-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [10:2.00]
-; BDVER2-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm1 # sched: [10:2.00]
-; BDVER2-NEXT:    retq # sched: [5:1.00]
+; BDVER2-NEXT:    vrcpps %ymm1, %ymm2
+; BDVER2-NEXT:    vmovaps {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; BDVER2-NEXT:    vrcpps %ymm0, %ymm4
+; BDVER2-NEXT:    vfnmaddps %ymm3, %ymm2, %ymm1, %ymm1
+; BDVER2-NEXT:    vfnmaddps %ymm3, %ymm4, %ymm0, %ymm0
+; BDVER2-NEXT:    vfmaddps %ymm2, %ymm1, %ymm2, %ymm1
+; BDVER2-NEXT:    vfmaddps %ymm4, %ymm0, %ymm4, %ymm0
+; BDVER2-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
+; BDVER2-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm1
+; BDVER2-NEXT:    retq
 ;
 ; BTVER2-LABEL: v16f32_one_step2:
 ; BTVER2:       # %bb.0:
-; BTVER2-NEXT:    vmovaps {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [5:1.00]
-; BTVER2-NEXT:    vrcpps %ymm1, %ymm2 # sched: [2:2.00]
-; BTVER2-NEXT:    vrcpps %ymm0, %ymm4 # sched: [2:2.00]
-; BTVER2-NEXT:    vmulps %ymm2, %ymm1, %ymm1 # sched: [2:2.00]
-; BTVER2-NEXT:    vmulps %ymm4, %ymm0, %ymm0 # sched: [2:2.00]
-; BTVER2-NEXT:    vsubps %ymm1, %ymm3, %ymm1 # sched: [3:2.00]
-; BTVER2-NEXT:    vsubps %ymm0, %ymm3, %ymm0 # sched: [3:2.00]
-; BTVER2-NEXT:    vmulps %ymm1, %ymm2, %ymm1 # sched: [2:2.00]
-; BTVER2-NEXT:    vmulps %ymm0, %ymm4, %ymm0 # sched: [2:2.00]
-; BTVER2-NEXT:    vaddps %ymm1, %ymm2, %ymm1 # sched: [3:2.00]
-; BTVER2-NEXT:    vaddps %ymm0, %ymm4, %ymm0 # sched: [3:2.00]
-; BTVER2-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [7:2.00]
-; BTVER2-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm1 # sched: [7:2.00]
-; BTVER2-NEXT:    retq # sched: [4:1.00]
+; BTVER2-NEXT:    vmovaps {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; BTVER2-NEXT:    vrcpps %ymm1, %ymm2
+; BTVER2-NEXT:    vrcpps %ymm0, %ymm4
+; BTVER2-NEXT:    vmulps %ymm2, %ymm1, %ymm1
+; BTVER2-NEXT:    vmulps %ymm4, %ymm0, %ymm0
+; BTVER2-NEXT:    vsubps %ymm1, %ymm3, %ymm1
+; BTVER2-NEXT:    vsubps %ymm0, %ymm3, %ymm0
+; BTVER2-NEXT:    vmulps %ymm1, %ymm2, %ymm1
+; BTVER2-NEXT:    vmulps %ymm0, %ymm4, %ymm0
+; BTVER2-NEXT:    vaddps %ymm1, %ymm2, %ymm1
+; BTVER2-NEXT:    vaddps %ymm0, %ymm4, %ymm0
+; BTVER2-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
+; BTVER2-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm1
+; BTVER2-NEXT:    retq
 ;
 ; SANDY-LABEL: v16f32_one_step2:
 ; SANDY:       # %bb.0:
-; SANDY-NEXT:    vrcpps %ymm1, %ymm2 # sched: [7:2.00]
-; SANDY-NEXT:    vmulps %ymm2, %ymm1, %ymm1 # sched: [5:1.00]
-; SANDY-NEXT:    vmovaps {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; SANDY-NEXT:    vsubps %ymm1, %ymm3, %ymm1 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %ymm1, %ymm2, %ymm1 # sched: [5:1.00]
-; SANDY-NEXT:    vaddps %ymm1, %ymm2, %ymm1 # sched: [3:1.00]
-; SANDY-NEXT:    vrcpps %ymm0, %ymm2 # sched: [7:2.00]
-; SANDY-NEXT:    vmulps %ymm2, %ymm0, %ymm0 # sched: [5:1.00]
-; SANDY-NEXT:    vsubps %ymm0, %ymm3, %ymm0 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %ymm0, %ymm2, %ymm0 # sched: [5:1.00]
-; SANDY-NEXT:    vaddps %ymm0, %ymm2, %ymm0 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [12:1.00]
-; SANDY-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm1 # sched: [12:1.00]
-; SANDY-NEXT:    retq # sched: [1:1.00]
+; SANDY-NEXT:    vrcpps %ymm1, %ymm2
+; SANDY-NEXT:    vmulps %ymm2, %ymm1, %ymm1
+; SANDY-NEXT:    vmovaps {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; SANDY-NEXT:    vsubps %ymm1, %ymm3, %ymm1
+; SANDY-NEXT:    vmulps %ymm1, %ymm2, %ymm1
+; SANDY-NEXT:    vaddps %ymm1, %ymm2, %ymm1
+; SANDY-NEXT:    vrcpps %ymm0, %ymm2
+; SANDY-NEXT:    vmulps %ymm2, %ymm0, %ymm0
+; SANDY-NEXT:    vsubps %ymm0, %ymm3, %ymm0
+; SANDY-NEXT:    vmulps %ymm0, %ymm2, %ymm0
+; SANDY-NEXT:    vaddps %ymm0, %ymm2, %ymm0
+; SANDY-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
+; SANDY-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm1
+; SANDY-NEXT:    retq
 ;
 ; HASWELL-LABEL: v16f32_one_step2:
 ; HASWELL:       # %bb.0:
-; HASWELL-NEXT:    vrcpps %ymm1, %ymm2 # sched: [11:2.00]
-; HASWELL-NEXT:    vbroadcastss {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; HASWELL-NEXT:    vrcpps %ymm0, %ymm4 # sched: [11:2.00]
-; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm1 = -(ymm2 * ymm1) + ymm3 sched: [5:0.50]
-; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm1 = (ymm1 * ymm2) + ymm2 sched: [5:0.50]
-; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm4 * ymm0) + ymm3 sched: [5:0.50]
-; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm4) + ymm4 sched: [5:0.50]
-; HASWELL-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [12:0.50]
-; HASWELL-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm1 # sched: [12:0.50]
-; HASWELL-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NEXT:    vrcpps %ymm1, %ymm2
+; HASWELL-NEXT:    vbroadcastss {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; HASWELL-NEXT:    vrcpps %ymm0, %ymm4
+; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm1 = -(ymm2 * ymm1) + ymm3
+; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm1 = (ymm1 * ymm2) + ymm2
+; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm4 * ymm0) + ymm3
+; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm4) + ymm4
+; HASWELL-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
+; HASWELL-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm1
+; HASWELL-NEXT:    retq
 ;
 ; HASWELL-NO-FMA-LABEL: v16f32_one_step2:
 ; HASWELL-NO-FMA:       # %bb.0:
-; HASWELL-NO-FMA-NEXT:    vrcpps %ymm1, %ymm2 # sched: [11:2.00]
-; HASWELL-NO-FMA-NEXT:    vmulps %ymm2, %ymm1, %ymm1 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vbroadcastss {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; HASWELL-NO-FMA-NEXT:    vsubps %ymm1, %ymm3, %ymm1 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulps %ymm1, %ymm2, %ymm1 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vaddps %ymm1, %ymm2, %ymm1 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vrcpps %ymm0, %ymm2 # sched: [11:2.00]
-; HASWELL-NO-FMA-NEXT:    vmulps %ymm2, %ymm0, %ymm0 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vsubps %ymm0, %ymm3, %ymm0 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulps %ymm0, %ymm2, %ymm0 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vaddps %ymm0, %ymm2, %ymm0 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [12:0.50]
-; HASWELL-NO-FMA-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm1 # sched: [12:0.50]
-; HASWELL-NO-FMA-NEXT:    retq # sched: [7:1.00]
-;
-; KNL-LABEL: v16f32_one_step2:
-; KNL:       # %bb.0:
-; KNL-NEXT:    vrcp14ps %zmm0, %zmm1 # sched: [11:2.00]
-; KNL-NEXT:    vfnmadd213ps {{.*#+}} zmm0 = -(zmm1 * zmm0) + mem sched: [12:0.50]
-; KNL-NEXT:    vfmadd132ps {{.*#+}} zmm0 = (zmm0 * zmm1) + zmm1 sched: [5:0.50]
-; KNL-NEXT:    vmulps {{.*}}(%rip), %zmm0, %zmm0 # sched: [12:0.50]
-; KNL-NEXT:    retq # sched: [7:1.00]
-;
-; SKX-LABEL: v16f32_one_step2:
-; SKX:       # %bb.0:
-; SKX-NEXT:    vrcp14ps %zmm0, %zmm1 # sched: [4:2.00]
-; SKX-NEXT:    vfnmadd213ps {{.*#+}} zmm0 = -(zmm1 * zmm0) + mem sched: [11:0.50]
-; SKX-NEXT:    vfmadd132ps {{.*#+}} zmm0 = (zmm0 * zmm1) + zmm1 sched: [4:0.50]
-; SKX-NEXT:    vmulps {{.*}}(%rip), %zmm0, %zmm0 # sched: [11:0.50]
-; SKX-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NO-FMA-NEXT:    vrcpps %ymm1, %ymm2
+; HASWELL-NO-FMA-NEXT:    vmulps %ymm2, %ymm1, %ymm1
+; HASWELL-NO-FMA-NEXT:    vbroadcastss {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; HASWELL-NO-FMA-NEXT:    vsubps %ymm1, %ymm3, %ymm1
+; HASWELL-NO-FMA-NEXT:    vmulps %ymm1, %ymm2, %ymm1
+; HASWELL-NO-FMA-NEXT:    vaddps %ymm1, %ymm2, %ymm1
+; HASWELL-NO-FMA-NEXT:    vrcpps %ymm0, %ymm2
+; HASWELL-NO-FMA-NEXT:    vmulps %ymm2, %ymm0, %ymm0
+; HASWELL-NO-FMA-NEXT:    vsubps %ymm0, %ymm3, %ymm0
+; HASWELL-NO-FMA-NEXT:    vmulps %ymm0, %ymm2, %ymm0
+; HASWELL-NO-FMA-NEXT:    vaddps %ymm0, %ymm2, %ymm0
+; HASWELL-NO-FMA-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
+; HASWELL-NO-FMA-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm1
+; HASWELL-NO-FMA-NEXT:    retq
+;
+; AVX512-LABEL: v16f32_one_step2:
+; AVX512:       # %bb.0:
+; AVX512-NEXT:    vrcp14ps %zmm0, %zmm1
+; AVX512-NEXT:    vfnmadd213ps {{.*#+}} zmm0 = -(zmm1 * zmm0) + mem
+; AVX512-NEXT:    vfmadd132ps {{.*#+}} zmm0 = (zmm0 * zmm1) + zmm1
+; AVX512-NEXT:    vmulps {{.*}}(%rip), %zmm0, %zmm0
+; AVX512-NEXT:    retq
   %div = fdiv fast <16 x float> <float 1.0, float 2.0, float 3.0, float 4.0, float 5.0, float 6.0, float 7.0, float 8.0, float 9.0, float 10.0, float 11.0, float 12.0, float 13.0, float 14.0, float 15.0, float 16.0>, %x
   ret <16 x float> %div
 }
 
 define <16 x float> @v16f32_one_step_2_divs(<16 x float> %x) #1 {
 ; SSE-LABEL: v16f32_one_step_2_divs:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    rcpps %xmm0, %xmm6

 ; FMA-RECIP-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm2
 ; FMA-RECIP-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm3
 ; FMA-RECIP-NEXT:    vmulps %ymm0, %ymm3, %ymm0
 ; FMA-RECIP-NEXT:    vmulps %ymm1, %ymm2, %ymm1
 ; FMA-RECIP-NEXT:    retq
 ;
 ; BDVER2-LABEL: v16f32_one_step_2_divs:
 ; BDVER2:       # %bb.0:
-; BDVER2-NEXT:    vrcpps %ymm0, %ymm2 # sched: [5:2.00]
-; BDVER2-NEXT:    vmovaps {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [5:0.50]
-; BDVER2-NEXT:    vfnmaddps %ymm3, %ymm2, %ymm0, %ymm0 # sched: [5:0.50]
-; BDVER2-NEXT:    vfmaddps %ymm2, %ymm0, %ymm2, %ymm0 # sched: [5:0.50]
-; BDVER2-NEXT:    vrcpps %ymm1, %ymm2 # sched: [5:2.00]
-; BDVER2-NEXT:    vfnmaddps %ymm3, %ymm2, %ymm1, %ymm1 # sched: [5:0.50]
-; BDVER2-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm3 # sched: [10:2.00]
-; BDVER2-NEXT:    vfmaddps %ymm2, %ymm1, %ymm2, %ymm1 # sched: [5:0.50]
-; BDVER2-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm2 # sched: [10:2.00]
-; BDVER2-NEXT:    vmulps %ymm0, %ymm3, %ymm0 # sched: [5:2.00]
-; BDVER2-NEXT:    vmulps %ymm1, %ymm2, %ymm1 # sched: [5:2.00]
-; BDVER2-NEXT:    retq # sched: [5:1.00]
+; BDVER2-NEXT:    vrcpps %ymm0, %ymm2
+; BDVER2-NEXT:    vmovaps {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; BDVER2-NEXT:    vfnmaddps %ymm3, %ymm2, %ymm0, %ymm0
+; BDVER2-NEXT:    vfmaddps %ymm2, %ymm0, %ymm2, %ymm0
+; BDVER2-NEXT:    vrcpps %ymm1, %ymm2
+; BDVER2-NEXT:    vfnmaddps %ymm3, %ymm2, %ymm1, %ymm1
+; BDVER2-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm3
+; BDVER2-NEXT:    vfmaddps %ymm2, %ymm1, %ymm2, %ymm1
+; BDVER2-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm2
+; BDVER2-NEXT:    vmulps %ymm0, %ymm3, %ymm0
+; BDVER2-NEXT:    vmulps %ymm1, %ymm2, %ymm1
+; BDVER2-NEXT:    retq
 ;
 ; BTVER2-LABEL: v16f32_one_step_2_divs:
 ; BTVER2:       # %bb.0:
-; BTVER2-NEXT:    vmovaps {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [5:1.00]
-; BTVER2-NEXT:    vrcpps %ymm0, %ymm2 # sched: [2:2.00]
-; BTVER2-NEXT:    vmulps %ymm2, %ymm0, %ymm0 # sched: [2:2.00]
-; BTVER2-NEXT:    vsubps %ymm0, %ymm3, %ymm0 # sched: [3:2.00]
-; BTVER2-NEXT:    vmulps %ymm0, %ymm2, %ymm0 # sched: [2:2.00]
-; BTVER2-NEXT:    vaddps %ymm0, %ymm2, %ymm0 # sched: [3:2.00]
-; BTVER2-NEXT:    vrcpps %ymm1, %ymm2 # sched: [2:2.00]
-; BTVER2-NEXT:    vmulps %ymm2, %ymm1, %ymm1 # sched: [2:2.00]
-; BTVER2-NEXT:    vsubps %ymm1, %ymm3, %ymm1 # sched: [3:2.00]
-; BTVER2-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm3 # sched: [7:2.00]
-; BTVER2-NEXT:    vmulps %ymm1, %ymm2, %ymm1 # sched: [2:2.00]
-; BTVER2-NEXT:    vaddps %ymm1, %ymm2, %ymm1 # sched: [3:2.00]
-; BTVER2-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm2 # sched: [7:2.00]
-; BTVER2-NEXT:    vmulps %ymm0, %ymm3, %ymm0 # sched: [2:2.00]
-; BTVER2-NEXT:    vmulps %ymm1, %ymm2, %ymm1 # sched: [2:2.00]
-; BTVER2-NEXT:    retq # sched: [4:1.00]
+; BTVER2-NEXT:    vmovaps {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; BTVER2-NEXT:    vrcpps %ymm0, %ymm2
+; BTVER2-NEXT:    vmulps %ymm2, %ymm0, %ymm0
+; BTVER2-NEXT:    vsubps %ymm0, %ymm3, %ymm0
+; BTVER2-NEXT:    vmulps %ymm0, %ymm2, %ymm0
+; BTVER2-NEXT:    vaddps %ymm0, %ymm2, %ymm0
+; BTVER2-NEXT:    vrcpps %ymm1, %ymm2
+; BTVER2-NEXT:    vmulps %ymm2, %ymm1, %ymm1
+; BTVER2-NEXT:    vsubps %ymm1, %ymm3, %ymm1
+; BTVER2-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm3
+; BTVER2-NEXT:    vmulps %ymm1, %ymm2, %ymm1
+; BTVER2-NEXT:    vaddps %ymm1, %ymm2, %ymm1
+; BTVER2-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm2
+; BTVER2-NEXT:    vmulps %ymm0, %ymm3, %ymm0
+; BTVER2-NEXT:    vmulps %ymm1, %ymm2, %ymm1
+; BTVER2-NEXT:    retq
 ;
 ; SANDY-LABEL: v16f32_one_step_2_divs:
 ; SANDY:       # %bb.0:
-; SANDY-NEXT:    vrcpps %ymm0, %ymm2 # sched: [7:2.00]
-; SANDY-NEXT:    vmulps %ymm2, %ymm0, %ymm0 # sched: [5:1.00]
-; SANDY-NEXT:    vmovaps {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; SANDY-NEXT:    vsubps %ymm0, %ymm3, %ymm0 # sched: [3:1.00]
-; SANDY-NEXT:    vrcpps %ymm1, %ymm4 # sched: [7:2.00]
-; SANDY-NEXT:    vmulps %ymm0, %ymm2, %ymm0 # sched: [5:1.00]
-; SANDY-NEXT:    vaddps %ymm0, %ymm2, %ymm0 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %ymm4, %ymm1, %ymm1 # sched: [5:1.00]
-; SANDY-NEXT:    vsubps %ymm1, %ymm3, %ymm1 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %ymm1, %ymm4, %ymm1 # sched: [5:1.00]
-; SANDY-NEXT:    vaddps %ymm1, %ymm4, %ymm1 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm2 # sched: [12:1.00]
-; SANDY-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm3 # sched: [12:1.00]
-; SANDY-NEXT:    vmulps %ymm0, %ymm3, %ymm0 # sched: [5:1.00]
-; SANDY-NEXT:    vmulps %ymm1, %ymm2, %ymm1 # sched: [5:1.00]
-; SANDY-NEXT:    retq # sched: [1:1.00]
+; SANDY-NEXT:    vrcpps %ymm0, %ymm2
+; SANDY-NEXT:    vmulps %ymm2, %ymm0, %ymm0
+; SANDY-NEXT:    vmovaps {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; SANDY-NEXT:    vsubps %ymm0, %ymm3, %ymm0
+; SANDY-NEXT:    vrcpps %ymm1, %ymm4
+; SANDY-NEXT:    vmulps %ymm0, %ymm2, %ymm0
+; SANDY-NEXT:    vaddps %ymm0, %ymm2, %ymm0
+; SANDY-NEXT:    vmulps %ymm4, %ymm1, %ymm1
+; SANDY-NEXT:    vsubps %ymm1, %ymm3, %ymm1
+; SANDY-NEXT:    vmulps %ymm1, %ymm4, %ymm1
+; SANDY-NEXT:    vaddps %ymm1, %ymm4, %ymm1
+; SANDY-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm2
+; SANDY-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm3
+; SANDY-NEXT:    vmulps %ymm0, %ymm3, %ymm0
+; SANDY-NEXT:    vmulps %ymm1, %ymm2, %ymm1
+; SANDY-NEXT:    retq
 ;
 ; HASWELL-LABEL: v16f32_one_step_2_divs:
 ; HASWELL:       # %bb.0:
-; HASWELL-NEXT:    vrcpps %ymm0, %ymm2 # sched: [11:2.00]
-; HASWELL-NEXT:    vbroadcastss {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm2 * ymm0) + ymm3 sched: [5:0.50]
-; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm2) + ymm2 sched: [5:0.50]
-; HASWELL-NEXT:    vrcpps %ymm1, %ymm2 # sched: [11:2.00]
-; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm1 = -(ymm2 * ymm1) + ymm3 sched: [5:0.50]
-; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm1 = (ymm1 * ymm2) + ymm2 sched: [5:0.50]
-; HASWELL-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm2 # sched: [12:0.50]
-; HASWELL-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm3 # sched: [12:0.50]
-; HASWELL-NEXT:    vmulps %ymm0, %ymm3, %ymm0 # sched: [5:0.50]
-; HASWELL-NEXT:    vmulps %ymm1, %ymm2, %ymm1 # sched: [5:0.50]
-; HASWELL-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NEXT:    vrcpps %ymm0, %ymm2
+; HASWELL-NEXT:    vbroadcastss {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm2 * ymm0) + ymm3
+; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm2) + ymm2
+; HASWELL-NEXT:    vrcpps %ymm1, %ymm2
+; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm1 = -(ymm2 * ymm1) + ymm3
+; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm1 = (ymm1 * ymm2) + ymm2
+; HASWELL-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm2
+; HASWELL-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm3
+; HASWELL-NEXT:    vmulps %ymm0, %ymm3, %ymm0
+; HASWELL-NEXT:    vmulps %ymm1, %ymm2, %ymm1
+; HASWELL-NEXT:    retq
 ;
 ; HASWELL-NO-FMA-LABEL: v16f32_one_step_2_divs:
 ; HASWELL-NO-FMA:       # %bb.0:
-; HASWELL-NO-FMA-NEXT:    vrcpps %ymm0, %ymm2 # sched: [11:2.00]
-; HASWELL-NO-FMA-NEXT:    vmulps %ymm2, %ymm0, %ymm0 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vbroadcastss {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; HASWELL-NO-FMA-NEXT:    vsubps %ymm0, %ymm3, %ymm0 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vrcpps %ymm1, %ymm4 # sched: [11:2.00]
-; HASWELL-NO-FMA-NEXT:    vmulps %ymm0, %ymm2, %ymm0 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vaddps %ymm0, %ymm2, %ymm0 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulps %ymm4, %ymm1, %ymm1 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vsubps %ymm1, %ymm3, %ymm1 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulps %ymm1, %ymm4, %ymm1 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vaddps %ymm1, %ymm4, %ymm1 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm2 # sched: [12:0.50]
-; HASWELL-NO-FMA-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm3 # sched: [12:0.50]
-; HASWELL-NO-FMA-NEXT:    vmulps %ymm0, %ymm3, %ymm0 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vmulps %ymm1, %ymm2, %ymm1 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    retq # sched: [7:1.00]
-;
-; KNL-LABEL: v16f32_one_step_2_divs:
-; KNL:       # %bb.0:
-; KNL-NEXT:    vrcp14ps %zmm0, %zmm1 # sched: [11:2.00]
-; KNL-NEXT:    vfnmadd213ps {{.*#+}} zmm0 = -(zmm1 * zmm0) + mem sched: [12:0.50]
-; KNL-NEXT:    vfmadd132ps {{.*#+}} zmm0 = (zmm0 * zmm1) + zmm1 sched: [5:0.50]
-; KNL-NEXT:    vmulps {{.*}}(%rip), %zmm0, %zmm1 # sched: [12:0.50]
-; KNL-NEXT:    vmulps %zmm0, %zmm1, %zmm0 # sched: [5:0.50]
-; KNL-NEXT:    retq # sched: [7:1.00]
-;
-; SKX-LABEL: v16f32_one_step_2_divs:
-; SKX:       # %bb.0:
-; SKX-NEXT:    vrcp14ps %zmm0, %zmm1 # sched: [4:2.00]
-; SKX-NEXT:    vfnmadd213ps {{.*#+}} zmm0 = -(zmm1 * zmm0) + mem sched: [11:0.50]
-; SKX-NEXT:    vfmadd132ps {{.*#+}} zmm0 = (zmm0 * zmm1) + zmm1 sched: [4:0.50]
-; SKX-NEXT:    vmulps {{.*}}(%rip), %zmm0, %zmm1 # sched: [11:0.50]
-; SKX-NEXT:    vmulps %zmm0, %zmm1, %zmm0 # sched: [4:0.50]
-; SKX-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NO-FMA-NEXT:    vrcpps %ymm0, %ymm2
+; HASWELL-NO-FMA-NEXT:    vmulps %ymm2, %ymm0, %ymm0
+; HASWELL-NO-FMA-NEXT:    vbroadcastss {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; HASWELL-NO-FMA-NEXT:    vsubps %ymm0, %ymm3, %ymm0
+; HASWELL-NO-FMA-NEXT:    vrcpps %ymm1, %ymm4
+; HASWELL-NO-FMA-NEXT:    vmulps %ymm0, %ymm2, %ymm0
+; HASWELL-NO-FMA-NEXT:    vaddps %ymm0, %ymm2, %ymm0
+; HASWELL-NO-FMA-NEXT:    vmulps %ymm4, %ymm1, %ymm1
+; HASWELL-NO-FMA-NEXT:    vsubps %ymm1, %ymm3, %ymm1
+; HASWELL-NO-FMA-NEXT:    vmulps %ymm1, %ymm4, %ymm1
+; HASWELL-NO-FMA-NEXT:    vaddps %ymm1, %ymm4, %ymm1
+; HASWELL-NO-FMA-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm2
+; HASWELL-NO-FMA-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm3
+; HASWELL-NO-FMA-NEXT:    vmulps %ymm0, %ymm3, %ymm0
+; HASWELL-NO-FMA-NEXT:    vmulps %ymm1, %ymm2, %ymm1
+; HASWELL-NO-FMA-NEXT:    retq
+;
+; AVX512-LABEL: v16f32_one_step_2_divs:
+; AVX512:       # %bb.0:
+; AVX512-NEXT:    vrcp14ps %zmm0, %zmm1
+; AVX512-NEXT:    vfnmadd213ps {{.*#+}} zmm0 = -(zmm1 * zmm0) + mem
+; AVX512-NEXT:    vfmadd132ps {{.*#+}} zmm0 = (zmm0 * zmm1) + zmm1
+; AVX512-NEXT:    vmulps {{.*}}(%rip), %zmm0, %zmm1
+; AVX512-NEXT:    vmulps %zmm0, %zmm1, %zmm0
+; AVX512-NEXT:    retq
   %div = fdiv fast <16 x float> <float 1.0, float 2.0, float 3.0, float 4.0, float 5.0, float 6.0, float 7.0, float 8.0, float 9.0, float 10.0, float 11.0, float 12.0, float 13.0, float 14.0, float 15.0, float 16.0>, %x
   %div2 = fdiv fast <16 x float> %div, %x
   ret <16 x float> %div2
 }
 
 define <16 x float> @v16f32_two_step2(<16 x float> %x) #2 {
 ; SSE-LABEL: v16f32_two_step2:
 ; SSE:       # %bb.0:

 ; FMA-RECIP-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm4 * ymm0) + ymm3
 ; FMA-RECIP-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm4) + ymm4
 ; FMA-RECIP-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
 ; FMA-RECIP-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm1
 ; FMA-RECIP-NEXT:    retq
 ;
 ; BDVER2-LABEL: v16f32_two_step2:
 ; BDVER2:       # %bb.0:
-; BDVER2-NEXT:    vrcpps %ymm1, %ymm2 # sched: [5:2.00]
-; BDVER2-NEXT:    vmovaps {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [5:0.50]
-; BDVER2-NEXT:    vfnmaddps %ymm3, %ymm2, %ymm1, %ymm4 # sched: [5:0.50]
-; BDVER2-NEXT:    vfmaddps %ymm2, %ymm4, %ymm2, %ymm2 # sched: [5:0.50]
-; BDVER2-NEXT:    vfnmaddps %ymm3, %ymm2, %ymm1, %ymm1 # sched: [5:0.50]
-; BDVER2-NEXT:    vfmaddps %ymm2, %ymm1, %ymm2, %ymm1 # sched: [5:0.50]
-; BDVER2-NEXT:    vrcpps %ymm0, %ymm2 # sched: [5:2.00]
-; BDVER2-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm1 # sched: [10:2.00]
-; BDVER2-NEXT:    vfnmaddps %ymm3, %ymm2, %ymm0, %ymm4 # sched: [5:0.50]
-; BDVER2-NEXT:    vfmaddps %ymm2, %ymm4, %ymm2, %ymm2 # sched: [5:0.50]
-; BDVER2-NEXT:    vfnmaddps %ymm3, %ymm2, %ymm0, %ymm0 # sched: [5:0.50]
-; BDVER2-NEXT:    vfmaddps %ymm2, %ymm0, %ymm2, %ymm0 # sched: [5:0.50]
-; BDVER2-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [10:2.00]
-; BDVER2-NEXT:    retq # sched: [5:1.00]
+; BDVER2-NEXT:    vrcpps %ymm1, %ymm2
+; BDVER2-NEXT:    vmovaps {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; BDVER2-NEXT:    vfnmaddps %ymm3, %ymm2, %ymm1, %ymm4
+; BDVER2-NEXT:    vfmaddps %ymm2, %ymm4, %ymm2, %ymm2
+; BDVER2-NEXT:    vfnmaddps %ymm3, %ymm2, %ymm1, %ymm1
+; BDVER2-NEXT:    vfmaddps %ymm2, %ymm1, %ymm2, %ymm1
+; BDVER2-NEXT:    vrcpps %ymm0, %ymm2
+; BDVER2-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm1
+; BDVER2-NEXT:    vfnmaddps %ymm3, %ymm2, %ymm0, %ymm4
+; BDVER2-NEXT:    vfmaddps %ymm2, %ymm4, %ymm2, %ymm2
+; BDVER2-NEXT:    vfnmaddps %ymm3, %ymm2, %ymm0, %ymm0
+; BDVER2-NEXT:    vfmaddps %ymm2, %ymm0, %ymm2, %ymm0
+; BDVER2-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
+; BDVER2-NEXT:    retq
 ;
 ; BTVER2-LABEL: v16f32_two_step2:
 ; BTVER2:       # %bb.0:
-; BTVER2-NEXT:    vmovaps {{.*#+}} ymm4 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [5:1.00]
-; BTVER2-NEXT:    vrcpps %ymm1, %ymm2 # sched: [2:2.00]
-; BTVER2-NEXT:    vmulps %ymm2, %ymm1, %ymm3 # sched: [2:2.00]
-; BTVER2-NEXT:    vsubps %ymm3, %ymm4, %ymm3 # sched: [3:2.00]
-; BTVER2-NEXT:    vmulps %ymm3, %ymm2, %ymm3 # sched: [2:2.00]
-; BTVER2-NEXT:    vaddps %ymm3, %ymm2, %ymm2 # sched: [3:2.00]
-; BTVER2-NEXT:    vmulps %ymm2, %ymm1, %ymm1 # sched: [2:2.00]
-; BTVER2-NEXT:    vsubps %ymm1, %ymm4, %ymm1 # sched: [3:2.00]
-; BTVER2-NEXT:    vmulps %ymm1, %ymm2, %ymm1 # sched: [2:2.00]
-; BTVER2-NEXT:    vaddps %ymm1, %ymm2, %ymm1 # sched: [3:2.00]
-; BTVER2-NEXT:    vrcpps %ymm0, %ymm2 # sched: [2:2.00]
-; BTVER2-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm1 # sched: [7:2.00]
-; BTVER2-NEXT:    vmulps %ymm2, %ymm0, %ymm3 # sched: [2:2.00]
-; BTVER2-NEXT:    vsubps %ymm3, %ymm4, %ymm3 # sched: [3:2.00]
-; BTVER2-NEXT:    vmulps %ymm3, %ymm2, %ymm3 # sched: [2:2.00]
-; BTVER2-NEXT:    vaddps %ymm3, %ymm2, %ymm2 # sched: [3:2.00]
-; BTVER2-NEXT:    vmulps %ymm2, %ymm0, %ymm0 # sched: [2:2.00]
-; BTVER2-NEXT:    vsubps %ymm0, %ymm4, %ymm0 # sched: [3:2.00]
-; BTVER2-NEXT:    vmulps %ymm0, %ymm2, %ymm0 # sched: [2:2.00]
-; BTVER2-NEXT:    vaddps %ymm0, %ymm2, %ymm0 # sched: [3:2.00]
-; BTVER2-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [7:2.00]
-; BTVER2-NEXT:    retq # sched: [4:1.00]
+; BTVER2-NEXT:    vmovaps {{.*#+}} ymm4 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; BTVER2-NEXT:    vrcpps %ymm1, %ymm2
+; BTVER2-NEXT:    vmulps %ymm2, %ymm1, %ymm3
+; BTVER2-NEXT:    vsubps %ymm3, %ymm4, %ymm3
+; BTVER2-NEXT:    vmulps %ymm3, %ymm2, %ymm3
+; BTVER2-NEXT:    vaddps %ymm3, %ymm2, %ymm2
+; BTVER2-NEXT:    vmulps %ymm2, %ymm1, %ymm1
+; BTVER2-NEXT:    vsubps %ymm1, %ymm4, %ymm1
+; BTVER2-NEXT:    vmulps %ymm1, %ymm2, %ymm1
+; BTVER2-NEXT:    vaddps %ymm1, %ymm2, %ymm1
+; BTVER2-NEXT:    vrcpps %ymm0, %ymm2
+; BTVER2-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm1
+; BTVER2-NEXT:    vmulps %ymm2, %ymm0, %ymm3
+; BTVER2-NEXT:    vsubps %ymm3, %ymm4, %ymm3
+; BTVER2-NEXT:    vmulps %ymm3, %ymm2, %ymm3
+; BTVER2-NEXT:    vaddps %ymm3, %ymm2, %ymm2
+; BTVER2-NEXT:    vmulps %ymm2, %ymm0, %ymm0
+; BTVER2-NEXT:    vsubps %ymm0, %ymm4, %ymm0
+; BTVER2-NEXT:    vmulps %ymm0, %ymm2, %ymm0
+; BTVER2-NEXT:    vaddps %ymm0, %ymm2, %ymm0
+; BTVER2-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
+; BTVER2-NEXT:    retq
 ;
 ; SANDY-LABEL: v16f32_two_step2:
 ; SANDY:       # %bb.0:
-; SANDY-NEXT:    vrcpps %ymm1, %ymm2 # sched: [7:2.00]
-; SANDY-NEXT:    vmulps %ymm2, %ymm1, %ymm3 # sched: [5:1.00]
-; SANDY-NEXT:    vmovaps {{.*#+}} ymm4 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; SANDY-NEXT:    vsubps %ymm3, %ymm4, %ymm3 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %ymm3, %ymm2, %ymm3 # sched: [5:1.00]
-; SANDY-NEXT:    vaddps %ymm3, %ymm2, %ymm2 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %ymm2, %ymm1, %ymm1 # sched: [5:1.00]
-; SANDY-NEXT:    vsubps %ymm1, %ymm4, %ymm1 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %ymm1, %ymm2, %ymm1 # sched: [5:1.00]
-; SANDY-NEXT:    vaddps %ymm1, %ymm2, %ymm1 # sched: [3:1.00]
-; SANDY-NEXT:    vrcpps %ymm0, %ymm2 # sched: [7:2.00]
-; SANDY-NEXT:    vmulps %ymm2, %ymm0, %ymm3 # sched: [5:1.00]
-; SANDY-NEXT:    vsubps %ymm3, %ymm4, %ymm3 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %ymm3, %ymm2, %ymm3 # sched: [5:1.00]
-; SANDY-NEXT:    vaddps %ymm3, %ymm2, %ymm2 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %ymm2, %ymm0, %ymm0 # sched: [5:1.00]
-; SANDY-NEXT:    vsubps %ymm0, %ymm4, %ymm0 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps %ymm0, %ymm2, %ymm0 # sched: [5:1.00]
-; SANDY-NEXT:    vaddps %ymm0, %ymm2, %ymm0 # sched: [3:1.00]
-; SANDY-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [12:1.00]
-; SANDY-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm1 # sched: [12:1.00]
-; SANDY-NEXT:    retq # sched: [1:1.00]
+; SANDY-NEXT:    vrcpps %ymm1, %ymm2
+; SANDY-NEXT:    vmulps %ymm2, %ymm1, %ymm3
+; SANDY-NEXT:    vmovaps {{.*#+}} ymm4 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; SANDY-NEXT:    vsubps %ymm3, %ymm4, %ymm3
+; SANDY-NEXT:    vmulps %ymm3, %ymm2, %ymm3
+; SANDY-NEXT:    vaddps %ymm3, %ymm2, %ymm2
+; SANDY-NEXT:    vmulps %ymm2, %ymm1, %ymm1
+; SANDY-NEXT:    vsubps %ymm1, %ymm4, %ymm1
+; SANDY-NEXT:    vmulps %ymm1, %ymm2, %ymm1
+; SANDY-NEXT:    vaddps %ymm1, %ymm2, %ymm1
+; SANDY-NEXT:    vrcpps %ymm0, %ymm2
+; SANDY-NEXT:    vmulps %ymm2, %ymm0, %ymm3
+; SANDY-NEXT:    vsubps %ymm3, %ymm4, %ymm3
+; SANDY-NEXT:    vmulps %ymm3, %ymm2, %ymm3
+; SANDY-NEXT:    vaddps %ymm3, %ymm2, %ymm2
+; SANDY-NEXT:    vmulps %ymm2, %ymm0, %ymm0
+; SANDY-NEXT:    vsubps %ymm0, %ymm4, %ymm0
+; SANDY-NEXT:    vmulps %ymm0, %ymm2, %ymm0
+; SANDY-NEXT:    vaddps %ymm0, %ymm2, %ymm0
+; SANDY-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
+; SANDY-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm1
+; SANDY-NEXT:    retq
 ;
 ; HASWELL-LABEL: v16f32_two_step2:
 ; HASWELL:       # %bb.0:
-; HASWELL-NEXT:    vrcpps %ymm1, %ymm2 # sched: [11:2.00]
-; HASWELL-NEXT:    vbroadcastss {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; HASWELL-NEXT:    vmovaps %ymm2, %ymm4 # sched: [1:1.00]
-; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm4 = -(ymm1 * ymm4) + ymm3 sched: [5:0.50]
-; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm4 = (ymm4 * ymm2) + ymm2 sched: [5:0.50]
-; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm1 = -(ymm4 * ymm1) + ymm3 sched: [5:0.50]
-; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm1 = (ymm1 * ymm4) + ymm4 sched: [5:0.50]
-; HASWELL-NEXT:    vrcpps %ymm0, %ymm2 # sched: [11:2.00]
-; HASWELL-NEXT:    vmovaps %ymm2, %ymm4 # sched: [1:1.00]
-; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm4 = -(ymm0 * ymm4) + ymm3 sched: [5:0.50]
-; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm4 = (ymm4 * ymm2) + ymm2 sched: [5:0.50]
-; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm4 * ymm0) + ymm3 sched: [5:0.50]
-; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm4) + ymm4 sched: [5:0.50]
-; HASWELL-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [12:0.50]
-; HASWELL-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm1 # sched: [12:0.50]
-; HASWELL-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NEXT:    vrcpps %ymm1, %ymm2
+; HASWELL-NEXT:    vbroadcastss {{.*#+}} ymm3 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; HASWELL-NEXT:    vmovaps %ymm2, %ymm4
+; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm4 = -(ymm1 * ymm4) + ymm3
+; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm4 = (ymm4 * ymm2) + ymm2
+; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm1 = -(ymm4 * ymm1) + ymm3
+; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm1 = (ymm1 * ymm4) + ymm4
+; HASWELL-NEXT:    vrcpps %ymm0, %ymm2
+; HASWELL-NEXT:    vmovaps %ymm2, %ymm4
+; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm4 = -(ymm0 * ymm4) + ymm3
+; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm4 = (ymm4 * ymm2) + ymm2
+; HASWELL-NEXT:    vfnmadd213ps {{.*#+}} ymm0 = -(ymm4 * ymm0) + ymm3
+; HASWELL-NEXT:    vfmadd132ps {{.*#+}} ymm0 = (ymm0 * ymm4) + ymm4
+; HASWELL-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
+; HASWELL-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm1
+; HASWELL-NEXT:    retq
 ;
 ; HASWELL-NO-FMA-LABEL: v16f32_two_step2:
 ; HASWELL-NO-FMA:       # %bb.0:
-; HASWELL-NO-FMA-NEXT:    vrcpps %ymm1, %ymm2 # sched: [11:2.00]
-; HASWELL-NO-FMA-NEXT:    vmulps %ymm2, %ymm1, %ymm3 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vbroadcastss {{.*#+}} ymm4 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [7:0.50]
-; HASWELL-NO-FMA-NEXT:    vsubps %ymm3, %ymm4, %ymm3 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulps %ymm3, %ymm2, %ymm3 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vaddps %ymm3, %ymm2, %ymm2 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulps %ymm2, %ymm1, %ymm1 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vsubps %ymm1, %ymm4, %ymm1 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulps %ymm1, %ymm2, %ymm1 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vaddps %ymm1, %ymm2, %ymm1 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vrcpps %ymm0, %ymm2 # sched: [11:2.00]
-; HASWELL-NO-FMA-NEXT:    vmulps %ymm2, %ymm0, %ymm3 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vsubps %ymm3, %ymm4, %ymm3 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulps %ymm3, %ymm2, %ymm3 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vaddps %ymm3, %ymm2, %ymm2 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulps %ymm2, %ymm0, %ymm0 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vsubps %ymm0, %ymm4, %ymm0 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulps %ymm0, %ymm2, %ymm0 # sched: [5:0.50]
-; HASWELL-NO-FMA-NEXT:    vaddps %ymm0, %ymm2, %ymm0 # sched: [3:1.00]
-; HASWELL-NO-FMA-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [12:0.50]
-; HASWELL-NO-FMA-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm1 # sched: [12:0.50]
-; HASWELL-NO-FMA-NEXT:    retq # sched: [7:1.00]
-;
-; KNL-LABEL: v16f32_two_step2:
-; KNL:       # %bb.0:
-; KNL-NEXT:    vrcp14ps %zmm0, %zmm1 # sched: [11:2.00]
-; KNL-NEXT:    vbroadcastss {{.*#+}} zmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [10:1.00]
-; KNL-NEXT:    vmovaps %zmm1, %zmm3 # sched: [1:1.00]
-; KNL-NEXT:    vfnmadd213ps {{.*#+}} zmm3 = -(zmm0 * zmm3) + zmm2 sched: [5:0.50]
-; KNL-NEXT:    vfmadd132ps {{.*#+}} zmm3 = (zmm3 * zmm1) + zmm1 sched: [5:0.50]
-; KNL-NEXT:    vfnmadd213ps {{.*#+}} zmm0 = -(zmm3 * zmm0) + zmm2 sched: [5:0.50]
-; KNL-NEXT:    vfmadd132ps {{.*#+}} zmm0 = (zmm0 * zmm3) + zmm3 sched: [5:0.50]
-; KNL-NEXT:    vmulps {{.*}}(%rip), %zmm0, %zmm0 # sched: [12:0.50]
-; KNL-NEXT:    retq # sched: [7:1.00]
-;
-; SKX-LABEL: v16f32_two_step2:
-; SKX:       # %bb.0:
-; SKX-NEXT:    vrcp14ps %zmm0, %zmm1 # sched: [4:2.00]
-; SKX-NEXT:    vbroadcastss {{.*#+}} zmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0] sched: [8:0.50]
-; SKX-NEXT:    vmovaps %zmm1, %zmm3 # sched: [1:0.33]
-; SKX-NEXT:    vfnmadd213ps {{.*#+}} zmm3 = -(zmm0 * zmm3) + zmm2 sched: [4:0.50]
-; SKX-NEXT:    vfmadd132ps {{.*#+}} zmm3 = (zmm3 * zmm1) + zmm1 sched: [4:0.50]
-; SKX-NEXT:    vfnmadd213ps {{.*#+}} zmm0 = -(zmm3 * zmm0) + zmm2 sched: [4:0.50]
-; SKX-NEXT:    vfmadd132ps {{.*#+}} zmm0 = (zmm0 * zmm3) + zmm3 sched: [4:0.50]
-; SKX-NEXT:    vmulps {{.*}}(%rip), %zmm0, %zmm0 # sched: [11:0.50]
-; SKX-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NO-FMA-NEXT:    vrcpps %ymm1, %ymm2
+; HASWELL-NO-FMA-NEXT:    vmulps %ymm2, %ymm1, %ymm3
+; HASWELL-NO-FMA-NEXT:    vbroadcastss {{.*#+}} ymm4 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; HASWELL-NO-FMA-NEXT:    vsubps %ymm3, %ymm4, %ymm3
+; HASWELL-NO-FMA-NEXT:    vmulps %ymm3, %ymm2, %ymm3
+; HASWELL-NO-FMA-NEXT:    vaddps %ymm3, %ymm2, %ymm2
+; HASWELL-NO-FMA-NEXT:    vmulps %ymm2, %ymm1, %ymm1
+; HASWELL-NO-FMA-NEXT:    vsubps %ymm1, %ymm4, %ymm1
+; HASWELL-NO-FMA-NEXT:    vmulps %ymm1, %ymm2, %ymm1
+; HASWELL-NO-FMA-NEXT:    vaddps %ymm1, %ymm2, %ymm1
+; HASWELL-NO-FMA-NEXT:    vrcpps %ymm0, %ymm2
+; HASWELL-NO-FMA-NEXT:    vmulps %ymm2, %ymm0, %ymm3
+; HASWELL-NO-FMA-NEXT:    vsubps %ymm3, %ymm4, %ymm3
+; HASWELL-NO-FMA-NEXT:    vmulps %ymm3, %ymm2, %ymm3
+; HASWELL-NO-FMA-NEXT:    vaddps %ymm3, %ymm2, %ymm2
+; HASWELL-NO-FMA-NEXT:    vmulps %ymm2, %ymm0, %ymm0
+; HASWELL-NO-FMA-NEXT:    vsubps %ymm0, %ymm4, %ymm0
+; HASWELL-NO-FMA-NEXT:    vmulps %ymm0, %ymm2, %ymm0
+; HASWELL-NO-FMA-NEXT:    vaddps %ymm0, %ymm2, %ymm0
+; HASWELL-NO-FMA-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
+; HASWELL-NO-FMA-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm1
+; HASWELL-NO-FMA-NEXT:    retq
+;
+; AVX512-LABEL: v16f32_two_step2:
+; AVX512:       # %bb.0:
+; AVX512-NEXT:    vrcp14ps %zmm0, %zmm1
+; AVX512-NEXT:    vbroadcastss {{.*#+}} zmm2 = [1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0,1.0E+0]
+; AVX512-NEXT:    vmovaps %zmm1, %zmm3
+; AVX512-NEXT:    vfnmadd213ps {{.*#+}} zmm3 = -(zmm0 * zmm3) + zmm2
+; AVX512-NEXT:    vfmadd132ps {{.*#+}} zmm3 = (zmm3 * zmm1) + zmm1
+; AVX512-NEXT:    vfnmadd213ps {{.*#+}} zmm0 = -(zmm3 * zmm0) + zmm2
+; AVX512-NEXT:    vfmadd132ps {{.*#+}} zmm0 = (zmm0 * zmm3) + zmm3
+; AVX512-NEXT:    vmulps {{.*}}(%rip), %zmm0, %zmm0
+; AVX512-NEXT:    retq
   %div = fdiv fast <16 x float> <float 1.0, float 2.0, float 3.0, float 4.0, float 5.0, float 6.0, float 7.0, float 8.0, float 9.0, float 10.0, float 11.0, float 12.0, float 13.0, float 14.0, float 15.0, float 16.0>, %x
   ret <16 x float> %div
 }
 
 define <16 x float> @v16f32_no_step(<16 x float> %x) #3 {
 ; SSE-LABEL: v16f32_no_step:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    rcpps %xmm0, %xmm0

 ; FMA-RECIP-LABEL: v16f32_no_step:
 ; FMA-RECIP:       # %bb.0:
 ; FMA-RECIP-NEXT:    vrcpps %ymm0, %ymm0
 ; FMA-RECIP-NEXT:    vrcpps %ymm1, %ymm1
 ; FMA-RECIP-NEXT:    retq
 ;
 ; BDVER2-LABEL: v16f32_no_step:
 ; BDVER2:       # %bb.0:
-; BDVER2-NEXT:    vrcpps %ymm0, %ymm0 # sched: [5:2.00]
-; BDVER2-NEXT:    vrcpps %ymm1, %ymm1 # sched: [5:2.00]
-; BDVER2-NEXT:    retq # sched: [5:1.00]
+; BDVER2-NEXT:    vrcpps %ymm0, %ymm0
+; BDVER2-NEXT:    vrcpps %ymm1, %ymm1
+; BDVER2-NEXT:    retq
 ;
 ; BTVER2-LABEL: v16f32_no_step:
 ; BTVER2:       # %bb.0:
-; BTVER2-NEXT:    vrcpps %ymm0, %ymm0 # sched: [2:2.00]
-; BTVER2-NEXT:    vrcpps %ymm1, %ymm1 # sched: [2:2.00]
-; BTVER2-NEXT:    retq # sched: [4:1.00]
+; BTVER2-NEXT:    vrcpps %ymm0, %ymm0
+; BTVER2-NEXT:    vrcpps %ymm1, %ymm1
+; BTVER2-NEXT:    retq
 ;
 ; SANDY-LABEL: v16f32_no_step:
 ; SANDY:       # %bb.0:
-; SANDY-NEXT:    vrcpps %ymm0, %ymm0 # sched: [7:2.00]
-; SANDY-NEXT:    vrcpps %ymm1, %ymm1 # sched: [7:2.00]
-; SANDY-NEXT:    retq # sched: [1:1.00]
+; SANDY-NEXT:    vrcpps %ymm0, %ymm0
+; SANDY-NEXT:    vrcpps %ymm1, %ymm1
+; SANDY-NEXT:    retq
 ;
 ; HASWELL-LABEL: v16f32_no_step:
 ; HASWELL:       # %bb.0:
-; HASWELL-NEXT:    vrcpps %ymm0, %ymm0 # sched: [11:2.00]
-; HASWELL-NEXT:    vrcpps %ymm1, %ymm1 # sched: [11:2.00]
-; HASWELL-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NEXT:    vrcpps %ymm0, %ymm0
+; HASWELL-NEXT:    vrcpps %ymm1, %ymm1
+; HASWELL-NEXT:    retq
 ;
 ; HASWELL-NO-FMA-LABEL: v16f32_no_step:
 ; HASWELL-NO-FMA:       # %bb.0:
-; HASWELL-NO-FMA-NEXT:    vrcpps %ymm0, %ymm0 # sched: [11:2.00]
-; HASWELL-NO-FMA-NEXT:    vrcpps %ymm1, %ymm1 # sched: [11:2.00]
-; HASWELL-NO-FMA-NEXT:    retq # sched: [7:1.00]
-;
-; KNL-LABEL: v16f32_no_step:
-; KNL:       # %bb.0:
-; KNL-NEXT:    vrcp14ps %zmm0, %zmm0 # sched: [11:2.00]
-; KNL-NEXT:    retq # sched: [7:1.00]
-;
-; SKX-LABEL: v16f32_no_step:
-; SKX:       # %bb.0:
-; SKX-NEXT:    vrcp14ps %zmm0, %zmm0 # sched: [4:2.00]
-; SKX-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NO-FMA-NEXT:    vrcpps %ymm0, %ymm0
+; HASWELL-NO-FMA-NEXT:    vrcpps %ymm1, %ymm1
+; HASWELL-NO-FMA-NEXT:    retq
+;
+; AVX512-LABEL: v16f32_no_step:
+; AVX512:       # %bb.0:
+; AVX512-NEXT:    vrcp14ps %zmm0, %zmm0
+; AVX512-NEXT:    retq
   %div = fdiv fast <16 x float> <float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0>, %x
   ret <16 x float> %div
 }
 
 define <16 x float> @v16f32_no_step2(<16 x float> %x) #3 {
 ; SSE-LABEL: v16f32_no_step2:
 ; SSE:       # %bb.0:
 ; SSE-NEXT:    rcpps %xmm3, %xmm3

 ; FMA-RECIP-NEXT:    vrcpps %ymm1, %ymm1
 ; FMA-RECIP-NEXT:    vrcpps %ymm0, %ymm0
 ; FMA-RECIP-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
 ; FMA-RECIP-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm1
 ; FMA-RECIP-NEXT:    retq
 ;
 ; BDVER2-LABEL: v16f32_no_step2:
 ; BDVER2:       # %bb.0:
-; BDVER2-NEXT:    vrcpps %ymm1, %ymm1 # sched: [5:2.00]
-; BDVER2-NEXT:    vrcpps %ymm0, %ymm0 # sched: [5:2.00]
-; BDVER2-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [10:2.00]
-; BDVER2-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm1 # sched: [10:2.00]
-; BDVER2-NEXT:    retq # sched: [5:1.00]
+; BDVER2-NEXT:    vrcpps %ymm1, %ymm1
+; BDVER2-NEXT:    vrcpps %ymm0, %ymm0
+; BDVER2-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
+; BDVER2-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm1
+; BDVER2-NEXT:    retq
 ;
 ; BTVER2-LABEL: v16f32_no_step2:
 ; BTVER2:       # %bb.0:
-; BTVER2-NEXT:    vrcpps %ymm1, %ymm1 # sched: [2:2.00]
-; BTVER2-NEXT:    vrcpps %ymm0, %ymm0 # sched: [2:2.00]
-; BTVER2-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [7:2.00]
-; BTVER2-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm1 # sched: [7:2.00]
-; BTVER2-NEXT:    retq # sched: [4:1.00]
+; BTVER2-NEXT:    vrcpps %ymm1, %ymm1
+; BTVER2-NEXT:    vrcpps %ymm0, %ymm0
+; BTVER2-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
+; BTVER2-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm1
+; BTVER2-NEXT:    retq
 ;
 ; SANDY-LABEL: v16f32_no_step2:
 ; SANDY:       # %bb.0:
-; SANDY-NEXT:    vrcpps %ymm1, %ymm1 # sched: [7:2.00]
-; SANDY-NEXT:    vrcpps %ymm0, %ymm0 # sched: [7:2.00]
-; SANDY-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [12:1.00]
-; SANDY-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm1 # sched: [12:1.00]
-; SANDY-NEXT:    retq # sched: [1:1.00]
+; SANDY-NEXT:    vrcpps %ymm1, %ymm1
+; SANDY-NEXT:    vrcpps %ymm0, %ymm0
+; SANDY-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
+; SANDY-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm1
+; SANDY-NEXT:    retq
 ;
 ; HASWELL-LABEL: v16f32_no_step2:
 ; HASWELL:       # %bb.0:
-; HASWELL-NEXT:    vrcpps %ymm1, %ymm1 # sched: [11:2.00]
-; HASWELL-NEXT:    vrcpps %ymm0, %ymm0 # sched: [11:2.00]
-; HASWELL-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [12:0.50]
-; HASWELL-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm1 # sched: [12:0.50]
-; HASWELL-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NEXT:    vrcpps %ymm1, %ymm1
+; HASWELL-NEXT:    vrcpps %ymm0, %ymm0
+; HASWELL-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
+; HASWELL-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm1
+; HASWELL-NEXT:    retq
 ;
 ; HASWELL-NO-FMA-LABEL: v16f32_no_step2:
 ; HASWELL-NO-FMA:       # %bb.0:
-; HASWELL-NO-FMA-NEXT:    vrcpps %ymm1, %ymm1 # sched: [11:2.00]
-; HASWELL-NO-FMA-NEXT:    vrcpps %ymm0, %ymm0 # sched: [11:2.00]
-; HASWELL-NO-FMA-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0 # sched: [12:0.50]
-; HASWELL-NO-FMA-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm1 # sched: [12:0.50]
-; HASWELL-NO-FMA-NEXT:    retq # sched: [7:1.00]
-;
-; KNL-LABEL: v16f32_no_step2:
-; KNL:       # %bb.0:
-; KNL-NEXT:    vrcp14ps %zmm0, %zmm0 # sched: [11:2.00]
-; KNL-NEXT:    vmulps {{.*}}(%rip), %zmm0, %zmm0 # sched: [12:0.50]
-; KNL-NEXT:    retq # sched: [7:1.00]
-;
-; SKX-LABEL: v16f32_no_step2:
-; SKX:       # %bb.0:
-; SKX-NEXT:    vrcp14ps %zmm0, %zmm0 # sched: [4:2.00]
-; SKX-NEXT:    vmulps {{.*}}(%rip), %zmm0, %zmm0 # sched: [11:0.50]
-; SKX-NEXT:    retq # sched: [7:1.00]
+; HASWELL-NO-FMA-NEXT:    vrcpps %ymm1, %ymm1
+; HASWELL-NO-FMA-NEXT:    vrcpps %ymm0, %ymm0
+; HASWELL-NO-FMA-NEXT:    vmulps {{.*}}(%rip), %ymm0, %ymm0
+; HASWELL-NO-FMA-NEXT:    vmulps {{.*}}(%rip), %ymm1, %ymm1
+; HASWELL-NO-FMA-NEXT:    retq
+;
+; AVX512-LABEL: v16f32_no_step2:
+; AVX512:       # %bb.0:
+; AVX512-NEXT:    vrcp14ps %zmm0, %zmm0
+; AVX512-NEXT:    vmulps {{.*}}(%rip), %zmm0, %zmm0
+; AVX512-NEXT:    retq
   %div = fdiv fast <16 x float> <float 1.0, float 2.0, float 3.0, float 4.0, float 5.0, float 6.0, float 7.0, float 8.0, float 9.0, float 10.0, float 11.0, float 12.0, float 13.0, float 14.0, float 15.0, float 16.0>, %x
   ret <16 x float> %div
 }
 
 attributes #0 = { "unsafe-fp-math"="true" "reciprocal-estimates"="!divf,!vec-divf" }
 attributes #1 = { "unsafe-fp-math"="true" "reciprocal-estimates"="divf,vec-divf" }
 attributes #2 = { "unsafe-fp-math"="true" "reciprocal-estimates"="divf:2,vec-divf:2" }
 attributes #3 = { "unsafe-fp-math"="true" "reciprocal-estimates"="divf:0,vec-divf:0" }
 

tools/llvm-exegesis/llvm-exegesis.cpp

public:
   explicit BenchmarkCodeStreamer(llvm::MCContext *Context,
                                  const llvm::MCRegisterInfo *TheRegInfo,
                                  BenchmarkCode *Result)
       : llvm::MCStreamer(*Context), RegInfo(TheRegInfo), Result(Result) {}
 
   // Implementation of the llvm::MCStreamer interface. We only care about
   // instructions.
   void EmitInstruction(const llvm::MCInst &Instruction,
-                       const llvm::MCSubtargetInfo &STI,
-                       bool PrintSchedInfo) override {
+                       const llvm::MCSubtargetInfo &STI) override {
     Result->Instructions.push_back(Instruction);
   }
 
   // Implementation of the llvm::AsmCommentConsumer.
   void HandleComment(llvm::SMLoc Loc, llvm::StringRef CommentText) override {
     CommentText = CommentText.trim();
     if (!CommentText.consume_front("LLVM-EXEGESIS-"))
       return;

tools/llvm-mca/CodeRegionGenerator.cpp

class MCStreamerWrapper final : public MCStreamer {
   CodeRegions &Regions;
 
 public:
   MCStreamerWrapper(MCContext &Context, mca::CodeRegions &R)
       : MCStreamer(Context), Regions(R) {}
 
   // We only want to intercept the emission of new instructions.
   virtual void EmitInstruction(const MCInst &Inst,
-                               const MCSubtargetInfo & /* unused */,
-                               bool /* unused */) override {
+                               const MCSubtargetInfo &/* unused */) override {
     Regions.addInstruction(Inst);
   }
 
   bool EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override {
     return true;
   }
 
   void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,