#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.

130 {}

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 MoveNodeUse::LOOP.

◆ 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 TTAProgram::Move::isFunctionCall(), TTAProgram::Terminal::isImmediate(), MoveNode::isMove(), MoveNode::isSourceOperation(), MoveNode::isSourceVariable(), MoveNode::move(), DataDependenceGraph::onlyRegisterRawSource(), TTAProgram::Move::source(), SimValue::unsignedValue(), and TTAProgram::Terminal::value().

Referenced by GlobalVsStackAA::analyze(), 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);
 }

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

Public Member Functions

Static Public Member Functions