ExtractFunctionArguments.h

Go to the documentation of this file.

#pragma once

#include <rose.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);
};