ssaUnfilteredCfg.h

Go to the documentation of this file.

//Author: George Vulov <georgevulov@hotmail.com>
#pragma once

#include <rose.h>
#include <string>
#include <iostream>
#include <map>
#include <set>
#include <vector>
#include <algorithm>
#include <ostream>
#include <fstream>
#include <sstream>
#include <boost/foreach.hpp>
#include "filteredCFG.h"
#include <boost/unordered_map.hpp>
#include "reachingDefUnfilteredCfg.h"
#include "CallGraph.h"
#include <uniqueNameTraversal.h>

namespace ssa_unfiltered_cfg
{

    struct FunctionFilter
    {

        bool operator()(SgFunctionDeclaration * funcDecl)
        {
            ROSE_ASSERT(funcDecl != NULL);

            //Exclude compiler generated functions, but keep template instantiations
            if (funcDecl->get_file_info()->isCompilerGenerated() && !isSgTemplateInstantiationFunctionDecl(funcDecl)
                    && !isSgTemplateInstantiationMemberFunctionDecl(funcDecl))
                return false;

            //We don't process functions that don't have definitions
            if (funcDecl->get_definingDeclaration() == NULL)
                return false;

            return true;
        }
    };

    class SSA_UnfilteredCfg
    {
    private:
        SgProject* project;

    public:

        typedef std::vector<SgInitializedName*> VarName;

        typedef boost::shared_ptr<ReachingDef> ReachingDefPtr;

        typedef std::map<VarName, ReachingDefPtr> NodeReachingDefTable;

        typedef std::map<CFGNode, std::set<VarName> > CFGNodeToVarNamesMap;

        typedef std::map<SgNode*, std::set<SgVarRefExp*> > ASTNodeToVarRefsMap;

        typedef std::map<CFGNode, NodeReachingDefTable> CFGNodeToDefTableMap;

    private:

        ASTNodeToVarRefsMap astNodeToUses;

        CFGNodeToDefTableMap localDefTable;

        CFGNodeToDefTableMap reachingDefTable;

        CFGNodeToDefTableMap outgoingDefTable;

    public:

        SSA_UnfilteredCfg(SgProject* proj) : project(proj) { }

        ~SSA_UnfilteredCfg() { }

        void run();

        static bool getDebug()
        {
            return SgProject::get_verbose() > 0;
        }

        static bool getDebugExtra()
        {
            return SgProject::get_verbose() > 1;
        }

    private:
        void runDefUseDataFlow(SgFunctionDefinition* func);

        static bool isBuiltinVar(const VarName& var);

        void expandParentMemberDefinitions(const CFGNodeToVarNamesMap& defs);

        void insertDefsForChildMemberUses(const CFGNodeToVarNamesMap& defs, const std::set<VarName>& usedNames);

        void insertDefsForExternalVariables(SgFunctionDefinition* function, const std::set<VarName>& usedNames);

        void insertPhiFunctions(SgFunctionDefinition* function, const std::vector<CFGNode>& cfgNodesInPostOrder);

        void renumberAllDefinitions(SgFunctionDefinition* func, const std::vector<CFGNode>& cfgNodesInPostOrder);

        void updateIncomingPropagatedDefs(const CFGNode& cfgNode);

        bool propagateDefs(const CFGNode& cfgNode);

        static std::vector<CFGNode> getCfgNodesInPostorder(SgFunctionDefinition* func);


        //------------ GRAPH OUTPUT FUNCTIONS ------------ //

        void printToDOT(SgNode* root, std::ostream &outFile);
        void printToFilteredDOT(SgSourceFile* file, std::ofstream &outFile);

    public:
        //External static helper functions/variables

        static VarName emptyName;

        /*
         *  Printing functions.
         */

        void toDOT(const std::string fileName);

        void toFilteredDOT(const std::string fileName);


        //------------ DEF/USE TABLE ACCESS FUNCTIONS ------------ //

        const NodeReachingDefTable& getReachingDefsBefore(const CFGNode& node) const;

        const NodeReachingDefTable& getReachingDefsAfter(const CFGNode& node) const;

        const NodeReachingDefTable& getDefsAtNode(const CFGNode& node) const;

        const NodeReachingDefTable& getReachingDefsBefore(SgNode* astNode) const;

        const NodeReachingDefTable& getReachingDefsAfter(SgNode* astNode) const;

        const NodeReachingDefTable& getLastVersions(SgFunctionDefinition* astNode) const;

        const std::set<SgVarRefExp*>& getUsesAtNode(SgNode* astNode) const;

        const ReachingDefPtr getDefinitionForUse(SgVarRefExp* astNode) const;

        const ASTNodeToVarRefsMap& getUseTable() const;

        //------------ STATIC UTILITY FUNCTIONS FUNCTIONS ------------ //

        static bool isPrefixOfName(VarName name, VarName prefix);

        static ssa_private::VarUniqueName* getUniqueName(SgNode* node);

        static const VarName& getVarName(SgNode* node);

        static const VarName& getVarForExpression(SgNode* node);

        static SgExpression* buildVariableReference(const VarName& var, SgScopeStatement* scope = NULL);

        static std::string varnameToString(const VarName& vec);

        static void printNodeDefTable(const NodeReachingDefTable& table);
        static void printFullDefTable(const CFGNodeToDefTableMap& defTable);
    };

} //namespace ssa_unfiltered_cfg

---