#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);
     }
 }