#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 58 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 182 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 77 of file LLVMTCERISCVIntrinsicsLowering.cc.

                                                          {
    return false;
}

◆ findOperationName()

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

private

Definition at line 119 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 147 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()) {
            // TODO: Fix this virtual to physical reg mapping
#ifdef LLVM_OLDER_THAN_17
            const int magicNumber = 40;
#else
            const int magicNumber = 41;
#endif
            int idx = mo.getReg() - magicNumber;
            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 98 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 82 of file LLVMTCERISCVIntrinsicsLowering.cc.

                                            {
    InstructionFormat* format = NULL;
    for (int f = 0; f < bem_->instructionFormatCount(); f++) {
        if (bem_->instructionFormat(f).name() == RISCVFields::RISCV_R_TYPE_NAME) {
            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(), InstructionFormat::name(), and RISCVFields::RISCV_R_TYPE_NAME.

Referenced by LLVMTCERISCVIntrinsicsLowering().

Here is the call graph for this function:

◆ runOnMachineFunction()

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

virtual

Definition at line 200 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;
}