llvm::MachineDCE Struct Reference

#include <MachineDCE.hh>

Inheritance diagram for llvm::MachineDCE:

Collaboration diagram for llvm::MachineDCE:

Public Types
typedef std::map< std::string, MachineFunction * >	FunctionMap
typedef std::set< std::string >	UserList
typedef std::map< std::string, UserList >	UserRelations
typedef std::set< const std::string * >	AvoidRecursionSet
typedef std::set< std::string >	UnusedFunctionsList

Public Member Functions
	MachineDCE ()
virtual bool	doInitialization (Module &M) override
virtual bool	runOnMachineFunction (MachineFunction &F) override
virtual bool	doFinalization (Module &M) override
virtual StringRef	getPassName () const override
bool	canFindStart (const std::string &user, AvoidRecursionSet &avoid_recursion)
void	addInitializer (const Constant *init, std::string &name)

Public Attributes
FunctionMap	functionMappings_
	Function name to MachineFunction map. More...
UserRelations	usersOfValue_
	List of users of a symbol. More...
UserList	baseUsers_
	If users are traced to this list it means that function cannot be eliminated. More...
UnusedFunctionsList	removeableFunctions

Static Public Attributes
static char	ID = 0

Detailed Description

Definition at line 66 of file MachineDCE.hh.

Member Typedef Documentation

AvoidRecursionSet

typedef std::set<const std::string*> llvm::MachineDCE::AvoidRecursionSet

Definition at line 72 of file MachineDCE.hh.

FunctionMap

typedef std::map<std::string, MachineFunction*> llvm::MachineDCE::FunctionMap

Definition at line 69 of file MachineDCE.hh.

UnusedFunctionsList

typedef std::set<std::string> llvm::MachineDCE::UnusedFunctionsList

Definition at line 96 of file MachineDCE.hh.

UserList

typedef std::set<std::string> llvm::MachineDCE::UserList

Definition at line 70 of file MachineDCE.hh.

UserRelations

typedef std::map<std::string, UserList> llvm::MachineDCE::UserRelations

Definition at line 71 of file MachineDCE.hh.

Constructor & Destructor Documentation

MachineDCE()

llvm::MachineDCE::MachineDCE ( )

inline

Definition at line 68 of file MachineDCE.hh.

: MachineFunctionPass(ID) {}

Member Function Documentation

addInitializer()

void MachineDCE::addInitializer	(	const Constant *	init,
		std::string &	name
	)

Definition at line 85 of file MachineDCE.cc.

                                                                     {
 
    if (const GlobalValue* gv = dyn_cast<GlobalValue>(init)) {
#ifdef DEBUG_MACHINE_DCE
        errs() << "Added data " << name 
               << " to uses of value: " << gv->getName()
               << " and " << name << " to baseUsers." 
               << "\n";
#endif
        baseUsers_.insert(name);
        usersOfValue_[gv->getName().str()].insert(name);
    }
    
    if ((dyn_cast<ConstantArray>(init) != NULL) ||
        (dyn_cast<ConstantStruct>(init) != NULL) ||
        (dyn_cast<ConstantVector>(init) != NULL) ||
        (dyn_cast<ConstantExpr>(init) != NULL)) {
        
        for (unsigned i = 0, e = init->getNumOperands(); i != e; ++i) {
            //init->getOperand(i)->dump();
            //addInitializer(dyn_cast<const Constant*>(init->getOperand(i)), name);
            addInitializer(cast<Constant>(init->getOperand(i)), name);
        }
    }
}

References baseUsers_, and usersOfValue_.

Referenced by doInitialization().

canFindStart()

bool MachineDCE::canFindStart	(	const std::string &	user,
		AvoidRecursionSet &	avoid_recursion
	)

Returns true if can find startpoint.

Definition at line 62 of file MachineDCE.cc.

                                                                                       {
    if (avoid_recursion.find(&user) != avoid_recursion.end()) {
        return false;
    } else {
        avoid_recursion.insert(&user);
    }
 
    // current function is actually the start point.. nice job.
    if (baseUsers_.find(user) != baseUsers_.end()) {
        return true;
    }
 
    UserList &usesList = usersOfValue_[user];
 
    // check if this function is used by start point to be sure...
    for (UserList::iterator i= usesList.begin(); i != usesList.end(); i++) {
        if (canFindStart((*i), avoid_recursion)) {
            return true;
        }
    }    
    return false;
}

References baseUsers_, and usersOfValue_.

Referenced by doFinalization().

doFinalization()

bool MachineDCE::doFinalization ( Module &  M )

overridevirtual

Definition at line 185 of file MachineDCE.cc.

                                       {    
 
    // errs() << "Finalizing MachineDCE\n";
    
    // For all functions check that they are reached from entrypoint of module.
    for (FunctionMap::iterator func = functionMappings_.begin(); 
         func != functionMappings_.end(); ++func) {
 
        AvoidRecursionSet avoid_recursion;
 
        if (!canFindStart(func->first, avoid_recursion)) {
#ifdef DEBUG_MACHINE_DCE
            std::cerr << "Function was not referred add it to dce data: " 
                      << func->first << "\n";
#endif
            removeableFunctions.insert(func->first);
        }
    }
   
    return true;
}

References canFindStart(), functionMappings_, and removeableFunctions.

Here is the call graph for this function:

doInitialization()

bool MachineDCE::doInitialization ( Module &  M )

overridevirtual

Definition at line 111 of file MachineDCE.cc.

                                           {
 
#ifdef DEBUG_MACHINE_DCE
    std::cerr << "Initializing MachineDCE\n";
#endif
 
    for (Module::const_iterator f = M.begin(), e = M.end(); f != e; ++f) {
        if (!(f->getName().equals("_start") ||
              f->getName().equals("_exit")))
            continue;
        baseUsers_.insert(f->getName().data());
#ifdef DEBUG_MACHINE_DCE
        std::cerr << "Added " << f->getName().str()
                  << " to entry/exit functions"
                  << std::endl;
        f->dump();
#endif
        continue;
    }
 
    // Go through global variables to find out.
    for (Module::const_global_iterator i = M.global_begin();
         i != M.global_end(); i++) {
        std::string name = i->getName().str();
 
        if (!i->hasInitializer()) {
            continue;
            assert(false && "No initializer. External linkage?");
        }
 
        const Constant* initializer = i->getInitializer();
#if 0
        const Type* type = initializer->getType();
        errs() << "Data name: " << name
               << "\ttype: " << type->getDescription() << "\n";
#endif
        addInitializer(initializer, name);        
    }
    
    return true;
}

References addInitializer(), assert, and baseUsers_.

Here is the call graph for this function:

getPassName()

virtual StringRef llvm::MachineDCE::getPassName ( ) const

inlineoverridevirtual

Definition at line 88 of file MachineDCE.hh.

                                                   {
        return "TCE deadcode elimination of unused emulation functions";
    }

runOnMachineFunction()

bool MachineDCE::runOnMachineFunction ( MachineFunction &  F )

overridevirtual

Definition at line 153 of file MachineDCE.cc.

                                                        {
    std::string funcName = F.getFunction().getName().str();
 
    // add function to function map...
    functionMappings_[funcName] = &F;
    
    for (MachineFunction::const_iterator i = F.begin();
         i != F.end(); i++) {        
        for (MachineBasicBlock::const_iterator j = i->begin();
             j != i->end(); j++) {
            
            for (unsigned k = 0; k < j->getNumOperands(); k++) {
                const MachineOperand& mo = j->getOperand(k);
                
                std::string moName;
 
                if (mo.isGlobal()) {
                    moName = mo.getGlobal()->getName().str();
                } else if (mo.isSymbol()) {
                    moName = mo.getSymbolName();
                }
                
                if (!moName.empty()) {
                    usersOfValue_[moName].insert(funcName);
                }
            }
        }        
    }    
    return true;
}

References functionMappings_, and usersOfValue_.

Member Data Documentation

baseUsers_

UserList llvm::MachineDCE::baseUsers_

If users are traced to this list it means that function cannot be eliminated.

Definition at line 82 of file MachineDCE.hh.

Referenced by addInitializer(), canFindStart(), and doInitialization().

functionMappings_

FunctionMap llvm::MachineDCE::functionMappings_

Function name to MachineFunction map.

Definition at line 75 of file MachineDCE.hh.

Referenced by doFinalization(), and runOnMachineFunction().

ID

char MachineDCE::ID = 0

static

Definition at line 67 of file MachineDCE.hh.

removeableFunctions

UnusedFunctionsList llvm::MachineDCE::removeableFunctions

Definition at line 97 of file MachineDCE.hh.

Referenced by llvm::LLVMTCEBuilder::deleteDeadProcedures(), and doFinalization().

usersOfValue_

UserRelations llvm::MachineDCE::usersOfValue_

List of users of a symbol.

Definition at line 78 of file MachineDCE.hh.

Referenced by addInitializer(), canFindStart(), and runOnMachineFunction().

---

The documentation for this struct was generated from the following files:

• MachineDCE.hh
• MachineDCE.cc