delete the llvm.expect intrinsic and its lowering pass

[spatel]

Summary

This is the LLVM counterpart to:
http://reviews.llvm.org/D19299
Please see that patch for the motivation and more steps in this plan.

[mgrang]

test/Assembler/auto_upgrade_intrinsics.ll

92

Extraneous newlines.

[spatel]

Removed excess blank lines from test file.

[davidxl]

lib/IR/AutoUpgrade.cpp

664

Is there a reason not to upgrade it properly with meta data?

Another question for deprecation, can you just remove the documentation and leave the support for the intrinsic support for now?

[spatel]

lib/IR/AutoUpgrade.cpp

664

AFAIK, we don't make any guarantees to support legacy IR, except that we don't die processing it or miscompile it, so this is the minimal patch. Given that we're still losing metadata and/or not using it in a lot of cases (PR27344), I figured we should just focus on improving that instead of spending time on backwards support. If others disagree, I can add it.

If we just remove the docs, we'd still be doing unnecessary work for every compile, right? I don't see any reason to take that path.

[davidxl]

lib/IR/AutoUpgrade.cpp

664

Personally, I don't have issues with completely removing it -- but I can not speak for others in this aspect. IMO, removing documentation can be a safe first step -- the compile time impact should be minimal.

[spatel]

lib/IR/AutoUpgrade.cpp

664

Let me send a note to the dev list about this patch. If anyone objects or would like us to implement this in stages, we should hear about it. :)

[spatel]

Abandoning.

The feedback on the dev list was that handling the builtin_expect() in clang is ugly, so it's better to pay a small cost in LLVM to do it.

Note that the current llvm.expect lowering pass doesn't actually work for anything but the simplest cases. The pass needs to be enhanced to handle patterns like:

int foo(int x, int y) {
  if (__builtin_expect(x, 20) > 10) return 234;  // expected value is not 1
  return 2;
}

or:

int foo(int n) {
  int b = __builtin_expect(n, 1);  // expect is not directly used in comparison
  if (b) return 24;
  return 234;
}

Currently, the llvm.expect is discarded in these cases without generating any metadata.

docs/LangRef.rst

.. code-block:: llvm
     !2 = !{ i8 0, i8 2, i8 3, i8 6 }
     !3 = !{ i8 -2, i8 0, i8 3, i8 6 }
 
 '``unpredictable``' Metadata
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 ``unpredictable`` metadata may be attached to any branch or switch
 instruction. It can be used to express the unpredictability of control
-flow. Similar to the llvm.expect intrinsic, it may be used to alter
-optimizations related to compare and branch instructions. The metadata
-is treated as a boolean value; if it exists, it signals that the branch
-or switch that it is attached to is completely unpredictable.
+flow and alter optimizations related to compare and branch instructions.
+The metadata is treated as a boolean value; if it exists, it signals that
+the branch or switch that it is attached to is completely unpredictable.
 
 '``llvm.loop``'
 ^^^^^^^^^^^^^^^
 
 It is sometimes useful to attach information to loop constructs. Currently,
 loop metadata is implemented as metadata attached to the branch instruction
 in the loop latch block. This type of metadata refer to a metadata node that is
 guaranteed to be separate for each loop. The loop identifier metadata is

 Semantics:
 """"""""""
 
 The ``llvm.objectsize`` intrinsic is lowered to a constant representing
 the size of the object concerned. If the size cannot be determined at
 compile time, ``llvm.objectsize`` returns ``i32/i64 -1 or 0`` (depending
 on the ``min`` argument).
 
-'``llvm.expect``' Intrinsic
-^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Syntax:
-"""""""
-
-This is an overloaded intrinsic. You can use ``llvm.expect`` on any
-integer bit width.
-
-::
-
-      declare i1 @llvm.expect.i1(i1 <val>, i1 <expected_val>)
-      declare i32 @llvm.expect.i32(i32 <val>, i32 <expected_val>)
-      declare i64 @llvm.expect.i64(i64 <val>, i64 <expected_val>)
-
-Overview:
-"""""""""
-
-The ``llvm.expect`` intrinsic provides information about expected (the
-most probable) value of ``val``, which can be used by optimizers.
-
-Arguments:
-""""""""""
-
-The ``llvm.expect`` intrinsic takes two arguments. The first argument is
-a value. The second argument is an expected value, this needs to be a
-constant value, variables are not allowed.
-
-Semantics:
-""""""""""
-
-This intrinsic is lowered to the ``val``.
-
 .. _int_assume:
 
 '``llvm.assume``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 

include/llvm-c/Transforms/Scalar.h

 void LLVMAddVerifierPass(LLVMPassManagerRef PM);
 
 /** See llvm::createCorrelatedValuePropagationPass function */
 void LLVMAddCorrelatedValuePropagationPass(LLVMPassManagerRef PM);
 
 /** See llvm::createEarlyCSEPass function */
 void LLVMAddEarlyCSEPass(LLVMPassManagerRef PM);
 
-/** See llvm::createLowerExpectIntrinsicPass function */
-void LLVMAddLowerExpectIntrinsicPass(LLVMPassManagerRef PM);
-
 /** See llvm::createTypeBasedAliasAnalysisPass function */
 void LLVMAddTypeBasedAliasAnalysisPass(LLVMPassManagerRef PM);
 
 /** See llvm::createScopedNoAliasAAPass function */
 void LLVMAddScopedNoAliasAAPass(LLVMPassManagerRef PM);
 
 /** See llvm::createBasicAliasAnalysisPass function */
 void LLVMAddBasicAliasAnalysisPass(LLVMPassManagerRef PM);

include/llvm/IR/Intrinsics.td

 def int_sigsetjmp  : Intrinsic<[llvm_i32_ty] , [llvm_ptr_ty, llvm_i32_ty]>;
 def int_siglongjmp : Intrinsic<[], [llvm_ptr_ty, llvm_i32_ty], [IntrNoReturn]>;
 
 // Internal interface for object size checking
 def int_objectsize : Intrinsic<[llvm_anyint_ty], [llvm_anyptr_ty, llvm_i1_ty],
                                [IntrNoMem]>,
                                GCCBuiltin<"__builtin_object_size">;
 
-//===------------------------- Expect Intrinsics --------------------------===//
-//
-def int_expect : Intrinsic<[llvm_anyint_ty], [LLVMMatchType<0>,
-                                              LLVMMatchType<0>], [IntrNoMem]>;
-
 //===-------------------- Bit Manipulation Intrinsics ---------------------===//
 //
 
 // None of these intrinsics accesses memory at all.
 let IntrProperties = [IntrNoMem] in {
   def int_bswap: Intrinsic<[llvm_anyint_ty], [LLVMMatchType<0>]>;
   def int_ctpop: Intrinsic<[llvm_anyint_ty], [LLVMMatchType<0>]>;
   def int_ctlz : Intrinsic<[llvm_anyint_ty], [LLVMMatchType<0>, llvm_i1_ty]>;

include/llvm/InitializePasses.h

 void initializeGlobalMergePass(PassRegistry&);
 void initializeLoopRerollPass(PassRegistry&);
 void initializeLoopUnrollPass(PassRegistry&);
 void initializeLoopUnswitchPass(PassRegistry&);
 void initializeLoopVersioningLICMPass(PassRegistry&);
 void initializeLoopIdiomRecognizePass(PassRegistry&);
 void initializeLowerAtomicPass(PassRegistry&);
 void initializeLowerBitSetsPass(PassRegistry&);
-void initializeLowerExpectIntrinsicPass(PassRegistry&);
 void initializeLowerGuardIntrinsicPass(PassRegistry&);
 void initializeLowerIntrinsicsPass(PassRegistry&);
 void initializeLowerInvokePass(PassRegistry&);
 void initializeLowerSwitchPass(PassRegistry&);
 void initializeLowerEmuTLSPass(PassRegistry&);
 void initializeMachineBlockFrequencyInfoPass(PassRegistry&);
 void initializeMachineBlockPlacementPass(PassRegistry&);
 void initializeMachineBlockPlacementStatsPass(PassRegistry&);

include/llvm/LinkAllPasses.h

ForcePassLinking() {
       (void) llvm::createLoopSimplifyCFGPass();
       (void) llvm::createLoopStrengthReducePass();
       (void) llvm::createLoopRerollPass();
       (void) llvm::createLoopUnrollPass();
       (void) llvm::createLoopUnswitchPass();
       (void) llvm::createLoopVersioningLICMPass();
       (void) llvm::createLoopIdiomPass();
       (void) llvm::createLoopRotatePass();
-      (void) llvm::createLowerExpectIntrinsicPass();
       (void) llvm::createLowerInvokePass();
       (void) llvm::createLowerSwitchPass();
       (void) llvm::createNaryReassociatePass();
       (void) llvm::createObjCARCAAWrapperPass();
       (void) llvm::createObjCARCAPElimPass();
       (void) llvm::createObjCARCExpandPass();
       (void) llvm::createObjCARCContractPass();
       (void) llvm::createObjCARCOptPass();

include/llvm/Transforms/Scalar.h

 //
 // InstructionSimplifier - Remove redundant instructions.
 //
 FunctionPass *createInstructionSimplifierPass();
 extern char &InstructionSimplifierID;
 
 //===----------------------------------------------------------------------===//
 //
-// LowerExpectIntrinsics - Removes llvm.expect intrinsics and creates
-// "block_weights" metadata.
-FunctionPass *createLowerExpectIntrinsicPass();
-
-//===----------------------------------------------------------------------===//
-//
 // PartiallyInlineLibCalls - Tries to inline the fast path of library
 // calls such as sqrt.
 //
 FunctionPass *createPartiallyInlineLibCallsPass();
 
 //===----------------------------------------------------------------------===//
 //
 // ScalarizerPass - Converts vector operations into scalar operations

include/llvm/Transforms/Scalar/LowerExpectIntrinsic.h

-//===- LowerExpectIntrinsic.h - LowerExpectIntrinsic pass -------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-/// \file
-///
-/// The header file for the LowerExpectIntrinsic pass as used by the new pass
-/// manager.
-///
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_TRANSFORMS_SCALAR_LOWEREXPECTINTRINSIC_H
-#define LLVM_TRANSFORMS_SCALAR_LOWEREXPECTINTRINSIC_H
-
-#include "llvm/IR/Function.h"
-#include "llvm/IR/PassManager.h"
-
-namespace llvm {
-
-struct LowerExpectIntrinsicPass : PassInfoMixin<LowerExpectIntrinsicPass> {
-  /// \brief Run the pass over the function.
-  ///
-  /// This will lower all of th expect intrinsic calls in this function into
-  /// branch weight metadata. That metadata will subsequently feed the analysis
-  /// of the probabilities and frequencies of the CFG. After running this pass,
-  /// no more expect intrinsics remain, allowing the rest of the optimizer to
-  /// ignore them.
-  PreservedAnalyses run(Function &F);
-};
-
-}
-
-#endif

lib/CodeGen/IntrinsicLowering.cpp

void IntrinsicLowering::LowerIntrinsicCall(CallInst *CI) {
   switch (Callee->getIntrinsicID()) {
   case Intrinsic::not_intrinsic:
     report_fatal_error("Cannot lower a call to a non-intrinsic function '"+
                       Callee->getName() + "'!");
   default:
     report_fatal_error("Code generator does not support intrinsic function '"+
                       Callee->getName()+"'!");
 
-  case Intrinsic::expect: {
-    // Just replace __builtin_expect(exp, c) with EXP.
-    Value *V = CI->getArgOperand(0);
-    CI->replaceAllUsesWith(V);
-    break;
-  }
-
     // The setjmp/longjmp intrinsics should only exist in the code if it was
     // never optimized (ie, right out of the CFE), or if it has been hacked on
     // by the lowerinvoke pass.  In both cases, the right thing to do is to
     // convert the call to an explicit setjmp or longjmp call.
   case Intrinsic::setjmp: {
     Value *V = ReplaceCallWith("setjmp", CI, CS.arg_begin(), CS.arg_end(),
                                Type::getInt32Ty(Context));
     if (!CI->getType()->isVoidTy())

lib/CodeGen/SelectionDAG/FastISel.cpp

case Intrinsic::objectsize: {
     unsigned long long Res = CI->isZero() ? -1ULL : 0;
     Constant *ResCI = ConstantInt::get(II->getType(), Res);
     unsigned ResultReg = getRegForValue(ResCI);
     if (!ResultReg)
       return false;
     updateValueMap(II, ResultReg);
     return true;
   }
-  case Intrinsic::expect: {
-    unsigned ResultReg = getRegForValue(II->getArgOperand(0));
-    if (!ResultReg)
-      return false;
-    updateValueMap(II, ResultReg);
-    return true;
-  }
   case Intrinsic::experimental_stackmap:
     return selectStackmap(II);
   case Intrinsic::experimental_patchpoint_void:
   case Intrinsic::experimental_patchpoint_i64:
     return selectPatchpoint(II);
   }
 
   return fastLowerIntrinsicCall(II);

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

SelectionDAGBuilder::visitIntrinsicCall(const CallInst &I, unsigned Intrinsic) {
   }
   case Intrinsic::gcread:
   case Intrinsic::gcwrite:
     llvm_unreachable("GC failed to lower gcread/gcwrite intrinsics!");
   case Intrinsic::flt_rounds:
     setValue(&I, DAG.getNode(ISD::FLT_ROUNDS_, sdl, MVT::i32));
     return nullptr;
 
-  case Intrinsic::expect: {
-    // Just replace __builtin_expect(exp, c) with EXP.
-    setValue(&I, getValue(I.getArgOperand(0)));
-    return nullptr;
-  }
-
   case Intrinsic::debugtrap:
   case Intrinsic::trap: {
     StringRef TrapFuncName =
         I.getAttributes()
             .getAttribute(AttributeSet::FunctionIndex, "trap-func-name")
             .getValueAsString();
     if (TrapFuncName.empty()) {
       ISD::NodeType Op = (Intrinsic == Intrinsic::trap) ?

lib/IR/AutoUpgrade.cpp

if (Name.startswith("cttz.") && F->arg_size() == 1) {
       F->setName(Name + ".old");
       NewFn = Intrinsic::getDeclaration(F->getParent(), Intrinsic::cttz,
                                         F->arg_begin()->getType());
       return true;
     }
     break;
   }
 
+  case 'e':
+    if (Name.startswith("expect.") && F->arg_size() == 2) {
+      NewFn = nullptr;
+      return true;
+    }
+
   case 'o':
     // We only need to change the name to match the mangling including the
     // address space.
     if (F->arg_size() == 2 && Name.startswith("objectsize.")) {
       Type *Tys[2] = { F->getReturnType(), F->arg_begin()->getType() };
       if (F->getName() != Intrinsic::getName(Intrinsic::objectsize, Tys)) {
         F->setName(Name + ".old");
         NewFn = Intrinsic::getDeclaration(F->getParent(),
if (Name.startswith("llvm.x86.sse2.pcmpeq.") ||
         unsigned Idx = Imm ? (i + NumElts) : i;
         Idxs[i] = Builder.getInt32(Idx);
       }
 
       Value *UndefV = UndefValue::get(Op0->getType());
       Rep = Builder.CreateShuffleVector(Op0, UndefV, ConstantVector::get(Idxs));
     } else if (Name == "llvm.stackprotectorcheck") {
       Rep = nullptr;
+    } else if (Name.startswith("llvm.expect")) {
+      // The expect intrinsic always lowered to its first argument.
+      // TODO: We could create the appropriate metadata here to better support
+      // legacy code?
+      Rep = CI->getArgOperand(0);
     } else {
       bool PD128 = false, PD256 = false, PS128 = false, PS256 = false;
       if (Name == "llvm.x86.avx.vpermil.pd.256")
         PD256 = true;
       else if (Name == "llvm.x86.avx.vpermil.pd")
         PD128 = true;
       else if (Name == "llvm.x86.avx.vpermil.ps.256")
         PS256 = true;

lib/Passes/PassBuilder.cpp

 #include "llvm/Transforms/IPO/ForceFunctionAttrs.h"
 #include "llvm/Transforms/IPO/FunctionAttrs.h"
 #include "llvm/Transforms/IPO/InferFunctionAttrs.h"
 #include "llvm/Transforms/IPO/StripDeadPrototypes.h"
 #include "llvm/Transforms/InstCombine/InstCombine.h"
 #include "llvm/Transforms/InstrProfiling.h"
 #include "llvm/Transforms/Scalar/ADCE.h"
 #include "llvm/Transforms/Scalar/EarlyCSE.h"
-#include "llvm/Transforms/Scalar/LowerExpectIntrinsic.h"
 #include "llvm/Transforms/Scalar/GVN.h"
 #include "llvm/Transforms/Scalar/SROA.h"
 #include "llvm/Transforms/Scalar/SimplifyCFG.h"
 #include <type_traits>
 
 using namespace llvm;
 
 static Regex DefaultAliasRegex("^(default|lto-pre-link|lto)<(O[0123sz])>$");

 void PassBuilder::addPerModuleDefaultPipeline(ModulePassManager &MPM,
                                               OptimizationLevel Level,
                                               bool DebugLogging) {
   // FIXME: Finish fleshing this out to match the legacy pipelines.
   FunctionPassManager EarlyFPM(DebugLogging);
   EarlyFPM.addPass(SimplifyCFGPass());
   EarlyFPM.addPass(SROA());
   EarlyFPM.addPass(EarlyCSEPass());
-  EarlyFPM.addPass(LowerExpectIntrinsicPass());
 
   MPM.addPass(createModuleToFunctionPassAdaptor(std::move(EarlyFPM)));
 }
 
 void PassBuilder::addLTOPreLinkDefaultPipeline(ModulePassManager &MPM,
                                                OptimizationLevel Level,
                                                bool DebugLogging) {
   // FIXME: We should use a customized pre-link pipeline!

lib/Passes/PassRegistry.def

 #define FUNCTION_PASS(NAME, CREATE_PASS)
 #endif
 FUNCTION_PASS("aa-eval", AAEvaluator())
 FUNCTION_PASS("adce", ADCEPass())
 FUNCTION_PASS("early-cse", EarlyCSEPass())
 FUNCTION_PASS("instcombine", InstCombinePass())
 FUNCTION_PASS("invalidate<all>", InvalidateAllAnalysesPass())
 FUNCTION_PASS("no-op-function", NoOpFunctionPass())
-FUNCTION_PASS("lower-expect", LowerExpectIntrinsicPass())
 FUNCTION_PASS("gvn", GVN())
 FUNCTION_PASS("print", PrintFunctionPass(dbgs()))
 FUNCTION_PASS("print<assumptions>", AssumptionPrinterPass(dbgs()))
 FUNCTION_PASS("print<domtree>", DominatorTreePrinterPass(dbgs()))
 FUNCTION_PASS("print<postdomtree>", PostDominatorTreePrinterPass(dbgs()))
 FUNCTION_PASS("print<demanded-bits>", DemandedBitsPrinterPass(dbgs()))
 FUNCTION_PASS("print<domfrontier>", DominanceFrontierPrinterPass(dbgs()))
 FUNCTION_PASS("print<loops>", LoopPrinterPass(dbgs()))

lib/Transforms/IPO/PassManagerBuilder.cpp

void PassManagerBuilder::populateFunctionPassManager(
   addInitialAliasAnalysisPasses(FPM);
 
   FPM.add(createCFGSimplificationPass());
   if (UseNewSROA)
     FPM.add(createSROAPass());
   else
     FPM.add(createScalarReplAggregatesPass());
   FPM.add(createEarlyCSEPass());
-  FPM.add(createLowerExpectIntrinsicPass());
 }
 
 // Do PGO instrumentation generation or use pass as the option specified.
 void PassManagerBuilder::addPGOInstrPasses(legacy::PassManagerBase &MPM) {
   if (!PGOInstrGen.empty()) {
     MPM.add(createPGOInstrumentationGenPass());
     // Add the profile lowering pass.
     InstrProfOptions Options;

lib/Transforms/Scalar/CMakeLists.txt

add_llvm_library(LLVMScalarOpts
   LoopRerollPass.cpp
   LoopRotation.cpp
   LoopSimplifyCFG.cpp
   LoopStrengthReduce.cpp
   LoopUnrollPass.cpp
   LoopUnswitch.cpp
   LoopVersioningLICM.cpp
   LowerAtomic.cpp
-  LowerExpectIntrinsic.cpp
   LowerGuardIntrinsic.cpp
   MemCpyOptimizer.cpp
   MergedLoadStoreMotion.cpp
   NaryReassociate.cpp
   PartiallyInlineLibCalls.cpp
   PlaceSafepoints.cpp
   Reassociate.cpp
   Reg2Mem.cpp

lib/Transforms/Scalar/LowerExpectIntrinsic.cpp

-//===- LowerExpectIntrinsic.cpp - Lower expect intrinsic ------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This pass lowers the 'expect' intrinsic to LLVM metadata.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/Transforms/Scalar/LowerExpectIntrinsic.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/Statistic.h"
-#include "llvm/IR/BasicBlock.h"
-#include "llvm/IR/Constants.h"
-#include "llvm/IR/Function.h"
-#include "llvm/IR/Instructions.h"
-#include "llvm/IR/Intrinsics.h"
-#include "llvm/IR/LLVMContext.h"
-#include "llvm/IR/MDBuilder.h"
-#include "llvm/IR/Metadata.h"
-#include "llvm/Pass.h"
-#include "llvm/Support/CommandLine.h"
-#include "llvm/Support/Debug.h"
-#include "llvm/Transforms/Scalar.h"
-
-using namespace llvm;
-
-#define DEBUG_TYPE "lower-expect-intrinsic"
-
-STATISTIC(ExpectIntrinsicsHandled,
-          "Number of 'expect' intrinsic instructions handled");
-
-static cl::opt<uint32_t>
-LikelyBranchWeight("likely-branch-weight", cl::Hidden, cl::init(64),
-                   cl::desc("Weight of the branch likely to be taken (default = 64)"));
-static cl::opt<uint32_t>
-UnlikelyBranchWeight("unlikely-branch-weight", cl::Hidden, cl::init(4),
-                   cl::desc("Weight of the branch unlikely to be taken (default = 4)"));
-
-static bool handleSwitchExpect(SwitchInst &SI) {
-  CallInst *CI = dyn_cast<CallInst>(SI.getCondition());
-  if (!CI)
-    return false;
-
-  Function *Fn = CI->getCalledFunction();
-  if (!Fn || Fn->getIntrinsicID() != Intrinsic::expect)
-    return false;
-
-  Value *ArgValue = CI->getArgOperand(0);
-  ConstantInt *ExpectedValue = dyn_cast<ConstantInt>(CI->getArgOperand(1));
-  if (!ExpectedValue)
-    return false;
-
-  SwitchInst::CaseIt Case = SI.findCaseValue(ExpectedValue);
-  unsigned n = SI.getNumCases(); // +1 for default case.
-  SmallVector<uint32_t, 16> Weights(n + 1, UnlikelyBranchWeight);
-
-  if (Case == SI.case_default())
-    Weights[0] = LikelyBranchWeight;
-  else
-    Weights[Case.getCaseIndex() + 1] = LikelyBranchWeight;
-
-  SI.setMetadata(LLVMContext::MD_prof,
-                 MDBuilder(CI->getContext()).createBranchWeights(Weights));
-
-  SI.setCondition(ArgValue);
-  return true;
-}
-
-static bool handleBranchExpect(BranchInst &BI) {
-  if (BI.isUnconditional())
-    return false;
-
-  // Handle non-optimized IR code like:
-  //   %expval = call i64 @llvm.expect.i64(i64 %conv1, i64 1)
-  //   %tobool = icmp ne i64 %expval, 0
-  //   br i1 %tobool, label %if.then, label %if.end
-  //
-  // Or the following simpler case:
-  //   %expval = call i1 @llvm.expect.i1(i1 %cmp, i1 1)
-  //   br i1 %expval, label %if.then, label %if.end
-
-  CallInst *CI;
-
-  ICmpInst *CmpI = dyn_cast<ICmpInst>(BI.getCondition());
-  if (!CmpI) {
-    CI = dyn_cast<CallInst>(BI.getCondition());
-  } else {
-    if (CmpI->getPredicate() != CmpInst::ICMP_NE)
-      return false;
-    CI = dyn_cast<CallInst>(CmpI->getOperand(0));
-  }
-
-  if (!CI)
-    return false;
-
-  Function *Fn = CI->getCalledFunction();
-  if (!Fn || Fn->getIntrinsicID() != Intrinsic::expect)
-    return false;
-
-  Value *ArgValue = CI->getArgOperand(0);
-  ConstantInt *ExpectedValue = dyn_cast<ConstantInt>(CI->getArgOperand(1));
-  if (!ExpectedValue)
-    return false;
-
-  MDBuilder MDB(CI->getContext());
-  MDNode *Node;
-
-  // If expect value is equal to 1 it means that we are more likely to take
-  // branch 0, in other case more likely is branch 1.
-  if (ExpectedValue->isOne())
-    Node = MDB.createBranchWeights(LikelyBranchWeight, UnlikelyBranchWeight);
-  else
-    Node = MDB.createBranchWeights(UnlikelyBranchWeight, LikelyBranchWeight);
-
-  BI.setMetadata(LLVMContext::MD_prof, Node);
-
-  if (CmpI)
-    CmpI->setOperand(0, ArgValue);
-  else
-    BI.setCondition(ArgValue);
-  return true;
-}
-
-static bool lowerExpectIntrinsic(Function &F) {
-  bool Changed = false;
-
-  for (BasicBlock &BB : F) {
-    // Create "block_weights" metadata.
-    if (BranchInst *BI = dyn_cast<BranchInst>(BB.getTerminator())) {
-      if (handleBranchExpect(*BI))
-        ExpectIntrinsicsHandled++;
-    } else if (SwitchInst *SI = dyn_cast<SwitchInst>(BB.getTerminator())) {
-      if (handleSwitchExpect(*SI))
-        ExpectIntrinsicsHandled++;
-    }
-
-    // Remove llvm.expect intrinsics.
-    for (BasicBlock::iterator BI = BB.begin(), BE = BB.end(); BI != BE;) {
-      CallInst *CI = dyn_cast<CallInst>(BI++);
-      if (!CI)
-        continue;
-
-      Function *Fn = CI->getCalledFunction();
-      if (Fn && Fn->getIntrinsicID() == Intrinsic::expect) {
-        Value *Exp = CI->getArgOperand(0);
-        CI->replaceAllUsesWith(Exp);
-        CI->eraseFromParent();
-        Changed = true;
-      }
-    }
-  }
-
-  return Changed;
-}
-
-PreservedAnalyses LowerExpectIntrinsicPass::run(Function &F) {
-  if (lowerExpectIntrinsic(F))
-    return PreservedAnalyses::none();
-
-  return PreservedAnalyses::all();
-}
-
-namespace {
-/// \brief Legacy pass for lowering expect intrinsics out of the IR.
-///
-/// When this pass is run over a function it uses expect intrinsics which feed
-/// branches and switches to provide branch weight metadata for those
-/// terminators. It then removes the expect intrinsics from the IR so the rest
-/// of the optimizer can ignore them.
-class LowerExpectIntrinsic : public FunctionPass {
-public:
-  static char ID;
-  LowerExpectIntrinsic() : FunctionPass(ID) {
-    initializeLowerExpectIntrinsicPass(*PassRegistry::getPassRegistry());
-  }
-
-  bool runOnFunction(Function &F) override { return lowerExpectIntrinsic(F); }
-};
-}
-
-char LowerExpectIntrinsic::ID = 0;
-INITIALIZE_PASS(LowerExpectIntrinsic, "lower-expect",
-                "Lower 'expect' Intrinsics", false, false)
-
-FunctionPass *llvm::createLowerExpectIntrinsicPass() {
-  return new LowerExpectIntrinsic();
-}

lib/Transforms/Scalar/Scalar.cpp

void llvm::initializeScalarOpts(PassRegistry &Registry) {
   initializeLoopRotatePass(Registry);
   initializeLoopStrengthReducePass(Registry);
   initializeLoopRerollPass(Registry);
   initializeLoopUnrollPass(Registry);
   initializeLoopUnswitchPass(Registry);
   initializeLoopVersioningLICMPass(Registry);
   initializeLoopIdiomRecognizePass(Registry);
   initializeLowerAtomicPass(Registry);
-  initializeLowerExpectIntrinsicPass(Registry);
   initializeLowerGuardIntrinsicPass(Registry);
   initializeMemCpyOptPass(Registry);
   initializeMergedLoadStoreMotionPass(Registry);
   initializeNaryReassociatePass(Registry);
   initializePartiallyInlineLibCallsPass(Registry);
   initializeReassociatePass(Registry);
   initializeRegToMemPass(Registry);
   initializeRewriteStatepointsForGCPass(Registry);

 
 void LLVMAddScopedNoAliasAAPass(LLVMPassManagerRef PM) {
   unwrap(PM)->add(createScopedNoAliasAAWrapperPass());
 }
 
 void LLVMAddBasicAliasAnalysisPass(LLVMPassManagerRef PM) {
   unwrap(PM)->add(createBasicAAWrapperPass());
 }
-
-void LLVMAddLowerExpectIntrinsicPass(LLVMPassManagerRef PM) {
-  unwrap(PM)->add(createLowerExpectIntrinsicPass());
-}

test/Assembler/auto_upgrade_intrinsics.ll

 
 define void @test.stackprotectorcheck() {
 ; CHECK-LABEL: @test.stackprotectorcheck(
 ; CHECK-NEXT: ret void
   call void @llvm.stackprotectorcheck(i8** @__stack_chk_guard)
   ret void
 }
 
+define i32 @test_expect(i32 %x) {
+; CHECK-LABEL: @test_expect(
+; CHECK:       %tobool = icmp ne i32 %x, 0
+
+entry:
+  %expval = call i32 @llvm.expect.i32(i32 %x, i32 1)
+  %tobool = icmp ne i32 %expval, 0
+  br i1 %tobool, label %if, label %else
+
+if:
+  ret i32 54321
+
+else:
+  ret i32 12345
+}
+
+declare i32 @llvm.expect.i32(i32, i32) nounwind readnone
+
 ; This is part of @test.objectsize(), since llvm.objectsize declaration gets
 ; emitted at the end.
 ; CHECK: declare i32 @llvm.objectsize.i32.p0i8
+
+

test/CodeGen/Generic/builtin-expect.ll

-; RUN: llc < %s
-
-define i32 @test1(i32 %x) nounwind uwtable ssp {
-entry:
-  %retval = alloca i32, align 4
-  %x.addr = alloca i32, align 4
-  store i32 %x, i32* %x.addr, align 4
-  %tmp = load i32, i32* %x.addr, align 4
-  %cmp = icmp sgt i32 %tmp, 1
-  %conv = zext i1 %cmp to i32
-  %conv1 = sext i32 %conv to i64
-  %expval = call i64 @llvm.expect.i64(i64 %conv1, i64 1)
-  %tobool = icmp ne i64 %expval, 0
-  br i1 %tobool, label %if.then, label %if.end
-
-if.then:                                          ; preds = %entry
-  %call = call i32 (...) @f()
-  store i32 %call, i32* %retval
-  br label %return
-
-if.end:                                           ; preds = %entry
-  store i32 1, i32* %retval
-  br label %return
-
-return:                                           ; preds = %if.end, %if.then
-  %0 = load i32, i32* %retval
-  ret i32 %0
-}
-
-declare i64 @llvm.expect.i64(i64, i64) nounwind readnone
-
-declare i32 @f(...)
-
-define i32 @test2(i32 %x) nounwind uwtable ssp {
-entry:
-  %retval = alloca i32, align 4
-  %x.addr = alloca i32, align 4
-  store i32 %x, i32* %x.addr, align 4
-  %tmp = load i32, i32* %x.addr, align 4
-  %conv = sext i32 %tmp to i64
-  %expval = call i64 @llvm.expect.i64(i64 %conv, i64 1)
-  %tobool = icmp ne i64 %expval, 0
-  br i1 %tobool, label %if.then, label %if.end
-
-if.then:                                          ; preds = %entry
-  %call = call i32 (...) @f()
-  store i32 %call, i32* %retval
-  br label %return
-
-if.end:                                           ; preds = %entry
-  store i32 1, i32* %retval
-  br label %return
-
-return:                                           ; preds = %if.end, %if.then
-  %0 = load i32, i32* %retval
-  ret i32 %0
-}
-
-define i32 @test3(i32 %x) nounwind uwtable ssp {
-entry:
-  %retval = alloca i32, align 4
-  %x.addr = alloca i32, align 4
-  store i32 %x, i32* %x.addr, align 4
-  %tmp = load i32, i32* %x.addr, align 4
-  %tobool = icmp ne i32 %tmp, 0
-  %lnot = xor i1 %tobool, true
-  %lnot.ext = zext i1 %lnot to i32
-  %conv = sext i32 %lnot.ext to i64
-  %expval = call i64 @llvm.expect.i64(i64 %conv, i64 1)
-  %tobool1 = icmp ne i64 %expval, 0
-  br i1 %tobool1, label %if.then, label %if.end
-
-if.then:                                          ; preds = %entry
-  %call = call i32 (...) @f()
-  store i32 %call, i32* %retval
-  br label %return
-
-if.end:                                           ; preds = %entry
-  store i32 1, i32* %retval
-  br label %return
-
-return:                                           ; preds = %if.end, %if.then
-  %0 = load i32, i32* %retval
-  ret i32 %0
-}
-
-define i32 @test4(i32 %x) nounwind uwtable ssp {
-entry:
-  %retval = alloca i32, align 4
-  %x.addr = alloca i32, align 4
-  store i32 %x, i32* %x.addr, align 4
-  %tmp = load i32, i32* %x.addr, align 4
-  %tobool = icmp ne i32 %tmp, 0
-  %lnot = xor i1 %tobool, true
-  %lnot1 = xor i1 %lnot, true
-  %lnot.ext = zext i1 %lnot1 to i32
-  %conv = sext i32 %lnot.ext to i64
-  %expval = call i64 @llvm.expect.i64(i64 %conv, i64 1)
-  %tobool2 = icmp ne i64 %expval, 0
-  br i1 %tobool2, label %if.then, label %if.end
-
-if.then:                                          ; preds = %entry
-  %call = call i32 (...) @f()
-  store i32 %call, i32* %retval
-  br label %return
-
-if.end:                                           ; preds = %entry
-  store i32 1, i32* %retval
-  br label %return
-
-return:                                           ; preds = %if.end, %if.then
-  %0 = load i32, i32* %retval
-  ret i32 %0
-}
-
-define i32 @test5(i32 %x) nounwind uwtable ssp {
-entry:
-  %retval = alloca i32, align 4
-  %x.addr = alloca i32, align 4
-  store i32 %x, i32* %x.addr, align 4
-  %tmp = load i32, i32* %x.addr, align 4
-  %cmp = icmp slt i32 %tmp, 0
-  %conv = zext i1 %cmp to i32
-  %conv1 = sext i32 %conv to i64
-  %expval = call i64 @llvm.expect.i64(i64 %conv1, i64 0)
-  %tobool = icmp ne i64 %expval, 0
-  br i1 %tobool, label %if.then, label %if.end
-
-if.then:                                          ; preds = %entry
-  %call = call i32 (...) @f()
-  store i32 %call, i32* %retval
-  br label %return
-
-if.end:                                           ; preds = %entry
-  store i32 1, i32* %retval
-  br label %return
-
-return:                                           ; preds = %if.end, %if.then
-  %0 = load i32, i32* %retval
-  ret i32 %0
-}
-
-define i32 @test6(i32 %x) nounwind uwtable ssp {
-entry:
-  %retval = alloca i32, align 4
-  %x.addr = alloca i32, align 4
-  store i32 %x, i32* %x.addr, align 4
-  %tmp = load i32, i32* %x.addr, align 4
-  %conv = sext i32 %tmp to i64
-  %expval = call i64 @llvm.expect.i64(i64 %conv, i64 1)
-  switch i64 %expval, label %sw.epilog [
-    i64 1, label %sw.bb
-    i64 2, label %sw.bb
-  ]
-
-sw.bb:                                            ; preds = %entry, %entry
-  store i32 0, i32* %retval
-  br label %return
-
-sw.epilog:                                        ; preds = %entry
-  store i32 1, i32* %retval
-  br label %return
-
-return:                                           ; preds = %sw.epilog, %sw.bb
-  %0 = load i32, i32* %retval
-  ret i32 %0
-}
-
-define i32 @test7(i32 %x) nounwind uwtable ssp {
-entry:
-  %retval = alloca i32, align 4
-  %x.addr = alloca i32, align 4
-  store i32 %x, i32* %x.addr, align 4
-  %tmp = load i32, i32* %x.addr, align 4
-  %conv = sext i32 %tmp to i64
-  %expval = call i64 @llvm.expect.i64(i64 %conv, i64 1)
-  switch i64 %expval, label %sw.epilog [
-    i64 2, label %sw.bb
-    i64 3, label %sw.bb
-  ]
-
-sw.bb:                                            ; preds = %entry, %entry
-  %tmp1 = load i32, i32* %x.addr, align 4
-  store i32 %tmp1, i32* %retval
-  br label %return
-
-sw.epilog:                                        ; preds = %entry
-  store i32 0, i32* %retval
-  br label %return
-
-return:                                           ; preds = %sw.epilog, %sw.bb
-  %0 = load i32, i32* %retval
-  ret i32 %0
-}
-
-define i32 @test8(i32 %x) nounwind uwtable ssp {
-entry:
-  %retval = alloca i32, align 4
-  %x.addr = alloca i32, align 4
-  store i32 %x, i32* %x.addr, align 4
-  %tmp = load i32, i32* %x.addr, align 4
-  %cmp = icmp sgt i32 %tmp, 1
-  %conv = zext i1 %cmp to i32
-  %expval = call i32 @llvm.expect.i32(i32 %conv, i32 1)
-  %tobool = icmp ne i32 %expval, 0
-  br i1 %tobool, label %if.then, label %if.end
-
-if.then:                                          ; preds = %entry
-  %call = call i32 (...) @f()
-  store i32 %call, i32* %retval
-  br label %return
-
-if.end:                                           ; preds = %entry
-  store i32 1, i32* %retval
-  br label %return
-
-return:                                           ; preds = %if.end, %if.then
-  %0 = load i32, i32* %retval
-  ret i32 %0
-}
-
-declare i32 @llvm.expect.i32(i32, i32) nounwind readnone
-

test/Other/new-pass-manager.ll

 ; RUN:     | FileCheck %s --check-prefix=CHECK-O2
 ; RUN: opt -disable-output -disable-verify -debug-pass-manager \
 ; RUN:     -passes='lto-pre-link<O2>' %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-O2
 ; CHECK-O2: Starting llvm::Module pass manager run
 ; CHECK-O2: Running pass: SimplifyCFGPass
 ; CHECK-O2: Running pass: SROA
 ; CHECK-O2: Running pass: EarlyCSEPass
-; CHECK-O2: Running pass: LowerExpectIntrinsicPass
 
 ; RUN: opt -disable-output -disable-verify -debug-pass-manager \
 ; RUN:     -passes='lto<O2>' %s 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=CHECK-LTO-O2
 ; CHECK-LTO-O2: Starting llvm::Module pass manager run
 ; CHECK-LTO-O2: Running pass: InstCombinePass
 ; CHECK-LTO-O2: Running pass: SimplifyCFGPass
 
 define void @foo() {
   ret void
 }
 
 declare void @bar()

test/Transforms/LowerExpectIntrinsic/basic.ll

-; RUN: opt -lower-expect -strip-dead-prototypes -S -o - < %s | FileCheck %s
-; RUN: opt -S -passes='function(lower-expect),strip-dead-prototypes' < %s | FileCheck %s
-
-; CHECK-LABEL: @test1(
-define i32 @test1(i32 %x) nounwind uwtable ssp {
-entry:
-  %retval = alloca i32, align 4
-  %x.addr = alloca i32, align 4
-  store i32 %x, i32* %x.addr, align 4
-  %tmp = load i32, i32* %x.addr, align 4
-  %cmp = icmp sgt i32 %tmp, 1
-  %conv = zext i1 %cmp to i32
-  %conv1 = sext i32 %conv to i64
-  %expval = call i64 @llvm.expect.i64(i64 %conv1, i64 1)
-  %tobool = icmp ne i64 %expval, 0
-; CHECK: !prof !0
-; CHECK-NOT: @llvm.expect
-  br i1 %tobool, label %if.then, label %if.end
-
-if.then:                                          ; preds = %entry
-  %call = call i32 (...) @f()
-  store i32 %call, i32* %retval
-  br label %return
-
-if.end:                                           ; preds = %entry
-  store i32 1, i32* %retval
-  br label %return
-
-return:                                           ; preds = %if.end, %if.then
-  %0 = load i32, i32* %retval
-  ret i32 %0
-}
-
-declare i64 @llvm.expect.i64(i64, i64) nounwind readnone
-
-declare i32 @f(...)
-
-; CHECK-LABEL: @test2(
-define i32 @test2(i32 %x) nounwind uwtable ssp {
-entry:
-  %retval = alloca i32, align 4
-  %x.addr = alloca i32, align 4
-  store i32 %x, i32* %x.addr, align 4
-  %tmp = load i32, i32* %x.addr, align 4
-  %conv = sext i32 %tmp to i64
-  %expval = call i64 @llvm.expect.i64(i64 %conv, i64 1)
-  %tobool = icmp ne i64 %expval, 0
-; CHECK: !prof !0
-; CHECK-NOT: @llvm.expect
-  br i1 %tobool, label %if.then, label %if.end
-
-if.then:                                          ; preds = %entry
-  %call = call i32 (...) @f()
-  store i32 %call, i32* %retval
-  br label %return
-
-if.end:                                           ; preds = %entry
-  store i32 1, i32* %retval
-  br label %return
-
-return:                                           ; preds = %if.end, %if.then
-  %0 = load i32, i32* %retval
-  ret i32 %0
-}
-
-; CHECK-LABEL: @test3(
-define i32 @test3(i32 %x) nounwind uwtable ssp {
-entry:
-  %retval = alloca i32, align 4
-  %x.addr = alloca i32, align 4
-  store i32 %x, i32* %x.addr, align 4
-  %tmp = load i32, i32* %x.addr, align 4
-  %tobool = icmp ne i32 %tmp, 0
-  %lnot = xor i1 %tobool, true
-  %lnot.ext = zext i1 %lnot to i32
-  %conv = sext i32 %lnot.ext to i64
-  %expval = call i64 @llvm.expect.i64(i64 %conv, i64 1)
-  %tobool1 = icmp ne i64 %expval, 0
-; CHECK: !prof !0
-; CHECK-NOT: @llvm.expect
-  br i1 %tobool1, label %if.then, label %if.end
-
-if.then:                                          ; preds = %entry
-  %call = call i32 (...) @f()
-  store i32 %call, i32* %retval
-  br label %return
-
-if.end:                                           ; preds = %entry
-  store i32 1, i32* %retval
-  br label %return
-
-return:                                           ; preds = %if.end, %if.then
-  %0 = load i32, i32* %retval
-  ret i32 %0
-}
-
-; CHECK-LABEL: @test4(
-define i32 @test4(i32 %x) nounwind uwtable ssp {
-entry:
-  %retval = alloca i32, align 4
-  %x.addr = alloca i32, align 4
-  store i32 %x, i32* %x.addr, align 4
-  %tmp = load i32, i32* %x.addr, align 4
-  %tobool = icmp ne i32 %tmp, 0
-  %lnot = xor i1 %tobool, true
-  %lnot1 = xor i1 %lnot, true
-  %lnot.ext = zext i1 %lnot1 to i32
-  %conv = sext i32 %lnot.ext to i64
-  %expval = call i64 @llvm.expect.i64(i64 %conv, i64 1)
-  %tobool2 = icmp ne i64 %expval, 0
-; CHECK: !prof !0
-; CHECK-NOT: @llvm.expect
-  br i1 %tobool2, label %if.then, label %if.end
-
-if.then:                                          ; preds = %entry
-  %call = call i32 (...) @f()
-  store i32 %call, i32* %retval
-  br label %return
-
-if.end:                                           ; preds = %entry
-  store i32 1, i32* %retval
-  br label %return
-
-return:                                           ; preds = %if.end, %if.then
-  %0 = load i32, i32* %retval
-  ret i32 %0
-}
-
-; CHECK-LABEL: @test5(
-define i32 @test5(i32 %x) nounwind uwtable ssp {
-entry:
-  %retval = alloca i32, align 4
-  %x.addr = alloca i32, align 4
-  store i32 %x, i32* %x.addr, align 4
-  %tmp = load i32, i32* %x.addr, align 4
-  %cmp = icmp slt i32 %tmp, 0
-  %conv = zext i1 %cmp to i32
-  %conv1 = sext i32 %conv to i64
-  %expval = call i64 @llvm.expect.i64(i64 %conv1, i64 0)
-  %tobool = icmp ne i64 %expval, 0
-; CHECK: !prof !1
-; CHECK-NOT: @llvm.expect
-  br i1 %tobool, label %if.then, label %if.end
-
-if.then:                                          ; preds = %entry
-  %call = call i32 (...) @f()
-  store i32 %call, i32* %retval
-  br label %return
-
-if.end:                                           ; preds = %entry
-  store i32 1, i32* %retval
-  br label %return
-
-return:                                           ; preds = %if.end, %if.then
-  %0 = load i32, i32* %retval
-  ret i32 %0
-}
-
-; CHECK-LABEL: @test6(
-define i32 @test6(i32 %x) nounwind uwtable ssp {
-entry:
-  %retval = alloca i32, align 4
-  %x.addr = alloca i32, align 4
-  store i32 %x, i32* %x.addr, align 4
-  %tmp = load i32, i32* %x.addr, align 4
-  %conv = sext i32 %tmp to i64
-  %expval = call i64 @llvm.expect.i64(i64 %conv, i64 1)
-; CHECK: !prof !2
-; CHECK-NOT: @llvm.expect
-  switch i64 %expval, label %sw.epilog [
-    i64 1, label %sw.bb
-    i64 2, label %sw.bb
-  ]
-
-sw.bb:                                            ; preds = %entry, %entry
-  store i32 0, i32* %retval
-  br label %return
-
-sw.epilog:                                        ; preds = %entry
-  store i32 1, i32* %retval
-  br label %return
-
-return:                                           ; preds = %sw.epilog, %sw.bb
-  %0 = load i32, i32* %retval
-  ret i32 %0
-}
-
-; CHECK-LABEL: @test7(
-define i32 @test7(i32 %x) nounwind uwtable ssp {
-entry:
-  %retval = alloca i32, align 4
-  %x.addr = alloca i32, align 4
-  store i32 %x, i32* %x.addr, align 4
-  %tmp = load i32, i32* %x.addr, align 4
-  %conv = sext i32 %tmp to i64
-  %expval = call i64 @llvm.expect.i64(i64 %conv, i64 1)
-; CHECK: !prof !3
-; CHECK-NOT: @llvm.expect
-  switch i64 %expval, label %sw.epilog [
-    i64 2, label %sw.bb
-    i64 3, label %sw.bb
-  ]
-
-sw.bb:                                            ; preds = %entry, %entry
-  %tmp1 = load i32, i32* %x.addr, align 4
-  store i32 %tmp1, i32* %retval
-  br label %return
-
-sw.epilog:                                        ; preds = %entry
-  store i32 0, i32* %retval
-  br label %return
-
-return:                                           ; preds = %sw.epilog, %sw.bb
-  %0 = load i32, i32* %retval
-  ret i32 %0
-}
-
-; CHECK-LABEL: @test8(
-define i32 @test8(i32 %x) nounwind uwtable ssp {
-entry:
-  %retval = alloca i32, align 4
-  %x.addr = alloca i32, align 4
-  store i32 %x, i32* %x.addr, align 4
-  %tmp = load i32, i32* %x.addr, align 4
-  %cmp = icmp sgt i32 %tmp, 1
-  %conv = zext i1 %cmp to i32
-  %expval = call i32 @llvm.expect.i32(i32 %conv, i32 1)
-  %tobool = icmp ne i32 %expval, 0
-; CHECK: !prof !0
-; CHECK-NOT: @llvm.expect
-  br i1 %tobool, label %if.then, label %if.end
-
-if.then:                                          ; preds = %entry
-  %call = call i32 (...) @f()
-  store i32 %call, i32* %retval
-  br label %return
-
-if.end:                                           ; preds = %entry
-  store i32 1, i32* %retval
-  br label %return
-
-return:                                           ; preds = %if.end, %if.then
-  %0 = load i32, i32* %retval
-  ret i32 %0
-}
-
-declare i32 @llvm.expect.i32(i32, i32) nounwind readnone
-
-; CHECK-LABEL: @test9(
-define i32 @test9(i32 %x) nounwind uwtable ssp {
-entry:
-  %retval = alloca i32, align 4
-  %x.addr = alloca i32, align 4
-  store i32 %x, i32* %x.addr, align 4
-  %tmp = load i32, i32* %x.addr, align 4
-  %cmp = icmp sgt i32 %tmp, 1
-  %expval = call i1 @llvm.expect.i1(i1 %cmp, i1 1)
-; CHECK: !prof !0
-; CHECK-NOT: @llvm.expect
-  br i1 %expval, label %if.then, label %if.end
-
-if.then:                                          ; preds = %entry
-  %call = call i32 (...) @f()
-  store i32 %call, i32* %retval
-  br label %return
-
-if.end:                                           ; preds = %entry
-  store i32 1, i32* %retval
-  br label %return
-
-return:                                           ; preds = %if.end, %if.then
-  %0 = load i32, i32* %retval
-  ret i32 %0
-}
-
-declare i1 @llvm.expect.i1(i1, i1) nounwind readnone
-
-; CHECK: !0 = !{!"branch_weights", i32 64, i32 4}
-; CHECK: !1 = !{!"branch_weights", i32 4, i32 64}
-; CHECK: !2 = !{!"branch_weights", i32 4, i32 64, i32 4}
-; CHECK: !3 = !{!"branch_weights", i32 64, i32 4, i32 4}