[cfe-commits] r41252 - in /cfe/trunk: AST/CFG.cpp Driver/ASTStreamers.cpp Driver/ASTStreamers.h Driver/clang.cpp include/clang/AST/CFG.h
Ted Kremenek
kremenek at apple.com
Tue Aug 21 14:42:04 PDT 2007
Author: kremenek
Date: Tue Aug 21 16:42:03 2007
New Revision: 41252
URL: http://llvm.org/viewvc/llvm-project?rev=41252&view=rev
Log:
Added CFG infrastructure (CFG.cpp and CFG.h) for clang ASTs.
Added builder code to translate ASTs to CFGs. This currently supports
if, return, and non-control flow statements.
Added pretty-printer to debug CFGs.
Added a "-dump-cfg" option to the clang driver to dump CFGs for code
sent through the frontend.
Added:
cfe/trunk/AST/CFG.cpp
cfe/trunk/include/clang/AST/CFG.h
Modified:
cfe/trunk/Driver/ASTStreamers.cpp
cfe/trunk/Driver/ASTStreamers.h
cfe/trunk/Driver/clang.cpp
Added: cfe/trunk/AST/CFG.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/AST/CFG.cpp?rev=41252&view=auto
==============================================================================
--- cfe/trunk/AST/CFG.cpp (added)
+++ cfe/trunk/AST/CFG.cpp Tue Aug 21 16:42:03 2007
@@ -0,0 +1,351 @@
+//===--- CFG.cpp - Classes for representing and building CFGs----*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by Ted Kremenek and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the CFG and CFGBuilder classes for representing and
+// building Control-Flow Graphs (CFGs) from ASTs.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/AST/CFG.h"
+#include "clang/AST/Expr.h"
+#include <iostream>
+#include <iomanip>
+#include <algorithm>
+using namespace clang;
+
+namespace {
+
+ // SaveAndRestore - A utility class that uses RIIA to save and restore
+ // the value of a variable.
+ template<typename T>
+ struct SaveAndRestore {
+ SaveAndRestore(T& x) : X(x), old_value(x) {}
+ ~SaveAndRestore() { X = old_value; }
+
+ T& X;
+ T old_value;
+ };
+}
+
+/// CFGBuilder - This class is implements CFG construction from an AST.
+/// The builder is stateful: an instance of the builder should be used to only
+/// construct a single CFG.
+///
+/// Example usage:
+///
+/// CFGBuilder builder;
+/// CFG* cfg = builder.BuildAST(stmt1);
+///
+class CFGBuilder {
+ CFG* cfg;
+ CFGBlock* Block;
+ CFGBlock* Exit;
+ CFGBlock* Succ;
+ unsigned NumBlocks;
+
+public:
+ explicit CFGBuilder() : cfg(NULL), Block(NULL), Exit(NULL), Succ(NULL),
+ NumBlocks(0) {
+ // Create an empty CFG.
+ cfg = new CFG();
+ }
+
+ ~CFGBuilder() { delete cfg; }
+
+ /// buildCFG - Constructs a CFG from an AST (a Stmt*). The AST can
+ /// represent an arbitrary statement. Examples include a single expression
+ /// or a function body (compound statement). The ownership of the returned
+ /// CFG is transferred to the caller. If CFG construction fails, this method
+ /// returns NULL.
+ CFG* buildCFG(Stmt* Statement) {
+ if (!Statement) return NULL;
+
+ assert (cfg && "CFGBuilder should only be used to construct one CFG");
+
+ // Create the exit block.
+ Block = createBlock();
+ Exit = Block;
+
+ // Visit the statements and create the CFG.
+ if (CFGBlock* B = visitStmt(Statement)) {
+ // Reverse the statements in the last constructed block. Statements
+ // are inserted into the blocks in reverse order.
+ B->reverseStmts();
+ // NULL out cfg so that repeated calls
+ CFG* t = cfg;
+ cfg = NULL;
+ return t;
+ }
+ else {
+ // Error occured while building CFG: Delete the partially constructed CFG.
+ delete cfg;
+ cfg = NULL;
+ return NULL;
+ }
+ }
+
+private:
+
+ // createBlock - Used to lazily create blocks that are connected
+ // to the current (global) succcessor.
+ CFGBlock* createBlock( bool add_successor = true ) {
+ CFGBlock* B = cfg->createBlock(NumBlocks++);
+ if (add_successor && Succ) B->addSuccessor(Succ);
+ return B;
+ }
+
+ // visitStmt - CFG construction is done via a recursive walk of an AST.
+ // We actually parse the AST in reverse order so that the successor
+ // of a basic block is constructed prior to its predecessor. This
+ // allows us to nicely capture implicit fall-throughs without extra
+ // basic blocks.
+ //
+ // The value returned from this function is the last created CFGBlock
+ // that represents the "entry" point for the translated AST node.
+ CFGBlock* visitStmt(Stmt* Statement) {
+ assert (Statement && "visitStmt does not accept NULL Stmt*");
+
+ switch (Statement->getStmtClass()) {
+ default:
+ assert (false && "statement case for CFGBuilder not yet implemented");
+ return NULL;
+
+ // Statements with no branching control flow.
+ case Stmt::NullStmtClass:
+ case Stmt::DeclStmtClass:
+ case Stmt::PreDefinedExprClass:
+ case Stmt::DeclRefExprClass:
+ case Stmt::IntegerLiteralClass:
+ case Stmt::FloatingLiteralClass:
+ case Stmt::StringLiteralClass:
+ case Stmt::CharacterLiteralClass:
+ case Stmt::ParenExprClass:
+ case Stmt::UnaryOperatorClass:
+ case Stmt::SizeOfAlignOfTypeExprClass:
+ case Stmt::ArraySubscriptExprClass:
+ case Stmt::CallExprClass:
+ case Stmt::BinaryOperatorClass:
+ case Stmt::ImplicitCastExprClass:
+ case Stmt::CompoundLiteralExprClass:
+ case Stmt::OCUVectorElementExprClass:
+ // We cannot assume that we are in the middle of a basic block, since
+ // the CFG might only be constructed for this single statement. If
+ // we have no current basic block, just create one lazily.
+ if (!Block) Block = createBlock();
+
+ // Simply add the statement to the current block. We actually
+ // insert statements in reverse order; this order is reversed later
+ // when processing the containing element in the AST.
+ Block->appendStmt(Statement);
+ break;
+
+ case Stmt::CompoundStmtClass: {
+ // Iterate through the statements of the compound statement in reverse
+ // order. Because this statement may contain statements that have
+ // complicated control flow, the value of "Block" may change at any
+ // time. This means that statements in the compound statement will
+ // automatically be distributed across multiple basic blocks when
+ // necessary.
+ CompoundStmt* C = cast<CompoundStmt>(Statement);
+
+ for (CompoundStmt::reverse_body_iterator I = C->body_rbegin(),
+ E = C->body_rend(); I != E; ++I )
+ // Add the statement to the current block.
+ if (!visitStmt(*I)) return NULL;
+
+ break;
+ }
+
+ case Stmt::IfStmtClass: {
+ IfStmt* I = cast<IfStmt>(Statement);
+
+ // We may see an if statement in the middle of a basic block, or
+ // it may be the first statement we are processing. In either case,
+ // we create a new basic block. First, we create the blocks for
+ // the then...else statements, and then we create the block containing
+ // the if statement. If we were in the middle of a block, we
+ // stop processing that block and reverse its statements. That block
+ // is then the implicit successor for the "then" and "else" clauses.
+
+ // The block we were proccessing is now finished. Make it the
+ // successor block.
+ if (Block) {
+ Succ = Block;
+ Block->reverseStmts();
+ }
+
+ // Process the false branch. NULL out Block so that the recursive
+ // call to visitStmt will create a new basic block.
+ // Null out Block so that all successor
+ CFGBlock* ElseBlock = Succ;
+
+ if (Stmt* Else = I->getElse()) {
+ SaveAndRestore<CFGBlock*> sv(Succ);
+
+ // NULL out Block so that the recursive call to visitStmt will
+ // create a new basic block.
+ Block = NULL;
+ ElseBlock = visitStmt(Else);
+ if (!ElseBlock) return NULL;
+ ElseBlock->reverseStmts();
+ }
+
+ // Process the true branch. NULL out Block so that the recursive
+ // call to visitStmt will create a new basic block.
+ // Null out Block so that all successor
+ CFGBlock* ThenBlock;
+ {
+ Stmt* Then = I->getThen();
+ assert (Then);
+ SaveAndRestore<CFGBlock*> sv(Succ);
+ Block = NULL;
+ ThenBlock = visitStmt(Then);
+ if (!ThenBlock) return NULL;
+ ThenBlock->reverseStmts();
+ }
+
+ // Now create a new block containing the if statement.
+ Block = createBlock(false);
+
+ // Add the condition as the last statement in the new block.
+ Block->appendStmt(I->getCond());
+
+ // Set the terminator of the new block to the If statement.
+ Block->setTerminator(I);
+
+ // Now add the successors.
+ Block->addSuccessor(ThenBlock);
+ Block->addSuccessor(ElseBlock);
+
+ break;
+ }
+
+ case Stmt::ReturnStmtClass: {
+ ReturnStmt* R = cast<ReturnStmt>(Statement);
+
+ // If we were in the middle of a block we stop processing that block
+ // and reverse its statements.
+ //
+ // NOTE: If a "return" appears in the middle of a block, this means
+ // that the code afterwards is DEAD (unreachable). We still
+ // keep a basic block for that code; a simple "mark-and-sweep"
+ // from the entry block will be able to report such dead
+ // blocks.
+ if (Block) Block->reverseStmts();
+
+ // Create the new block.
+ Block = createBlock(false);
+
+ // The Exit block is the only successor.
+ Block->addSuccessor(Exit);
+
+ // Add the return expression to the block.
+ Block->appendStmt(R);
+
+ // Add the return statement itself to the block.
+ if (R->getRetValue()) Block->appendStmt(R->getRetValue());
+
+ break;
+ }
+ } // end dispatch on statement class
+
+ return Block;
+ }
+
+};
+
+// BuildCFG - A helper function that builds CFGs from ASTS.
+CFG* CFG::BuildCFG( Stmt* Statement ) {
+ CFGBuilder Builder;
+ return Builder.buildCFG(Statement);
+}
+
+// reverseStmts - A method that reverses the order of the statements within
+// a CFGBlock.
+void CFGBlock::reverseStmts() { std::reverse(Stmts.begin(),Stmts.end()); }
+
+// dump - A simple pretty printer of a CFG that outputs to stderr.
+void CFG::dump() { print(std::cerr); }
+
+// print - A simple pretty printer of a CFG that outputs to an ostream.
+void CFG::print(std::ostream& OS) {
+ // Iterate through the CFGBlocks and print them one by one. Specially
+ // designate the Entry and Exit blocks.
+ for (iterator I = Blocks.begin(), E = Blocks.end() ; I != E ; ++I) {
+ OS << "\n [ B" << I->getBlockID();
+ if (&(*I) == getExit()) OS << " (EXIT) ]\n";
+ else if (&(*I) == getEntry()) OS << " (ENTRY) ]\n";
+ else OS << " ]\n";
+ I->print(OS);
+ }
+ OS << "\n";
+}
+
+// dump - A simply pretty printer of a CFGBlock that outputs to stderr.
+void CFGBlock::dump() { print(std::cerr); }
+
+// print - A simple pretty printer of a CFGBlock that outputs to an ostream.
+// Generally this will only be called from CFG::print.
+void CFGBlock::print(std::ostream& OS) {
+
+ // Iterate through the statements in the block and print them.
+ OS << " ------------------------\n";
+ unsigned j = 1;
+ for (iterator I = Stmts.begin(), E = Stmts.end() ; I != E ; ++I, ++j ) {
+ OS << " " << std::setw(3) << j << ": ";
+ (*I)->printPretty(OS);
+ if (isa<Expr>(*I)) OS << '\n';
+ }
+ OS << " ------------------------\n";
+
+ // Print the predecessors of this block.
+ OS << " Predecessors (" << pred_size() << "):";
+ unsigned i = 0;
+ for (pred_iterator I = pred_begin(), E = pred_end(); I != E; ++I, ++i ) {
+ if (i == 8 || (i-8) == 0) {
+ OS << "\n ";
+ }
+ OS << " B" << (*I)->getBlockID();
+ }
+
+ // Print the terminator of this block.
+ OS << "\n Terminator: ";
+ if (ControlFlowStmt) {
+ switch (ControlFlowStmt->getStmtClass()) {
+ case Stmt::IfStmtClass: {
+ IfStmt* I = cast<IfStmt>(ControlFlowStmt);
+ OS << "if ";
+ I->getCond()->printPretty(std::cerr);
+ OS << "\n";
+ break;
+ }
+
+ case Stmt::ReturnStmtClass: {
+ ReturnStmt* R = cast<ReturnStmt>(ControlFlowStmt);
+ R->printPretty(std::cerr);
+ break;
+ }
+
+ default:
+ assert(false && "terminator print not fully implemented");
+ }
+ }
+ else OS << "<NULL>\n";
+
+ // Print the successors of this block.
+ OS << " Successors (" << succ_size() << "):";
+ i = 0;
+ for (succ_iterator I = succ_begin(), E = succ_end(); I != E; ++I, ++i ) {
+ if (i == 8 || (i-8) % 10 == 0) {
+ OS << "\n ";
+ }
+ OS << " B" << (*I)->getBlockID();
+ }
+ OS << '\n';
+}
\ No newline at end of file
Modified: cfe/trunk/Driver/ASTStreamers.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/Driver/ASTStreamers.cpp?rev=41252&r1=41251&r2=41252&view=diff
==============================================================================
--- cfe/trunk/Driver/ASTStreamers.cpp (original)
+++ cfe/trunk/Driver/ASTStreamers.cpp Tue Aug 21 16:42:03 2007
@@ -13,6 +13,7 @@
#include "ASTStreamers.h"
#include "clang/AST/AST.h"
+#include "clang/AST/CFG.h"
#include "clang/Lex/Preprocessor.h"
#include "clang/Sema/ASTStreamer.h"
using namespace clang;
@@ -142,4 +143,30 @@
ASTStreamer_Terminate(Streamer);
}
+void clang::DumpCFGs(Preprocessor &PP, unsigned MainFileID, bool Stats) {
+ ASTContext Context(PP.getTargetInfo(), PP.getIdentifierTable());
+ ASTStreamerTy *Streamer = ASTStreamer_Init(PP, Context, MainFileID);
+
+ while (Decl *D = ASTStreamer_ReadTopLevelDecl(Streamer)) {
+ if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
+ if (FD->getBody()) {
+ PrintFunctionDeclStart(FD);
+ fprintf(stderr,"\n");
+ if (CFG* C = CFG::BuildCFG(FD->getBody()))
+ C->dump();
+ else
+ fprintf(stderr," Error processing CFG.\n");
+ }
+ }
+ }
+
+ if (Stats) {
+ fprintf(stderr, "\nSTATISTICS:\n");
+ ASTStreamer_PrintStats(Streamer);
+ Context.PrintStats();
+ }
+
+ ASTStreamer_Terminate(Streamer);
+}
+
Modified: cfe/trunk/Driver/ASTStreamers.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/Driver/ASTStreamers.h?rev=41252&r1=41251&r2=41252&view=diff
==============================================================================
--- cfe/trunk/Driver/ASTStreamers.h (original)
+++ cfe/trunk/Driver/ASTStreamers.h Tue Aug 21 16:42:03 2007
@@ -23,6 +23,7 @@
void BuildASTs(Preprocessor &PP, unsigned MainFileID, bool Stats);
void PrintASTs(Preprocessor &PP, unsigned MainFileID, bool Stats);
void DumpASTs(Preprocessor &PP, unsigned MainFileID, bool Stats);
+void DumpCFGs(Preprocessor &PP, unsigned MainFileID, bool Stats);
} // end clang namespace
Modified: cfe/trunk/Driver/clang.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/Driver/clang.cpp?rev=41252&r1=41251&r2=41252&view=diff
==============================================================================
--- cfe/trunk/Driver/clang.cpp (original)
+++ cfe/trunk/Driver/clang.cpp Tue Aug 21 16:42:03 2007
@@ -52,6 +52,7 @@
ParseASTDump, // Parse ASTs and dump them.
ParseASTCheck, // Parse ASTs and check diagnostics.
ParseAST, // Parse ASTs.
+ ParseCFGDump, // Parse ASTS. Build CFGs. Print CFGs.
ParsePrintCallbacks, // Parse and print each callback.
ParseSyntaxOnly, // Parse and perform semantic analysis.
ParseNoop, // Parse with noop callbacks.
@@ -84,6 +85,8 @@
"Run parser, build ASTs, then dump them"),
clEnumValN(ParseASTCheck, "parse-ast-check",
"Run parser, build ASTs, then check diagnostics"),
+ clEnumValN(ParseCFGDump, "dump-cfg",
+ "Run parser, build ASTs, then build and print CFGs."),
clEnumValN(EmitLLVM, "emit-llvm",
"Build ASTs then convert to LLVM, emit .ll file"),
clEnumValEnd));
@@ -825,6 +828,9 @@
case ParseASTDump:
DumpASTs(PP, MainFileID, Stats);
break;
+ case ParseCFGDump:
+ DumpCFGs(PP, MainFileID, Stats);
+ break;
case EmitLLVM:
EmitLLVMFromASTs(PP, MainFileID, Stats);
break;
Added: cfe/trunk/include/clang/AST/CFG.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/AST/CFG.h?rev=41252&view=auto
==============================================================================
--- cfe/trunk/include/clang/AST/CFG.h (added)
+++ cfe/trunk/include/clang/AST/CFG.h Tue Aug 21 16:42:03 2007
@@ -0,0 +1,196 @@
+//===--- CFG.h - Classes for representing and building CFGs------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by Ted Kremenek and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the CFG and CFGBuilder classes for representing and
+// building Control-Flow Graphs (CFGs) from ASTs.
+//
+//===----------------------------------------------------------------------===//
+
+#include <list>
+#include <vector>
+#include <iosfwd>
+
+namespace clang {
+
+class Stmt;
+
+/// CFGBlock - Represents a single basic block in a source-level CFG.
+/// It consists of:
+///
+/// (1) A set of statements/expressions (which may contain subexpressions).
+/// (2) A "terminator" statement (not in the set of statements).
+/// (3) A list of successors and predecessors.
+///
+/// Terminator: The terminator represents the type of control-flow that occurs
+/// at the end of the basic block. The terminator is a Stmt* referring to an
+/// AST node that has control-flow: if-statements, breaks, loops, etc.
+/// If the control-flow is conditional, the condition expression will appear
+/// within the set of statements in the block (usually the last statement).
+///
+/// Predecessors: the order in the set of predecessors is arbitrary.
+///
+/// Successors: the order in the set of successors is NOT arbitrary. We
+/// currently have the following orderings based on the terminator:
+///
+/// Terminator Successor Ordering
+/// -----------------------------------------------------
+/// if Then Block; Else Block
+///
+class CFGBlock {
+ typedef std::vector<Stmt*> StatementListTy;
+ /// Stmts - The set of statements in the basic block.
+ StatementListTy Stmts;
+ /// ControlFlowStmt - The terminator for a basic block that
+ /// indicates the type of control-flow that occurs between a block
+ /// and its successors.
+ Stmt* ControlFlowStmt;
+ /// BlockID - A numerical ID assigned to a CFGBlock during construction
+ /// of the CFG.
+ unsigned BlockID;
+
+ /// Predecessors/Successors - Keep track of the predecessor / successor
+ /// CFG blocks.
+ typedef std::vector<CFGBlock*> AdjacentBlocks;
+ AdjacentBlocks Preds;
+ AdjacentBlocks Succs;
+
+public:
+ explicit CFGBlock(unsigned blockid) : ControlFlowStmt(NULL),
+ BlockID(blockid) {}
+ ~CFGBlock() {};
+
+ // Statement iterators
+ typedef StatementListTy::iterator iterator;
+ typedef StatementListTy::const_iterator const_iterator;
+ typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+ typedef std::reverse_iterator<iterator> reverse_iterator;
+
+ Stmt* front() { return Stmts.front(); }
+ Stmt* back() { return Stmts.back(); }
+
+ iterator begin() { return Stmts.begin(); }
+ iterator end() { return Stmts.end(); }
+ const_iterator begin() const { return Stmts.begin(); }
+ const_iterator end() const { return Stmts.end(); }
+
+ reverse_iterator rbegin() { return Stmts.rbegin(); }
+ reverse_iterator rend() { return Stmts.rend(); }
+ const_reverse_iterator rbegin() const { return Stmts.rbegin(); }
+ const_reverse_iterator rend() const { return Stmts.rend(); }
+
+ unsigned size() const { return Stmts.size(); }
+ bool empty() const { return Stmts.empty(); }
+
+ // CFG iterators
+ typedef AdjacentBlocks::iterator pred_iterator;
+ typedef AdjacentBlocks::const_iterator const_pred_iterator;
+ typedef AdjacentBlocks::reverse_iterator pred_reverse_iterator;
+ typedef AdjacentBlocks::const_reverse_iterator const_pred_reverse_iterator;
+
+ typedef AdjacentBlocks::iterator succ_iterator;
+ typedef AdjacentBlocks::const_iterator const_succ_iterator;
+ typedef AdjacentBlocks::reverse_iterator succ_reverse_iterator;
+ typedef AdjacentBlocks::const_reverse_iterator const_succ_reverse_iterator;
+
+ pred_iterator pred_begin() { return Preds.begin(); }
+ pred_iterator pred_end() { return Preds.end(); }
+ const_pred_iterator pred_begin() const { return Preds.begin(); }
+ const_pred_iterator pred_end() const { return Preds.end(); }
+
+ pred_reverse_iterator pred_rbegin() { return Preds.rbegin(); }
+ pred_reverse_iterator pred_rend() { return Preds.rend(); }
+ const_pred_reverse_iterator pred_rbegin() const { return Preds.rbegin(); }
+ const_pred_reverse_iterator pred_rend() const { return Preds.rend(); }
+
+ succ_iterator succ_begin() { return Succs.begin(); }
+ succ_iterator succ_end() { return Succs.end(); }
+ const_succ_iterator succ_begin() const { return Succs.begin(); }
+ const_succ_iterator succ_end() const { return Succs.end(); }
+
+ succ_reverse_iterator succ_rbegin() { return Succs.rbegin(); }
+ succ_reverse_iterator succ_rend() { return Succs.rend(); }
+ const_succ_reverse_iterator succ_rbegin() const { return Succs.rbegin(); }
+ const_succ_reverse_iterator succ_rend() const { return Succs.rend(); }
+
+ unsigned succ_size() const { return Succs.size(); }
+ bool succ_empty() const { return Succs.empty(); }
+
+ unsigned pred_size() const { return Preds.size(); }
+ bool pred_empty() const { return Preds.empty(); }
+
+ // Manipulation of block contents
+
+ void appendStmt(Stmt* Statement) { Stmts.push_back(Statement); }
+ void setTerminator(Stmt* Statement) { ControlFlowStmt = Statement; }
+ void reverseStmts();
+
+ void addSuccessor(CFGBlock* Block) {
+ Block->Preds.push_back(this);
+ Succs.push_back(Block);
+ }
+
+ unsigned getBlockID() const { return BlockID; }
+
+ void dump();
+ void print(std::ostream& OS);
+};
+
+
+/// CFG - Represents a source-level, intra-procedural CFG that represents the
+/// control-flow of a Stmt. The Stmt can represent an entire function body,
+/// or a single expression. A CFG will always contain one empty block that
+/// represents the Exit point of the CFG. A CFG will also contain a designated
+/// Entry block. The CFG solely represents control-flow; it consists of
+/// CFGBlocks which are simply containers of Stmt*'s in the AST the CFG
+/// was constructed from.
+class CFG {
+ typedef std::list<CFGBlock> CFGBlockListTy;
+ CFGBlockListTy Blocks;
+
+public:
+
+ CFG() {};
+ ~CFG() {};
+
+ CFGBlock* createBlock(unsigned blockID) {
+ Blocks.push_front(CFGBlock(blockID));
+ return front();
+ }
+
+ // Block iterators
+ typedef CFGBlockListTy::iterator iterator;
+ typedef CFGBlockListTy::const_iterator const_iterator;
+ typedef std::reverse_iterator<iterator> reverse_iterator;
+ typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+ CFGBlock* front() { return &Blocks.front(); }
+ CFGBlock* back() { return &Blocks.back(); }
+
+ iterator begin() { return Blocks.begin(); }
+ iterator end() { return Blocks.end(); }
+ const_iterator begin() const { return Blocks.begin(); }
+ const_iterator end() const { return Blocks.end(); }
+
+ reverse_iterator rbegin() { return Blocks.rbegin(); }
+ reverse_iterator rend() { return Blocks.rend(); }
+ const_reverse_iterator rbegin() const { return Blocks.rbegin(); }
+ const_reverse_iterator rend() const { return Blocks.rend(); }
+
+ CFGBlock* getEntry() { return front(); }
+ CFGBlock* getExit() { return back(); }
+
+ // Utility
+
+ static CFG* BuildCFG(Stmt* AST);
+ void print(std::ostream& OS);
+ void dump();
+
+};
+
+} // end namespace clang
\ No newline at end of file
More information about the cfe-commits
mailing list