diff --git a/llvm/include/llvm/Analysis/InlineCost.h b/llvm/include/llvm/Analysis/InlineCost.h
--- a/llvm/include/llvm/Analysis/InlineCost.h
+++ b/llvm/include/llvm/Analysis/InlineCost.h
@@ -44,7 +44,7 @@
 // Various magic constants used to adjust heuristics.
 const int InstrCost = 5;
 const int IndirectCallThreshold = 100;
-const int CallPenalty = 25;
+const int LoopPenalty = 25;
 const int LastCallToStaticBonus = 15000;
 const int ColdccPenalty = 2000;
 /// Do not inline functions which allocate this many bytes on the stack
diff --git a/llvm/lib/Analysis/InlineCost.cpp b/llvm/lib/Analysis/InlineCost.cpp
--- a/llvm/lib/Analysis/InlineCost.cpp
+++ b/llvm/lib/Analysis/InlineCost.cpp
@@ -113,6 +113,10 @@
              "entry frequency, for a callsite to be hot in the absence of "
              "profile information."));
 
+static cl::opt<int> CallPenalty(
+    "inline-call-penalty", cl::Hidden, cl::init(25),
+    cl::desc("Call penalty that is applied per callsite when inlining"));
+
 static cl::opt<bool> OptComputeFullInlineCost(
     "inline-cost-full", cl::Hidden, cl::init(false), cl::ZeroOrMore,
     cl::desc("Compute the full inline cost of a call site even when the cost "
@@ -554,7 +558,7 @@
     addCost(LoadEliminationCost);
     LoadEliminationCost = 0;
   }
-  void onCallPenalty() override { addCost(InlineConstants::CallPenalty); }
+  void onCallPenalty() override { addCost(CallPenalty); }
   void onCallArgumentSetup(const CallBase &Call) override {
     // Pay the price of the argument setup. We account for the average 1
     // instruction per call argument setup here.
@@ -589,7 +593,7 @@
       }
     } else
       // Otherwise simply add the cost for merely making the call.
-      addCost(InlineConstants::CallPenalty);
+      addCost(CallPenalty);
   }
 
   void onFinalizeSwitch(unsigned JumpTableSize,
@@ -832,7 +836,7 @@
           continue;
         NumLoops++;
       }
-      addCost(NumLoops * InlineConstants::CallPenalty);
+      addCost(NumLoops * InlineConstants::LoopPenalty);
     }
 
     // We applied the maximum possible vector bonus at the beginning. Now,
@@ -993,8 +997,7 @@
   }
 
   void onCallPenalty() override {
-    increment(InlineCostFeatureIndex::CallPenalty,
-              InlineConstants::CallPenalty);
+    increment(InlineCostFeatureIndex::CallPenalty, CallPenalty);
   }
 
   void onCallArgumentSetup(const CallBase &Call) override {
@@ -1092,7 +1095,7 @@
         if (DeadBlocks.count(L->getHeader()))
           continue;
         increment(InlineCostFeatureIndex::NumLoops,
-                  InlineConstants::CallPenalty);
+                  InlineConstants::LoopPenalty);
       }
     }
     set(InlineCostFeatureIndex::DeadBlocks, DeadBlocks.size());
@@ -2679,7 +2682,7 @@
     }
   }
   // The call instruction also disappears after inlining.
-  Cost += InlineConstants::InstrCost + InlineConstants::CallPenalty;
+  Cost += InlineConstants::InstrCost + CallPenalty;
   return Cost;
 }
 
diff --git a/llvm/test/Transforms/Inline/inline-call-penalty-option.ll b/llvm/test/Transforms/Inline/inline-call-penalty-option.ll
new file mode 100644
--- /dev/null
+++ b/llvm/test/Transforms/Inline/inline-call-penalty-option.ll
@@ -0,0 +1,28 @@
+; Check that calls are not inlined if the call penalty is low. The value of the
+; call penalty is provided with the '--inline-call-penalty' option.
+;
+; RUN: opt < %s -inline --inline-call-penalty=0 --inline-threshold=5 -S | FileCheck %s
+; RUN: opt < %s -inline --inline-threshold=5 -S | FileCheck %s -check-prefix=DEFAULT_CALL_PENALTY
+
+define i32 @X9(i32 %x) nounwind {
+  %x2 = add i32 %x, %x
+  %x3 = add i32 %x2, %x
+  %x4 = add i32 %x3, %x
+  %x5 = add i32 %x4, %x
+  %x6 = add i32 %x5, %x
+  %x7 = add i32 %x6, %x
+  %x8 = add i32 %x7, %x
+  %x9 = add i32 %x8, %x
+
+  ret i32 %x9
+}
+
+define i32 @f1(i32 %x) nounwind {
+  %res = call i32 @X9(i32 %x)
+  ret i32 %res
+; CHECK-LABEL: @f1(
+; CHECK: %res = call i32 @X9
+
+; DEFAULT_CALL_PENALTY-LABEL: @f1(
+; DEFAULT_CALL_PENALTY-NOT: call
+}