ExtractFunctionArguments.h

#pragma once
 
// DQ (10/5/2014): This is more strict now that we include rose_config.h in the sage3basic.h.
// #include "rose.h"
#include "sage3basic.h"
 
#include "functionEvaluationOrderTraversal.h"
 
//class FunctionCallInfo;
 
class ExtractFunctionArguments
{
public:
 
    void NormalizeTree(SgNode* tree, bool doUnsafeNormalization = false);
 
    // returns a vector of newly introduced temporaries
    std::vector<SgVariableDeclaration*> GetTemporariesIntroduced();
    
    /*
     IsNormalized: Given a subtree, returns true if every argument of every function call is a trivial arguemnt.
     */    
    bool IsNormalized(SgNode* tree);
    
    /*
     IsNormalizable: Given a subtree, returns true if every argument of every function call is a either trivial arguemnt or
     is present in a SAFE place from where lifting is possible.
     */    
    bool IsNormalizable(SgNode* tree);
 
    
private:
 
    std::vector<SgVariableDeclaration*> temporariesIntroduced;
    std::pair< std::vector<FunctionCallInfo>, std::vector<FunctionCallInfo> > functionCalls;
    
    bool FunctionArgumentNeedsNormalization(SgExpression* argument);
 
    bool FunctionArgsNeedNormalization(SgExprListExp* functionArgs);
 
    bool SubtreeNeedsNormalization(SgNode* top);
 
    void RewriteFunctionCallArguments(const FunctionCallInfo& functionCallInfo);
 
    void InsertStatement(SgStatement* newStatement, SgStatement* location, const FunctionCallInfo& insertionMode);
 
    bool FunctionArgumentCanBeNormalized(SgExpression* argument);
    
    
    /* Given the expression which is the argument to a function call, returns true if that
     expression is trivial. Trivial expressions are those which are simple variable references or constants.
     */
    bool IsFunctionArgumentTrivial(SgExpression* argument);
 
    /* Given a vector of function call sites returns true if every argument of every function call is a trivial expression
     (IsFunctionArgumentTrivial). Such functions don't need to be normalized.
     */
    bool AreAllFunctionCallsTrivial(std::vector<FunctionCallInfo> functions);
    
    /* Given a vector of function call sites, returns true if every argument
     at every function call site is either trivial (IsFunctionArgumentTrivial) or can be normalized (FunctionArgumentCanBeNormalized).
     */
    bool AreAllFunctionCallsNormalizable(std::vector<FunctionCallInfo> functions);
};