From ff2046a93e8fccf00bb4ffafcf651895d7494798 Mon Sep 17 00:00:00 2001 From: Alexander Kornienko Date: Fri, 8 Jul 2016 10:50:51 +0000 Subject: [PATCH] CFGBuilder: Fix crash when visiting a range-based for over a dependent type Summary: CFG generation is expected to fail in this case, but it should not crash. Also added a test that reproduces the crash. Reviewers: klimek Subscribers: cfe-commits Patch by Martin Boehme! Differential Revision: http://reviews.llvm.org/D21895 llvm-svn: 274834 --- clang/lib/Analysis/CFG.cpp | 2 + clang/unittests/Analysis/CFGTest.cpp | 58 +++++++++++++++++++++++++ clang/unittests/Analysis/CMakeLists.txt | 13 ++++++ clang/unittests/CMakeLists.txt | 1 + 4 files changed, 74 insertions(+) create mode 100644 clang/unittests/Analysis/CFGTest.cpp create mode 100644 clang/unittests/Analysis/CMakeLists.txt diff --git a/clang/lib/Analysis/CFG.cpp b/clang/lib/Analysis/CFG.cpp index d9349fc4092d..2c502cdcf4e0 100644 --- a/clang/lib/Analysis/CFG.cpp +++ b/clang/lib/Analysis/CFG.cpp @@ -3457,6 +3457,8 @@ CFGBlock *CFGBuilder::VisitCXXForRangeStmt(CXXForRangeStmt *S) { // continue statements. Block = nullptr; Succ = addStmt(S->getInc()); + if (badCFG) + return nullptr; ContinueJumpTarget = JumpTarget(Succ, ContinueScopePos); // The starting block for the loop increment is the block that should diff --git a/clang/unittests/Analysis/CFGTest.cpp b/clang/unittests/Analysis/CFGTest.cpp new file mode 100644 index 000000000000..715fdcb80605 --- /dev/null +++ b/clang/unittests/Analysis/CFGTest.cpp @@ -0,0 +1,58 @@ +//===- unittests/Analysis/CFGTest.cpp - CFG tests -------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "clang/ASTMatchers/ASTMatchFinder.h" +#include "clang/Analysis/CFG.h" +#include "clang/Tooling/Tooling.h" +#include "gtest/gtest.h" +#include +#include + +namespace clang { +namespace analysis { +namespace { + +// Constructing a CFG for a range-based for over a dependent type fails (but +// should not crash). +TEST(CFG, RangeBasedForOverDependentType) { + const char *Code = "class Foo;\n" + "template \n" + "void f(const T &Range) {\n" + " for (const Foo *TheFoo : Range) {\n" + " }\n" + "}\n"; + + class CFGCallback : public ast_matchers::MatchFinder::MatchCallback { + public: + bool SawFunctionBody = false; + + void run(const ast_matchers::MatchFinder::MatchResult &Result) override { + const auto *Func = Result.Nodes.getNodeAs("func"); + Stmt *Body = Func->getBody(); + if (!Body) + return; + SawFunctionBody = true; + std::unique_ptr cfg = + CFG::buildCFG(nullptr, Body, Result.Context, CFG::BuildOptions()); + EXPECT_EQ(nullptr, cfg); + } + } Callback; + + ast_matchers::MatchFinder Finder; + Finder.addMatcher(ast_matchers::functionDecl().bind("func"), &Callback); + std::unique_ptr Factory( + tooling::newFrontendActionFactory(&Finder)); + std::vector Args = {"-std=c++11"}; + ASSERT_TRUE(tooling::runToolOnCodeWithArgs(Factory->create(), Code, Args)); + EXPECT_TRUE(Callback.SawFunctionBody); +} + +} // namespace +} // namespace analysis +} // namespace clang diff --git a/clang/unittests/Analysis/CMakeLists.txt b/clang/unittests/Analysis/CMakeLists.txt new file mode 100644 index 000000000000..e31447caf73b --- /dev/null +++ b/clang/unittests/Analysis/CMakeLists.txt @@ -0,0 +1,13 @@ +set(LLVM_LINK_COMPONENTS + Support + ) + +add_clang_unittest(CFGTests + CFGTest.cpp + ) + +target_link_libraries(CFGTests + clangAnalysis + clangASTMatchers + clangTooling + ) diff --git a/clang/unittests/CMakeLists.txt b/clang/unittests/CMakeLists.txt index b85ec7e6dfa0..7d407ce3f649 100644 --- a/clang/unittests/CMakeLists.txt +++ b/clang/unittests/CMakeLists.txt @@ -13,6 +13,7 @@ add_subdirectory(Basic) add_subdirectory(Lex) add_subdirectory(Driver) if(CLANG_ENABLE_STATIC_ANALYZER) + add_subdirectory(Analysis) add_subdirectory(StaticAnalyzer) add_subdirectory(Frontend) endif()