Index: cfe/trunk/docs/analyzer/DebugChecks.rst
===================================================================
--- cfe/trunk/docs/analyzer/DebugChecks.rst
+++ cfe/trunk/docs/analyzer/DebugChecks.rst
@@ -255,6 +255,23 @@
       clang_analyzer_hashDump(x); // expected-warning{{hashed string for x}}
     }
 
+- ``void clang_analyzer_denote(int, const char *);``
+
+  Denotes symbols with strings. A subsequent call to clang_analyzer_express()
+  will expresses another symbol in terms of these string. Useful for testing
+  relationships between different symbols.
+
+  Example usage::
+
+    void foo(int x) {
+      clang_analyzer_denote(x, "$x");
+      clang_analyzer_express(x + 1); // expected-warning{{$x + 1}}
+    }
+
+- ``void clang_analyzer_express(int);``
+
+  See clang_analyzer_denote().
+
 Statistics
 ==========
 
Index: cfe/trunk/lib/StaticAnalyzer/Checkers/ExprInspectionChecker.cpp
===================================================================
--- cfe/trunk/lib/StaticAnalyzer/Checkers/ExprInspectionChecker.cpp
+++ cfe/trunk/lib/StaticAnalyzer/Checkers/ExprInspectionChecker.cpp
@@ -43,6 +43,8 @@
   void analyzerPrintState(const CallExpr *CE, CheckerContext &C) const;
   void analyzerGetExtent(const CallExpr *CE, CheckerContext &C) const;
   void analyzerHashDump(const CallExpr *CE, CheckerContext &C) const;
+  void analyzerDenote(const CallExpr *CE, CheckerContext &C) const;
+  void analyzerExpress(const CallExpr *CE, CheckerContext &C) const;
 
   typedef void (ExprInspectionChecker::*FnCheck)(const CallExpr *,
                                                  CheckerContext &C) const;
@@ -60,6 +62,7 @@
 }
 
 REGISTER_SET_WITH_PROGRAMSTATE(MarkedSymbols, SymbolRef)
+REGISTER_MAP_WITH_PROGRAMSTATE(DenotedSymbols, SymbolRef, const StringLiteral *)
 
 bool ExprInspectionChecker::evalCall(const CallExpr *CE,
                                      CheckerContext &C) const {
@@ -82,6 +85,8 @@
     .Case("clang_analyzer_numTimesReached",
           &ExprInspectionChecker::analyzerNumTimesReached)
     .Case("clang_analyzer_hashDump", &ExprInspectionChecker::analyzerHashDump)
+    .Case("clang_analyzer_denote", &ExprInspectionChecker::analyzerDenote)
+    .Case("clang_analyzer_express", &ExprInspectionChecker::analyzerExpress)
     .Default(nullptr);
 
   if (!Handler)
@@ -264,6 +269,13 @@
       N = BugNode;
     State = State->remove<MarkedSymbols>(Sym);
   }
+
+  for (auto I : State->get<DenotedSymbols>()) {
+    SymbolRef Sym = I.first;
+    if (!SymReaper.isLive(Sym))
+      State = State->remove<DenotedSymbols>(Sym);
+  }
+
   C.addTransition(State, N);
 }
 
@@ -295,6 +307,92 @@
   reportBug(HashContent, C);
 }
 
+void ExprInspectionChecker::analyzerDenote(const CallExpr *CE,
+                                           CheckerContext &C) const {
+  if (CE->getNumArgs() < 2) {
+    reportBug("clang_analyzer_denote() requires a symbol and a string literal",
+              C);
+    return;
+  }
+
+  SymbolRef Sym = C.getSVal(CE->getArg(0)).getAsSymbol();
+  if (!Sym) {
+    reportBug("Not a symbol", C);
+    return;
+  }
+
+  if (!isa<SymbolData>(Sym)) {
+    reportBug("Not an atomic symbol", C);
+    return;
+  }
+
+  const auto *E = dyn_cast<StringLiteral>(CE->getArg(1)->IgnoreParenCasts());
+  if (!E) {
+    reportBug("Not a string literal", C);
+    return;
+  }
+
+  ProgramStateRef State = C.getState();
+
+  C.addTransition(C.getState()->set<DenotedSymbols>(Sym, E));
+}
+
+class SymbolExpressor
+    : public SymExprVisitor<SymbolExpressor, Optional<std::string>> {
+  ProgramStateRef State;
+
+public:
+  SymbolExpressor(ProgramStateRef State) : State(State) {}
+
+  Optional<std::string> VisitSymExpr(const SymExpr *S) {
+    if (const StringLiteral *const *SLPtr = State->get<DenotedSymbols>(S)) {
+      const StringLiteral *SL = *SLPtr;
+      return std::string(SL->getBytes());
+    }
+    return None;
+  }
+
+  Optional<std::string> VisitSymIntExpr(const SymIntExpr *S) {
+    if (auto Str = Visit(S->getLHS()))
+      return (*Str + " " + BinaryOperator::getOpcodeStr(S->getOpcode()) + " " +
+              std::to_string(S->getRHS().getLimitedValue()) +
+              (S->getRHS().isUnsigned() ? "U" : ""))
+          .str();
+    return None;
+  }
+
+  Optional<std::string> VisitSymSymExpr(const SymSymExpr *S) {
+    if (auto Str1 = Visit(S->getLHS()))
+      if (auto Str2 = Visit(S->getRHS()))
+        return (*Str1 + " " + BinaryOperator::getOpcodeStr(S->getOpcode()) +
+                " " + *Str2).str();
+    return None;
+  }
+};
+
+void ExprInspectionChecker::analyzerExpress(const CallExpr *CE,
+                                            CheckerContext &C) const {
+  if (CE->getNumArgs() == 0) {
+    reportBug("clang_analyzer_express() requires a symbol", C);
+    return;
+  }
+
+  SymbolRef Sym = C.getSVal(CE->getArg(0)).getAsSymbol();
+  if (!Sym) {
+    reportBug("Not a symbol", C);
+    return;
+  }
+
+  SymbolExpressor V(C.getState());
+  auto Str = V.Visit(Sym);
+  if (!Str) {
+    reportBug("Unable to express", C);
+    return;
+  }
+
+  reportBug(*Str, C);
+}
+
 void ento::registerExprInspectionChecker(CheckerManager &Mgr) {
   Mgr.registerChecker<ExprInspectionChecker>();
 }
Index: cfe/trunk/test/Analysis/expr-inspection.cpp
===================================================================
--- cfe/trunk/test/Analysis/expr-inspection.cpp
+++ cfe/trunk/test/Analysis/expr-inspection.cpp
@@ -0,0 +1,30 @@
+// RUN: %clang_analyze_cc1 -x c++ -analyzer-checker=debug.ExprInspection -verify %s
+
+// Self-tests for the debug.ExprInspection checker.
+
+void clang_analyzer_denote(int x, const char *str);
+void clang_analyzer_express(int x);
+
+// Invalid declarations to test sanity checks.
+void clang_analyzer_denote();
+void clang_analyzer_denote(int x);
+void clang_analyzer_express();
+
+void foo(int x, unsigned y) {
+  clang_analyzer_denote(); // expected-warning{{clang_analyzer_denote() requires a symbol and a string literal}}
+  clang_analyzer_express(); // expected-warning{{clang_analyzer_express() requires a symbol}}
+
+  clang_analyzer_denote(x); // expected-warning{{clang_analyzer_denote() requires a symbol and a string literal}}
+  clang_analyzer_express(x); // expected-warning{{Unable to express}}
+
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  clang_analyzer_express(x + y); // expected-warning{{$x + $y}}
+
+  clang_analyzer_denote(1, "$z");     // expected-warning{{Not a symbol}}
+  clang_analyzer_express(1);     // expected-warning{{Not a symbol}}
+
+  clang_analyzer_denote(x + 1, "$w"); // expected-warning{{Not an atomic symbol}}
+  clang_analyzer_express(x + 1); // expected-warning{{$x + 1}}
+  clang_analyzer_express(y + 1); // expected-warning{{$y + 1U}}
+}
Index: cfe/trunk/test/Analysis/svalbuilder-rearrange-comparisons.c
===================================================================
--- cfe/trunk/test/Analysis/svalbuilder-rearrange-comparisons.c
+++ cfe/trunk/test/Analysis/svalbuilder-rearrange-comparisons.c
@@ -1,10 +1,8 @@
 // RUN: %clang_analyze_cc1 -analyzer-checker=debug.ExprInspection,core.builtin -analyzer-config aggressive-binary-operation-simplification=true -verify -analyzer-config eagerly-assume=false %s
 
-// Temporary xfailing, as debug printing functionality has changed.
-// XFAIL: *
-
-void clang_analyzer_dump(int x);
 void clang_analyzer_eval(int x);
+void clang_analyzer_denote(int x, const char *literal);
+void clang_analyzer_express(int x);
 
 void exit(int);
 
@@ -29,907 +27,951 @@
 
 void compare_different_symbol_equal() {
   int x = f(), y = f();
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) == 0}}
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  clang_analyzer_express(x == y); // expected-warning {{$x - $y == 0}}
 }
 
 void compare_different_symbol_plus_left_int_equal() {
-  int x = f()+1, y = f();
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) == 1}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x += 1;
+  clang_analyzer_express(x == y); // expected-warning {{$y - $x == 1}}
 }
 
 void compare_different_symbol_minus_left_int_equal() {
-  int x = f()-1, y = f();
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) == 1}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x -= 1;
+  clang_analyzer_express(x == y); // expected-warning {{$x - $y == 1}}
 }
 
 void compare_different_symbol_plus_right_int_equal() {
-  int x = f(), y = f()+2;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 2}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) == 2}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  y += 2;
+  clang_analyzer_express(y); // expected-warning {{$y + 2}}
+  clang_analyzer_express(x == y); // expected-warning {{$x - $y == 2}}
 }
 
 void compare_different_symbol_minus_right_int_equal() {
-  int x = f(), y = f()-2;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 2}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) == 2}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  y -= 2;
+  clang_analyzer_express(y); // expected-warning {{$y - 2}}
+  clang_analyzer_express(x == y); // expected-warning {{$y - $x == 2}}
 }
 
 void compare_different_symbol_plus_left_plus_right_int_equal() {
-  int x = f()+2, y = f()+1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) == 1}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x += 2;
+  y += 1;
+  clang_analyzer_express(x); // expected-warning {{$x + 2}}
+  clang_analyzer_express(y); // expected-warning {{$y + 1}}
+  clang_analyzer_express(x == y); // expected-warning {{$y - $x == 1}}
 }
 
 void compare_different_symbol_plus_left_minus_right_int_equal() {
-  int x = f()+2, y = f()-1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) == 3}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x += 2;
+  y -= 1;
+  clang_analyzer_express(x); // expected-warning {{$x + 2}}
+  clang_analyzer_express(y); // expected-warning {{$y - 1}}
+  clang_analyzer_express(x == y); // expected-warning {{$y - $x == 3}}
 }
 
 void compare_different_symbol_minus_left_plus_right_int_equal() {
-  int x = f()-2, y = f()+1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) == 3}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x -= 2;
+  y += 1;
+  clang_analyzer_express(x); // expected-warning {{$x - 2}}
+  clang_analyzer_express(y); // expected-warning {{$y + 1}}
+  clang_analyzer_express(x == y); // expected-warning {{$x - $y == 3}}
 }
 
 void compare_different_symbol_minus_left_minus_right_int_equal() {
-  int x = f()-2, y = f()-1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) == 1}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x -= 2;
+  y -= 1;
+  clang_analyzer_express(x); // expected-warning {{$x - 2}}
+  clang_analyzer_express(y); // expected-warning {{$y - 1}}
+  clang_analyzer_express(x == y); // expected-warning {{$x - $y == 1}}
 }
 
 void compare_same_symbol_equal() {
   int x = f(), y = x;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_eval(x == y);
-  // expected-warning@-1{{TRUE}}
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_eval(x == y); // expected-warning {{TRUE}}
 }
 
 void compare_same_symbol_plus_left_int_equal() {
   int x = f(), y = x;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_eval(x == y);
-  // expected-warning@-1{{FALSE}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_eval(x == y); // expected-warning {{FALSE}}
 }
 
 void compare_same_symbol_minus_left_int_equal() {
   int x = f(), y = x;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_eval(x == y);
-  // expected-warning@-1{{FALSE}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_eval(x == y); // expected-warning {{FALSE}}
 }
 
 void compare_same_symbol_plus_right_int_equal() {
-  int x = f(), y = x+1;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_eval(x == y);
-  // expected-warning@-1{{FALSE}}
+  int x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_eval(x == y); // expected-warning {{FALSE}}
 }
 
 void compare_same_symbol_minus_right_int_equal() {
-  int x = f(), y = x-1;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_eval(x == y);
-  // expected-warning@-1{{FALSE}}
+  int x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_eval(x == y); // expected-warning {{FALSE}}
 }
 
 void compare_same_symbol_plus_left_plus_right_int_equal() {
-  int x = f(), y = x+1;
+  int x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_eval(x == y);
-  // expected-warning@-1{{TRUE}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_eval(x == y); // expected-warning {{TRUE}}
 }
 
 void compare_same_symbol_plus_left_minus_right_int_equal() {
-  int x = f(), y = x-1;
+  int x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_eval(x == y);
-  // expected-warning@-1{{FALSE}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_eval(x == y); // expected-warning {{FALSE}}
 }
 
 void compare_same_symbol_minus_left_plus_right_int_equal() {
-  int x = f(), y = x+1;
+  int x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_eval(x == y);
-  // expected-warning@-1{{FALSE}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_eval(x == y); // expected-warning {{FALSE}}
 }
 
 void compare_same_symbol_minus_left_minus_right_int_equal() {
-  int x = f(), y = x-1;
+  int x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_eval(x == y);
-  // expected-warning@-1{{TRUE}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_eval(x == y); // expected-warning {{TRUE}}
 }
 
 void compare_different_symbol_less_or_equal() {
   int x = f(), y = f();
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) <= 0}}
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  clang_analyzer_express(x <= y); // expected-warning {{$x - $y <= 0}}
 }
 
 void compare_different_symbol_plus_left_int_less_or_equal() {
-  int x = f()+1, y = f();
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) >= 1}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x += 1;
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(x <= y); // expected-warning {{$y - $x >= 1}}
 }
 
 void compare_different_symbol_minus_left_int_less_or_equal() {
-  int x = f()-1, y = f();
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) <= 1}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x -= 1;
+  clang_analyzer_express(x <= y); // expected-warning {{$x - $y <= 1}}
 }
 
 void compare_different_symbol_plus_right_int_less_or_equal() {
-  int x = f(), y = f()+2;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 2}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) <= 2}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  y += 2;
+  clang_analyzer_express(x <= y); // expected-warning {{$x - $y <= 2}}
 }
 
 void compare_different_symbol_minus_right_int_less_or_equal() {
-  int x = f(), y = f()-2;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 2}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) >= 2}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  y -= 2;
+  clang_analyzer_express(y); // expected-warning {{$y - 2}}
+  clang_analyzer_express(x <= y); // expected-warning {{$y - $x >= 2}}
 }
 
 void compare_different_symbol_plus_left_plus_right_int_less_or_equal() {
-  int x = f()+2, y = f()+1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) >= 1}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x += 2;
+  y += 1;
+  clang_analyzer_express(x); // expected-warning {{$x + 2}}
+  clang_analyzer_express(y); // expected-warning {{$y + 1}}
+  clang_analyzer_express(x <= y); // expected-warning {{$y - $x >= 1}}
 }
 
 void compare_different_symbol_plus_left_minus_right_int_less_or_equal() {
-  int x = f()+2, y = f()-1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) >= 3}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x += 2;
+  y -= 1;
+  clang_analyzer_express(x); // expected-warning {{$x + 2}}
+  clang_analyzer_express(y); // expected-warning {{$y - 1}}
+  clang_analyzer_express(x <= y); // expected-warning {{$y - $x >= 3}}
 }
 
 void compare_different_symbol_minus_left_plus_right_int_less_or_equal() {
-  int x = f()-2, y = f()+1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) <= 3}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x -= 2;
+  y += 1;
+  clang_analyzer_express(x); // expected-warning {{$x - 2}}
+  clang_analyzer_express(y); // expected-warning {{$y + 1}}
+  clang_analyzer_express(x <= y); // expected-warning {{$x - $y <= 3}}
 }
 
 void compare_different_symbol_minus_left_minus_right_int_less_or_equal() {
-  int x = f()-2, y = f()-1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) <= 1}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x -= 2;
+  y -= 1;
+  clang_analyzer_express(x); // expected-warning {{$x - 2}}
+  clang_analyzer_express(y); // expected-warning {{$y - 1}}
+  clang_analyzer_express(x <= y); // expected-warning {{$x - $y <= 1}}
 }
 
 void compare_same_symbol_less_or_equal() {
   int x = f(), y = x;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_eval(x <= y);
-  // expected-warning@-1{{TRUE}}
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_eval(x <= y); // expected-warning {{TRUE}}
 }
 
 void compare_same_symbol_plus_left_int_less_or_equal() {
   int x = f(), y = x;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_eval(x <= y);
-  // expected-warning@-1{{FALSE}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_eval(x <= y); // expected-warning {{FALSE}}
 }
 
 void compare_same_symbol_minus_left_int_less_or_equal() {
   int x = f(), y = x;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_eval(x <= y);
-  // expected-warning@-1{{TRUE}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_eval(x <= y); // expected-warning {{TRUE}}
 }
 
 void compare_same_symbol_plus_right_int_less_or_equal() {
-  int x = f(), y = x+1;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_eval(x <= y);
-  // expected-warning@-1{{TRUE}}
+  int x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_eval(x <= y); // expected-warning {{TRUE}}
 }
 
 void compare_same_symbol_minus_right_int_less_or_equal() {
-  int x = f(), y = x-1;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_eval(x <= y);
-  // expected-warning@-1{{FALSE}}
+  int x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_eval(x <= y); // expected-warning {{FALSE}}
 }
 
 void compare_same_symbol_plus_left_plus_right_int_less_or_equal() {
-  int x = f(), y = x+1;
+  int x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_eval(x <= y);
-  // expected-warning@-1{{TRUE}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_eval(x <= y); // expected-warning {{TRUE}}
 }
 
 void compare_same_symbol_plus_left_minus_right_int_less_or_equal() {
-  int x = f(), y = x-1;
+  int x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_eval(x <= y);
-  // expected-warning@-1{{FALSE}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_eval(x <= y); // expected-warning {{FALSE}}
 }
 
 void compare_same_symbol_minus_left_plus_right_int_less_or_equal() {
-  int x = f(), y = x+1;
+  int x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_eval(x <= y);
-  // expected-warning@-1{{TRUE}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_eval(x <= y); // expected-warning {{TRUE}}
 }
 
 void compare_same_symbol_minus_left_minus_right_int_less_or_equal() {
-  int x = f(), y = x-1;
+  int x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_eval(x <= y);
-  // expected-warning@-1{{TRUE}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_eval(x <= y); // expected-warning {{TRUE}}
 }
 
 void compare_different_symbol_less() {
   int x = f(), y = f();
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) < 0}}
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  clang_analyzer_express(y); // expected-warning {{$y}}
+  clang_analyzer_express(x < y); // expected-warning {{$x - $y < 0}}
 }
 
 void compare_different_symbol_plus_left_int_less() {
-  int x = f()+1, y = f();
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) > 1}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x += 1;
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$y}}
+  clang_analyzer_express(x < y); // expected-warning {{$y - $x > 1}}
 }
 
 void compare_different_symbol_minus_left_int_less() {
-  int x = f()-1, y = f();
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) < 1}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x -= 1;
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$y}}
+  clang_analyzer_express(x < y); // expected-warning {{$x - $y < 1}}
 }
 
 void compare_different_symbol_plus_right_int_less() {
-  int x = f(), y = f()+2;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 2}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) < 2}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  y += 2;
+  clang_analyzer_express(y); // expected-warning {{$y + 2}}
+  clang_analyzer_express(x < y); // expected-warning {{$x - $y < 2}}
 }
 
 void compare_different_symbol_minus_right_int_less() {
-  int x = f(), y = f()-2;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 2}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) > 2}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  y -= 2;
+  clang_analyzer_express(y); // expected-warning {{$y - 2}}
+  clang_analyzer_express(x < y); // expected-warning {{$y - $x > 2}}
 }
 
 void compare_different_symbol_plus_left_plus_right_int_less() {
-  int x = f()+2, y = f()+1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) > 1}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x += 2;
+  y += 1;
+  clang_analyzer_express(x); // expected-warning {{$x + 2}}
+  clang_analyzer_express(y); // expected-warning {{$y + 1}}
+  clang_analyzer_express(x < y); // expected-warning {{$y - $x > 1}}
 }
 
 void compare_different_symbol_plus_left_minus_right_int_less() {
-  int x = f()+2, y = f()-1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) > 3}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x += 2;
+  y -= 1;
+  clang_analyzer_express(x); // expected-warning {{$x + 2}}
+  clang_analyzer_express(y); // expected-warning {{$y - 1}}
+  clang_analyzer_express(x < y); // expected-warning {{$y - $x > 3}}
 }
 
 void compare_different_symbol_minus_left_plus_right_int_less() {
-  int x = f()-2, y = f()+1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) < 3}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x -= 2;
+  y += 1;
+  clang_analyzer_express(x); // expected-warning {{$x - 2}}
+  clang_analyzer_express(y); // expected-warning {{$y + 1}}
+  clang_analyzer_express(x < y); // expected-warning {{$x - $y < 3}}
 }
 
 void compare_different_symbol_minus_left_minus_right_int_less() {
-  int x = f()-2, y = f()-1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) < 1}}
+  int x = f(), y = f();
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  x -= 2;
+  y -= 1;
+  clang_analyzer_express(x); // expected-warning {{$x - 2}}
+  clang_analyzer_express(y); // expected-warning {{$y - 1}}
+  clang_analyzer_express(x < y); // expected-warning {{$x - $y < 1}}
 }
 
 void compare_same_symbol_less() {
   int x = f(), y = x;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_eval(x < y);
-  // expected-warning@-1{{FALSE}}
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_eval(x < y); // expected-warning {{FALSE}}
 }
 
 void compare_same_symbol_plus_left_int_less() {
   int x = f(), y = x;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_eval(x < y);
-  // expected-warning@-1{{FALSE}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_eval(x < y); // expected-warning {{FALSE}}
 }
 
 void compare_same_symbol_minus_left_int_less() {
   int x = f(), y = x;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_eval(x < y);
-  // expected-warning@-1{{TRUE}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_eval(x < y); // expected-warning {{TRUE}}
 }
 
 void compare_same_symbol_plus_right_int_less() {
-  int x = f(), y = x+1;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_eval(x < y);
-  // expected-warning@-1{{TRUE}}
+  int x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_eval(x < y); // expected-warning {{TRUE}}
 }
 
 void compare_same_symbol_minus_right_int_less() {
-  int x = f(), y = x-1;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_eval(x < y);
-  // expected-warning@-1{{FALSE}}
+  int x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_eval(x < y); // expected-warning {{FALSE}}
 }
 
 void compare_same_symbol_plus_left_plus_right_int_less() {
-  int x = f(), y = x+1;
+  int x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_eval(x < y);
-  // expected-warning@-1{{FALSE}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_eval(x < y); // expected-warning {{FALSE}}
 }
 
 void compare_same_symbol_plus_left_minus_right_int_less() {
-  int x = f(), y = x-1;
+  int x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_eval(x < y);
-  // expected-warning@-1{{FALSE}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_eval(x < y); // expected-warning {{FALSE}}
 }
 
 void compare_same_symbol_minus_left_plus_right_int_less() {
-  int x = f(), y = x+1;
+  int x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_eval(x < y);
-  // expected-warning@-1{{TRUE}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_eval(x < y); // expected-warning {{TRUE}}
 }
 
 void compare_same_symbol_minus_left_minus_right_int_less() {
-  int x = f(), y = x-1;
+  int x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_eval(x < y);
-  // expected-warning@-1{{FALSE}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_eval(x < y); // expected-warning {{FALSE}}
 }
 
 void compare_different_symbol_equal_unsigned() {
   unsigned x = f(), y = f();
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) == 0}}
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  clang_analyzer_express(y); // expected-warning {{$y}}
+  clang_analyzer_express(x == y); // expected-warning {{$x - $y == 0}}
 }
 
 void compare_different_symbol_plus_left_int_equal_unsigned() {
-  unsigned x = f()+1, y = f();
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) == 1}}
+  unsigned x = f() + 1, y = f();
+  clang_analyzer_denote(x - 1, "$x");
+  clang_analyzer_denote(y, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$y}}
+  clang_analyzer_express(x == y); // expected-warning {{$y - $x == 1}}
 }
 
 void compare_different_symbol_minus_left_int_equal_unsigned() {
-  unsigned x = f()-1, y = f();
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) == 1}}
+  unsigned x = f() - 1, y = f();
+  clang_analyzer_denote(x + 1, "$x");
+  clang_analyzer_denote(y, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$y}}
+  clang_analyzer_express(x == y); // expected-warning {{$x - $y == 1}}
 }
 
 void compare_different_symbol_plus_right_int_equal_unsigned() {
-  unsigned x = f(), y = f()+2;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 2}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) == 2}}
+  unsigned x = f(), y = f() + 2;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y - 2, "$y");
+  clang_analyzer_express(y); // expected-warning {{$y + 2}}
+  clang_analyzer_express(x == y); // expected-warning {{$x - $y == 2}}
 }
 
 void compare_different_symbol_minus_right_int_equal_unsigned() {
-  unsigned x = f(), y = f()-2;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 2}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) == 2}}
+  unsigned x = f(), y = f() - 2;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y + 2, "$y");
+  clang_analyzer_express(y); // expected-warning {{$y - 2}}
+  clang_analyzer_express(x == y); // expected-warning {{$y - $x == 2}}
 }
 
 void compare_different_symbol_plus_left_plus_right_int_equal_unsigned() {
-  unsigned x = f()+2, y = f()+1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) == 1}}
+  unsigned x = f() + 2, y = f() + 1;
+  clang_analyzer_denote(x - 2, "$x");
+  clang_analyzer_denote(y - 1, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x + 2}}
+  clang_analyzer_express(y); // expected-warning {{$y + 1}}
+  clang_analyzer_express(x == y); // expected-warning {{$y - $x == 1}}
 }
 
 void compare_different_symbol_plus_left_minus_right_int_equal_unsigned() {
-  unsigned x = f()+2, y = f()-1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) == 3}}
+  unsigned x = f() + 2, y = f() - 1;
+  clang_analyzer_denote(x - 2, "$x");
+  clang_analyzer_denote(y + 1, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x + 2}}
+  clang_analyzer_express(y); // expected-warning {{$y - 1}}
+  clang_analyzer_express(x == y); // expected-warning {{$y - $x == 3}}
 }
 
 void compare_different_symbol_minus_left_plus_right_int_equal_unsigned() {
-  unsigned x = f()-2, y = f()+1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) == 3}}
+  unsigned x = f() - 2, y = f() + 1;
+  clang_analyzer_denote(x + 2, "$x");
+  clang_analyzer_denote(y - 1, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x - 2}}
+  clang_analyzer_express(y); // expected-warning {{$y + 1}}
+  clang_analyzer_express(x == y); // expected-warning {{$x - $y == 3}}
 }
 
 void compare_different_symbol_minus_left_minus_right_int_equal_unsigned() {
-  unsigned x = f()-2, y = f()-1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) == 1}}
+  unsigned x = f() - 2, y = f() - 1;
+  clang_analyzer_denote(x + 2, "$x");
+  clang_analyzer_denote(y + 1, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x - 2}}
+  clang_analyzer_express(y); // expected-warning {{$y - 1}}
+  clang_analyzer_express(x == y); // expected-warning {{$x - $y == 1}}
 }
 
 void compare_same_symbol_equal_unsigned() {
   unsigned x = f(), y = x;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_eval(x == y);
-  // expected-warning@-1{{TRUE}}
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_eval(x == y); // expected-warning {{TRUE}}
 }
 
 void compare_same_symbol_plus_left_int_equal_unsigned() {
   unsigned x = f(), y = x;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$2{int}) + 1U) == (conj_$2{int})}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_express(x == y); // expected-warning {{$x + 1U == $x}}
 }
 
 void compare_same_symbol_minus_left_int_equal_unsigned() {
   unsigned x = f(), y = x;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$2{int}) - 1U) == (conj_$2{int})}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_express(x == y); // expected-warning {{$x - 1U == $x}}
 }
 
 void compare_same_symbol_plus_right_int_equal_unsigned() {
-  unsigned x = f(), y = x+1;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{(conj_$2{int}) == ((conj_$2{int}) + 1U)}}
+  unsigned x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_express(x == y); // expected-warning {{$x == $x + 1U}}
 }
 
 void compare_same_symbol_minus_right_int_equal_unsigned() {
-  unsigned x = f(), y = x-1;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{(conj_$2{int}) == ((conj_$2{int}) - 1U)}}
+  unsigned x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_express(x == y); // expected-warning {{$x == $x - 1U}}
 }
 
 void compare_same_symbol_plus_left_plus_right_int_equal_unsigned() {
-  unsigned x = f(), y = x+1;
+  unsigned x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_eval(x == y);
-  // expected-warning@-1{{TRUE}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_eval(x == y); // expected-warning {{TRUE}}
 }
 
 void compare_same_symbol_plus_left_minus_right_int_equal_unsigned() {
-  unsigned x = f(), y = x-1;
+  unsigned x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$2{int}) + 1U) == ((conj_$2{int}) - 1U)}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_express(x == y); // expected-warning {{$x + 1U == $x - 1U}}
 }
 
 void compare_same_symbol_minus_left_plus_right_int_equal_unsigned() {
-  unsigned x = f(), y = x+1;
+  unsigned x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(x == y);
-  // expected-warning@-1{{((conj_$2{int}) - 1U) == ((conj_$2{int}) + 1U)}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_express(x == y); // expected-warning {{$x - 1U == $x + 1U}}
 }
 
 void compare_same_symbol_minus_left_minus_right_int_equal_unsigned() {
-  unsigned x = f(), y = x-1;
+  unsigned x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_eval(x == y);
-  // expected-warning@-1{{TRUE}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_eval(x == y); // expected-warning {{TRUE}}
 }
 
 void compare_different_symbol_less_or_equal_unsigned() {
   unsigned x = f(), y = f();
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) <= 0}}
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  clang_analyzer_express(y); // expected-warning {{$y}}
+  clang_analyzer_express(x <= y); // expected-warning {{$x - $y <= 0}}
 }
 
 void compare_different_symbol_plus_left_int_less_or_equal_unsigned() {
-  unsigned x = f()+1, y = f();
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) >= 1}}
+  unsigned x = f() + 1, y = f();
+  clang_analyzer_denote(x - 1, "$x");
+  clang_analyzer_denote(y, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$y}}
+  clang_analyzer_express(x <= y); // expected-warning {{$y - $x >= 1}}
 }
 
 void compare_different_symbol_minus_left_int_less_or_equal_unsigned() {
-  unsigned x = f()-1, y = f();
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) <= 1}}
+  unsigned x = f() - 1, y = f();
+  clang_analyzer_denote(x + 1, "$x");
+  clang_analyzer_denote(y, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$y}}
+  clang_analyzer_express(x <= y); // expected-warning {{$x - $y <= 1}}
 }
 
 void compare_different_symbol_plus_right_int_less_or_equal_unsigned() {
-  unsigned x = f(), y = f()+2;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 2}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) <= 2}}
+  unsigned x = f(), y = f() + 2;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y - 2, "$y");
+  clang_analyzer_express(y); // expected-warning {{$y + 2}}
+  clang_analyzer_express(x <= y); // expected-warning {{$x - $y <= 2}}
 }
 
 void compare_different_symbol_minus_right_int_less_or_equal_unsigned() {
-  unsigned x = f(), y = f()-2;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 2}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) >= 2}}
+  unsigned x = f(), y = f() - 2;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y + 2, "$y");
+  clang_analyzer_express(y); // expected-warning {{$y - 2}}
+  clang_analyzer_express(x <= y); // expected-warning {{$y - $x >= 2}}
 }
 
 void compare_different_symbol_plus_left_plus_right_int_less_or_equal_unsigned() {
-  unsigned x = f()+2, y = f()+1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) >= 1}}
+  unsigned x = f() + 2, y = f() + 1;
+  clang_analyzer_denote(x - 2, "$x");
+  clang_analyzer_denote(y - 1, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x + 2}}
+  clang_analyzer_express(y); // expected-warning {{$y + 1}}
+  clang_analyzer_express(x <= y); // expected-warning {{$y - $x >= 1}}
 }
 
 void compare_different_symbol_plus_left_minus_right_int_less_or_equal_unsigned() {
-  unsigned x = f()+2, y = f()-1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) >= 3}}
+  unsigned x = f() + 2, y = f() - 1;
+  clang_analyzer_denote(x - 2, "$x");
+  clang_analyzer_denote(y + 1, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x + 2}}
+  clang_analyzer_express(y); // expected-warning {{$y - 1}}
+  clang_analyzer_express(x <= y); // expected-warning {{$y - $x >= 3}}
 }
 
 void compare_different_symbol_minus_left_plus_right_int_less_or_equal_unsigned() {
-  unsigned x = f()-2, y = f()+1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) <= 3}}
+  unsigned x = f() - 2, y = f() + 1;
+  clang_analyzer_denote(x + 2, "$x");
+  clang_analyzer_denote(y - 1, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x - 2}}
+  clang_analyzer_express(y); // expected-warning {{$y + 1}}
+  clang_analyzer_express(x <= y); // expected-warning {{$x - $y <= 3}}
 }
 
 void compare_different_symbol_minus_left_minus_right_int_less_or_equal_unsigned() {
-  unsigned x = f()-2, y = f()-1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) <= 1}}
+  unsigned x = f() - 2, y = f() - 1;
+  clang_analyzer_denote(x + 2, "$x");
+  clang_analyzer_denote(y + 1, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x - 2}}
+  clang_analyzer_express(y); // expected-warning {{$y - 1}}
+  clang_analyzer_express(x <= y); // expected-warning {{$x - $y <= 1}}
 }
 
 void compare_same_symbol_less_or_equal_unsigned() {
   unsigned x = f(), y = x;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_eval(x <= y);
-  // expected-warning@-1{{TRUE}}
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_eval(x <= y); // expected-warning {{TRUE}}
 }
 
 void compare_same_symbol_plus_left_int_less_or_equal_unsigned() {
   unsigned x = f(), y = x;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$2{int}) + 1U) <= (conj_$2{int})}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_express(x <= y); // expected-warning {{$x + 1U <= $x}}
 }
 
 void compare_same_symbol_minus_left_int_less_or_equal_unsigned() {
   unsigned x = f(), y = x;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$2{int}) - 1U) <= (conj_$2{int})}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_express(x <= y); // expected-warning {{$x - 1U <= $x}}
 }
 
 void compare_same_symbol_plus_right_int_less_or_equal_unsigned() {
-  unsigned x = f(), y = x+1;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{(conj_$2{int}) <= ((conj_$2{int}) + 1U)}}
+  unsigned x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_express(x <= y); // expected-warning {{$x <= $x + 1U}}
 }
 
 void compare_same_symbol_minus_right_int_less_or_equal_unsigned() {
-  unsigned x = f(), y = x-1;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{(conj_$2{int}) <= ((conj_$2{int}) - 1U)}}
+  unsigned x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_express(x <= y); // expected-warning {{$x <= $x - 1U}}
 }
 
 void compare_same_symbol_plus_left_plus_right_int_less_or_equal_unsigned() {
-  unsigned x = f(), y = x+1;
+  unsigned x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_eval(x <= y);
-  // expected-warning@-1{{TRUE}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_eval(x <= y); // expected-warning {{TRUE}}
 }
 
 void compare_same_symbol_plus_left_minus_right_int_less_or_equal_unsigned() {
-  unsigned x = f(), y = x-1;
+  unsigned x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$2{int}) + 1U) <= ((conj_$2{int}) - 1U)}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_express(x <= y); // expected-warning {{$x + 1U <= $x - 1U}}
 }
 
 void compare_same_symbol_minus_left_plus_right_int_less_or_equal_unsigned() {
-  unsigned x = f(), y = x+1;
+  unsigned x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(x <= y);
-  // expected-warning@-1{{((conj_$2{int}) - 1U) <= ((conj_$2{int}) + 1U)}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_express(x <= y); // expected-warning {{$x - 1U <= $x + 1U}}
 }
 
 void compare_same_symbol_minus_left_minus_right_int_less_or_equal_unsigned() {
-  unsigned x = f(), y = x-1;
+  unsigned x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_eval(x <= y);
-  // expected-warning@-1{{TRUE}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_eval(x <= y); // expected-warning {{TRUE}}
 }
 
 void compare_different_symbol_less_unsigned() {
   unsigned x = f(), y = f();
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) < 0}}
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y, "$y");
+  clang_analyzer_express(y); // expected-warning {{$y}}
+  clang_analyzer_express(x < y); // expected-warning {{$x - $y < 0}}
 }
 
 void compare_different_symbol_plus_left_int_less_unsigned() {
-  unsigned x = f()+1, y = f();
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) > 1}}
+  unsigned x = f() + 1, y = f();
+  clang_analyzer_denote(x - 1, "$x");
+  clang_analyzer_denote(y, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$y}}
+  clang_analyzer_express(x < y); // expected-warning {{$y - $x > 1}}
 }
 
 void compare_different_symbol_minus_left_int_less_unsigned() {
-  unsigned x = f()-1, y = f();
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$9{int}}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) < 1}}
+  unsigned x = f() - 1, y = f();
+  clang_analyzer_denote(x + 1, "$x");
+  clang_analyzer_denote(y, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$y}}
+  clang_analyzer_express(x < y); // expected-warning {{$x - $y < 1}}
 }
 
 void compare_different_symbol_plus_right_int_less_unsigned() {
-  unsigned x = f(), y = f()+2;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 2}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) < 2}}
+  unsigned x = f(), y = f() + 2;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y - 2, "$y");
+  clang_analyzer_express(y); // expected-warning {{$y + 2}}
+  clang_analyzer_express(x < y); // expected-warning {{$x - $y < 2}}
 }
 
 void compare_different_symbol_minus_right_int_less_unsigned() {
-  unsigned x = f(), y = f()-2;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 2}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) > 2}}
+  unsigned x = f(), y = f() - 2;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_denote(y + 2, "$y");
+  clang_analyzer_express(y); // expected-warning {{$y - 2}}
+  clang_analyzer_express(x < y); // expected-warning {{$y - $x > 2}}
 }
 
 void compare_different_symbol_plus_left_plus_right_int_less_unsigned() {
-  unsigned x = f()+2, y = f()+1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) > 1}}
+  unsigned x = f() + 2, y = f() + 1;
+  clang_analyzer_denote(x - 2, "$x");
+  clang_analyzer_denote(y - 1, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x + 2}}
+  clang_analyzer_express(y); // expected-warning {{$y + 1}}
+  clang_analyzer_express(x < y); // expected-warning {{$y - $x > 1}}
 }
 
 void compare_different_symbol_plus_left_minus_right_int_less_unsigned() {
-  unsigned x = f()+2, y = f()-1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$9{int}) - (conj_$2{int})) > 3}}
+  unsigned x = f() + 2, y = f() - 1;
+  clang_analyzer_denote(x - 2, "$x");
+  clang_analyzer_denote(y + 1, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x + 2}}
+  clang_analyzer_express(y); // expected-warning {{$y - 1}}
+  clang_analyzer_express(x < y); // expected-warning {{$y - $x > 3}}
 }
 
 void compare_different_symbol_minus_left_plus_right_int_less_unsigned() {
-  unsigned x = f()-2, y = f()+1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) + 1}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) < 3}}
+  unsigned x = f() - 2, y = f() + 1;
+  clang_analyzer_denote(x + 2, "$x");
+  clang_analyzer_denote(y - 1, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x - 2}}
+  clang_analyzer_express(y); // expected-warning {{$y + 1}}
+  clang_analyzer_express(x < y); // expected-warning {{$x - $y < 3}}
 }
 
 void compare_different_symbol_minus_left_minus_right_int_less_unsigned() {
-  unsigned x = f()-2, y = f()-1;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 2}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$9{int}) - 1}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$2{int}) - (conj_$9{int})) < 1}}
+  unsigned x = f() - 2, y = f() - 1;
+  clang_analyzer_denote(x + 2, "$x");
+  clang_analyzer_denote(y + 1, "$y");
+  clang_analyzer_express(x); // expected-warning {{$x - 2}}
+  clang_analyzer_express(y); // expected-warning {{$y - 1}}
+  clang_analyzer_express(x < y); // expected-warning {{$x - $y < 1}}
 }
 
 void compare_same_symbol_less_unsigned() {
   unsigned x = f(), y = x;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_eval(x < y);
-  // expected-warning@-1{{FALSE}}
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_eval(x < y); // expected-warning {{FALSE}}
 }
 
 void compare_same_symbol_plus_left_int_less_unsigned() {
   unsigned x = f(), y = x;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$2{int}) + 1U) < (conj_$2{int})}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_express(x < y); // expected-warning {{$x + 1U < $x}}
 }
 
 void compare_same_symbol_minus_left_int_less_unsigned() {
   unsigned x = f(), y = x;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$2{int}) - 1U) < (conj_$2{int})}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x}}
+  clang_analyzer_express(x < y); // expected-warning {{$x - 1U < $x}}
 }
 
 void compare_same_symbol_plus_right_int_less_unsigned() {
-  unsigned x = f(), y = x+1;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{(conj_$2{int}) < ((conj_$2{int}) + 1U)}}
+  unsigned x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_express(x < y); // expected-warning {{$x < $x + 1U}}
 }
 
 void compare_same_symbol_minus_right_int_less_unsigned() {
-  unsigned x = f(), y = x-1;
-  clang_analyzer_dump(x); // expected-warning{{conj_$2{int}}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{(conj_$2{int}) < ((conj_$2{int}) - 1U)}}
+  unsigned x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_express(x < y); // expected-warning {{$x < $x - 1U}}
 }
 
 void compare_same_symbol_plus_left_plus_right_int_less_unsigned() {
-  unsigned x = f(), y = x+1;
+  unsigned x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_eval(x < y);
-  // expected-warning@-1{{FALSE}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_eval(x < y); // expected-warning {{FALSE}}
 }
 
 void compare_same_symbol_plus_left_minus_right_int_less_unsigned() {
-  unsigned x = f(), y = x-1;
+  unsigned x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
   ++x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$2{int}) + 1U) < ((conj_$2{int}) - 1U)}}
+  clang_analyzer_express(x); // expected-warning {{$x + 1}}
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_express(x < y); // expected-warning {{$x + 1U < $x - 1U}}
 }
 
 void compare_same_symbol_minus_left_plus_right_int_less_unsigned() {
-  unsigned x = f(), y = x+1;
+  unsigned x = f(), y = x + 1;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) + 1}}
-  clang_analyzer_dump(x < y);
-  // expected-warning@-1{{((conj_$2{int}) - 1U) < ((conj_$2{int}) + 1U)}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x + 1}}
+  clang_analyzer_express(x < y); // expected-warning {{$x - 1U < $x + 1U}}
 }
 
 void compare_same_symbol_minus_left_minus_right_int_less_unsigned() {
-  unsigned x = f(), y = x-1;
+  unsigned x = f(), y = x - 1;
+  clang_analyzer_denote(x, "$x");
   --x;
-  clang_analyzer_dump(x); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_dump(y); // expected-warning{{(conj_$2{int}) - 1}}
-  clang_analyzer_eval(x < y);
-  // expected-warning@-1{{FALSE}}
+  clang_analyzer_express(x); // expected-warning {{$x - 1}}
+  clang_analyzer_express(y); // expected-warning {{$x - 1}}
+  clang_analyzer_eval(x < y); // expected-warning {{FALSE}}
 }
 
 void overflow(signed char n, signed char m) {
   if (n + 0 > m + 0) {
-    clang_analyzer_eval(n - 126 == m + 3); // expected-warning{{UNKNOWN}}
+    clang_analyzer_eval(n - 126 == m + 3); // expected-warning {{UNKNOWN}}
   }
 }