ConstantTransformer Class Reference

#include <ConstantTransformer.hh>

Inheritance diagram for ConstantTransformer:

Collaboration diagram for ConstantTransformer:

Public Member Functions
	ConstantTransformer (const TTAMachine::Machine &mach)
virtual	~ConstantTransformer ()
bool	doInitialization (llvm::Module &M)
bool	runOnMachineFunction (llvm::MachineFunction &mf)
bool	doFinalization (llvm::Module &M)

Static Public Attributes
static char	ID

Private Attributes
const TTAMachine::Machine &	mach_

Detailed Description

Transforms constants in the program that cannot be encoded by the machine to ones that can be.

Definition at line 43 of file ConstantTransformer.hh.

Constructor & Destructor Documentation

ConstantTransformer()

ConstantTransformer::ConstantTransformer ( const TTAMachine::Machine &  mach )

inline

Definition at line 46 of file ConstantTransformer.hh.

                                       : 
        MachineFunctionPass(ID), mach_(mach) {}

~ConstantTransformer()

virtual ConstantTransformer::~ConstantTransformer ( )

inlinevirtual

Definition at line 49 of file ConstantTransformer.hh.

{}

Member Function Documentation

doFinalization()

bool ConstantTransformer::doFinalization

(

llvm::Module &

M

)

Definition at line 244 of file ConstantTransformer.cc.

                                               {
    return false;
}

doInitialization()

bool ConstantTransformer::doInitialization

(

llvm::Module &

M

)

Definition at line 68 of file ConstantTransformer.cc.

                                                 {
    return false;
}

runOnMachineFunction()

bool ConstantTransformer::runOnMachineFunction

(

llvm::MachineFunction &

mf

)

Definition at line 113 of file ConstantTransformer.cc.

                                                                 {
 
    const TCETargetMachine& tm = 
        dynamic_cast<const TCETargetMachine&>(mf.getTarget());
    TCETargetMachinePlugin& plugin = tm.targetPlugin();
 
    OperationPool osal;
 
    bool changed = false;
    for (MachineFunction::iterator i = mf.begin(); i != mf.end(); i++) {
        MachineBasicBlock& mbb = *i;
        for (MachineBasicBlock::iterator j = mbb.begin();
             j != mbb.end(); j++) {
            const llvm::MachineInstr* mi = &*j;
            unsigned opc = mi->getOpcode();
 
            const llvm::MCInstrDesc& opDesc = mi->getDesc();
            if (opDesc.isReturn()) {
                continue;
            }
            if (opc == llvm::TargetOpcode::DBG_VALUE
                || opc == llvm::TargetOpcode::DBG_LABEL
                || opc == llvm::TargetOpcode::DBG_INSTR_REF
                || opc == llvm::TargetOpcode::DBG_VALUE_LIST
                || opc == llvm::TargetOpcode::DBG_PHI
                || opc == llvm::TargetOpcode::KILL) {
                continue;
            }
 
            TCEString opname = tm.operationName(opc);
            if (opname == "") continue;
            bool hasGuard = opname[0] == '?' || opname[0] == '!';
            if (hasGuard) opname = opname.substr(1);
 
            const Operation& op = osal.operation(opname.c_str());
            if (op.isNull() || op.isBranch() || op.isCall() || 
                op.readsMemory()) {
                // isNull = INLINE asm, a pseudo asm block or similar.
                // TODO: add support for at least INLINE and MOVE.
 
                // In case the operation reads memory, assume the 
                // possible immediate operand is a global address
                // we cannot fix at this point.
                // TODO: Fix global address constants. Needs to have new type
                // of data symbol/relocation info in case an address
                // constant is broken down.
 
                continue;
            }
 
            for (unsigned operandI = 0; operandI < mi->getNumOperands();
                 ++operandI) {
                
                const MachineOperand& mo = mi->getOperand(operandI);
                if (!mo.isImm()) continue;
 
                unsigned inputIndex = osalInputIndex(op, *mi, operandI);
                if (inputIndex == 0) continue; 
                const Operand& operand = op.operand(inputIndex);
                if (operand.isNull() || !operand.isInput()) {
                    continue; // ignore output operands
                    Application::errorStream() 
                        << "Input " << inputIndex 
                        << " not found for operation "
                        << opname << std::endl;
                    assert(false);
                }
                assert(operand.isInput());
                size_t operandWidth = operand.width();
 
                if (MachineInfo::canEncodeImmediateInteger(
                        mach_, mo.getImm(), operandWidth)) continue;
                    
                // check if it's possible to convert C to SUB(0, -C) such
                // that it can be encoded for the target
                if (MachineInfo::canEncodeImmediateInteger(mach_, 0) &&
                    MachineInfo::canEncodeImmediateInteger(
                        mach_, -mo.getImm()) && /* SUB is 32b */
                    MachineInfo::supportsOperation(mach_, sub)) {
 
                    const llvm::MCInstrInfo* iinfo = 
                        mf.getTarget().getSubtargetImpl(
                            mf.getFunction())->getInstrInfo();
                    // RV_HIGH = SUB 0 -X
                    BuildMI(
                        mbb, j, j->getDebugLoc(), iinfo->get(plugin.opcode(sub)),
                        plugin.rvHighDRegNum()).addImm(0).addImm(-mo.getImm());
                        
                    // replace the original instruction's immediate operand
                    // with the RV_HIGH
                    llvm::MachineInstrBuilder mib = 
                        BuildMI(mbb, j, j->getDebugLoc(), j->getDesc());
                    for (unsigned opr = 0; opr < j->getNumOperands(); ++opr) {
                        MachineOperand& orig = j->getOperand(opr);
                        if (opr == operandI) {
                mib.add(MachineOperand::CreateReg(
                    plugin.rvHighDRegNum(), false));
                            continue;
                        }
                        mib.add(orig);
                        orig.clearParent();
                    }
                        
                    // the original instruction can be now deleted
                    j->eraseFromParent();
                    // start scanning the MBB from the beginning due to
                    // possibly invalidated iterators from adding the 
                    // new instructions
                    j = mbb.begin();
                    changed = true;
                } else {
                    std::ostringstream errMsg;
                    errMsg << "Program uses constant '"
                           << mo.getImm() << "'";
                    if (Application::verboseLevel() > 0) {
                        errMsg << " -> " << opname
                               << " (llvm opc = " << opc << ")";
                    }
                    errMsg << " that cannot be encoded "
                           << "for the machine by the current compiler.";
                    throw CompileError(
                        __FILE__, __LINE__, __func__, errMsg.str());
                }
            }
        }
           
    }
    return changed;
}

References __func__, assert, MachineInfo::canEncodeImmediateInteger(), Application::errorStream(), Operation::isBranch(), Operation::isCall(), Operand::isInput(), Operand::isNull(), Operation::isNull(), mach_, llvm::TCETargetMachinePlugin::opcode(), Operation::operand(), OperationPool::operation(), llvm::TCETargetMachine::operationName(), osalInputIndex(), Operation::readsMemory(), llvm::TCETargetMachinePlugin::rvHighDRegNum(), sub, MachineInfo::supportsOperation(), llvm::TCETargetMachine::targetPlugin(), Application::verboseLevel(), and Operand::width().

Here is the call graph for this function:

Member Data Documentation

ID

char ConstantTransformer::ID

static

Definition at line 45 of file ConstantTransformer.hh.

mach_

const TTAMachine::Machine& ConstantTransformer::mach_

private

Definition at line 56 of file ConstantTransformer.hh.

Referenced by runOnMachineFunction().

---

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

• ConstantTransformer.hh
• ConstantTransformer.cc