#include <PRegionMarkerAnalyzer.hh>

Collaboration diagram for PRegionMarkerAnalyzer:

Public Member Functions
	PRegionMarkerAnalyzer (const llvm::MachineFunction &MF_)

virtual	~PRegionMarkerAnalyzer ()

bool	markersFound () const

unsigned	pregion (const llvm::MachineInstr &I) const

Private Member Functions
bool	isPregionEndMarker (const llvm::MachineInstr &I) const

bool	isPregionStartMarker (const llvm::MachineInstr &I) const

unsigned	parsePregionID (const llvm::MachineInstr &I) const

void	findPregions ()

void	propagatePregionID (const llvm::MachineInstr &start, unsigned id)

Private Attributes
const llvm::MachineFunction &	MF

bool	markersFound_

std::map< const llvm::MachineInstr *, unsigned >	pregionIDs_

Detailed Description

Definition at line 42 of file PRegionMarkerAnalyzer.hh.

Constructor & Destructor Documentation

◆ PRegionMarkerAnalyzer()

PRegionMarkerAnalyzer::PRegionMarkerAnalyzer ( const llvm::MachineFunction & MF_ )

Definition at line 48 of file PRegionMarkerAnalyzer.cc.

                                    : MF(MF_), markersFound_(false) {
 
    for (MachineFunction::const_iterator i = MF.begin();
         i != MF.end() && !markersFound_; i++) {        
        for (MachineBasicBlock::const_iterator j = i->begin();
             j != i->end(); j++) {
            const llvm::MachineInstr& mi = *j; 
            if (isPregionStartMarker(mi) || isPregionEndMarker(mi)) {
                markersFound_ = true;
                break;
            }
        }
    }
 
    if (!markersFound_) return;
    findPregions();
}

References findPregions(), isPregionEndMarker(), isPregionStartMarker(), markersFound_, and MF.

Here is the call graph for this function:

◆ ~PRegionMarkerAnalyzer()

virtual PRegionMarkerAnalyzer::~PRegionMarkerAnalyzer ( )

inlinevirtual

Definition at line 45 of file PRegionMarkerAnalyzer.hh.

45{}

Member Function Documentation

◆ findPregions()

void PRegionMarkerAnalyzer::findPregions ( )

private

Finds the parallel region markers and propagates the parallel region ids to the instructions dominated by it.

Definition at line 107 of file PRegionMarkerAnalyzer.cc.

                                    {
 
    for (MachineFunction::const_iterator i = MF.begin();
         i != MF.end(); i++) {        
        for (MachineBasicBlock::const_iterator j = i->begin();
             j != i->end(); j++) {
            const llvm::MachineInstr& mi = *j; 
            if (!isPregionStartMarker(mi))
                continue;
            unsigned pregionId = parsePregionID(mi);
            propagatePregionID(mi, pregionId);
        }
    }
}

References isPregionStartMarker(), MF, parsePregionID(), and propagatePregionID().

Referenced by PRegionMarkerAnalyzer().

Here is the call graph for this function:

◆ isPregionEndMarker()

bool PRegionMarkerAnalyzer::isPregionEndMarker ( const llvm::MachineInstr & I ) const

private

Definition at line 128 of file PRegionMarkerAnalyzer.cc.

                                                                         {
    // Count the number of register definitions.
    if (!I.isInlineAsm()) return false;
    unsigned numDefs = 0;
    while (I.getOperand(numDefs).isReg() &&
           I.getOperand(numDefs).isDef())
        ++numDefs;
    TCEString opName = I.getOperand(numDefs).getSymbolName();
    return opName.startsWith(".pregion_end");
}

References TCEString::startsWith().

Referenced by PRegionMarkerAnalyzer(), and propagatePregionID().

Here is the call graph for this function:

◆ isPregionStartMarker()

bool PRegionMarkerAnalyzer::isPregionStartMarker ( const llvm::MachineInstr & I ) const

private

Definition at line 140 of file PRegionMarkerAnalyzer.cc.

                                                                           {
    if (!I.isInlineAsm()) return false;
    // Count the number of register definitions.
    unsigned numDefs = 0;
    while (I.getOperand(numDefs).isReg() &&
           I.getOperand(numDefs).isDef())
        ++numDefs;
    TCEString opName = I.getOperand(numDefs).getSymbolName();
    return opName.startsWith(".pregion_start.");
}

References TCEString::startsWith().

Referenced by findPregions(), parsePregionID(), PRegionMarkerAnalyzer(), and propagatePregionID().

Here is the call graph for this function:

◆ markersFound()

bool PRegionMarkerAnalyzer::markersFound ( ) const

Definition at line 123 of file PRegionMarkerAnalyzer.cc.

                                          {
    return markersFound_;
}

References markersFound_.

Referenced by llvm::LLVMTCEBuilder::addPointerAnnotations().

◆ parsePregionID()

unsigned PRegionMarkerAnalyzer::parsePregionID ( const llvm::MachineInstr & I ) const

private

Definition at line 152 of file PRegionMarkerAnalyzer.cc.

                                                                     {
    if (!isPregionStartMarker(I)) return UINT_MAX;
 
    unsigned numDefs = 0;
    while (I.getOperand(numDefs).isReg() &&
           I.getOperand(numDefs).isDef())
        ++numDefs;
 
    TCEString opName = I.getOperand(numDefs).getSymbolName();
 
    return Conversion::toUnsignedInt(opName.split(".").at(2));
}

References isPregionStartMarker(), TCEString::split(), and Conversion::toUnsignedInt().

Referenced by findPregions().

Here is the call graph for this function:

◆ pregion()

unsigned PRegionMarkerAnalyzer::pregion ( const llvm::MachineInstr & I ) const

Definition at line 166 of file PRegionMarkerAnalyzer.cc.

                                                              {
    if (pregionIDs_.find(&I) != pregionIDs_.end())
        return (*pregionIDs_.find(&I)).second;
    else
        return UINT_MAX;
}

References pregionIDs_.

Referenced by llvm::LLVMTCEBuilder::addPointerAnnotations().

◆ propagatePregionID()

void PRegionMarkerAnalyzer::propagatePregionID	(	const llvm::MachineInstr &	start,
		unsigned	id
	)

private

Definition at line 68 of file PRegionMarkerAnalyzer.cc.

                                                {
    const llvm::MachineBasicBlock* mbb = start.getParent();
 
    for (MachineBasicBlock::const_iterator i = &start; 
         i != mbb->end(); 
         ++i) {
        const llvm::MachineInstr* mi = &*i;
        if (mi != &start && 
            (isPregionEndMarker(*mi) || isPregionStartMarker(*mi)))
            return;
 
        if (mi->isCall() && !mi->isInlineAsm()) return;
 
#ifdef DEBUG_PREGIONS
        std::cerr << "### PRA: propagating region id " << id << " to ";
        mi->dump();                
#endif 
        pregionIDs_[mi] = id;
    }
    for (MachineBasicBlock::const_succ_iterator i = mbb->succ_begin();
         i != mbb->succ_end(); ++i) {
        const llvm::MachineBasicBlock* child = *i;
        const llvm::MachineInstr* first = &child->front();
        // avoid looping forever by checking whether the info
        // has been propagated already to the recusrively
        // traversed basic blocks
        if (pregionIDs_.find(first) == pregionIDs_.end() &&
            !isPregionStartMarker(*first) && !isPregionEndMarker(*first))
            propagatePregionID(child->front(), id);
    }
}