#include <AnnotatedInstructionElement.hh>

Inheritance diagram for TTAProgram::AnnotatedInstructionElement:

Collaboration diagram for TTAProgram::AnnotatedInstructionElement:

Public Member Functions
	AnnotatedInstructionElement ()

	~AnnotatedInstructionElement ()

void	addAnnotation (const ProgramAnnotation &annotation)

void	setAnnotation (const ProgramAnnotation &annotation)

ProgramAnnotation	annotation (int index, ProgramAnnotation::Id id=ProgramAnnotation::ANN_UNDEF_ID) const

int	annotationCount (ProgramAnnotation::Id id=ProgramAnnotation::ANN_UNDEF_ID) const

void	removeAnnotations (ProgramAnnotation::Id id=ProgramAnnotation::ANN_UNDEF_ID)

bool	hasAnnotations (ProgramAnnotation::Id id=ProgramAnnotation::ANN_UNDEF_ID) const

bool	hasAnnotation (ProgramAnnotation::Id id, const TCEString &data) const

void	copyAnnotationsFrom (const AnnotatedInstructionElement &other)

Private Types
typedef std::multimap< ProgramAnnotation::Id, ProgramAnnotation >	AnnotationIndex
	a type for the container of the annotations

Private Attributes
AnnotationIndex	annotations_
	container for annotations

Detailed Description

AnnotatedInstructionElements provide an interface for the classes that can be attached an instruction annotation.

Basically the TerminalImmediate and Move inherit this to provide such capabilities.

Definition at line 53 of file AnnotatedInstructionElement.hh.

Member Typedef Documentation

◆ AnnotationIndex

typedef std::multimap<ProgramAnnotation::Id, ProgramAnnotation> TTAProgram::AnnotatedInstructionElement::AnnotationIndex

private

a type for the container of the annotations

Definition at line 76 of file AnnotatedInstructionElement.hh.

Constructor & Destructor Documentation

◆ AnnotatedInstructionElement()

TTAProgram::AnnotatedInstructionElement::AnnotatedInstructionElement ( )

Constructor.

Definition at line 48 of file AnnotatedInstructionElement.cc.

48 {

49}

◆ ~AnnotatedInstructionElement()

TTAProgram::AnnotatedInstructionElement::~AnnotatedInstructionElement ( )

Destructor.

Definition at line 54 of file AnnotatedInstructionElement.cc.

54 {

55}

Member Function Documentation

◆ addAnnotation()

void TTAProgram::AnnotatedInstructionElement::addAnnotation ( const ProgramAnnotation & annotation )

Adds an annotation to the instruction element.

Parameters

annotation The annotation to add.

Definition at line 63 of file AnnotatedInstructionElement.cc.

                                         {
    annotations_.insert(
        std::pair<ProgramAnnotation::Id, ProgramAnnotation>(
            annotation.id(), annotation));
}

References annotation(), annotations_, and TTAProgram::ProgramAnnotation::id().

Referenced by llvm::LLVMTCEBuilder::addCandidateLSUAnnotations(), RegisterCopyAdder::addCandidateSetAnnotations(), RegisterCopyAdder::addConnectionRegisterCopies(), RegisterCopyAdder::addConnectionRegisterCopiesImmediate(), InlineAsmParser::addDebugInfoToInlineAsmBB(), llvm::LLVMTCEBuilder::addPointerAnnotations(), annotateAllInputs(), annotateAllOutputs(), llvm::LLVMTCEBuilder::copyFUAnnotations(), TTAProgram::TPEFProgramFactory::createInstruction(), TTAProgram::TPEFProgramFactory::createTerminal(), llvm::LLVMTCEBuilder::debugDataToAnnotations(), DataDependenceGraph::mergeAndKeepSource(), DataDependenceGraph::mergeAndKeepUser(), and BFCopyRegWithOp::splitMove().

Here is the call graph for this function:

◆ annotation()

ProgramAnnotation TTAProgram::AnnotatedInstructionElement::annotation	(	int	index,
		ProgramAnnotation::Id	id = `ProgramAnnotation::ANN_UNDEF_ID`
	)		const

Returns the annotation at the given index (and id).

Parameters

index	The index of the annotation.
id	The id of the annotation (optional).

Exceptions

OutOfRange If the index is out of range.

Definition at line 100 of file AnnotatedInstructionElement.cc.

                                             {
    std::pair<AnnotationIndex::const_iterator, 
        AnnotationIndex::const_iterator> range(
        annotations_.end(), annotations_.end());
 
    if (id != ProgramAnnotation::ANN_UNDEF_ID)
        // set the iterators to point to the set of elements with the given id
        range = annotations_.equal_range(id); 
    else
        // go through all elements
        range = std::make_pair(annotations_.begin(), annotations_.end());
 
    AnnotationIndex::const_iterator i = range.first;
    for (int counter = 0; counter < index; ++counter) {
        ++i;
        if (i == annotations_.end())
            break;
    }
 
    if (i == annotations_.end())
        throw OutOfRange(__FILE__, __LINE__, __func__);
 
    return (*i).second;
}

References __func__, TTAProgram::ProgramAnnotation::ANN_UNDEF_ID, and annotations_.

Referenced by MachineConnectivityCheck::addAnnotatedFUs(), addAnnotation(), PRegionAliasAnalyzer::analyze(), BFOptimization::assign(), TTAProgram::Move::copy(), llvm::LLVMTCEBuilder::copyFUAnnotations(), ControlFlowGraph::createBlock(), TTAProgram::ProgramWriter::createCodeSection(), DataDependenceGraphBuilder::findStaticRegisters(), DataDependenceGraphBuilder::isAlwaysDifferentFU(), DataDependenceGraphBuilder::memoryCategory(), DataDependenceGraph::mergeAndKeepSource(), DataDependenceGraph::mergeAndKeepUser(), setAnnotation(), TTAProgram::Move::sourceFileName(), and TTAProgram::Move::sourceLineNumber().

◆ annotationCount()

int TTAProgram::AnnotatedInstructionElement::annotationCount ( ProgramAnnotation::Id id = ProgramAnnotation::ANN_UNDEF_ID ) const

Returns the count of annotations (with the given id).

Parameters

id	The id of the annotations to count (optional).

Returns: The count of annotations (with the given id).

Definition at line 133 of file AnnotatedInstructionElement.cc.

                                                                         {
    if (id != ProgramAnnotation::ANN_UNDEF_ID)
        return static_cast<int>(annotations_.count(id));
    else
        return static_cast<int>(annotations_.size());
}

References TTAProgram::ProgramAnnotation::ANN_UNDEF_ID, and annotations_.

Referenced by MachineConnectivityCheck::addAnnotatedFUs(), BFOptimization::assign(), TTAProgram::Move::copy(), llvm::LLVMTCEBuilder::copyFUAnnotations(), TTAProgram::ProgramWriter::createCodeSection(), DataDependenceGraphBuilder::findStaticRegisters(), BFOptimization::hasAmbiguousResources(), hasAnnotations(), DataDependenceGraphBuilder::memoryCategory(), and TTAProgram::Move::sourceLineNumber().

◆ copyAnnotationsFrom()

void TTAProgram::AnnotatedInstructionElement::copyAnnotationsFrom ( const AnnotatedInstructionElement & other )

Copies annotations from another annotated element.

Possible old annotations are deleted.

Definition at line 193 of file AnnotatedInstructionElement.cc.

                                              {
    annotations_ = other.annotations_;
}

References annotations_.

Referenced by TTAProgram::Instruction::copy().

◆ hasAnnotation()

bool TTAProgram::AnnotatedInstructionElement::hasAnnotation	(	ProgramAnnotation::Id	id,
		const TCEString &	data
	)		const

Returns true in case there's at least one annotation with the given id and the given data.

Definition at line 174 of file AnnotatedInstructionElement.cc.

                                                         {
 
    auto range = annotations_.equal_range(id);
    for (auto i = range.first; i != range.second; i++) {
        if (i->second.stringValue() == data) {
            return true;
        }
    }
    return false;
}

References annotations_.

Referenced by RegisterCopyAdder::isAllowedUnit(), DataDependenceGraphBuilder::isAlwaysDifferentFU(), and ProgramOperation::isLegalFU().

◆ hasAnnotations()

bool TTAProgram::AnnotatedInstructionElement::hasAnnotations ( ProgramAnnotation::Id id = ProgramAnnotation::ANN_UNDEF_ID ) const

Returns true in case there's at least one annotation with the given id.

Parameters

id	An annotation id.

Returns: True in case there's at least one annotation with the given id.

Definition at line 165 of file AnnotatedInstructionElement.cc.

                                                                        {
    return annotationCount(id) > 0;
}

References annotationCount().

Referenced by PRegionAliasAnalyzer::analyze(), CycleLookBackSoftwareBypasser::bypassNode(), ControlFlowGraph::createBlock(), TTAProgram::ProgramWriter::createCodeSection(), llvm::LLVMTCEBuilder::hasAmbiguousASpaceRefs(), ControlFlowGraph::indirectJump(), RegisterCopyAdder::isAllowedUnit(), OutputPSocketBroker::isAlreadyAssigned(), DataDependenceGraphBuilder::isAlwaysDifferentFU(), OutputPSocketBroker::isApplicable(), IUBroker::isApplicable(), TTAProgram::Move::isFunctionCall(), TTAProgram::Move::isReturn(), DataDependenceGraphBuilder::memoryCategory(), BUBasicBlockScheduler::precedingTempMove(), BasicBlockScheduler::scheduleInputOperandTempMoves(), BUBasicBlockScheduler::scheduleInputOperandTempMoves(), SequentialScheduler::scheduleMove(), BUBasicBlockScheduler::scheduleMove(), BasicBlockScheduler::scheduleMove(), TTAProgram::Move::sourceFileName(), TTAProgram::Move::sourceLineNumber(), BasicBlockScheduler::succeedingTempMove(), BF2Scheduler::unreservePreallocatedFUs(), BasicBlockScheduler::unschedule(), and SequentialScheduler::unschedule().

Here is the call graph for this function:

◆ removeAnnotations()

void TTAProgram::AnnotatedInstructionElement::removeAnnotations ( ProgramAnnotation::Id id = ProgramAnnotation::ANN_UNDEF_ID )

Removes all annotations (with the given id).

Parameters

id	The id of the annotations to remove (optional).

Definition at line 146 of file AnnotatedInstructionElement.cc.

                                                                     {
 
    if (id == ProgramAnnotation::ANN_UNDEF_ID) {
        annotations_.clear();
    }
    AnnotationIndex::iterator i = annotations_.find(id);
    while (i != annotations_.end()) {
        annotations_.erase(i);
        i = annotations_.find(id);
    }
}

References TTAProgram::ProgramAnnotation::ANN_UNDEF_ID, and annotations_.

Referenced by BFOptimization::setPrologDstFUAnno(), BFOptimization::setPrologSrcFUAnno(), BFUpdateMoveOnBypass::undoOnlyMe(), BFCopyRegWithOp::undoSplit(), DataDependenceGraph::unMergeUser(), BF2Scheduler::unreservePreallocatedFUs(), BasicBlockScheduler::unschedule(), and SequentialScheduler::unschedule().

◆ setAnnotation()

void TTAProgram::AnnotatedInstructionElement::setAnnotation ( const ProgramAnnotation & annotation )

Sets an annotation to the instruction element as the sole annotation of that type.

Removes all annotations with the same type before adding the annotation.

Parameters

annotation The annotation to set.

Definition at line 79 of file AnnotatedInstructionElement.cc.

                                         {
    
    // hmm.. does multimap::erase(key) remove *all* elements with the given
    // key, or just first found?
    // multimap::erase(key) returns the number of elements removed as
    // size_type, so it erases all matching elements
    annotations_.erase(annotation.id());
    annotations_.insert(
        std::pair<ProgramAnnotation::Id, ProgramAnnotation>(
            annotation.id(), annotation));
}