[analyzer] Allow exploded graph dumps in release builds

[steakhal]

Summary

Historically, exploded graph dumps were disabled in non-debug builds.
It was done so probably because a regular user should not dump the
internal representation of the analyzer anyway and the dump methods
might introduce unnecessary binary size overhead.

It turns out some of the users actually want to dump this.

Note that e.g. LiveExpressionsDumper, LiveVariablesDumper,
ControlDependencyTreeDumper etc. worked previously, and they are
unaffected by this change.
However, CFGViewer and CFGDumper still won't work for a similar
reason. AFAIK only these two won't work after this change.

Addresses #53873

---

baseline

binary	size	size after strip
clang	103M	83M
clang-tidy	67M	54M

after this change

binary	size	size after strip
clang	103M	84M
clang-tidy	67M	54M

CMake configuration:

cmake -S llvm -GNinja -DBUILD_SHARED_LIBS=OFF -DCMAKE_BUILD_TYPE=Release
-DCMAKE_CXX_COMPILER=clang++ -DCMAKE_C_COMPILER=clang
-DLLVM_ENABLE_ASSERTIONS=OFF -DLLVM_USE_LINKER=lld
-DLLVM_ENABLE_DUMP=OFF -DLLVM_ENABLE_PROJECTS="clang;clang-tools-extra"
-DLLVM_ENABLE_Z3_SOLVER=ON -DLLVM_TARGETS_TO_BUILD="X86"

Built by clang-14.0.0.

[martong]

LGTM, thanks!

For the record, I am inserting the url of the issue:
https://github.com/llvm/llvm-project/issues/53873

clang/lib/StaticAnalyzer/Core/ExprEngine.cpp

void ExprEngine::VisitMSAsmStmt(const MSAsmStmt *A, ExplodedNode *Pred,
   StmtNodeBuilder Bldr(Pred, Dst, *currBldrCtx);
   Bldr.generateNode(A, Pred, Pred->getState());
 }
 
 //===----------------------------------------------------------------------===//
 // Visualization.
 //===----------------------------------------------------------------------===//
 
-#ifndef NDEBUG
 namespace llvm {
 
 template<>
 struct DOTGraphTraits<ExplodedGraph*> : public DefaultDOTGraphTraits {
   DOTGraphTraits (bool isSimple = false) : DefaultDOTGraphTraits(isSimple) {}
 
   static bool nodeHasBugReport(const ExplodedNode *N) {
     BugReporter &BR = static_cast<ExprEngine &>(
static std::string getNodeLabel(const ExplodedNode *N, ExplodedGraph *G){
     State->printDOT(Out, N->getLocationContext(), Space);
 
     Out << "\\l}\\l";
     return Out.str();
   }
 };
 
 } // namespace llvm
-#endif
 
 void ExprEngine::ViewGraph(bool trim) {
-#ifndef NDEBUG
   std::string Filename = DumpGraph(trim);
   llvm::DisplayGraph(Filename, false, llvm::GraphProgram::DOT);
-#else
-  llvm::errs() << "Warning: viewing graph requires assertions" << "\n";
-#endif
 }
 
-
-void ExprEngine::ViewGraph(ArrayRef<const ExplodedNode*> Nodes) {
-#ifndef NDEBUG
+void ExprEngine::ViewGraph(ArrayRef<const ExplodedNode *> Nodes) {
   std::string Filename = DumpGraph(Nodes);
   llvm::DisplayGraph(Filename, false, llvm::GraphProgram::DOT);
-#else
-  llvm::errs() << "Warning: viewing graph requires assertions" << "\n";
-#endif
 }
 
 std::string ExprEngine::DumpGraph(bool trim, StringRef Filename) {
-#ifndef NDEBUG
   if (trim) {
     std::vector<const ExplodedNode *> Src;
 
     // Iterate through the reports and get their nodes.
     for (BugReporter::EQClasses_iterator
            EI = BR.EQClasses_begin(), EE = BR.EQClasses_end(); EI != EE; ++EI) {
       const auto *R =
           dyn_cast<PathSensitiveBugReport>(EI->getReports()[0].get());
       if (!R)
         continue;
       const auto *N = const_cast<ExplodedNode *>(R->getErrorNode());
       Src.push_back(N);
     }
     return DumpGraph(Src, Filename);
-  } else {
-    return llvm::WriteGraph(&G, "ExprEngine", /*ShortNames=*/false,
-                            /*Title=*/"Exploded Graph",
-                            /*Filename=*/std::string(Filename));
-  }
-#else
-  llvm::errs() << "Warning: dumping graph requires assertions" << "\n";
-  return "";
-#endif
-}
+  }
+
 
-std::string ExprEngine::DumpGraph(ArrayRef<const ExplodedNode*> Nodes,
+std::string ExprEngine::DumpGraph(ArrayRef<const ExplodedNode *> Nodes,
                                   StringRef Filename) {
-#ifndef NDEBUG
   std::unique_ptr<ExplodedGraph> TrimmedG(G.trim(Nodes));
 
   if (!TrimmedG.get()) {
     llvm::errs() << "warning: Trimmed ExplodedGraph is empty.\n";
     return "";
-  } else {
-    return llvm::WriteGraph(TrimmedG.get(), "TrimmedExprEngine",
-                            /*ShortNames=*/false,
-                            /*Title=*/"Trimmed Exploded Graph",
-                            /*Filename=*/std::string(Filename));
-  }
-#else
-  llvm::errs() << "Warning: dumping graph requires assertions" << "\n";
-  return "";
-#endif
-}
+  }
+
 
 void *ProgramStateTrait<ReplayWithoutInlining>::GDMIndex() {
   static int index = 0;
   return &index;
 }
 
 void ExprEngine::anchor() { }

clang/test/Analysis/dump_egraph.c

 // RUN: %clang_analyze_cc1 -analyzer-checker=core \
 // RUN:  -analyzer-dump-egraph=%t.dot %s
 // RUN: cat %t.dot | FileCheck %s
 
 // RUN: %clang_analyze_cc1 -analyzer-checker=core \
 // RUN:  -analyzer-dump-egraph=%t.dot \
 // RUN:  -trim-egraph %s
 // RUN: cat %t.dot | FileCheck %s
 
-// REQUIRES: asserts
-
 int getJ(void);
 
 int foo(void) {
   int *x = 0, *y = 0;
   char c = '\x13';
 
   return *x + *y;
 }
 
 // CHECK: \"program_points\": [\l
 // CHECK-SAME: \{ \"kind\": \"Edge\", \"src_id\": 2, \"dst_id\": 1,
 // CHECK-SAME:    \"terminator\": null, \"term_kind\": null, \"tag\": null,
 // CHECK-SAME:    \"node_id\": 1, \"is_sink\": 0, \"has_report\": 0
 // CHECK-SAME: \},
 // CHECK-SAME: \{ \"kind\": \"BlockEntrance\", \"block_id\": 1, \"tag\": null,
 // CHECK-SAME:    \"node_id\": 2, \"is_sink\": 0, \"has_report\": 0
 // CHECK-SAME: \},
 // CHECK-SAME: \{ \"kind\": \"Statement\", \"stmt_kind\": \"IntegerLiteral\",
 // CHECK-SAME:    \"stmt_id\": {{[0-9]*}}, \"pointer\": \"0x{{[0-9a-f]*}}\",
 // CHECK-SAME:    \"pretty\": \"0\", \"location\": \{
-// CHECK-SAME:        \"line\": 15, \"column\": 12, \"file\":
+// CHECK-SAME:        \"line\": 13, \"column\": 12, \"file\":
 // CHECK-SAME:    \}, \"stmt_point_kind\": \"PreStmtPurgeDeadSymbols\",
 // CHECK-SAME:    \"tag\": \"ExprEngine : Clean Node\", \"node_id\": 3,
 // CHECK-SAME:    \"is_sink\": 0, \"has_report\": 0
 // CHECK-SAME: \},
 // CHECK-SAME: \{ \"kind\": \"Statement\", \"stmt_kind\": \"IntegerLiteral\",
 // CHECK-SAME:    \"stmt_id\": {{[0-9]*}}, \"pointer\": \"0x{{[0-9a-f]*}}\",
 // CHECK-SAME:    \"pretty\": \"0\", \"location\": \{
-// CHECK-SAME:        \"line\": 15, \"column\": 12, \"file\":
+// CHECK-SAME:        \"line\": 13, \"column\": 12, \"file\":
 // CHECK-SAME:    \}, \"stmt_point_kind\": \"PostStmt\", \"tag\": null,
 // CHECK-SAME:    \"node_id\": 4, \"is_sink\": 0, \"has_report\": 0
 // CHECK-SAME: \}
 // CHECK-SAME: ]
 
-// CHECK: \"pretty\": \"*x\", \"location\": \{ \"line\": 18, \"column\": 10, \"file\": \"{{(.+)}}dump_egraph.c\" \}
+// CHECK: \"pretty\": \"*x\", \"location\": \{ \"line\": 16, \"column\": 10, \"file\": \"{{(.+)}}dump_egraph.c\" \}
 
 // CHECK: \"pretty\": \"'\\\\x13'\"
 
 // CHECK: \"has_report\": 1
 
 // CHECK-NOT: \"program_state\": null

clang/test/Analysis/dump_egraph.cpp

 // RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-dump-egraph=%t.dot %s
 // RUN: cat %t.dot | FileCheck %s
-// REQUIRES: asserts
 
 struct S {
   ~S();
 };
 
 struct T {
   S s;
   T() : s() {}
 };
 
 void foo() {
   // Test that dumping symbols conjured on null statements doesn't crash.
   T t;
 
   new S;
 }
 
 // CHECK: \"location_context\": \"#0 Call\", \"calling\": \"foo\", \"location\": null, \"items\": [\l        \{ \"stmt_id\": {{[0-9]+}}, \"kind\": \"construct into local variable\", \"argument_index\": null, \"pretty\": \"T t;\", \"value\": \"&t\"
 
-// CHECK: \"location_context\": \"#0 Call\", \"calling\": \"T::T\", \"location\": \{ \"line\": 16, \"column\": 5, \"file\": \"{{.*}}dump_egraph.cpp\" \}, \"items\": [\l        \{ \"init_id\": {{[0-9]+}}, \"kind\": \"construct into member variable\", \"argument_index\": null, \"pretty\": \"s\", \"value\": \"&t.s\"
+// CHECK: \"location_context\": \"#0 Call\", \"calling\": \"T::T\", \"location\": \{ \"line\": 15, \"column\": 5, \"file\": \"{{.*}}dump_egraph.cpp\" \}, \"items\": [\l        \{ \"init_id\": {{[0-9]+}}, \"kind\": \"construct into member variable\", \"argument_index\": null, \"pretty\": \"s\", \"value\": \"&t.s\"
 
 // CHECK: \"cluster\": \"t\", \"pointer\": \"{{0x[0-9a-f]+}}\", \"items\": [\l        \{ \"kind\": \"Default\", \"offset\": 0, \"value\": \"conj_$2\{int, LC5, no stmt, #1\}\"
 
 // CHECK: \"dynamic_types\": [\l      \{ \"region\": \"HeapSymRegion\{conj_$1\{struct S *, LC1, S{{[0-9]+}}, #1\}\}\", \"dyn_type\": \"struct S\", \"sub_classable\": false \}\l
 

clang/test/Analysis/exploded-graph-rewriter/dynamic_types.cpp

 // FIXME: Figure out how to use %clang_analyze_cc1 with our lit.local.cfg.
 // RUN: %clang_cc1 -analyze -triple x86_64-unknown-linux-gnu \
 // RUN:                     -analyzer-checker=core \
 // RUN:                     -analyzer-dump-egraph=%t.dot %s
 // RUN: %exploded_graph_rewriter %t.dot | FileCheck %s
-// REQUIRES: asserts
 
 struct S {};
 
 void test() {
   // CHECK: Dynamic Types:
   // CHECK-SAME: <tr><td align="left"><table border="0"><tr>
   // CHECK-SAME:   <td align="left">HeapSymRegion\{conj_$1\{struct S *, LC1,
   // CHECK-SAME:       S{{[0-9]*}}, #1\}\}</td>
   // CHECK-SAME:   <td align="left">struct S</td>
   // CHECK-SAME: </tr></table></td></tr>
   new S;
 }

clang/test/Analysis/exploded-graph-rewriter/escapes.c

 // FIXME: Figure out how to use %clang_analyze_cc1 with our lit.local.cfg.
 // RUN: %clang_cc1 -analyze -triple x86_64-unknown-linux-gnu \
 // RUN:                     -analyzer-checker=core \
 // RUN:                     -analyzer-dump-egraph=%t.dot %s
 // RUN: %exploded_graph_rewriter %t.dot | FileCheck %s
-// REQUIRES: asserts
 
 void escapes(void) {
   // CHECK: <td align="left"><b>Store: </b> <font color="gray">(0x{{[0-9a-f]*}})</font></td>
   // CHECK-SAME: <td align="left">foo</td><td align="left">0</td>
   // CHECK-SAME: <td align="left">&amp;Element\{"foo",0 S64b,char\}</td>
   // CHECK: <td align="left"><b>Expressions: </b></td>
   // CHECK-SAME: <td align="left">"foo"</td>
   // CHECK-SAME: <td align="left">&amp;Element\{"foo",0 S64b,char\}</td>
   const char *const foo = "\x66\x6f\x6f";
 
   // CHECK: <font color="cyan4">BinaryOperator</font>
   // CHECK-SAME: <td align="left">1 \| 2</td>
   // CHECK-SAME: <td align="left">3 S32b</td>
   int x = 1 | 2;
 }

clang/test/Analysis/exploded-graph-rewriter/initializers_under_construction.cpp

 // FIXME: Figure out how to use %clang_analyze_cc1 with our lit.local.cfg.
 // RUN: %clang_cc1 -analyze -triple x86_64-unknown-linux-gnu \
 // RUN:                     -analyzer-checker=core \
 // RUN:                     -analyzer-dump-egraph=%t.dot %s
 // RUN: %exploded_graph_rewriter %t.dot | FileCheck %s
-// REQUIRES: asserts
 
 struct A {
   A() {}
 };
 
 struct B {
   A a;
   B() : a() {}
 };
 
 void test() {
   // CHECK: (construct into member variable)
   // CHECK-SAME: <td align="left">a</td>
   // CHECK-SAME: <td align="left">&amp;b.a</td>
   B b;
 }

clang/test/Analysis/exploded-graph-rewriter/l_name_starts_with_l.cpp

 // CAUTION: The name of this file should start with `l` for proper tests.
 // FIXME: Figure out how to use %clang_analyze_cc1 with our lit.local.cfg.
 // RUN: %clang_cc1 -analyze -triple x86_64-unknown-linux-gnu \
 // RUN:                     -analyzer-checker=core \
 // RUN:                     -analyzer-dump-egraph=%t.dot %s
 // RUN: %exploded_graph_rewriter %t.dot | FileCheck %s
-// REQUIRES: asserts
 
 void test1() {
   // Here __FILE__ macros produces a string with `\` delimiters on Windows
   // and the name of the file starts with `l`.
   char text[] = __FILE__;
 }
 
 void test2() {

clang/test/Analysis/exploded-graph-rewriter/macros.c

 #define NULL 0
 void *foo(void) {
   return NULL;
 }
 
 // The code above shall go first, because check tags below are sensetive to the line numbers on which the code is placed.
 // You can change lines below in the way you need.
 
 // FIXME: Figure out how to use %clang_analyze_cc1 with our lit.local.cfg.
 // RUN: %clang_cc1 -analyze -triple x86_64-unknown-linux-gnu \
 // RUN:                     -analyzer-checker=core \
 // RUN:                     -analyzer-dump-egraph=%t.dot %s
 // RUN: %exploded_graph_rewriter %t.dot | FileCheck %s
-// REQUIRES: asserts
 
 // CHECK: macros.c:<b>3</b>:<b>10</b>
 // CHECK-SAME: <font color="royalblue1">
 // CHECK-SAME:   (<i>spelling at </i> macros.c:<b>1</b>:<b>14</b>)
 // CHECK-SAME: </font>

clang/test/Analysis/exploded-graph-rewriter/objects_under_construction.cpp

 // FIXME: Figure out how to use %clang_analyze_cc1 with our lit.local.cfg.
 // RUN: %clang_cc1 -analyze -triple x86_64-unknown-linux-gnu \
 // RUN:                     -analyze-function "test()" \
 // RUN:                     -analyzer-checker=core \
 // RUN:                     -analyzer-dump-egraph=%t.dot %s
 // RUN: %exploded_graph_rewriter %t.dot | FileCheck %s
-// REQUIRES: asserts
 
 struct S {
   S() {}
 };
 
 void test() {
   // CHECK: Objects Under Construction:
   // CHECK-SAME: <tr>

clang/test/Analysis/exploded-graph-rewriter/win_path_forbidden_chars.cpp

 // FIXME: Figure out how to use %clang_analyze_cc1 with our lit.local.cfg.
 // RUN: %clang_cc1 -analyze -triple x86_64-unknown-linux-gnu \
 // RUN:                     -analyzer-checker=core \
 // RUN:                     -analyzer-dump-egraph=%t.dot %s
 // RUN: %exploded_graph_rewriter --verbose %t.dot 2>&1 | FileCheck %s
-// REQUIRES: asserts
 // UNSUPPORTED: !windows
 
 // Angle brackets shall not be presented in the field `file`,
 // because exploded_graph_rewriter handles it as a file path
 // and such symbols are forbidden on Windows platform.
 
 void test() {
   // This produces angle brackets.
   char text[] = __FILE__;
 }
 
 // This test is passed if exploded_graph_rewriter handles dot file without errors.
 // CHECK: DEBUG:root:Line: digraph "Exploded Graph"
 // CHECK: \"file\": \"scratch space\"