[NFC][Inliner] Add Load/Store handler

[vitalybuka]

Summary

This is an additional signal which may benefit sanitizers.

[kda]

llvm/lib/Analysis/InlineCost.cpp

130

An additional cost of zero? Is that correct?

[vitalybuka]

llvm/lib/Analysis/InlineCost.cpp

130

Yes. So as is it's NFC.
From my experiments on CTMark ~20 is good for sanitizers. I will try to use this constant internally. It will not be reverted I'll update upstream later.

llvm/lib/Analysis/InlineCost.cpp

static cl::opt<int> HotCallSiteRelFreq(
     cl::desc("Minimum block frequency, expressed as a multiple of caller's "
              "entry frequency, for a callsite to be hot in the absence of "
              "profile information."));
 
 static cl::opt<int>
     InstrCost("inline-instr-cost", cl::Hidden, cl::init(5),
               cl::desc("Cost of a single instruction when inlining"));
 
+static cl::opt<int>
+    MemAccessCost("inline-memaccess-cost", cl::Hidden, cl::init(0),
+                  cl::desc("Cost of load/store instruction when inlining"));
+
 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<size_t>
     StackSizeThreshold("inline-max-stacksize", cl::Hidden,
                        cl::init(std::numeric_limits<size_t>::max()),
                        cl::desc("Do not inline functions with a stack size "
protected:
 
   /// Called when we visit a CallBase, before the analysis starts. Return false
   /// to stop further processing of the instruction.
   virtual bool onCallBaseVisitStart(CallBase &Call) { return true; }
 
   /// Called to account for a call.
   virtual void onCallPenalty() {}
 
+  /// Called to account for a load or store.
+  virtual void onMemAccess(){};
+
   /// Called to account for the expectation the inlining would result in a load
   /// elimination.
   virtual void onLoadEliminationOpportunity() {}
 
   /// Called to account for the cost of argument setup for the Call in the
   /// callee's body (not the callsite currently under analysis).
   virtual void onCallArgumentSetup(const CallBase &Call) {}
 
if (Optional<int> AttrCallCost =
       // Prevent further processing of the call since we want to override its
       // inline cost, not just add to it.
       return false;
     }
     return true;
   }
 
   void onCallPenalty() override { addCost(CallPenalty); }
+
+  void onMemAccess() override { addCost(MemAccessCost); }
+
   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.
     addCost(Call.arg_size() * InstrCost);
   }
   void onLoadRelativeIntrinsic() override {
     // This is normally lowered to 4 LLVM instructions.
     addCost(3 * InstrCost);
bool CallAnalyzer::visitLoad(LoadInst &I) {
   // by any stores or calls, this load is likely to be redundant and can be
   // eliminated.
   if (EnableLoadElimination &&
       !LoadAddrSet.insert(I.getPointerOperand()).second && I.isUnordered()) {
     onLoadEliminationOpportunity();
     return true;
   }
 
+  onMemAccess();
   return false;
 }
 
 bool CallAnalyzer::visitStore(StoreInst &I) {
   if (handleSROA(I.getPointerOperand(), I.isSimple()))
     return true;
 
   // The store can potentially clobber loads and prevent repeated loads from
   // being eliminated.
   // FIXME:
   // 1. We can probably keep an initial set of eliminatable loads substracted
   // from the cost even when we finally see a store. We just need to disable
   // *further* accumulation of elimination savings.
   // 2. We should probably at some point thread MemorySSA for the callee into
   // this and then use that to actually compute *really* precise savings.
   disableLoadElimination();
+
+  onMemAccess();
   return false;
 }
 
 bool CallAnalyzer::visitExtractValue(ExtractValueInst &I) {
   // Constant folding for extract value is trivial.
   if (simplifyInstruction(I))
     return true;