diff --git a/lib/Analysis/BasicConstraintManager.cpp b/lib/Analysis/BasicConstraintManager.cpp
index 8d391bb..aab1f5e 100644
--- a/lib/Analysis/BasicConstraintManager.cpp
+++ b/lib/Analysis/BasicConstraintManager.cpp
@@ -33,19 +33,19 @@
 public:
   BasicConstraintManager(GRStateManager& statemgr) : StateMgr(statemgr) {}
 
-  virtual const GRState* Assume(const GRState* St, RVal Cond,
+  virtual const GRState* Assume(const GRState* St, SVal Cond,
                                 bool Assumption, bool& isFeasible);
 
-  const GRState* Assume(const GRState* St, LVal Cond, bool Assumption,
+  const GRState* Assume(const GRState* St, Loc Cond, bool Assumption,
                         bool& isFeasible);
 
-  const GRState* AssumeAux(const GRState* St, LVal Cond,bool Assumption,
+  const GRState* AssumeAux(const GRState* St, Loc Cond,bool Assumption,
                            bool& isFeasible);
 
-  const GRState* Assume(const GRState* St, NonLVal Cond, bool Assumption,
+  const GRState* Assume(const GRState* St, NonLoc Cond, bool Assumption,
                         bool& isFeasible);
 
-  const GRState* AssumeAux(const GRState* St, NonLVal Cond, bool Assumption,
+  const GRState* AssumeAux(const GRState* St, NonLoc Cond, bool Assumption,
                            bool& isFeasible);
 
   const GRState* AssumeSymInt(const GRState* St, bool Assumption,
@@ -92,52 +92,52 @@
   return new BasicConstraintManager(StateMgr);
 }
 
-const GRState* BasicConstraintManager::Assume(const GRState* St, RVal Cond,
+const GRState* BasicConstraintManager::Assume(const GRState* St, SVal Cond,
                                             bool Assumption, bool& isFeasible) {
   if (Cond.isUnknown()) {
     isFeasible = true;
     return St;
   }
 
-  if (isa<NonLVal>(Cond))
-    return Assume(St, cast<NonLVal>(Cond), Assumption, isFeasible);
+  if (isa<NonLoc>(Cond))
+    return Assume(St, cast<NonLoc>(Cond), Assumption, isFeasible);
   else
-    return Assume(St, cast<LVal>(Cond), Assumption, isFeasible);
+    return Assume(St, cast<Loc>(Cond), Assumption, isFeasible);
 }
 
-const GRState* BasicConstraintManager::Assume(const GRState* St, LVal Cond,
+const GRState* BasicConstraintManager::Assume(const GRState* St, Loc Cond,
                                             bool Assumption, bool& isFeasible) {
   St = AssumeAux(St, Cond, Assumption, isFeasible);
   // TF->EvalAssume(*this, St, Cond, Assumption, isFeasible)
   return St;
 }
 
-const GRState* BasicConstraintManager::AssumeAux(const GRState* St, LVal Cond,
+const GRState* BasicConstraintManager::AssumeAux(const GRState* St, Loc Cond,
                                             bool Assumption, bool& isFeasible) {
   BasicValueFactory& BasicVals = StateMgr.getBasicVals();
 
   switch (Cond.getSubKind()) {
   default:
-    assert (false && "'Assume' not implemented for this LVal.");
+    assert (false && "'Assume' not implemented for this Loc.");
     return St;
 
-  case lval::SymbolValKind:
+  case loc::SymbolValKind:
     if (Assumption)
-      return AssumeSymNE(St, cast<lval::SymbolVal>(Cond).getSymbol(),
+      return AssumeSymNE(St, cast<loc::SymbolVal>(Cond).getSymbol(),
                          BasicVals.getZeroWithPtrWidth(), isFeasible);
     else
-      return AssumeSymEQ(St, cast<lval::SymbolVal>(Cond).getSymbol(),
+      return AssumeSymEQ(St, cast<loc::SymbolVal>(Cond).getSymbol(),
                          BasicVals.getZeroWithPtrWidth(), isFeasible);
 
-  case lval::MemRegionKind:
-  case lval::FuncValKind:
-  case lval::GotoLabelKind:
-  case lval::StringLiteralValKind:
+  case loc::MemRegionKind:
+  case loc::FuncValKind:
+  case loc::GotoLabelKind:
+  case loc::StringLiteralValKind:
     isFeasible = Assumption;
     return St;
 
-  case lval::ConcreteIntKind: {
-    bool b = cast<lval::ConcreteInt>(Cond).getValue() != 0;
+  case loc::ConcreteIntKind: {
+    bool b = cast<loc::ConcreteInt>(Cond).getValue() != 0;
     isFeasible = b ? Assumption : !Assumption;
     return St;
   }
@@ -145,7 +145,7 @@
 }
 
 const GRState*
-BasicConstraintManager::Assume(const GRState* St, NonLVal Cond, bool Assumption,
+BasicConstraintManager::Assume(const GRState* St, NonLoc Cond, bool Assumption,
                                bool& isFeasible) {
   St = AssumeAux(St, Cond, Assumption, isFeasible);
   // TF->EvalAssume() does nothing now.
@@ -153,17 +153,17 @@
 }
 
 const GRState*
-BasicConstraintManager::AssumeAux(const GRState* St,NonLVal Cond,
+BasicConstraintManager::AssumeAux(const GRState* St,NonLoc Cond,
                                   bool Assumption, bool& isFeasible) {
   BasicValueFactory& BasicVals = StateMgr.getBasicVals();
   SymbolManager& SymMgr = StateMgr.getSymbolManager();
 
   switch (Cond.getSubKind()) {
   default:
-    assert(false && "'Assume' not implemented for this NonLVal");
+    assert(false && "'Assume' not implemented for this NonLoc");
 
-  case nonlval::SymbolValKind: {
-    nonlval::SymbolVal& SV = cast<nonlval::SymbolVal>(Cond);
+  case nonloc::SymbolValKind: {
+    nonloc::SymbolVal& SV = cast<nonloc::SymbolVal>(Cond);
     SymbolID sym = SV.getSymbol();
 
     if (Assumption)
@@ -174,20 +174,20 @@
                          isFeasible);
   }
 
-  case nonlval::SymIntConstraintValKind:
+  case nonloc::SymIntConstraintValKind:
     return
       AssumeSymInt(St, Assumption,
-                   cast<nonlval::SymIntConstraintVal>(Cond).getConstraint(),
+                   cast<nonloc::SymIntConstraintVal>(Cond).getConstraint(),
                    isFeasible);
 
-  case nonlval::ConcreteIntKind: {
-    bool b = cast<nonlval::ConcreteInt>(Cond).getValue() != 0;
+  case nonloc::ConcreteIntKind: {
+    bool b = cast<nonloc::ConcreteInt>(Cond).getValue() != 0;
     isFeasible = b ? Assumption : !Assumption;
     return St;
   }
 
-  case nonlval::LValAsIntegerKind:
-    return AssumeAux(St, cast<nonlval::LValAsInteger>(Cond).getLVal(),
+  case nonloc::LocAsIntegerKind:
+    return AssumeAux(St, cast<nonloc::LocAsInteger>(Cond).getLoc(),
                      Assumption, isFeasible);
   } // end switch
 }