[cfe-commits] r41868 - in /cfe/trunk: AST/CFG.cpp include/clang/AST/CFG.h

[Chris Lattner]

> 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