[analyzer] Refactoring: Drop the 'GR' prefix.

llvm-svn: 122424

44 files changed, 223 insertions, 223 deletions

diff --git a/clang/lib/GR/Checkers/AdjustedReturnValueChecker.cpp b/clang/lib/GR/Checkers/AdjustedReturnValueChecker.cpp
index d9cfd3cac84..3c78b39d207 100644
--- a/clang/lib/GR/Checkers/AdjustedReturnValueChecker.cpp
+++ b/clang/lib/GR/Checkers/AdjustedReturnValueChecker.cpp
@@ -13,9 +13,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "GRExprEngineInternalChecks.h"
+#include "ExprEngineInternalChecks.h"
 #include "clang/GR/BugReporter/BugReporter.h"
-#include "clang/GR/PathSensitive/GRExprEngine.h"
+#include "clang/GR/PathSensitive/ExprEngine.h"
 #include "clang/GR/PathSensitive/CheckerVisitor.h"
 
 using namespace clang;
@@ -35,7 +35,7 @@ public:
 };
 }
 
-void GR::RegisterAdjustedReturnValueChecker(GRExprEngine &Eng) {
+void GR::RegisterAdjustedReturnValueChecker(ExprEngine &Eng) {
   Eng.registerCheck(new AdjustedReturnValueChecker());
 }
 
diff --git a/clang/lib/GR/Checkers/ArrayBoundChecker.cpp b/clang/lib/GR/Checkers/ArrayBoundChecker.cpp
index f97adf3d145..9dc53a2360b 100644
--- a/clang/lib/GR/Checkers/ArrayBoundChecker.cpp
+++ b/clang/lib/GR/Checkers/ArrayBoundChecker.cpp
@@ -12,10 +12,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "GRExprEngineInternalChecks.h"
+#include "ExprEngineInternalChecks.h"
 #include "clang/GR/BugReporter/BugType.h"
 #include "clang/GR/PathSensitive/CheckerVisitor.h"
-#include "clang/GR/PathSensitive/GRExprEngine.h"
+#include "clang/GR/PathSensitive/ExprEngine.h"
 
 using namespace clang;
 using namespace GR;
@@ -31,7 +31,7 @@ public:
 };
 }
 
-void GR::RegisterArrayBoundChecker(GRExprEngine &Eng) {
+void GR::RegisterArrayBoundChecker(ExprEngine &Eng) {
   Eng.registerCheck(new ArrayBoundChecker());
 }
 
diff --git a/clang/lib/GR/Checkers/AttrNonNullChecker.cpp b/clang/lib/GR/Checkers/AttrNonNullChecker.cpp
index baf209e3c86..74eb882d545 100644
--- a/clang/lib/GR/Checkers/AttrNonNullChecker.cpp
+++ b/clang/lib/GR/Checkers/AttrNonNullChecker.cpp
@@ -7,12 +7,12 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// This defines AttrNonNullChecker, a builtin check in GRExprEngine that 
+// This defines AttrNonNullChecker, a builtin check in ExprEngine that 
 // performs checks for arguments declared to have nonnull attribute.
 //
 //===----------------------------------------------------------------------===//
 
-#include "GRExprEngineInternalChecks.h"
+#include "ExprEngineInternalChecks.h"
 #include "clang/GR/BugReporter/BugType.h"
 #include "clang/GR/PathSensitive/CheckerVisitor.h"
 
@@ -33,7 +33,7 @@ public:
 };
 } // end anonymous namespace
 
-void GR::RegisterAttrNonNullChecker(GRExprEngine &Eng) {
+void GR::RegisterAttrNonNullChecker(ExprEngine &Eng) {
   Eng.registerCheck(new AttrNonNullChecker());
 }
 
diff --git a/clang/lib/GR/Checkers/BasicObjCFoundationChecks.cpp b/clang/lib/GR/Checkers/BasicObjCFoundationChecks.cpp
index 93c8babde13..33a58bdec9a 100644
--- a/clang/lib/GR/Checkers/BasicObjCFoundationChecks.cpp
+++ b/clang/lib/GR/Checkers/BasicObjCFoundationChecks.cpp
@@ -17,7 +17,7 @@
 
 #include "clang/GR/PathSensitive/ExplodedGraph.h"
 #include "clang/GR/PathSensitive/CheckerVisitor.h"
-#include "clang/GR/PathSensitive/GRExprEngine.h"
+#include "clang/GR/PathSensitive/ExprEngine.h"
 #include "clang/GR/PathSensitive/GRState.h"
 #include "clang/GR/BugReporter/BugType.h"
 #include "clang/GR/PathSensitive/MemRegion.h"
@@ -511,7 +511,7 @@ void ClassReleaseChecker::PreVisitObjCMessageExpr(CheckerContext &C,
 // Check registration.
 //===----------------------------------------------------------------------===//
   
-void GR::RegisterAppleChecks(GRExprEngine& Eng, const Decl &D) {
+void GR::RegisterAppleChecks(ExprEngine& Eng, const Decl &D) {
   Eng.registerCheck(new NilArgChecker());
   Eng.registerCheck(new CFNumberCreateChecker());
   RegisterNSErrorChecks(Eng.getBugReporter(), Eng, D);
diff --git a/clang/lib/GR/Checkers/BasicObjCFoundationChecks.h b/clang/lib/GR/Checkers/BasicObjCFoundationChecks.h
index 7fdccdcacb8..63143ebe252 100644
--- a/clang/lib/GR/Checkers/BasicObjCFoundationChecks.h
+++ b/clang/lib/GR/Checkers/BasicObjCFoundationChecks.h
@@ -24,10 +24,10 @@ class Decl;
 namespace GR {
 
 class BugReporter;
-class GRExprEngine;
+class ExprEngine;
 
-void RegisterNSErrorChecks(BugReporter& BR, GRExprEngine &Eng, const Decl &D);
-void RegisterNSAutoreleasePoolChecks(GRExprEngine &Eng);
+void RegisterNSErrorChecks(BugReporter& BR, ExprEngine &Eng, const Decl &D);
+void RegisterNSAutoreleasePoolChecks(ExprEngine &Eng);
 
 } // end GR namespace
 
diff --git a/clang/lib/GR/Checkers/BuiltinFunctionChecker.cpp b/clang/lib/GR/Checkers/BuiltinFunctionChecker.cpp
index dc55a65ff5a..27162e40af9 100644
--- a/clang/lib/GR/Checkers/BuiltinFunctionChecker.cpp
+++ b/clang/lib/GR/Checkers/BuiltinFunctionChecker.cpp
@@ -11,7 +11,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "GRExprEngineInternalChecks.h"
+#include "ExprEngineInternalChecks.h"
 #include "clang/GR/PathSensitive/Checker.h"
 #include "clang/Basic/Builtins.h"
 
@@ -28,7 +28,7 @@ public:
 
 }
 
-void GR::RegisterBuiltinFunctionChecker(GRExprEngine &Eng) {
+void GR::RegisterBuiltinFunctionChecker(ExprEngine &Eng) {
   Eng.registerCheck(new BuiltinFunctionChecker());
 }
 
diff --git a/clang/lib/GR/Checkers/CMakeLists.txt b/clang/lib/GR/Checkers/CMakeLists.txt
index 700adb544b8..cae050d94cb 100644
--- a/clang/lib/GR/Checkers/CMakeLists.txt
+++ b/clang/lib/GR/Checkers/CMakeLists.txt
@@ -17,7 +17,7 @@ add_clang_library(clangGRCheckers
   DereferenceChecker.cpp
   DivZeroChecker.cpp
   FixedAddressChecker.cpp
-  GRExprEngineExperimentalChecks.cpp
+  ExprEngineExperimentalChecks.cpp
   IdempotentOperationChecker.cpp
   LLVMConventionsChecker.cpp
   MacOSXAPIChecker.cpp
diff --git a/clang/lib/GR/Checkers/CStringChecker.cpp b/clang/lib/GR/Checkers/CStringChecker.cpp
index da0bba37416..a9d3064fcaf 100644
--- a/clang/lib/GR/Checkers/CStringChecker.cpp
+++ b/clang/lib/GR/Checkers/CStringChecker.cpp
@@ -12,7 +12,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "GRExprEngineExperimentalChecks.h"
+#include "ExprEngineExperimentalChecks.h"
 #include "clang/GR/BugReporter/BugType.h"
 #include "clang/GR/PathSensitive/CheckerVisitor.h"
 #include "clang/GR/PathSensitive/GRStateTrait.h"
@@ -109,7 +109,7 @@ namespace GR {
 }
 }
 
-void GR::RegisterCStringChecker(GRExprEngine &Eng) {
+void GR::RegisterCStringChecker(ExprEngine &Eng) {
   Eng.registerCheck(new CStringChecker());
 }
 
diff --git a/clang/lib/GR/Checkers/CallAndMessageChecker.cpp b/clang/lib/GR/Checkers/CallAndMessageChecker.cpp
index 8b8f75faf68..f3306d136bc 100644
--- a/clang/lib/GR/Checkers/CallAndMessageChecker.cpp
+++ b/clang/lib/GR/Checkers/CallAndMessageChecker.cpp
@@ -12,7 +12,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "GRExprEngineInternalChecks.h"
+#include "ExprEngineInternalChecks.h"
 #include "clang/AST/ParentMap.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/GR/BugReporter/BugType.h"
@@ -62,7 +62,7 @@ private:
 };
 } // end anonymous namespace
 
-void GR::RegisterCallAndMessageChecker(GRExprEngine &Eng) {
+void GR::RegisterCallAndMessageChecker(ExprEngine &Eng) {
   Eng.registerCheck(new CallAndMessageChecker());
 }
 
diff --git a/clang/lib/GR/Checkers/CastSizeChecker.cpp b/clang/lib/GR/Checkers/CastSizeChecker.cpp
index bcbb89441f4..c17dc7a266e 100644
--- a/clang/lib/GR/Checkers/CastSizeChecker.cpp
+++ b/clang/lib/GR/Checkers/CastSizeChecker.cpp
@@ -14,7 +14,7 @@
 #include "clang/AST/CharUnits.h"
 #include "clang/GR/BugReporter/BugType.h"
 #include "clang/GR/PathSensitive/CheckerVisitor.h"
-#include "GRExprEngineInternalChecks.h"
+#include "ExprEngineInternalChecks.h"
 
 using namespace clang;
 using namespace GR;
@@ -86,6 +86,6 @@ void CastSizeChecker::PreVisitCastExpr(CheckerContext &C, const CastExpr *CE) {
 }
 
 
-void GR::RegisterCastSizeChecker(GRExprEngine &Eng) {
+void GR::RegisterCastSizeChecker(ExprEngine &Eng) {
   Eng.registerCheck(new CastSizeChecker());
 }
diff --git a/clang/lib/GR/Checkers/CastToStructChecker.cpp b/clang/lib/GR/Checkers/CastToStructChecker.cpp
index 0bcba284b86..7b0732938c1 100644
--- a/clang/lib/GR/Checkers/CastToStructChecker.cpp
+++ b/clang/lib/GR/Checkers/CastToStructChecker.cpp
@@ -15,7 +15,7 @@
 
 #include "clang/GR/BugReporter/BugType.h"
 #include "clang/GR/PathSensitive/CheckerVisitor.h"
-#include "GRExprEngineInternalChecks.h"
+#include "ExprEngineInternalChecks.h"
 
 using namespace clang;
 using namespace GR;
@@ -74,6 +74,6 @@ void CastToStructChecker::PreVisitCastExpr(CheckerContext &C,
   }
 }
 
-void GR::RegisterCastToStructChecker(GRExprEngine &Eng) {
+void GR::RegisterCastToStructChecker(ExprEngine &Eng) {
   Eng.registerCheck(new CastToStructChecker());
 }
diff --git a/clang/lib/GR/Checkers/CheckDeadStores.cpp b/clang/lib/GR/Checkers/CheckDeadStores.cpp
index 44fdb3afbba..edcf57ceca2 100644
--- a/clang/lib/GR/Checkers/CheckDeadStores.cpp
+++ b/clang/lib/GR/Checkers/CheckDeadStores.cpp
@@ -16,7 +16,7 @@
 #include "clang/Analysis/Analyses/LiveVariables.h"
 #include "clang/Analysis/Visitors/CFGRecStmtVisitor.h"
 #include "clang/GR/BugReporter/BugReporter.h"
-#include "clang/GR/PathSensitive/GRExprEngine.h"
+#include "clang/GR/PathSensitive/ExprEngine.h"
 #include "clang/Analysis/Visitors/CFGRecStmtDeclVisitor.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/AST/ASTContext.h"
diff --git a/clang/lib/GR/Checkers/ChrootChecker.cpp b/clang/lib/GR/Checkers/ChrootChecker.cpp
index f93ee7b9416..58b34d08520 100644
--- a/clang/lib/GR/Checkers/ChrootChecker.cpp
+++ b/clang/lib/GR/Checkers/ChrootChecker.cpp
@@ -11,7 +11,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "GRExprEngineExperimentalChecks.h"
+#include "ExprEngineExperimentalChecks.h"
 #include "clang/GR/BugReporter/BugType.h"
 #include "clang/GR/PathSensitive/CheckerVisitor.h"
 #include "clang/GR/PathSensitive/GRState.h"
@@ -59,7 +59,7 @@ private:
 
 } // end anonymous namespace
 
-void GR::RegisterChrootChecker(GRExprEngine &Eng) {
+void GR::RegisterChrootChecker(ExprEngine &Eng) {
   Eng.registerCheck(new ChrootChecker());
 }
 
diff --git a/clang/lib/GR/Checkers/DereferenceChecker.cpp b/clang/lib/GR/Checkers/DereferenceChecker.cpp
index 62b1f86fb48..dbe0ab3262e 100644
--- a/clang/lib/GR/Checkers/DereferenceChecker.cpp
+++ b/clang/lib/GR/Checkers/DereferenceChecker.cpp
@@ -7,16 +7,16 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// This defines NullDerefChecker, a builtin check in GRExprEngine that performs
+// This defines NullDerefChecker, a builtin check in ExprEngine that performs
 // checks for null pointers at loads and stores.
 //
 //===----------------------------------------------------------------------===//
 
-#include "GRExprEngineInternalChecks.h"
+#include "ExprEngineInternalChecks.h"
 #include "clang/GR/BugReporter/BugType.h"
 #include "clang/GR/Checkers/DereferenceChecker.h"
 #include "clang/GR/PathSensitive/Checker.h"
-#include "clang/GR/PathSensitive/GRExprEngine.h"
+#include "clang/GR/PathSensitive/ExprEngine.h"
 
 using namespace clang;
 using namespace GR;
@@ -43,12 +43,12 @@ public:
 };
 } // end anonymous namespace
 
-void GR::RegisterDereferenceChecker(GRExprEngine &Eng) {
+void GR::RegisterDereferenceChecker(ExprEngine &Eng) {
   Eng.registerCheck(new DereferenceChecker());
 }
 
 std::pair<ExplodedNode * const *, ExplodedNode * const *>
-GR::GetImplicitNullDereferences(GRExprEngine &Eng) {
+GR::GetImplicitNullDereferences(ExprEngine &Eng) {
   DereferenceChecker *checker = Eng.getChecker<DereferenceChecker>();
   if (!checker)
     return std::make_pair((ExplodedNode * const *) 0,
diff --git a/clang/lib/GR/Checkers/DivZeroChecker.cpp b/clang/lib/GR/Checkers/DivZeroChecker.cpp
index a4cb1a4a130..1475a9e1cd3 100644
--- a/clang/lib/GR/Checkers/DivZeroChecker.cpp
+++ b/clang/lib/GR/Checkers/DivZeroChecker.cpp
@@ -7,12 +7,12 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// This defines DivZeroChecker, a builtin check in GRExprEngine that performs
+// This defines DivZeroChecker, a builtin check in ExprEngine that performs
 // checks for division by zeros.
 //
 //===----------------------------------------------------------------------===//
 
-#include "GRExprEngineInternalChecks.h"
+#include "ExprEngineInternalChecks.h"
 #include "clang/GR/BugReporter/BugType.h"
 #include "clang/GR/PathSensitive/CheckerVisitor.h"
 
@@ -29,7 +29,7 @@ public:
 };  
 } // end anonymous namespace
 
-void GR::RegisterDivZeroChecker(GRExprEngine &Eng) {
+void GR::RegisterDivZeroChecker(ExprEngine &Eng) {
   Eng.registerCheck(new DivZeroChecker());
 }
 
diff --git a/clang/lib/GR/Checkers/GRExprEngineExperimentalChecks.cpp b/clang/lib/GR/Checkers/ExprEngineExperimentalChecks.cpp
index fd9bf5dd520..d7ad99ffc22 100644
--- a/clang/lib/GR/Checkers/GRExprEngineExperimentalChecks.cpp
+++ b/clang/lib/GR/Checkers/ExprEngineExperimentalChecks.cpp
@@ -1,4 +1,4 @@
-//=-- GRExprEngineExperimentalChecks.h ------------------------------*- C++ -*-=
+//=-- ExprEngineExperimentalChecks.h ------------------------------*- C++ -*-=
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -8,20 +8,20 @@
 //===----------------------------------------------------------------------===//
 //
 //  This file defines functions to instantiate and register experimental
-//  checks in GRExprEngine.
+//  checks in ExprEngine.
 //
 //===----------------------------------------------------------------------===//
 
-#include "GRExprEngineInternalChecks.h"
-#include "GRExprEngineExperimentalChecks.h"
+#include "ExprEngineInternalChecks.h"
+#include "ExprEngineExperimentalChecks.h"
 #include "clang/GR/Checkers/LocalCheckers.h"
 
 using namespace clang;
 using namespace GR;
 
-void GR::RegisterExperimentalChecks(GRExprEngine &Eng) {
+void GR::RegisterExperimentalChecks(ExprEngine &Eng) {
   // These are checks that never belong as internal checks
-  // within GRExprEngine.
+  // within ExprEngine.
   RegisterCStringChecker(Eng);
   RegisterChrootChecker(Eng);
   RegisterMallocChecker(Eng);
@@ -30,7 +30,7 @@ void GR::RegisterExperimentalChecks(GRExprEngine &Eng) {
   RegisterUnreachableCodeChecker(Eng);
 }
 
-void GR::RegisterExperimentalInternalChecks(GRExprEngine &Eng) {
+void GR::RegisterExperimentalInternalChecks(ExprEngine &Eng) {
   // These are internal checks that should eventually migrate to
   // RegisterInternalChecks() once they have been further tested.
   
diff --git a/clang/lib/GR/Checkers/ExprEngineExperimentalChecks.h b/clang/lib/GR/Checkers/ExprEngineExperimentalChecks.h
new file mode 100644
index 00000000000..4a04fb9b2f7
--- /dev/null
+++ b/clang/lib/GR/Checkers/ExprEngineExperimentalChecks.h
@@ -0,0 +1,37 @@
+//=-- ExprEngineExperimentalChecks.h ------------------------------*- C++ -*-=
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file defines functions to instantiate and register experimental
+//  checks in ExprEngine.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_GR_ExprEngine_EXPERIMENTAL_CHECKS
+#define LLVM_CLANG_GR_ExprEngine_EXPERIMENTAL_CHECKS
+
+namespace clang {
+
+namespace GR {
+
+class ExprEngine;
+
+void RegisterAnalyzerStatsChecker(ExprEngine &Eng);
+void RegisterChrootChecker(ExprEngine &Eng);
+void RegisterCStringChecker(ExprEngine &Eng);
+void RegisterIdempotentOperationChecker(ExprEngine &Eng);
+void RegisterMallocChecker(ExprEngine &Eng);
+void RegisterPthreadLockChecker(ExprEngine &Eng);
+void RegisterStreamChecker(ExprEngine &Eng);
+void RegisterUnreachableCodeChecker(ExprEngine &Eng);
+
+} // end GR namespace
+
+} // end clang namespace
+
+#endif
diff --git a/clang/lib/GR/Checkers/ExprEngineInternalChecks.h b/clang/lib/GR/Checkers/ExprEngineInternalChecks.h
new file mode 100644
index 00000000000..aa2f99b1a11
--- /dev/null
+++ b/clang/lib/GR/Checkers/ExprEngineInternalChecks.h
@@ -0,0 +1,58 @@
+//=-- ExprEngineInternalChecks.h- Builtin ExprEngine Checks -----*- C++ -*-=
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file defines functions to instantiate and register the "built-in"
+//  checks in ExprEngine.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_GR_ExprEngine_INTERNAL_CHECKS
+#define LLVM_CLANG_GR_ExprEngine_INTERNAL_CHECKS
+
+namespace clang {
+
+namespace GR {
+
+class ExprEngine;
+
+// Foundational checks that handle basic semantics.
+void RegisterAdjustedReturnValueChecker(ExprEngine &Eng);
+void RegisterArrayBoundChecker(ExprEngine &Eng);
+void RegisterAttrNonNullChecker(ExprEngine &Eng);
+void RegisterBuiltinFunctionChecker(ExprEngine &Eng);
+void RegisterCallAndMessageChecker(ExprEngine &Eng);
+void RegisterCastToStructChecker(ExprEngine &Eng);
+void RegisterCastSizeChecker(ExprEngine &Eng);
+void RegisterDereferenceChecker(ExprEngine &Eng);
+void RegisterDivZeroChecker(ExprEngine &Eng);
+void RegisterFixedAddressChecker(ExprEngine &Eng);
+void RegisterNoReturnFunctionChecker(ExprEngine &Eng);
+void RegisterObjCAtSyncChecker(ExprEngine &Eng);
+void RegisterPointerArithChecker(ExprEngine &Eng);
+void RegisterPointerSubChecker(ExprEngine &Eng);
+void RegisterReturnPointerRangeChecker(ExprEngine &Eng);
+void RegisterReturnUndefChecker(ExprEngine &Eng);
+void RegisterStackAddrLeakChecker(ExprEngine &Eng);
+void RegisterUndefBranchChecker(ExprEngine &Eng);
+void RegisterUndefCapturedBlockVarChecker(ExprEngine &Eng);
+void RegisterUndefResultChecker(ExprEngine &Eng);
+void RegisterUndefinedArraySubscriptChecker(ExprEngine &Eng);
+void RegisterUndefinedAssignmentChecker(ExprEngine &Eng);
+void RegisterVLASizeChecker(ExprEngine &Eng);
+
+// API checks.
+void RegisterMacOSXAPIChecker(ExprEngine &Eng);
+void RegisterOSAtomicChecker(ExprEngine &Eng);
+void RegisterUnixAPIChecker(ExprEngine &Eng);
+
+} // end GR namespace
+
+} // end clang namespace
+
+#endif
diff --git a/clang/lib/GR/Checkers/FixedAddressChecker.cpp b/clang/lib/GR/Checkers/FixedAddressChecker.cpp
index 4c7086f4f1e..d7caad17dab 100644
--- a/clang/lib/GR/Checkers/FixedAddressChecker.cpp
+++ b/clang/lib/GR/Checkers/FixedAddressChecker.cpp
@@ -13,7 +13,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "GRExprEngineInternalChecks.h"
+#include "ExprEngineInternalChecks.h"
 #include "clang/GR/BugReporter/BugType.h"
 #include "clang/GR/PathSensitive/CheckerVisitor.h"
 
@@ -67,6 +67,6 @@ void FixedAddressChecker::PreVisitBinaryOperator(CheckerContext &C,
   }
 }
 
-void GR::RegisterFixedAddressChecker(GRExprEngine &Eng) {
+void GR::RegisterFixedAddressChecker(ExprEngine &Eng) {
   Eng.registerCheck(new FixedAddressChecker());
 }
diff --git a/clang/lib/GR/Checkers/GRExprEngineExperimentalChecks.h b/clang/lib/GR/Checkers/GRExprEngineExperimentalChecks.h
deleted file mode 100644
index 54a61256590..00000000000
--- a/clang/lib/GR/Checkers/GRExprEngineExperimentalChecks.h
+++ /dev/null
@@ -1,37 +0,0 @@
-//=-- GRExprEngineExperimentalChecks.h ------------------------------*- C++ -*-=
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-//  This file defines functions to instantiate and register experimental
-//  checks in GRExprEngine.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_GR_GREXPRENGINE_EXPERIMENTAL_CHECKS
-#define LLVM_CLANG_GR_GREXPRENGINE_EXPERIMENTAL_CHECKS
-
-namespace clang {
-
-namespace GR {
-
-class GRExprEngine;
-
-void RegisterAnalyzerStatsChecker(GRExprEngine &Eng);
-void RegisterChrootChecker(GRExprEngine &Eng);
-void RegisterCStringChecker(GRExprEngine &Eng);
-void RegisterIdempotentOperationChecker(GRExprEngine &Eng);
-void RegisterMallocChecker(GRExprEngine &Eng);
-void RegisterPthreadLockChecker(GRExprEngine &Eng);
-void RegisterStreamChecker(GRExprEngine &Eng);
-void RegisterUnreachableCodeChecker(GRExprEngine &Eng);
-
-} // end GR namespace
-
-} // end clang namespace
-
-#endif
diff --git a/clang/lib/GR/Checkers/GRExprEngineInternalChecks.h b/clang/lib/GR/Checkers/GRExprEngineInternalChecks.h
deleted file mode 100644
index cba419a9b60..00000000000
--- a/clang/lib/GR/Checkers/GRExprEngineInternalChecks.h
+++ /dev/null
@@ -1,58 +0,0 @@
-//=-- GRExprEngineInternalChecks.h- Builtin GRExprEngine Checks -----*- C++ -*-=
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-//  This file defines functions to instantiate and register the "built-in"
-//  checks in GRExprEngine.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_GR_GREXPRENGINE_INTERNAL_CHECKS
-#define LLVM_CLANG_GR_GREXPRENGINE_INTERNAL_CHECKS
-
-namespace clang {
-
-namespace GR {
-
-class GRExprEngine;
-
-// Foundational checks that handle basic semantics.
-void RegisterAdjustedReturnValueChecker(GRExprEngine &Eng);
-void RegisterArrayBoundChecker(GRExprEngine &Eng);
-void RegisterAttrNonNullChecker(GRExprEngine &Eng);
-void RegisterBuiltinFunctionChecker(GRExprEngine &Eng);
-void RegisterCallAndMessageChecker(GRExprEngine &Eng);
-void RegisterCastToStructChecker(GRExprEngine &Eng);
-void RegisterCastSizeChecker(GRExprEngine &Eng);
-void RegisterDereferenceChecker(GRExprEngine &Eng);
-void RegisterDivZeroChecker(GRExprEngine &Eng);
-void RegisterFixedAddressChecker(GRExprEngine &Eng);
-void RegisterNoReturnFunctionChecker(GRExprEngine &Eng);
-void RegisterObjCAtSyncChecker(GRExprEngine &Eng);
-void RegisterPointerArithChecker(GRExprEngine &Eng);
-void RegisterPointerSubChecker(GRExprEngine &Eng);
-void RegisterReturnPointerRangeChecker(GRExprEngine &Eng);
-void RegisterReturnUndefChecker(GRExprEngine &Eng);
-void RegisterStackAddrLeakChecker(GRExprEngine &Eng);
-void RegisterUndefBranchChecker(GRExprEngine &Eng);
-void RegisterUndefCapturedBlockVarChecker(GRExprEngine &Eng);
-void RegisterUndefResultChecker(GRExprEngine &Eng);
-void RegisterUndefinedArraySubscriptChecker(GRExprEngine &Eng);
-void RegisterUndefinedAssignmentChecker(GRExprEngine &Eng);
-void RegisterVLASizeChecker(GRExprEngine &Eng);
-
-// API checks.
-void RegisterMacOSXAPIChecker(GRExprEngine &Eng);
-void RegisterOSAtomicChecker(GRExprEngine &Eng);
-void RegisterUnixAPIChecker(GRExprEngine &Eng);
-
-} // end GR namespace
-
-} // end clang namespace
-
-#endif
diff --git a/clang/lib/GR/Checkers/IdempotentOperationChecker.cpp b/clang/lib/GR/Checkers/IdempotentOperationChecker.cpp
index b28edc3b12d..15e9be95804 100644
--- a/clang/lib/GR/Checkers/IdempotentOperationChecker.cpp
+++ b/clang/lib/GR/Checkers/IdempotentOperationChecker.cpp
@@ -42,14 +42,14 @@
 // - Finer grained false positive control (levels)
 // - Handling ~0 values
 
-#include "GRExprEngineExperimentalChecks.h"
+#include "ExprEngineExperimentalChecks.h"
 #include "clang/Analysis/CFGStmtMap.h"
 #include "clang/Analysis/Analyses/PseudoConstantAnalysis.h"
 #include "clang/GR/BugReporter/BugReporter.h"
 #include "clang/GR/BugReporter/BugType.h"
 #include "clang/GR/PathSensitive/CheckerHelpers.h"
 #include "clang/GR/PathSensitive/CheckerVisitor.h"
-#include "clang/GR/PathSensitive/GRCoreEngine.h"
+#include "clang/GR/PathSensitive/CoreEngine.h"
 #include "clang/GR/PathSensitive/SVals.h"
 #include "clang/AST/Stmt.h"
 #include "llvm/ADT/DenseMap.h"
@@ -67,7 +67,7 @@ public:
   static void *getTag();
   void PreVisitBinaryOperator(CheckerContext &C, const BinaryOperator *B);
   void PostVisitBinaryOperator(CheckerContext &C, const BinaryOperator *B);
-  void VisitEndAnalysis(ExplodedGraph &G, BugReporter &B, GRExprEngine &Eng);
+  void VisitEndAnalysis(ExplodedGraph &G, BugReporter &B, ExprEngine &Eng);
 
 private:
   // Our assumption about a particular operation.
@@ -84,7 +84,7 @@ private:
   bool PathWasCompletelyAnalyzed(const CFG *C,
                                  const CFGBlock *CB,
                                  const CFGStmtMap *CBM,
-                                 const GRCoreEngine &CE);
+                                 const CoreEngine &CE);
   static bool CanVary(const Expr *Ex,
                       AnalysisContext *AC);
   static bool isConstantOrPseudoConstant(const DeclRefExpr *DR,
@@ -130,7 +130,7 @@ void *IdempotentOperationChecker::getTag() {
   return &x;
 }
 
-void GR::RegisterIdempotentOperationChecker(GRExprEngine &Eng) {
+void GR::RegisterIdempotentOperationChecker(ExprEngine &Eng) {
   Eng.registerCheck(new IdempotentOperationChecker());
 }
 
@@ -364,7 +364,7 @@ void IdempotentOperationChecker::PostVisitBinaryOperator(
 
 void IdempotentOperationChecker::VisitEndAnalysis(ExplodedGraph &G,
                                                   BugReporter &BR,
-                                                  GRExprEngine &Eng) {
+                                                  ExprEngine &Eng) {
   BugType *BT = new BugType("Idempotent operation", "Dead code");
   // Iterate over the hash to see if we have any paths with definite
   // idempotent operations.
@@ -553,9 +553,9 @@ bool IdempotentOperationChecker::PathWasCompletelyAnalyzed(
                                                        const CFG *C,
                                                        const CFGBlock *CB,
                                                        const CFGStmtMap *CBM,
-                                                       const GRCoreEngine &CE) {
+                                                       const CoreEngine &CE) {
   // Test for reachability from any aborted blocks to this block
-  typedef GRCoreEngine::BlocksAborted::const_iterator AbortedIterator;
+  typedef CoreEngine::BlocksAborted::const_iterator AbortedIterator;
   for (AbortedIterator I = CE.blocks_aborted_begin(),
       E = CE.blocks_aborted_end(); I != E; ++I) {
     const BlockEdge &BE =  I->first;
@@ -569,7 +569,7 @@ bool IdempotentOperationChecker::PathWasCompletelyAnalyzed(
   
   // For the items still on the worklist, see if they are in blocks that
   // can eventually reach 'CB'.
-  class VisitWL : public GRWorkList::Visitor {
+  class VisitWL : public WorkList::Visitor {
     const CFGStmtMap *CBM;
     const CFGBlock *TargetBlock;
     CFGReachabilityAnalysis &CRA;
@@ -577,7 +577,7 @@ bool IdempotentOperationChecker::PathWasCompletelyAnalyzed(
     VisitWL(const CFGStmtMap *cbm, const CFGBlock *targetBlock,
             CFGReachabilityAnalysis &cra)
       : CBM(cbm), TargetBlock(targetBlock), CRA(cra) {}
-    virtual bool Visit(const GRWorkListUnit &U) {
+    virtual bool Visit(const WorkListUnit &U) {
       ProgramPoint P = U.getNode()->getLocation();
       const CFGBlock *B = 0;
       if (StmtPoint *SP = dyn_cast<StmtPoint>(&P)) {
diff --git a/clang/lib/GR/Checkers/MacOSXAPIChecker.cpp b/clang/lib/GR/Checkers/MacOSXAPIChecker.cpp
index 316e37a40f4..d7728713f88 100644
--- a/clang/lib/GR/Checkers/MacOSXAPIChecker.cpp
+++ b/clang/lib/GR/Checkers/MacOSXAPIChecker.cpp
@@ -15,7 +15,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "GRExprEngineInternalChecks.h"
+#include "ExprEngineInternalChecks.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/GR/BugReporter/BugType.h"
 #include "clang/GR/PathSensitive/CheckerVisitor.h"
@@ -45,7 +45,7 @@ public:
 };
 } //end anonymous namespace
 
-void GR::RegisterMacOSXAPIChecker(GRExprEngine &Eng) {
+void GR::RegisterMacOSXAPIChecker(ExprEngine &Eng) {
   if (Eng.getContext().Target.getTriple().getVendor() == llvm::Triple::Apple)
     Eng.registerCheck(new MacOSXAPIChecker());
 }
diff --git a/clang/lib/GR/Checkers/MallocChecker.cpp b/clang/lib/GR/Checkers/MallocChecker.cpp
index cd5f636e961..bbfc7b076d3 100644
--- a/clang/lib/GR/Checkers/MallocChecker.cpp
+++ b/clang/lib/GR/Checkers/MallocChecker.cpp
@@ -12,7 +12,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "GRExprEngineExperimentalChecks.h"
+#include "ExprEngineExperimentalChecks.h"
 #include "clang/GR/BugReporter/BugType.h"
 #include "clang/GR/PathSensitive/CheckerVisitor.h"
 #include "clang/GR/PathSensitive/GRState.h"
@@ -78,7 +78,7 @@ public:
   static void *getTag();
   bool evalCallExpr(CheckerContext &C, const CallExpr *CE);
   void evalDeadSymbols(CheckerContext &C, SymbolReaper &SymReaper);
-  void evalEndPath(GREndPathNodeBuilder &B, void *tag, GRExprEngine &Eng);
+  void evalEndPath(EndPathNodeBuilder &B, void *tag, ExprEngine &Eng);
   void PreVisitReturnStmt(CheckerContext &C, const ReturnStmt *S);
   const GRState *evalAssume(const GRState *state, SVal Cond, bool Assumption,
                             bool *respondsToCallback);
@@ -126,7 +126,7 @@ namespace GR {
 }
 }
 
-void GR::RegisterMallocChecker(GRExprEngine &Eng) {
+void GR::RegisterMallocChecker(ExprEngine &Eng) {
   Eng.registerCheck(new MallocChecker());
 }
 
@@ -593,8 +593,8 @@ void MallocChecker::evalDeadSymbols(CheckerContext &C, SymbolReaper &SymReaper)
   C.generateNode(state->set<RegionState>(RS));
 }
 
-void MallocChecker::evalEndPath(GREndPathNodeBuilder &B, void *tag,
-                                GRExprEngine &Eng) {
+void MallocChecker::evalEndPath(EndPathNodeBuilder &B, void *tag,
+                                ExprEngine &Eng) {
   SaveAndRestore<bool> OldHasGen(B.HasGeneratedNode);
   const GRState *state = B.getState();
   RegionStateTy M = state->get<RegionState>();
diff --git a/clang/lib/GR/Checkers/NSAutoreleasePoolChecker.cpp b/clang/lib/GR/Checkers/NSAutoreleasePoolChecker.cpp
index d6701c7142c..beb4a81743b 100644
--- a/clang/lib/GR/Checkers/NSAutoreleasePoolChecker.cpp
+++ b/clang/lib/GR/Checkers/NSAutoreleasePoolChecker.cpp
@@ -16,7 +16,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "clang/GR/BugReporter/BugReporter.h"
-#include "clang/GR/PathSensitive/GRExprEngine.h"
+#include "clang/GR/PathSensitive/ExprEngine.h"
 #include "clang/GR/PathSensitive/CheckerVisitor.h"
 #include "BasicObjCFoundationChecks.h"
 #include "clang/AST/DeclObjC.h"
@@ -45,7 +45,7 @@ public:
 } // end anonymous namespace
 
 
-void GR::RegisterNSAutoreleasePoolChecks(GRExprEngine &Eng) {
+void GR::RegisterNSAutoreleasePoolChecks(ExprEngine &Eng) {
   ASTContext &Ctx = Eng.getContext();
   if (Ctx.getLangOptions().getGCMode() != LangOptions::NonGC) {    
     Eng.registerCheck(new NSAutoreleasePoolChecker(GetNullarySelector("release",
diff --git a/clang/lib/GR/Checkers/NSErrorChecker.cpp b/clang/lib/GR/Checkers/NSErrorChecker.cpp
index 44715bf9f94..3cfb044d6f8 100644
--- a/clang/lib/GR/Checkers/NSErrorChecker.cpp
+++ b/clang/lib/GR/Checkers/NSErrorChecker.cpp
@@ -17,7 +17,7 @@
 
 #include "clang/GR/Checkers/LocalCheckers.h"
 #include "clang/GR/BugReporter/BugType.h"
-#include "clang/GR/PathSensitive/GRExprEngine.h"
+#include "clang/GR/PathSensitive/ExprEngine.h"
 #include "clang/GR/Checkers/DereferenceChecker.h"
 #include "BasicObjCFoundationChecks.h"
 #include "clang/AST/DeclObjC.h"
@@ -32,7 +32,7 @@ class NSErrorChecker : public BugType {
   const Decl &CodeDecl;
   const bool isNSErrorWarning;
   IdentifierInfo * const II;
-  GRExprEngine &Eng;
+  ExprEngine &Eng;
 
   void CheckSignature(const ObjCMethodDecl& MD, QualType& ResultTy,
                       llvm::SmallVectorImpl<VarDecl*>& ErrorParams);
@@ -49,7 +49,7 @@ class NSErrorChecker : public BugType {
   void EmitRetTyWarning(BugReporter& BR, const Decl& CodeDecl);
 
 public:
-  NSErrorChecker(const Decl &D, bool isNSError, GRExprEngine& eng)
+  NSErrorChecker(const Decl &D, bool isNSError, ExprEngine& eng)
     : BugType(isNSError ? "NSError** null dereference"
                         : "CFErrorRef* null dereference",
               "Coding conventions (Apple)"),
@@ -63,7 +63,7 @@ public:
 
 } // end anonymous namespace
 
-void GR::RegisterNSErrorChecks(BugReporter& BR, GRExprEngine &Eng,
+void GR::RegisterNSErrorChecks(BugReporter& BR, ExprEngine &Eng,
                                   const Decl &D) {
   BR.Register(new NSErrorChecker(D, true, Eng));
   BR.Register(new NSErrorChecker(D, false, Eng));
diff --git a/clang/lib/GR/Checkers/NoReturnFunctionChecker.cpp b/clang/lib/GR/Checkers/NoReturnFunctionChecker.cpp
index 739460f781d..f6d33dbda8d 100644
--- a/clang/lib/GR/Checkers/NoReturnFunctionChecker.cpp
+++ b/clang/lib/GR/Checkers/NoReturnFunctionChecker.cpp
@@ -12,7 +12,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "GRExprEngineInternalChecks.h"
+#include "ExprEngineInternalChecks.h"
 #include "clang/GR/PathSensitive/CheckerVisitor.h"
 #include "llvm/ADT/StringSwitch.h"
 
@@ -29,7 +29,7 @@ public:
 
 }
 
-void GR::RegisterNoReturnFunctionChecker(GRExprEngine &Eng) {
+void GR::RegisterNoReturnFunctionChecker(ExprEngine &Eng) {
   Eng.registerCheck(new NoReturnFunctionChecker());
 }
 
diff --git a/clang/lib/GR/Checkers/OSAtomicChecker.cpp b/clang/lib/GR/Checkers/OSAtomicChecker.cpp
index 7df7a9eec04..c27e50880e1 100644
--- a/clang/lib/GR/Checkers/OSAtomicChecker.cpp
+++ b/clang/lib/GR/Checkers/OSAtomicChecker.cpp
@@ -11,7 +11,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "GRExprEngineInternalChecks.h"
+#include "ExprEngineInternalChecks.h"
 #include "clang/GR/PathSensitive/Checker.h"
 #include "clang/Basic/Builtins.h"
 
@@ -31,7 +31,7 @@ private:
 
 }
 
-void GR::RegisterOSAtomicChecker(GRExprEngine &Eng) {
+void GR::RegisterOSAtomicChecker(ExprEngine &Eng) {
   Eng.registerCheck(new OSAtomicChecker());
 }
 
@@ -97,7 +97,7 @@ bool OSAtomicChecker::evalOSAtomicCompareAndSwap(CheckerContext &C,
   const void *OSAtomicStoreTag = &magic_store;
 
   // Load 'theValue'.
-  GRExprEngine &Engine = C.getEngine();
+  ExprEngine &Engine = C.getEngine();
   const GRState *state = C.getState();
   ExplodedNodeSet Tmp;
   SVal location = state->getSVal(theValueExpr);
diff --git a/clang/lib/GR/Checkers/ObjCAtSyncChecker.cpp b/clang/lib/GR/Checkers/ObjCAtSyncChecker.cpp
index a3938627b1f..40619a2a853 100644
--- a/clang/lib/GR/Checkers/ObjCAtSyncChecker.cpp
+++ b/clang/lib/GR/Checkers/ObjCAtSyncChecker.cpp
@@ -12,11 +12,11 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "GRExprEngineInternalChecks.h"
+#include "ExprEngineInternalChecks.h"
 #include "clang/GR/BugReporter/BugType.h"
 #include "clang/GR/Checkers/DereferenceChecker.h"
 #include "clang/GR/PathSensitive/CheckerVisitor.h"
-#include "clang/GR/PathSensitive/GRExprEngine.h"
+#include "clang/GR/PathSensitive/ExprEngine.h"
 
 using namespace clang;
 using namespace GR;
@@ -33,7 +33,7 @@ public:
 };
 } // end anonymous namespace
 
-void GR::RegisterObjCAtSyncChecker(GRExprEngine &Eng) {
+void GR::RegisterObjCAtSyncChecker(ExprEngine &Eng) {
   // @synchronized is an Objective-C 2 feature.
   if (Eng.getContext().getLangOptions().ObjC2)
     Eng.registerCheck(new ObjCAtSyncChecker());
diff --git a/clang/lib/GR/Checkers/PointerArithChecker.cpp b/clang/lib/GR/Checkers/PointerArithChecker.cpp
index 485144a1421..1f870052c16 100644
--- a/clang/lib/GR/Checkers/PointerArithChecker.cpp
+++ b/clang/lib/GR/Checkers/PointerArithChecker.cpp
@@ -12,7 +12,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "GRExprEngineInternalChecks.h"
+#include "ExprEngineInternalChecks.h"
 #include "clang/GR/BugReporter/BugType.h"
 #include "clang/GR/PathSensitive/CheckerVisitor.h"
 
@@ -67,6 +67,6 @@ void PointerArithChecker::PreVisitBinaryOperator(CheckerContext &C,
   }
 }
 
-void GR::RegisterPointerArithChecker(GRExprEngine &Eng) {
+void GR::RegisterPointerArithChecker(ExprEngine &Eng) {
   Eng.registerCheck(new PointerArithChecker());
 }
diff --git a/clang/lib/GR/Checkers/PointerSubChecker.cpp b/clang/lib/GR/Checkers/PointerSubChecker.cpp
index 44e3d9f0090..57ab31803ce 100644
--- a/clang/lib/GR/Checkers/PointerSubChecker.cpp
+++ b/clang/lib/GR/Checkers/PointerSubChecker.cpp
@@ -13,7 +13,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "GRExprEngineInternalChecks.h"
+#include "ExprEngineInternalChecks.h"
 #include "clang/GR/BugReporter/BugType.h"
 #include "clang/GR/PathSensitive/CheckerVisitor.h"
 
@@ -74,6 +74,6 @@ void PointerSubChecker::PreVisitBinaryOperator(CheckerContext &C,
   }
 }
 
-void GR::RegisterPointerSubChecker(GRExprEngine &Eng) {
+void GR::RegisterPointerSubChecker(ExprEngine &Eng) {
   Eng.registerCheck(new PointerSubChecker());
 }
diff --git a/clang/lib/GR/Checkers/PthreadLockChecker.cpp b/clang/lib/GR/Checkers/PthreadLockChecker.cpp
index d880b066bc8..ae58b78fb8a 100644
--- a/clang/lib/GR/Checkers/PthreadLockChecker.cpp
+++ b/clang/lib/GR/Checkers/PthreadLockChecker.cpp
@@ -8,14 +8,14 @@
 //===----------------------------------------------------------------------===//
 //
 // This defines PthreadLockChecker, a simple lock -> unlock checker.  Eventually
-// this shouldn't be registered with GRExprEngineInternalChecks.
+// this shouldn't be registered with ExprEngineInternalChecks.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/GR/PathSensitive/CheckerVisitor.h"
 #include "clang/GR/BugReporter/BugReporter.h"
 #include "clang/GR/PathSensitive/GRStateTrait.h"
-#include "GRExprEngineExperimentalChecks.h"
+#include "ExprEngineExperimentalChecks.h"
 #include "llvm/ADT/ImmutableSet.h"
 
 using namespace clang;
@@ -53,7 +53,7 @@ template <> struct GRStateTrait<LockSet> :
 } // end GR namespace
 } // end clang namespace
 
-void GR::RegisterPthreadLockChecker(GRExprEngine &Eng) {
+void GR::RegisterPthreadLockChecker(ExprEngine &Eng) {
   Eng.registerCheck(new PthreadLockChecker());
 }
 
diff --git a/clang/lib/GR/Checkers/ReturnPointerRangeChecker.cpp b/clang/lib/GR/Checkers/ReturnPointerRangeChecker.cpp
index 98b4ea544d7..4ef5737f354 100644
--- a/clang/lib/GR/Checkers/ReturnPointerRangeChecker.cpp
+++ b/clang/lib/GR/Checkers/ReturnPointerRangeChecker.cpp
@@ -12,10 +12,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "GRExprEngineInternalChecks.h"
+#include "ExprEngineInternalChecks.h"
 #include "clang/GR/BugReporter/BugType.h"
 #include "clang/GR/PathSensitive/CheckerVisitor.h"
-#include "clang/GR/PathSensitive/GRExprEngine.h"
+#include "clang/GR/PathSensitive/ExprEngine.h"
 
 using namespace clang;
 using namespace GR;
@@ -31,7 +31,7 @@ public:
 };
 }
 
-void GR::RegisterReturnPointerRangeChecker(GRExprEngine &Eng) {
+void GR::RegisterReturnPointerRangeChecker(ExprEngine &Eng) {
   Eng.registerCheck(new ReturnPointerRangeChecker());
 }
 
diff --git a/clang/lib/GR/Checkers/ReturnUndefChecker.cpp b/clang/lib/GR/Checkers/ReturnUndefChecker.cpp
index addae5b1c01..2a1027a9301 100644
--- a/clang/lib/GR/Checkers/ReturnUndefChecker.cpp
+++ b/clang/lib/GR/Checkers/ReturnUndefChecker.cpp
@@ -13,10 +13,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "GRExprEngineInternalChecks.h"
+#include "ExprEngineInternalChecks.h"
 #include "clang/GR/BugReporter/BugType.h"
 #include "clang/GR/PathSensitive/CheckerVisitor.h"
-#include "clang/GR/PathSensitive/GRExprEngine.h"
+#include "clang/GR/PathSensitive/ExprEngine.h"
 
 using namespace clang;
 using namespace GR;
@@ -32,7 +32,7 @@ public:
 };
 }
 
-void GR::RegisterReturnUndefChecker(GRExprEngine &Eng) {
+void GR::RegisterReturnUndefChecker(ExprEngine &Eng) {
   Eng.registerCheck(new ReturnUndefChecker());
 }
 
diff --git a/clang/lib/GR/Checkers/StackAddrLeakChecker.cpp b/clang/lib/GR/Checkers/StackAddrLeakChecker.cpp
index 87f5819cf7e..3ef78a46fb1 100644
--- a/clang/lib/GR/Checkers/StackAddrLeakChecker.cpp
+++ b/clang/lib/GR/Checkers/StackAddrLeakChecker.cpp
@@ -12,7 +12,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "GRExprEngineInternalChecks.h"
+#include "ExprEngineInternalChecks.h"
 #include "clang/GR/BugReporter/BugType.h"
 #include "clang/GR/PathSensitive/CheckerVisitor.h"
 #include "clang/GR/PathSensitive/GRState.h"
@@ -33,7 +33,7 @@ public:
     return &x;
   }
   void PreVisitReturnStmt(CheckerContext &C, const ReturnStmt *RS);
-  void evalEndPath(GREndPathNodeBuilder &B, void *tag, GRExprEngine &Eng);
+  void evalEndPath(EndPathNodeBuilder &B, void *tag, ExprEngine &Eng);
 private:
   void EmitStackError(CheckerContext &C, const MemRegion *R, const Expr *RetE);
   SourceRange GenName(llvm::raw_ostream &os, const MemRegion *R,
@@ -41,7 +41,7 @@ private:
 };
 }
 
-void GR::RegisterStackAddrLeakChecker(GRExprEngine &Eng) {
+void GR::RegisterStackAddrLeakChecker(ExprEngine &Eng) {
   Eng.registerCheck(new StackAddrLeakChecker());
 }
 
@@ -130,8 +130,8 @@ void StackAddrLeakChecker::PreVisitReturnStmt(CheckerContext &C,
   }
 }
 
-void StackAddrLeakChecker::evalEndPath(GREndPathNodeBuilder &B, void *tag,
-                                       GRExprEngine &Eng) {
+void StackAddrLeakChecker::evalEndPath(EndPathNodeBuilder &B, void *tag,
+                                       ExprEngine &Eng) {
   SaveAndRestore<bool> OldHasGen(B.HasGeneratedNode);
   const GRState *state = B.getState();
 
diff --git a/clang/lib/GR/Checkers/StreamChecker.cpp b/clang/lib/GR/Checkers/StreamChecker.cpp
index 01186b52dfc..73c2920ad94 100644
--- a/clang/lib/GR/Checkers/StreamChecker.cpp
+++ b/clang/lib/GR/Checkers/StreamChecker.cpp
@@ -11,7 +11,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "GRExprEngineExperimentalChecks.h"
+#include "ExprEngineExperimentalChecks.h"
 #include "clang/GR/BugReporter/BugType.h"
 #include "clang/GR/PathSensitive/CheckerVisitor.h"
 #include "clang/GR/PathSensitive/GRState.h"
@@ -75,7 +75,7 @@ public:
 
   virtual bool evalCallExpr(CheckerContext &C, const CallExpr *CE);
   void evalDeadSymbols(CheckerContext &C, SymbolReaper &SymReaper);
-  void evalEndPath(GREndPathNodeBuilder &B, void *tag, GRExprEngine &Eng);
+  void evalEndPath(EndPathNodeBuilder &B, void *tag, ExprEngine &Eng);
   void PreVisitReturnStmt(CheckerContext &C, const ReturnStmt *S);
 
 private:
@@ -114,7 +114,7 @@ namespace GR {
 }
 }
 
-void GR::RegisterStreamChecker(GRExprEngine &Eng) {
+void GR::RegisterStreamChecker(ExprEngine &Eng) {
   Eng.registerCheck(new StreamChecker());
 }
 
@@ -421,8 +421,8 @@ void StreamChecker::evalDeadSymbols(CheckerContext &C,SymbolReaper &SymReaper) {
   }
 }
 
-void StreamChecker::evalEndPath(GREndPathNodeBuilder &B, void *tag,
-                                GRExprEngine &Eng) {
+void StreamChecker::evalEndPath(EndPathNodeBuilder &B, void *tag,
+                                ExprEngine &Eng) {
   SaveAndRestore<bool> OldHasGen(B.HasGeneratedNode);
   const GRState *state = B.getState();
   typedef llvm::ImmutableMap<SymbolRef, StreamState> SymMap;
diff --git a/clang/lib/GR/Checkers/UndefBranchChecker.cpp b/clang/lib/GR/Checkers/UndefBranchChecker.cpp
index fa3dfa59351..e999d8bc132 100644
--- a/clang/lib/GR/Checkers/UndefBranchChecker.cpp
+++ b/clang/lib/GR/Checkers/UndefBranchChecker.cpp
@@ -12,7 +12,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "GRExprEngineInternalChecks.h"
+#include "ExprEngineInternalChecks.h"
 #include "clang/GR/BugReporter/BugType.h"
 #include "clang/GR/PathSensitive/Checker.h"
 
@@ -50,13 +50,13 @@ class UndefBranchChecker : public Checker {
 public:
   UndefBranchChecker() : BT(0) {}
   static void *getTag();
-  void VisitBranchCondition(GRBranchNodeBuilder &Builder, GRExprEngine &Eng,
+  void VisitBranchCondition(BranchNodeBuilder &Builder, ExprEngine &Eng,
                             const Stmt *Condition, void *tag);
 };
 
 }
 
-void GR::RegisterUndefBranchChecker(GRExprEngine &Eng) {
+void GR::RegisterUndefBranchChecker(ExprEngine &Eng) {
   Eng.registerCheck(new UndefBranchChecker());
 }
 
@@ -65,8 +65,8 @@ void *UndefBranchChecker::getTag() {
   return &x;
 }
 
-void UndefBranchChecker::VisitBranchCondition(GRBranchNodeBuilder &Builder, 
-                                              GRExprEngine &Eng,
+void UndefBranchChecker::VisitBranchCondition(BranchNodeBuilder &Builder, 
+                                              ExprEngine &Eng,
                                               const Stmt *Condition, void *tag){
   const GRState *state = Builder.getState();
   SVal X = state->getSVal(Condition);
diff --git a/clang/lib/GR/Checkers/UndefCapturedBlockVarChecker.cpp b/clang/lib/GR/Checkers/UndefCapturedBlockVarChecker.cpp
index 8a1c285c173..2b45c95843e 100644
--- a/clang/lib/GR/Checkers/UndefCapturedBlockVarChecker.cpp
+++ b/clang/lib/GR/Checkers/UndefCapturedBlockVarChecker.cpp
@@ -11,9 +11,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "GRExprEngineInternalChecks.h"
+#include "ExprEngineInternalChecks.h"
 #include "clang/GR/PathSensitive/CheckerVisitor.h"
-#include "clang/GR/PathSensitive/GRExprEngine.h"
+#include "clang/GR/PathSensitive/ExprEngine.h"
 #include "clang/GR/BugReporter/BugType.h"
 #include "llvm/Support/raw_ostream.h"
 
@@ -32,7 +32,7 @@ public:
 };
 } // end anonymous namespace
 
-void GR::RegisterUndefCapturedBlockVarChecker(GRExprEngine &Eng) {
+void GR::RegisterUndefCapturedBlockVarChecker(ExprEngine &Eng) {
   Eng.registerCheck(new UndefCapturedBlockVarChecker());
 }
 
diff --git a/clang/lib/GR/Checkers/UndefResultChecker.cpp b/clang/lib/GR/Checkers/UndefResultChecker.cpp
index f4d30354e83..348573d21c6 100644
--- a/clang/lib/GR/Checkers/UndefResultChecker.cpp
+++ b/clang/lib/GR/Checkers/UndefResultChecker.cpp
@@ -7,15 +7,15 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// This defines UndefResultChecker, a builtin check in GRExprEngine that 
+// This defines UndefResultChecker, a builtin check in ExprEngine that 
 // performs checks for undefined results of non-assignment binary operators.
 //
 //===----------------------------------------------------------------------===//
 
-#include "GRExprEngineInternalChecks.h"
+#include "ExprEngineInternalChecks.h"
 #include "clang/GR/BugReporter/BugType.h"
 #include "clang/GR/PathSensitive/CheckerVisitor.h"
-#include "clang/GR/PathSensitive/GRExprEngine.h"
+#include "clang/GR/PathSensitive/ExprEngine.h"
 
 using namespace clang;
 using namespace GR;
@@ -33,7 +33,7 @@ public:
 };
 } // end anonymous namespace
 
-void GR::RegisterUndefResultChecker(GRExprEngine &Eng) {
+void GR::RegisterUndefResultChecker(ExprEngine &Eng) {
   Eng.registerCheck(new UndefResultChecker());
 }
 
diff --git a/clang/lib/GR/Checkers/UndefinedArraySubscriptChecker.cpp b/clang/lib/GR/Checkers/UndefinedArraySubscriptChecker.cpp
index 8946de39981..0a3cee43a12 100644
--- a/clang/lib/GR/Checkers/UndefinedArraySubscriptChecker.cpp
+++ b/clang/lib/GR/Checkers/UndefinedArraySubscriptChecker.cpp
@@ -7,12 +7,12 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// This defines UndefinedArraySubscriptChecker, a builtin check in GRExprEngine
+// This defines UndefinedArraySubscriptChecker, a builtin check in ExprEngine
 // that performs checks for undefined array subscripts.
 //
 //===----------------------------------------------------------------------===//
 
-#include "GRExprEngineInternalChecks.h"
+#include "ExprEngineInternalChecks.h"
 #include "clang/GR/BugReporter/BugType.h"
 #include "clang/GR/PathSensitive/CheckerVisitor.h"
 
@@ -34,7 +34,7 @@ public:
 };
 } // end anonymous namespace
 
-void GR::RegisterUndefinedArraySubscriptChecker(GRExprEngine &Eng) {
+void GR::RegisterUndefinedArraySubscriptChecker(ExprEngine &Eng) {
   Eng.registerCheck(new UndefinedArraySubscriptChecker());
 }
 
diff --git a/clang/lib/GR/Checkers/UndefinedAssignmentChecker.cpp b/clang/lib/GR/Checkers/UndefinedAssignmentChecker.cpp
index b1eb38704bc..fa43350da8f 100644
--- a/clang/lib/GR/Checkers/UndefinedAssignmentChecker.cpp
+++ b/clang/lib/GR/Checkers/UndefinedAssignmentChecker.cpp
@@ -7,12 +7,12 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// This defines UndefinedAssginmentChecker, a builtin check in GRExprEngine that
+// This defines UndefinedAssginmentChecker, a builtin check in ExprEngine that
 // checks for assigning undefined values.
 //
 //===----------------------------------------------------------------------===//
 
-#include "GRExprEngineInternalChecks.h"
+#include "ExprEngineInternalChecks.h"
 #include "clang/GR/BugReporter/BugType.h"
 #include "clang/GR/PathSensitive/CheckerVisitor.h"
 
@@ -31,7 +31,7 @@ public:
 };
 }
 
-void GR::RegisterUndefinedAssignmentChecker(GRExprEngine &Eng){
+void GR::RegisterUndefinedAssignmentChecker(ExprEngine &Eng){
   Eng.registerCheck(new UndefinedAssignmentChecker());
 }
 
diff --git a/clang/lib/GR/Checkers/UnixAPIChecker.cpp b/clang/lib/GR/Checkers/UnixAPIChecker.cpp
index f4c75f76ab6..c365e3042dd 100644
--- a/clang/lib/GR/Checkers/UnixAPIChecker.cpp
+++ b/clang/lib/GR/Checkers/UnixAPIChecker.cpp
@@ -12,7 +12,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "GRExprEngineInternalChecks.h"
+#include "ExprEngineInternalChecks.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/GR/BugReporter/BugType.h"
 #include "clang/GR/PathSensitive/CheckerVisitor.h"
@@ -46,7 +46,7 @@ public:
 };
 } //end anonymous namespace
 
-void GR::RegisterUnixAPIChecker(GRExprEngine &Eng) {
+void GR::RegisterUnixAPIChecker(ExprEngine &Eng) {
   Eng.registerCheck(new UnixAPIChecker());
 }
 
@@ -74,7 +74,7 @@ static void CheckOpen(CheckerContext &C, UnixAPIChecker &UC,
     else {
       // FIXME: We need a more general way of getting the O_CREAT value.
       // We could possibly grovel through the preprocessor state, but
-      // that would require passing the Preprocessor object to the GRExprEngine.
+      // that would require passing the Preprocessor object to the ExprEngine.
       return;
     }
   }
diff --git a/clang/lib/GR/Checkers/UnreachableCodeChecker.cpp b/clang/lib/GR/Checkers/UnreachableCodeChecker.cpp
index 0ab97c27d9c..97a2ff56af1 100644
--- a/clang/lib/GR/Checkers/UnreachableCodeChecker.cpp
+++ b/clang/lib/GR/Checkers/UnreachableCodeChecker.cpp
@@ -21,7 +21,7 @@
 #include "clang/GR/PathSensitive/SVals.h"
 #include "clang/GR/PathSensitive/CheckerHelpers.h"
 #include "clang/GR/BugReporter/BugReporter.h"
-#include "GRExprEngineExperimentalChecks.h"
+#include "ExprEngineExperimentalChecks.h"
 #include "llvm/ADT/SmallPtrSet.h"
 
 // The number of CFGBlock pointers we want to reserve memory for. This is used
@@ -37,7 +37,7 @@ public:
   static void *getTag();
   void VisitEndAnalysis(ExplodedGraph &G,
                         BugReporter &B,
-                        GRExprEngine &Eng);
+                        ExprEngine &Eng);
 private:
   static inline const Stmt *getUnreachableStmt(const CFGBlock *CB);
   void FindUnreachableEntryPoints(const CFGBlock *CB);
@@ -54,13 +54,13 @@ void *UnreachableCodeChecker::getTag() {
   return &x;
 }
 
-void GR::RegisterUnreachableCodeChecker(GRExprEngine &Eng) {
+void GR::RegisterUnreachableCodeChecker(ExprEngine &Eng) {
   Eng.registerCheck(new UnreachableCodeChecker());
 }
 
 void UnreachableCodeChecker::VisitEndAnalysis(ExplodedGraph &G,
                                               BugReporter &B,
-                                              GRExprEngine &Eng) {
+                                              ExprEngine &Eng) {
   // Bail out if we didn't cover all paths
   if (Eng.hasWorkRemaining())
     return;
diff --git a/clang/lib/GR/Checkers/VLASizeChecker.cpp b/clang/lib/GR/Checkers/VLASizeChecker.cpp
index d4e9d353398..b2ca2db02f2 100644
--- a/clang/lib/GR/Checkers/VLASizeChecker.cpp
+++ b/clang/lib/GR/Checkers/VLASizeChecker.cpp
@@ -7,18 +7,18 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// This defines VLASizeChecker, a builtin check in GRExprEngine that 
+// This defines VLASizeChecker, a builtin check in ExprEngine that 
 // performs checks for declaration of VLA of undefined or zero size.
 // In addition, VLASizeChecker is responsible for defining the extent
 // of the MemRegion that represents a VLA.
 //
 //===----------------------------------------------------------------------===//
 
-#include "GRExprEngineInternalChecks.h"
+#include "ExprEngineInternalChecks.h"
 #include "clang/AST/CharUnits.h"
 #include "clang/GR/BugReporter/BugType.h"
 #include "clang/GR/PathSensitive/CheckerVisitor.h"
-#include "clang/GR/PathSensitive/GRExprEngine.h"
+#include "clang/GR/PathSensitive/ExprEngine.h"
 
 using namespace clang;
 using namespace GR;
@@ -35,7 +35,7 @@ public:
 };
 } // end anonymous namespace
 
-void GR::RegisterVLASizeChecker(GRExprEngine &Eng) {
+void GR::RegisterVLASizeChecker(ExprEngine &Eng) {
   Eng.registerCheck(new VLASizeChecker());
 }