#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.

47 :

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

◆ ~ConstantTransformer()

virtual ConstantTransformer::~ConstantTransformer ( )

inlinevirtual

Definition at line 49 of file ConstantTransformer.hh.

49 {}

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