[analyzer] NFC: Minor code reuse in simplifySVal().

[NoQ]

Summary

Satisfies a review comment in D49749.

[NoQ]

Uhm, sry, rC338425 is not relevant, i screwed up the revision link again.

cfe/trunk/lib/StaticAnalyzer/Core/SimpleSValBuilder.cpp

class Simplifier : public FullSValVisitor<Simplifier, SVal> {
     // point of simplifying, and for that very reason it's pointless to maintain
     // the same cache for the duration of the whole analysis.
     llvm::DenseMap<SymbolRef, SVal> Cached;
 
     static bool isUnchanged(SymbolRef Sym, SVal Val) {
       return Sym == Val.getAsSymbol();
     }
 
+    SVal cache(SymbolRef Sym, SVal V) {
+      Cached[Sym] = V;
+      return V;
+    }
+
+    SVal skip(SymbolRef Sym) {
+      return cache(Sym, SVB.makeSymbolVal(Sym));
+    }
+
   public:
     Simplifier(ProgramStateRef State)
         : State(State), SVB(State->getStateManager().getSValBuilder()) {}
 
     SVal VisitSymbolData(const SymbolData *S) {
+      // No cache here.
       if (const llvm::APSInt *I =
               SVB.getKnownValue(State, SVB.makeSymbolVal(S)))
         return Loc::isLocType(S->getType()) ? (SVal)SVB.makeIntLocVal(*I)
                                             : (SVal)SVB.makeIntVal(*I);
       return SVB.makeSymbolVal(S);
     }
 
     // TODO: Support SymbolCast. Support IntSymExpr when/if we actually
     // start producing them.
 
     SVal VisitSymIntExpr(const SymIntExpr *S) {
       auto I = Cached.find(S);
       if (I != Cached.end())
         return I->second;
 
       SVal LHS = Visit(S->getLHS());
-      if (isUnchanged(S->getLHS(), LHS)) {
-        SVal V = SVB.makeSymbolVal(S);
-        Cached[S] = V;
-        return V;
-      }
+      if (isUnchanged(S->getLHS(), LHS))
+        return skip(S);
+
       SVal RHS;
       // By looking at the APSInt in the right-hand side of S, we cannot
       // figure out if it should be treated as a Loc or as a NonLoc.
       // So make our guess by recalling that we cannot multiply pointers
       // or compare a pointer to an integer.
       if (Loc::isLocType(S->getLHS()->getType()) &&
           BinaryOperator::isComparisonOp(S->getOpcode())) {
         // The usual conversion of $sym to &SymRegion{$sym}, as they have
         // the same meaning for Loc-type symbols, but the latter form
         // is preferred in SVal computations for being Loc itself.
         if (SymbolRef Sym = LHS.getAsSymbol()) {
           assert(Loc::isLocType(Sym->getType()));
           LHS = SVB.makeLoc(Sym);
         }
         RHS = SVB.makeIntLocVal(S->getRHS());
       } else {
         RHS = SVB.makeIntVal(S->getRHS());
       }
 
-      SVal V = SVB.evalBinOp(State, S->getOpcode(), LHS, RHS, S->getType());
-      Cached[S] = V;
-      return V;
+      return cache(
+          S, SVB.evalBinOp(State, S->getOpcode(), LHS, RHS, S->getType()));
     }
 
     SVal VisitSymSymExpr(const SymSymExpr *S) {
       auto I = Cached.find(S);
       if (I != Cached.end())
         return I->second;
 
       // For now don't try to simplify mixed Loc/NonLoc expressions
       // because they often appear from LocAsInteger operations
       // and we don't know how to combine a LocAsInteger
       // with a concrete value.
       if (Loc::isLocType(S->getLHS()->getType()) !=
-          Loc::isLocType(S->getRHS()->getType())) {
-        SVal V = SVB.makeSymbolVal(S);
-        Cached[S] = V;
-        return V;
-      }
+          Loc::isLocType(S->getRHS()->getType()))
+        return skip(S);
 
       SVal LHS = Visit(S->getLHS());
       SVal RHS = Visit(S->getRHS());
-      if (isUnchanged(S->getLHS(), LHS) && isUnchanged(S->getRHS(), RHS)) {
-        SVal V = SVB.makeSymbolVal(S);
-        Cached[S] = V;
-        return V;
-      }
-      SVal V = SVB.evalBinOp(State, S->getOpcode(), LHS, RHS, S->getType());
-      Cached[S] = V;
-      return V;
+      if (isUnchanged(S->getLHS(), LHS) && isUnchanged(S->getRHS(), RHS))
+        return skip(S);
+
+      return cache(
+          S, SVB.evalBinOp(State, S->getOpcode(), LHS, RHS, S->getType()));
     }
 
     SVal VisitSymExpr(SymbolRef S) { return nonloc::SymbolVal(S); }
 
     SVal VisitMemRegion(const MemRegion *R) { return loc::MemRegionVal(R); }
 
     SVal VisitNonLocSymbolVal(nonloc::SymbolVal V) {
       // Simplification is much more costly than computing complexity.