ssaUnfilteredCfg.h

//Author: George Vulov <georgevulov@hotmail.com>
#pragma once
 
// DQ (10/5/2014): This is more strict now that we include rose_config.h in the sage3basic.h.
// #include "rose.h"
// rose.h and sage3basic.h should not be included in librose header files. [Robb P. Matzke 2014-10-15]
// #include "sage3basic.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);
            bool returnValue = true;
 
            //Exclude compiler generated functions, but keep template instantiations
            if (funcDecl->get_file_info()->isCompilerGenerated() && !isSgTemplateInstantiationFunctionDecl(funcDecl)
                    && !isSgTemplateInstantiationMemberFunctionDecl(funcDecl))
                returnValue = false;
 
            //We don't process functions that don't have definitions
            if (funcDecl->get_definingDeclaration() == NULL)
                returnValue = false;
 
            return returnValue;
        }
    };
    struct FunctionFilter {…};
 
    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);
    };
    class SSA_UnfilteredCfg {…};
 
} //namespace ssa_unfiltered_cfg