[cfe-commits] r41868 - in /cfe/trunk: AST/CFG.cpp include/clang/AST/CFG.h
Chris Lattner
clattner at apple.com
Wed Sep 12 11:19:18 PDT 2007
> URL: http://llvm.org/viewvc/llvm-project?rev=41868&view=rev
> Log:
> Added static method "CFG::hasImplicitControlFlow".
>
> This method is used to determine if an expression contains implicit
> control-flow, and thus appears in a distinct statement slot in the
> CFG.
Hi Ted,
I think it would make sense to make this a method of the Stmt class.
When we add other operators and control flow constructs in the future
(e.g. for C++) it will be more likely that we'll notice that this
needs to be updated to handle it.
Thanks!
-Chirs
> Modified: cfe/trunk/AST/CFG.cpp
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/AST/CFG.cpp?
> rev=41868&r1=41867&r2=41868&view=diff
>
> ======================================================================
> ========
> --- cfe/trunk/AST/CFG.cpp (original)
> +++ cfe/trunk/AST/CFG.cpp Tue Sep 11 17:08:24 2007
> @@ -1240,6 +1240,30 @@
> print_block(OS, cfg, *this, &Helper, true);
> }
>
> +/// hasImplicitControlFlow - Returns true if a given expression is
> +/// is represented within a CFG as having a designated "statement
> slot"
> +bool CFG::hasImplicitControlFlow(const Stmt* S) {
> + switch (S->getStmtClass()) {
> + default:
> + return false;
> +
> + case Stmt::CallExprClass:
> + case Stmt::ConditionalOperatorClass:
> + case Stmt::ChooseExprClass:
> + case Stmt::StmtExprClass:
> + case Stmt::DeclStmtClass:
> + return true;
> +
> + case Stmt::BinaryOperatorClass: {
> + const BinaryOperator* B = cast<BinaryOperator>(S);
> + if (B->isLogicalOp() || B->getOpcode() ==
> BinaryOperator::Comma)
> + return true;
> + else
> + return false;
> + }
> + }
> +}
> +
> //
> ===-------------------------------------------------------------------
> ---===//
> // CFG Graphviz Visualization
> //
> ===-------------------------------------------------------------------
> ---===//
>
> Modified: cfe/trunk/include/clang/AST/CFG.h
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/
> AST/CFG.h?rev=41868&r1=41867&r2=41868&view=diff
>
> ======================================================================
> ========
> --- cfe/trunk/include/clang/AST/CFG.h (original)
> +++ cfe/trunk/include/clang/AST/CFG.h Tue Sep 11 17:08:24 2007
> @@ -222,7 +222,45 @@
> void print(std::ostream& OS) const;
> void dump() const;
> void setEntry(CFGBlock *B) { Entry = B; }
> - void setIndirectGotoBlock(CFGBlock* B) { IndirectGotoBlock = B; }
> + void setIndirectGotoBlock(CFGBlock* B) { IndirectGotoBlock = B; }
> +
> + // Useful Predicates
> +
> + /// hasImplicitControlFlow - Returns true if a given expression is
> + /// is represented within a CFG as having a designated
> "statement slot"
> + /// within a CFGBlock to represent the execution of that
> expression. This
> + /// is usefull for expressions that contain implicit control
> flow, such
> + /// as &&, ||, and ? operators, as well as commas and statement
> expressions.
> + ///
> + /// For example, considering a CFGBlock with the following
> statement:
> + ///
> + /// (1) x = ... ? ... ? ...
> + ///
> + /// When the CFG is built, this logically becomes:
> + ///
> + /// (1) ... ? ... : ... (a unique statement slot for the
> ternary ?)
> + /// (2) x = [E1] (where E1 is actually the
> ConditionalOperator*)
> + ///
> + /// A client of the CFG, when walking the statement at (2),
> will encounter
> + /// E1. In this case, hasImplicitControlFlow(E1) == true, and
> the client
> + /// will know that the expression E1 is explicitly placed into
> its own
> + /// statement slot to capture the implicit control-flow it has.
> + ///
> + /// Special cases:
> + ///
> + /// (1) Function calls.
> + /// Function calls are placed in their own statement slot so that
> + /// that we have a clear identification of "call-return"
> sites. If
> + /// you see a CallExpr nested as a subexpression of E, the
> CallExpr appears
> + /// in a statement slot in the CFG that dominates the location
> of E.
> + ///
> + /// (2) DeclStmts
> + /// We include DeclStmts because the initializer expressions
> for Decls
> + /// will be separated out into distinct statements in the CFG.
> These
> + /// statements will dominate the Decl.
> + ///
> + static bool hasImplicitControlFlow(const Stmt* S);
> +
> };
> } // end namespace clang
>
>
>
> _______________________________________________
> cfe-commits mailing list
> cfe-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
More information about the cfe-commits
mailing list