ConstantAliasAnalyzer Class Reference

#include <ConstantAliasAnalyzer.hh>

Inheritance diagram for ConstantAliasAnalyzer:

Collaboration diagram for ConstantAliasAnalyzer:

Public Member Functions
virtual bool	isAddressTraceable (DataDependenceGraph &ddg, const ProgramOperation &pop)
virtual AliasingResult	analyze (DataDependenceGraph &ddg, const ProgramOperation &pop1, const ProgramOperation &pop2, MoveNodeUse::BBRelation bbInfo)
	~ConstantAliasAnalyzer ()
Public Member Functions inherited from MemoryAliasAnalyzer
virtual void	initProcedure (TTAProgram::Procedure &)
virtual	~MemoryAliasAnalyzer ()

Static Public Member Functions
static bool	getConstantAddress (DataDependenceGraph &ddg, const ProgramOperation &po, long &addr, long &loopIncrement)

Additional Inherited Members
Public Types inherited from MemoryAliasAnalyzer
enum	AliasingResult { ALIAS_FALSE = 0 , ALIAS_TRUE = 1 , ALIAS_UNKNOWN = 2 , ALIAS_PARTIAL = 3 }
Protected Member Functions inherited from MemoryAliasAnalyzer
AliasingResult	compareIndeces (int index1, int index2, const ProgramOperation &pop1, const ProgramOperation &pop2)
Static Protected Member Functions inherited from MemoryAliasAnalyzer
static const MoveNode *	addressOperandMove (const ProgramOperation &po)
static TwoPartAddressOperandDetection	findTwoPartAddressOperands (const ProgramOperation &po)
static const MoveNode *	searchLoopIndexBasedIncrement (DataDependenceGraph &ddg, const MoveNode &mn, long &loopIncrement)
static const MoveNode *	findIncrement (const MoveNode &mn, long &increment)
static const MoveNode *	detectConstantScale (const MoveNode &mn, int &shiftAmount)

Detailed Description

Definition at line 42 of file ConstantAliasAnalyzer.hh.

Constructor & Destructor Documentation

~ConstantAliasAnalyzer()

ConstantAliasAnalyzer::~ConstantAliasAnalyzer

(

)

Definition at line 130 of file ConstantAliasAnalyzer.cc.

{}

Member Function Documentation

analyze()

MemoryAliasAnalyzer::AliasingResult ConstantAliasAnalyzer::analyze ( DataDependenceGraph &  ddg, const ProgramOperation &  pop1, const ProgramOperation &  pop2, MoveNodeUse::BBRelation  bbInfo  )

virtual

Implements MemoryAliasAnalyzer.

Definition at line 104 of file ConstantAliasAnalyzer.cc.

                                 {
 
    long addr1, addr2;
    long inc1 = 0, inc2 = 0;
 
    if (!getConstantAddress(ddg, pop1, addr1, inc1) ||
        !getConstantAddress(ddg, pop2, addr2, inc2)) {
        return ALIAS_UNKNOWN;
    }
 
    // if updated different amount, may overlap?
    if (inc1 != inc2) {
        return ALIAS_UNKNOWN;
    }
 
    if (bbRel != MoveNodeUse::LOOP) {
        return compareIndeces(addr1, addr2, pop1, pop2);
    } else {
        return compareIndeces(addr1, addr2+inc2, pop1, pop2);
    }
}

References MemoryAliasAnalyzer::ALIAS_UNKNOWN, MemoryAliasAnalyzer::compareIndeces(), getConstantAddress(), and MoveNodeUse::LOOP.

Here is the call graph for this function:

getConstantAddress()

bool ConstantAliasAnalyzer::getConstantAddress ( DataDependenceGraph &  ddg, const ProgramOperation &  po, long &  addr, long &  loopIncrement  )

static

Definition at line 50 of file ConstantAliasAnalyzer.cc.

                                     {
    const MoveNode* mn = addressOperandMove(po);
    addr = 0;
    while (mn != NULL && mn->isMove()) {
        if (mn->isSourceVariable()) {
            MoveNode* prevSrc = ddg.onlyRegisterRawSource(*mn,2,2);
            MoveNode* loopSrc = ddg.onlyRegisterRawSource(*mn,2,1);
            if (prevSrc == NULL) {
                break;
            }
            if (loopSrc) {
                if (!findIncrement(*loopSrc, loopIncrement)) {
                    return false;
                }
            }
            mn = prevSrc;
        } else {
            if (mn->isSourceOperation()) {
                const MoveNode* incrementInput = findIncrement(*mn, addr);
                if (incrementInput != NULL) {
                    mn = incrementInput;
                } else {
                    mn = searchLoopIndexBasedIncrement(ddg, *mn, loopIncrement);
                }
            } else {
                if (mn->isMove()) {
                    const Move& move = mn->move();
                    if (!move.isFunctionCall()) {
                        const Terminal& src = move.source();
                        if (src.isImmediate()) {
                            addr += src.value().unsignedValue();
                            return true;
                        }
                    }
                }
                return false;
            }
        }
    }
    return false;
}

References MemoryAliasAnalyzer::addressOperandMove(), MemoryAliasAnalyzer::findIncrement(), TTAProgram::Move::isFunctionCall(), TTAProgram::Terminal::isImmediate(), MoveNode::isMove(), MoveNode::isSourceOperation(), MoveNode::isSourceVariable(), MoveNode::move(), DataDependenceGraph::onlyRegisterRawSource(), MemoryAliasAnalyzer::searchLoopIndexBasedIncrement(), TTAProgram::Move::source(), SimValue::unsignedValue(), and TTAProgram::Terminal::value().

Referenced by analyze(), GlobalVsStackAA::analyze(), isAddressTraceable(), and GlobalVsStackAA::isAddressTraceable().

Here is the call graph for this function:

isAddressTraceable()

bool ConstantAliasAnalyzer::isAddressTraceable ( DataDependenceGraph &  ddg, const ProgramOperation &  pop  )

virtual

Checks whether the analyzer knows anything about the address.

ie. if it can return true or false to some query concerning this address.

Returns

true if analyzer can know something about the address.

Implements MemoryAliasAnalyzer.

Definition at line 95 of file ConstantAliasAnalyzer.cc.

                                                          {
    long tmp;
    long tmp2 = 0;
    return getConstantAddress(ddg, po, tmp, tmp2);
}

References getConstantAddress().

Here is the call graph for this function:

---

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

• ConstantAliasAnalyzer.hh
• ConstantAliasAnalyzer.cc