PreOptimizer Class Reference

#include <PreOptimizer.hh>

Inheritance diagram for PreOptimizer:

Collaboration diagram for PreOptimizer:

Public Member Functions
	PreOptimizer (InterPassData &data)
void	handleProgram (TTAProgram::Program &program, const TTAMachine::Machine &targetMachine)
void	handleProcedure (TTAProgram::Procedure &procedure, const TTAMachine::Machine &targetMachine)
void	handleControlFlowGraph (ControlFlowGraph &cfg, const TTAMachine::Machine &targetMachine)
void	handleCFGDDG (ControlFlowGraph &cfg, DataDependenceGraph &ddg)
std::string	shortDescription () const
Public Member Functions inherited from ProcedurePass
	ProcedurePass (InterPassData &data)
virtual	~ProcedurePass ()
Public Member Functions inherited from SchedulerPass
	SchedulerPass (InterPassData &data)
virtual	~SchedulerPass ()
InterPassData &	interPassData ()
virtual std::string	longDescription () const
Public Member Functions inherited from ProgramPass
	ProgramPass (InterPassData &data)
virtual	~ProgramPass ()
Public Member Functions inherited from ControlFlowGraphPass
	ControlFlowGraphPass (InterPassData &data)
virtual	~ControlFlowGraphPass ()
void	executeBasicBlockPass (ControlFlowGraph &cfg, const TTAMachine::Machine &targetMachine, BasicBlockPass &bbPass)

Private Member Functions
ControlFlowGraph::NodeSet	inverseGuardsOfHeads (DataDependenceGraph &ddg, DataDependenceGraph::EdgeSet &oEdges)
bool	checkGuardReversalAllowed (DataDependenceGraph &ddg, DataDependenceGraph::EdgeSet &oEdges)
bool	tryToOptimizeAddressReg (DataDependenceGraph &ddg, ProgramOperation &po)
ControlFlowGraph::NodeSet	tryToRemoveXor (DataDependenceGraph &ddg, ProgramOperation &po, TTAProgram::InstructionReferenceManager *irm, ControlFlowGraph &cfg)
ControlFlowGraph::NodeSet	tryToRemoveEq (DataDependenceGraph &ddg, ProgramOperation &po, TTAProgram::InstructionReferenceManager *irm, ControlFlowGraph &cfg)
ControlFlowGraph::NodeSet	tryToRemoveGuardInversingOp (DataDependenceGraph &ddg, ProgramOperation &po, TTAProgram::InstructionReferenceManager *irm, ControlFlowGraph &cfg)
bool	cfgAllowsJumpReversal (TTAProgram::Instruction &ins, ControlFlowGraph &cfg)
void	tryToPrecalcConstantAdd (DataDependenceGraph &ddg, ProgramOperation &po)

Additional Inherited Members
Static Public Member Functions inherited from ProcedurePass
static void	copyCfgToProcedure (TTAProgram::Procedure &procedure, ControlFlowGraph &cfg)
static void	executeControlFlowGraphPass (TTAProgram::Procedure &procedure, const TTAMachine::Machine &targetmachine, ControlFlowGraphPass &cfgp)
Static Public Member Functions inherited from ProgramPass
static void	executeProcedurePass (TTAProgram::Program &program, const TTAMachine::Machine &targetMachine, ProcedurePass &procedurePass)

Detailed Description

Definition at line 66 of file PreOptimizer.hh.

Constructor & Destructor Documentation

PreOptimizer()

PreOptimizer::PreOptimizer

(

InterPassData &

data

)

Constructor. Initializes interpassData.

Parameters

data	InterPassData to store.

Definition at line 69 of file PreOptimizer.cc.

                                              : ProcedurePass(data),
                                                  ProgramPass(data),
                                                  ControlFlowGraphPass(data) {
}

Member Function Documentation

cfgAllowsJumpReversal()

bool PreOptimizer::cfgAllowsJumpReversal ( TTAProgram::Instruction &  ins, ControlFlowGraph &  cfg  )

private

Check that we can revert the out edges of the cfg when reverting a jump guard

Definition at line 562 of file PreOptimizer.cc.

                                                       {
    TTAProgram::CodeSnippet* parent = &ins.parent();
    for (int j = 0; j < cfg.nodeCount(); j++) {
        BasicBlockNode& bbn = cfg.node(j);
        if (&bbn.basicBlock() == parent) {
            for (int i = 0; i < cfg.outDegree(bbn); i++) {
                ControlFlowEdge& e = cfg.outEdge(bbn,i);
                if (!e.isTrueEdge() && !e.isFalseEdge()) {
                    return false;
                }
            }
        }
    }
    return true;
}

References BasicBlockNode::basicBlock(), ControlFlowEdge::isFalseEdge(), ControlFlowEdge::isTrueEdge(), BoostGraph< GraphNode, GraphEdge >::node(), BoostGraph< GraphNode, GraphEdge >::nodeCount(), BoostGraph< GraphNode, GraphEdge >::outDegree(), BoostGraph< GraphNode, GraphEdge >::outEdge(), and TTAProgram::Instruction::parent().

Referenced by tryToRemoveGuardInversingOp().

Here is the call graph for this function:

checkGuardReversalAllowed()

bool PreOptimizer::checkGuardReversalAllowed ( DataDependenceGraph &  ddg, DataDependenceGraph::EdgeSet &  oEdges  )

private

Definition at line 326 of file PreOptimizer.cc.

                                        {
    
    // loop through all outedges.
    for (DataDependenceGraph::EdgeSet::iterator i = oEdges.begin();
         i != oEdges.end(); i++) {
        DataDependenceEdge& edge = **i;
        bool dstOpIsSelect = false;
        if (edge.dependenceType() == DataDependenceEdge::DEP_RAW && 
            !edge.guardUse()) {
            MoveNode& dstMN = ddg.headNode(edge);
            if (!dstMN.isDestinationOperation()) {
                return false;
            }
            ProgramOperation &dstOp = dstMN.destinationOperation();
            if (dstOp.operation().name() != "SELECT") {
                return false;
            }
            dstOpIsSelect = true;
        }
 
        
        // them checks that those guard usages cannot have some other
        // movenode writing the guard, if some complex guard 
        // calculation where guard write itself is conditional
        // or multiple guard sources in different BBs.
        int gRawCount = 0;
        MoveNode& head = ddg.headNode(edge);
        DataDependenceGraph::EdgeSet iEdges = ddg.inEdges(head);
        for (DataDependenceGraph::EdgeSet::iterator j = iEdges.begin();
             j != iEdges.end(); j++) {
            if ((**j).guardUse() && 
                (**j).dependenceType() == DataDependenceEdge::DEP_RAW) {
                gRawCount++;
                if (gRawCount > 1) {
                    return false;
                }
            }
 
            // Prevent select's condition to be reversed multiple times.
            if ((**j).dependenceType() == DataDependenceEdge::DEP_RAW &&
                dstOpIsSelect) {
                gRawCount++;
                if (gRawCount > 1) {
                    return false;
                }
            }
        }
    }
    return true;
}

References DataDependenceEdge::DEP_RAW, DataDependenceEdge::dependenceType(), MoveNode::destinationOperation(), DataDependenceEdge::guardUse(), BoostGraph< GraphNode, GraphEdge >::headNode(), BoostGraph< GraphNode, GraphEdge >::inEdges(), MoveNode::isDestinationOperation(), Operation::name(), and ProgramOperation::operation().

Referenced by tryToRemoveGuardInversingOp().

Here is the call graph for this function:

handleCFGDDG()

void PreOptimizer::handleCFGDDG	(	ControlFlowGraph &	cfg,
		DataDependenceGraph &	ddg
	)

Definition at line 511 of file PreOptimizer.cc.

                              {
 
    TTAProgram::Program* program = cfg.program();
    TTAProgram::InstructionReferenceManager* irm =
        program == NULL ? NULL :
        &program->instructionReferenceManager();
 
    // Loop over all programoperations. find XOR's by 1.
    for (int i = ddg.programOperationCount() - 1; i >= 0; i--) {
        ProgramOperation& po = ddg.programOperation(i);
        ControlFlowGraph::NodeSet jumpNodes;
        if (po.operation().name() == "XOR" ||
            po.operation().name() == "XOR64") {
            jumpNodes = tryToRemoveXor(ddg, po, irm, cfg);
        }
        if (po.operation().name() == "EQ") {
            jumpNodes = tryToRemoveEq(ddg, po, irm, cfg);
        }
        for (auto bbn : jumpNodes) {
            cfg.reverseGuardOnOutEdges(*bbn);
        }
        if (po.operation().readsMemory()) {
            tryToOptimizeAddressReg(ddg, po);
        }
 
        if (po.operation().name() == "ADD") {
            tryToPrecalcConstantAdd(ddg, po);
        }
    }
    // todo: remove also programoprations.
}

References Operation::name(), ProgramOperation::operation(), program, ControlFlowGraph::program(), DataDependenceGraph::programOperation(), DataDependenceGraph::programOperationCount(), Operation::readsMemory(), ControlFlowGraph::reverseGuardOnOutEdges(), tryToOptimizeAddressReg(), tryToPrecalcConstantAdd(), tryToRemoveEq(), and tryToRemoveXor().

Referenced by llvm::LLVMTCEIRBuilder::compileOptimized(), and handleControlFlowGraph().

Here is the call graph for this function:

handleControlFlowGraph()

void PreOptimizer::handleControlFlowGraph ( ControlFlowGraph &  cfg, const TTAMachine::Machine &  targetMachine  )

virtual

Handles a single control flow graph.

The pass should work with any kind of control flow graph, it should not assume the CFG represents a whole procedure, for example.

Parameters

cfg	The control flow graph to handle.
machine	The target machine if any. (NullMachine::instance() if target machine is irrelevant).

Exceptions

In	case handling is unsuccesful for any reason (cfg might still get modified).

Reimplemented from ControlFlowGraphPass.

Definition at line 546 of file PreOptimizer.cc.

                                                          {
    DataDependenceGraphBuilder ddgBuilder(ProcedurePass::interPassData());
    // only RAW register edges and operation edges. no mem edges, 
    // no anti-edges.
    DataDependenceGraph* ddg = ddgBuilder.build(
        cfg, DataDependenceGraph::NO_ANTIDEPS, mach, NULL, false);
    
    handleCFGDDG(cfg, *ddg);
 
    delete ddg;
}

References DataDependenceGraphBuilder::build(), handleCFGDDG(), SchedulerPass::interPassData(), and DataDependenceGraph::NO_ANTIDEPS.

Referenced by handleProcedure().

Here is the call graph for this function:

handleProcedure()

void PreOptimizer::handleProcedure ( TTAProgram::Procedure &  procedure, const TTAMachine::Machine &  mach  )

virtual

Handles a procedure.

Parameters

procedure	the procedure.
targetMachine	targetmachine. Not used at all.

Reimplemented from ProcedurePass.

Definition at line 484 of file PreOptimizer.cc.

                                                                   {
    // If procedure has too many instructions, may run out of memory.
    // so check the lowmem mode. in lowmem mode this optimiziation 
    // is disabled, so returns.
    SchedulerCmdLineOptions* opts = 
        dynamic_cast<SchedulerCmdLineOptions*>(Application::cmdLineOptions());
    int lowMemThreshold = DEFAULT_LOWMEM_MODE_THRESHOLD;
 
    if (opts != NULL && opts->lowMemModeThreshold() > -1) {
        lowMemThreshold = opts->lowMemModeThreshold();
    }
 
    if (procedure.instructionCount() >=lowMemThreshold) {
        return;
    }
 
    ControlFlowGraph cfg(procedure /*, ProcedurePass::interPassData()*/);
    cfg.updateReferencesFromProcToCfg();
 
    handleControlFlowGraph(cfg, mach);
 
    // copy back to the program.
    cfg.copyToProcedure(procedure);
}

References Application::cmdLineOptions(), ControlFlowGraph::copyToProcedure(), DEFAULT_LOWMEM_MODE_THRESHOLD, handleControlFlowGraph(), TTAProgram::CodeSnippet::instructionCount(), SchedulerCmdLineOptions::lowMemModeThreshold(), and ControlFlowGraph::updateReferencesFromProcToCfg().

Here is the call graph for this function:

handleProgram()

void PreOptimizer::handleProgram ( TTAProgram::Program &  program, const TTAMachine::Machine &  targetMachine  )

virtual

Handles a program.

Parameters

program	the program.
targetMachine	targetmachine. Not used at all.

Reimplemented from ProgramPass.

Definition at line 81 of file PreOptimizer.cc.

                                                                        {
    ProgramPass::executeProcedurePass(program, targetMachine, *this);
}

References ProgramPass::executeProcedurePass(), and program.

Here is the call graph for this function:

inverseGuardsOfHeads()

ControlFlowGraph::NodeSet PreOptimizer::inverseGuardsOfHeads ( DataDependenceGraph &  ddg, DataDependenceGraph::EdgeSet &  oEdges  )

private

Definition at line 380 of file PreOptimizer.cc.

                                        {
    ControlFlowGraph::NodeSet guardReverseBBs;
    for (DataDependenceGraph::EdgeSet::iterator i = oEdges.begin();
         i != oEdges.end(); i++) {
        DataDependenceEdge& edge = **i;
        if (edge.dependenceType() != DataDependenceEdge::DEP_RAW) {
            continue;
        }
        MoveNode& head = ddg.headNode(edge);
        if (edge.guardUse()) {
            TTAProgram::Move& guardUseMove = head.move();
            assert(!guardUseMove.isUnconditional());
            guardUseMove.setGuard(
                TTAProgram::CodeGenerator::createInverseGuard(
                    guardUseMove.guard()));
            if (guardUseMove.isJump()) {
                BasicBlockNode& jumpBBN = ddg.getBasicBlockNode(head);
                guardReverseBBs.insert(&jumpBBN);
            }
        } else {
            head.destinationOperation().switchInputs(1,2);
        }
    }
    return guardReverseBBs;
}

References assert, TTAProgram::CodeGenerator::createInverseGuard(), DataDependenceEdge::DEP_RAW, DataDependenceEdge::dependenceType(), MoveNode::destinationOperation(), DataDependenceGraph::getBasicBlockNode(), TTAProgram::Move::guard(), DataDependenceEdge::guardUse(), BoostGraph< GraphNode, GraphEdge >::headNode(), TTAProgram::Move::isJump(), TTAProgram::Move::isUnconditional(), MoveNode::move(), TTAProgram::Move::setGuard(), and ProgramOperation::switchInputs().

Referenced by tryToRemoveGuardInversingOp().

Here is the call graph for this function:

shortDescription()

std::string PreOptimizer::shortDescription ( ) const

inlinevirtual

A short description of the pass, usually the optimization name, such as "basic block scheduler".

Returns

The description as a string.

Implements SchedulerPass.

Definition at line 86 of file PreOptimizer.hh.

                                       { 
        return "optimizes away guard nagation operations, "
            "uses opposite guards instead"; };

tryToOptimizeAddressReg()

bool PreOptimizer::tryToOptimizeAddressReg ( DataDependenceGraph &  ddg, ProgramOperation &  po  )

private

Definition at line 87 of file PreOptimizer.cc.

                                                    {
 
    DataDependenceEdge* connectingEdge = NULL;
 
    if (po.outputMoveCount() != 1 || po.inputMoveCount() != 1) {
        return false;
    }
    MoveNode& address = po.inputMove(0);
    MoveNode& result = po.outputMove(0);
 
    DataDependenceGraph::EdgeSet iEdges = ddg.inEdges(address);
 
    if (!result.move().destination().isGPR()) {
        return false;
    }
 
    // do not put addresses to lane RF's
    const TTAMachine::RegisterFile& rf =
        result.move().destination().registerFile();
    if (rf.name().find("L_") == 0) {
        return false;
    }
 
    MoveNode* src = NULL;
    // loop thru all inedges find who writes the address.
    for (DataDependenceGraph::EdgeSet::iterator i = iEdges.begin();
         i != iEdges.end(); i++) {
        DataDependenceEdge& edge = **i;
        if (edge.dependenceType() == DataDependenceEdge::DEP_RAW &&
            !edge.guardUse()) {
            if (edge.edgeReason() != DataDependenceEdge::EDGE_REGISTER) {
                return false;
            }
            if (edge.isBackEdge()) {
                return false;
            }
            if (src == NULL) {
                src = &ddg.tailNode(edge);
                connectingEdge = &edge;
            } else {
                return false;
            }
        }
    }
    if (src == NULL) {
        // load address missing
        return false;
    }
 
    if (&ddg.getBasicBlockNode(address) != &ddg.getBasicBlockNode(*src)) {
        return false;
    }
 
    // TODO: multi-threading might make this fail too often!
    if (src->nodeID() != address.nodeID() - 1) {
        // some other moves between these moves.
        return false;
    }
 
    DataDependenceGraph::EdgeSet oEdges = ddg.outEdges(*src);
    // loop thru all outedges.
    for (DataDependenceGraph::EdgeSet::iterator i = oEdges.begin();
         i != oEdges.end(); i++) {
        DataDependenceEdge& edge = **i;
        if (edge.dependenceType() == DataDependenceEdge::DEP_RAW) {
            if (&ddg.headNode(edge) != &address) {
                // same address used for some other operation.
                return false;
            }
        }
    }
 
    // cannot use narrower reg for address.
    if (address.move().source().registerFile().width() !=
        result.move().destination().registerFile().width()) {
        return false;
    }
 
    TCEString oldReg = 
        DisassemblyRegister::registerName(address.move().source());
    TCEString newReg = 
        DisassemblyRegister::registerName(result.move().destination());
 
    address.move().setSource(result.move().destination().copy());
    src->move().setDestination(result.move().destination().copy());
 
    ddg.renamedSimpleLiveRange(
        *src, address, result, *connectingEdge, oldReg, newReg);
    return true;
}

References TTAProgram::Terminal::copy(), DataDependenceEdge::DEP_RAW, DataDependenceEdge::dependenceType(), TTAProgram::Move::destination(), DataDependenceEdge::EDGE_REGISTER, DataDependenceEdge::edgeReason(), DataDependenceGraph::getBasicBlockNode(), DataDependenceEdge::guardUse(), BoostGraph< GraphNode, GraphEdge >::headNode(), BoostGraph< GraphNode, GraphEdge >::inEdges(), ProgramOperation::inputMove(), ProgramOperation::inputMoveCount(), DataDependenceEdge::isBackEdge(), TTAProgram::Terminal::isGPR(), MoveNode::move(), TTAMachine::Component::name(), GraphNode::nodeID(), BoostGraph< GraphNode, GraphEdge >::outEdges(), ProgramOperation::outputMove(), ProgramOperation::outputMoveCount(), TTAProgram::Terminal::registerFile(), DisassemblyRegister::registerName(), DataDependenceGraph::renamedSimpleLiveRange(), TTAProgram::Move::setDestination(), TTAProgram::Move::setSource(), TTAProgram::Move::source(), BoostGraph< GraphNode, GraphEdge >::tailNode(), and TTAMachine::BaseRegisterFile::width().

Referenced by handleCFGDDG().

Here is the call graph for this function:

tryToPrecalcConstantAdd()

void PreOptimizer::tryToPrecalcConstantAdd ( DataDependenceGraph &  ddg, ProgramOperation &  po  )

private

Remove additions that can be removed staticly. LLVM leaves these when another ide of the addition is an address of a global variable.

Definition at line 412 of file PreOptimizer.cc.

                                                    {
 
    if (po.operation().name() != "ADD" ) return;
 
    MoveNode& result = po.outputMove(0);
    if (po.inputMoveCount() != 2) {
        return;
    }
    MoveNode& operand1 = po.inputMove(0);
    MoveNode& operand2 = po.inputMove(1);
    MoveNode* src1 = &operand1;
    MoveNode* src2 = &operand2;
 
    // allow hopping over regs
    while (src1->isSourceVariable()) {
        src1 = ddg.onlyRegisterRawSource(*src1,2);
        if (src1 == nullptr) {
            return;
        }
    }
 
    // allow hopping over regs
    while (src2->isSourceVariable()) {
        src2 = ddg.onlyRegisterRawSource(*src2,2);
        if (src2 == nullptr) {
            return;
        }
    }
    if (!src2->isSourceConstant() || !src1->isSourceConstant()) {
        return;
    }
 
    auto& s1 = src1->move().source();
    auto& s2 = src2->move().source();
 
    if (s1.value().intValue() == 0 || s2.value().intValue() == 0) {
        return;
    }
 
    // all tests ok, proceed and remove the add.
    TTAProgram::Instruction& operand1Ins = operand1.move().parent();
    TTAProgram::Instruction& operand2Ins = operand2.move().parent();
    TTAProgram::CodeSnippet& parent = operand1Ins.parent();
 
    int val = s1.value().intValue() + s2.value().intValue();
    auto immTerm =
        new TTAProgram::TerminalImmediate(SimValue(val, 32));
 
    result.unsetSourceOperation();
    po.removeOutputNode(result);
 
    result.move().setSource(immTerm);
 
    assert(operand1Ins.moveCount() == 1);
    ddg.deleteNode(operand1);
    parent.remove(operand1Ins);
    delete &operand1Ins;
 
    assert(operand2Ins.moveCount() == 1);
    ddg.deleteNode(operand2);
    parent.remove(operand2Ins);
    delete &operand2Ins;
}

References assert, DataDependenceGraph::deleteNode(), ProgramOperation::inputMove(), ProgramOperation::inputMoveCount(), MoveNode::isSourceConstant(), MoveNode::isSourceVariable(), MoveNode::move(), TTAProgram::Instruction::moveCount(), Operation::name(), DataDependenceGraph::onlyRegisterRawSource(), ProgramOperation::operation(), ProgramOperation::outputMove(), TTAProgram::Instruction::parent(), TTAProgram::Move::parent(), TTAProgram::CodeSnippet::remove(), ProgramOperation::removeOutputNode(), TTAProgram::Move::setSource(), TTAProgram::Move::source(), and MoveNode::unsetSourceOperation().

Referenced by handleCFGDDG().

Here is the call graph for this function:

tryToRemoveEq()

ControlFlowGraph::NodeSet PreOptimizer::tryToRemoveEq ( DataDependenceGraph &  ddg, ProgramOperation &  po, TTAProgram::InstructionReferenceManager *  irm, ControlFlowGraph &  cfg  )

private

Definition at line 215 of file PreOptimizer.cc.

                                                                       {
    if (po.outputMoveCount() != 1 || po.inputMoveCount() != 2) {
        return ControlFlowGraph::NodeSet();
    }
    // check that it's or by 0.
    MoveNode& operand1 = po.inputMove(0);
    MoveNode& operand2 = po.inputMove(1);
    TTAProgram::Terminal& src2 = operand2.move().source();
    if (!src2.isImmediate() || src2.value().intValue() != 0) {
        return ControlFlowGraph::NodeSet();
    }
    MoveNode* src = ddg.onlyRegisterRawSource(operand1);
    if (src == NULL || !src->isSourceOperation()) {
        return ControlFlowGraph::NodeSet();
    }
    ProgramOperation& srcOp = src->sourceOperation();
    if (srcOp.operation().operand(
            src->move().source().operationIndex()).type() == Operand::BOOL) {
        // now we have a xor op which is a truth value reversal.
        // find where the result is used.
        return tryToRemoveGuardInversingOp(ddg, po, irm, cfg);
    }
    return ControlFlowGraph::NodeSet();
}

References Operand::BOOL, ProgramOperation::inputMove(), ProgramOperation::inputMoveCount(), SimValue::intValue(), TTAProgram::Terminal::isImmediate(), MoveNode::isSourceOperation(), MoveNode::move(), DataDependenceGraph::onlyRegisterRawSource(), Operation::operand(), ProgramOperation::operation(), TTAProgram::Terminal::operationIndex(), ProgramOperation::outputMoveCount(), TTAProgram::Move::source(), MoveNode::sourceOperation(), tryToRemoveGuardInversingOp(), Operand::type(), and TTAProgram::Terminal::value().

Referenced by handleCFGDDG().

Here is the call graph for this function:

tryToRemoveGuardInversingOp()

ControlFlowGraph::NodeSet PreOptimizer::tryToRemoveGuardInversingOp ( DataDependenceGraph &  ddg, ProgramOperation &  po, TTAProgram::InstructionReferenceManager *  irm, ControlFlowGraph &  cfg  )

private

Definition at line 244 of file PreOptimizer.cc.

                           {
 
    MoveNode& operand1 = po.inputMove(0);
    MoveNode& operand2 = po.inputMove(1);
    MoveNode& result = po.outputMove(0);
    TTAProgram::Move& resultMove = result.move();
    DataDependenceGraph::EdgeSet oEdges = ddg.outEdges(result);
 
    // some more complex things done with the guard.
    // converting those not yet supported.
    if (!checkGuardReversalAllowed(ddg, oEdges)) {
        return ControlFlowGraph::NodeSet();
    }
    
    TTAProgram::Instruction& operand1Ins = operand1.move().parent();
    TTAProgram::Instruction& operand2Ins = operand2.move().parent();
    TTAProgram::Instruction& resultIns = resultMove.parent();
    
    // cannot remove if has refs. TODO: move refs to next ins.
    // if we don't have irm, assume we don't have irefs.
    if (irm != NULL && 
        (irm->hasReference(operand1Ins) || irm->hasReference(operand2Ins) ||
         irm->hasReference(resultIns))) {
        return ControlFlowGraph::NodeSet();
    }
    
    auto reverseJumpBBs = inverseGuardsOfHeads(ddg, oEdges);
 
    // If cannot reverse jumps, have to undo and abort.
    for ([[maybe_unused]] auto n: reverseJumpBBs) {
        if (!cfgAllowsJumpReversal(operand1Ins, cfg)) {
            inverseGuardsOfHeads(ddg, oEdges);
            return ControlFlowGraph::NodeSet();
        }
    }
 
    // need some copy from one predicate to another?
    TTAProgram::Terminal& src1 = operand1.move().source();
    TTAProgram::Terminal& dst = resultMove.destination();
    if (!src1.equals(dst)) {
        auto newMove = std::make_shared<TTAProgram::Move>(
            src1.copy(), dst.copy(), operand1.move().bus());
        
        TTAProgram::Instruction* newIns = new TTAProgram::Instruction;
        newIns->addMove(newMove);
        resultMove.parent().parent().insertAfter(
            resultMove.parent(), newIns);
        MoveNode* newMN = new MoveNode(newMove);
        ddg.addNode(*newMN, operand1);
        ddg.combineNodes(operand1, result, *newMN);
 
    } else {
        // the op just gets deleted.
        ddg.copyDepsOver(operand1, result, true, true);
    }
    
    // delete the xor operation. (the moves and instructions.)
    TTAProgram::CodeSnippet& parent = operand1Ins.parent();
    
    assert(operand1Ins.moveCount() == 1);
    ddg.deleteNode(operand1);
    parent.remove(operand1Ins);
    delete &operand1Ins;
    
    assert(operand2Ins.moveCount() == 1);
    ddg.deleteNode(operand2);
    parent.remove(operand2Ins);
    delete &operand2Ins;
    
    
    assert(resultIns.moveCount() == 1);
    ddg.deleteNode(result);
    parent.remove(resultIns);
    delete &resultIns;
 
    return reverseJumpBBs;
}

References TTAProgram::Instruction::addMove(), DataDependenceGraph::addNode(), assert, TTAProgram::Move::bus(), cfgAllowsJumpReversal(), checkGuardReversalAllowed(), DataDependenceGraph::combineNodes(), TTAProgram::Terminal::copy(), DataDependenceGraph::copyDepsOver(), DataDependenceGraph::deleteNode(), TTAProgram::Move::destination(), TTAProgram::Terminal::equals(), TTAProgram::InstructionReferenceManager::hasReference(), ProgramOperation::inputMove(), TTAProgram::CodeSnippet::insertAfter(), inverseGuardsOfHeads(), MoveNode::move(), TTAProgram::Instruction::moveCount(), BoostGraph< GraphNode, GraphEdge >::outEdges(), ProgramOperation::outputMove(), TTAProgram::Instruction::parent(), TTAProgram::Move::parent(), TTAProgram::CodeSnippet::remove(), and TTAProgram::Move::source().

Referenced by tryToRemoveEq(), and tryToRemoveXor().

Here is the call graph for this function:

tryToRemoveXor()

ControlFlowGraph::NodeSet PreOptimizer::tryToRemoveXor ( DataDependenceGraph &  ddg, ProgramOperation &  po, TTAProgram::InstructionReferenceManager *  irm, ControlFlowGraph &  cfg  )

private

Tries to remove an unnecessary guard value xor before a conditional jump.

Tries to remove xor operation which is used for converting false boolean value into true boolean value which is then used for jump. The xor operation is removed and the jump predicate reversed.

Parameters

ddg	The datadependence graph of the whole function
po	ProgramOperation which is a xor operation
irm	instructionreferencemanager of the program.

Returns

Basic block whose output edge predicates need to be reversed of cfg or NULL if no need to change cfg.

Definition at line 195 of file PreOptimizer.cc.

                                                                       {
    if (po.outputMoveCount() != 1 || po.inputMoveCount() != 2) {
        return ControlFlowGraph::NodeSet();
    }
    // check that it's or by 1.
    MoveNode& operand2 = po.inputMove(1);
    TTAProgram::Terminal& src2 = operand2.move().source();
    if (!src2.isImmediate() || src2.value().intValue() != 1) {
        return ControlFlowGraph::NodeSet();
    }
    // now we have a xor op which is a truth value reversal.
    // find where the result is used.
 
    return tryToRemoveGuardInversingOp(ddg, po, irm, cfg);
}

References ProgramOperation::inputMove(), ProgramOperation::inputMoveCount(), SimValue::intValue(), TTAProgram::Terminal::isImmediate(), MoveNode::move(), ProgramOperation::outputMoveCount(), TTAProgram::Move::source(), tryToRemoveGuardInversingOp(), and TTAProgram::Terminal::value().

Referenced by handleCFGDDG().

Here is the call graph for this function:

---

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

• PreOptimizer.hh
• PreOptimizer.cc