#include <LLVMTCERISCVIntrinsicsLowering.hh>

Inheritance diagram for llvm::LLVMTCERISCVIntrinsicsLowering:

Collaboration diagram for llvm::LLVMTCERISCVIntrinsicsLowering:

Public Member Functions
	LLVMTCERISCVIntrinsicsLowering ()

virtual	~LLVMTCERISCVIntrinsicsLowering ()

virtual bool	runOnMachineFunction (MachineFunction &MF)

Static Public Attributes
static char	ID = 0

Private Member Functions
InstructionFormat *	findRFormat ()

std::string	findRegs (const std::string &s) const

std::string	findOperationName (const std::string &s) const

std::vector< int >	findRegIndexes (const MachineBasicBlock::iterator &it) const

int	constructEncoding (const std::string &opName, const std::vector< int > &regIdxs) const

virtual bool	doInitialization (Module &m)

Private Attributes
TTAMachine::Machine *	mach_

BinaryEncoding *	bem_

InstructionFormat *	rFormat_

Detailed Description

Definition at line 42 of file LLVMTCERISCVIntrinsicsLowering.hh.

Constructor & Destructor Documentation

◆ LLVMTCERISCVIntrinsicsLowering()

llvm::LLVMTCERISCVIntrinsicsLowering::LLVMTCERISCVIntrinsicsLowering ( )

Definition at line 53 of file LLVMTCERISCVIntrinsicsLowering.cc.

     : MachineFunctionPass(ID) {
     auto* option = static_cast<llvm::cl::opt<std::string>*>(
         llvm::cl::getRegisteredOptions().lookup("adf"));
     const std::string adf = option->getValue();
     try {
         mach_ = TTAMachine::Machine::loadFromADF(adf);
     } catch (const Exception& e) {
         Application::logStream()
             << "TCE: unable to load the ADF:" << std::endl
             << e.errorMessage() << std::endl
             << "Make sure you give the"
             << " correct adf with the -adf switch to llc";
     }
     bem_ = BEMGenerator(*mach_).generate();
     rFormat_ = findRFormat();
 }

References bem_, Exception::errorMessage(), findRFormat(), BEMGenerator::generate(), TTAMachine::Machine::loadFromADF(), Application::logStream(), mach_, and rFormat_.

Here is the call graph for this function:

◆ ~LLVMTCERISCVIntrinsicsLowering()

virtual llvm::LLVMTCERISCVIntrinsicsLowering::~LLVMTCERISCVIntrinsicsLowering ( )

inlinevirtual

Definition at line 46 of file LLVMTCERISCVIntrinsicsLowering.hh.

46 {}

Member Function Documentation

◆ constructEncoding()

int llvm::LLVMTCERISCVIntrinsicsLowering::constructEncoding	(	const std::string &	opName,
		const std::vector< int > &	regIdxs
	)		const

private

Definition at line 171 of file LLVMTCERISCVIntrinsicsLowering.cc.

                                                                   {
     const int fu3Mask = 0b1110000000;
     const int fu7Mask = 0b11111110000000000;
     const int opcodeMask = 0b1111111;
     int encoding = rFormat_->encoding(opName);
     const int fu3Enc = ((encoding & fu3Mask) >> 7);
     const int fu7Enc = ((encoding & fu7Mask) >> 10);
     const int opcodeEnc = encoding & opcodeMask;
     const int shiftedEnc = (fu7Enc << 25) + (fu3Enc << 12) + opcodeEnc;
  
     encoding = shiftedEnc + (regIdxs.at(0) << 7) + (regIdxs.at(1) << 15) +
                (regIdxs.at(2) << 20);
  
     return encoding;
 }

References InstructionFormat::encoding(), and rFormat_.

Referenced by runOnMachineFunction().

Here is the call graph for this function:

◆ doInitialization()

bool llvm::LLVMTCERISCVIntrinsicsLowering::doInitialization ( Module & m )

privatevirtual

Definition at line 72 of file LLVMTCERISCVIntrinsicsLowering.cc.

                                                           {
     return false;
 }

◆ findOperationName()

std::string llvm::LLVMTCERISCVIntrinsicsLowering::findOperationName ( const std::string & s ) const

private

Definition at line 114 of file LLVMTCERISCVIntrinsicsLowering.cc.

                               {
     std::vector<TCEString> asmSubStrings = StringTools::chopString(s, " ");
     std::string opName = "";
     for (TCEString i : asmSubStrings) {
         std::string ss = static_cast<std::string>(i);
         if (StringTools::containsChar(ss, '/')) {
             ss = StringTools::replaceAllOccurrences(ss, "//", "");
             ss = StringTools::stringToLower(ss);
             if (rFormat_->hasOperation(ss)) {
                 opName = ss;
             } else {
                 std::string msg = "Machine does not have operation: " + ss;
                 throw InvalidData(__FILE__, __LINE__, __func__, msg);
             }
         }
     }
     if (opName == "") {
         const std::string msg = 
         "Warning: Failed to find operation name from: \"" + s + "\"";
         std::cerr << msg << std::endl;
         //std::string msg = "Failed to find operation name from: " + s;
         //throw InvalidData(__FILE__, __LINE__, __func__, msg);
     }
     return opName;
 }

References __func__, StringTools::chopString(), StringTools::containsChar(), InstructionFormat::hasOperation(), StringTools::replaceAllOccurrences(), rFormat_, and StringTools::stringToLower().

Referenced by runOnMachineFunction().

Here is the call graph for this function:

◆ findRegIndexes()

std::vector< int > llvm::LLVMTCERISCVIntrinsicsLowering::findRegIndexes ( const MachineBasicBlock::iterator & it ) const

private

Definition at line 142 of file LLVMTCERISCVIntrinsicsLowering.cc.

                                                {
     const unsigned OpIdx = 0;
     std::vector<int> regIdxs;
     const std::string asmString =
         std::string(it->getOperand(OpIdx).getSymbolName());
     for (unsigned o = 0; o < it->getNumOperands(); o++) {
         const MachineOperand& mo = it->getOperand(o);
         if (mo.isReg()) {
             int idx = mo.getReg() - 40;
             regIdxs.push_back(idx);
             if (idx < 0 && idx > 31) {
                 std::string msg =
                     "Invalid register index: " + std::to_string(idx) +
                     " in instruction: " + asmString;
                 throw InvalidData(__FILE__, __LINE__, __func__, msg);
             };
         }
     }
     if (regIdxs.size() != 3) {
         std::string msg = "3 reg operands required, found " +
                           std::to_string(regIdxs.size()) +
                           " in instruction: " + asmString;
         throw InvalidData(__FILE__, __LINE__, __func__, msg);
     }
     return regIdxs;
 }

References __func__.

Referenced by runOnMachineFunction().

◆ findRegs()

std::string llvm::LLVMTCERISCVIntrinsicsLowering::findRegs ( const std::string & s ) const

private

Definition at line 93 of file LLVMTCERISCVIntrinsicsLowering.cc.

                                                                  {
     std::vector<TCEString> asmSubStrings = StringTools::chopString(s, " ");
     std::string regs = "";
     int foundRegs = 0;
     for (TCEString i : asmSubStrings) {
         std::string ss = static_cast<std::string>(i);
         if (StringTools::containsChar(ss, '$')) {
             regs += " " + ss;
             foundRegs++;
         }
     }
     if (foundRegs != 3) {
         std::string msg =
             "Invalid amount of register operands, 3 required, found " +
             std::to_string(foundRegs);
         throw InvalidData(__FILE__, __LINE__, __func__, msg);
     }
     return regs;
 }

References __func__, StringTools::chopString(), and StringTools::containsChar().

Referenced by runOnMachineFunction().

Here is the call graph for this function:

◆ findRFormat()

InstructionFormat * llvm::LLVMTCERISCVIntrinsicsLowering::findRFormat ( )

private

Definition at line 77 of file LLVMTCERISCVIntrinsicsLowering.cc.

                                             {
     InstructionFormat* format = NULL;
     for (int f = 0; f < bem_->instructionFormatCount(); f++) {
         if (bem_->instructionFormat(f).name() == "riscv_r_type") {
             format = &bem_->instructionFormat(f);
             break;
         }
     }
     if (format == NULL) {
         std::string msg = "BEM does not identify R format ";
         throw InvalidData(__FILE__, __LINE__, __func__, msg);
     }
     return format;
 }

References __func__, bem_, BinaryEncoding::instructionFormat(), BinaryEncoding::instructionFormatCount(), and InstructionFormat::name().

Referenced by LLVMTCERISCVIntrinsicsLowering().

Here is the call graph for this function:

◆ runOnMachineFunction()

bool llvm::LLVMTCERISCVIntrinsicsLowering::runOnMachineFunction ( MachineFunction & MF )

virtual

Definition at line 189 of file LLVMTCERISCVIntrinsicsLowering.cc.

                                                                         {
     for (MachineFunction::iterator i = MF.begin(); i != MF.end(); i++) {
         for (MachineBasicBlock::iterator j = i->begin(); j != i->end(); j++) {
             if (j->isInlineAsm()) {
                 const unsigned OpIdx = 0;
                 std::string asmString =
                     std::string(j->getOperand(OpIdx).getSymbolName());
                 const std::string opName = findOperationName(asmString);
                 if (opName == "") {
                     continue;
                 }
                 const std::string regs = findRegs(asmString);
                 const std::vector<int> regIdxs = findRegIndexes(j);
  
                 int encoding = constructEncoding(opName, regIdxs);
                 std::string* cName = new std::string(
                     ".long " + std::to_string(encoding) + "; #" + opName +
                     regs);
                 j->getOperand(OpIdx).ChangeToES(
                     cName->c_str(), j->getOperand(OpIdx).getTargetFlags());
             }
         }
     }
     return false;
 }