InlineAsmParser Class Reference

#include <InlineAsmParser.hh>

Collaboration diagram for InlineAsmParser:

Public Member Functions
	InlineAsmParser ()=delete
	InlineAsmParser (const InlineAsmParser &)=delete
InlineAsmParser &	operator= (const InlineAsmParser &)=delete
	InlineAsmParser (const llvm::TCETargetMachine &tm, const llvm::Mangler &mangler)
bool	parse (const llvm::MachineInstr &inlineAsmMI, const std::map< std::string, unsigned > &symbolTable, TTAProgram::BasicBlock &bb, TTAProgram::InstructionReferenceManager &irm)
std::string	substituteAsmString (const llvm::MachineInstr &mi, const std::map< std::string, unsigned > &symbolTable, const llvm::Mangler &mangler)
void	addLiveRangeData (const llvm::MachineInstr &mi, TTAProgram::BasicBlock &bb)
bool	sanityChecks (const llvm::MachineInstr &mi, TTAProgram::BasicBlock &bb) const
std::string	registerName (const llvm::MachineOperand &mo) const
const AssemblyParserDiagnostic &	diagnostics () const

Static Public Member Functions
static void	addDebugInfoToInlineAsmBB (const llvm::MachineInstr &mi, TTAProgram::BasicBlock &bb)
static bool	isInlineAsm (const llvm::MachineInstr &mi)

Private Member Functions
void	reportError (size_t lineNum, const std::string &errorMsg)
void	reportError (const std::string &errorMsg)

Static Private Member Functions
static void	copyInstructions (TTAProgram::Program &prog, TTAProgram::BasicBlock &targetBB, TTAProgram::InstructionReferenceManager &irm)

Private Attributes
const llvm::TCETargetMachine &	tm_
	The target machine parsing context.
const llvm::Mangler &	mangler_
	The symbol name mangler for MIs' symbolic references.
AssemblyParserDiagnostic	parserDiagnostic_
	The diagnostic object to report parse and compile warnings and errors to.
unsigned	asmId_ = 0
	The unique id for "%=" template strings. Each parse() call increases the count.

Detailed Description

The class for parsing TCE assembly listing written as inline assembly in C code.

The inline assembly is parsed as parallel code that does not need or should be scheduled.

Definition at line 64 of file InlineAsmParser.hh.

Constructor & Destructor Documentation

InlineAsmParser() [1/3]

InlineAsmParser::InlineAsmParser ( )

delete

InlineAsmParser() [2/3]

InlineAsmParser::InlineAsmParser ( const InlineAsmParser &  )

delete

InlineAsmParser() [3/3]

InlineAsmParser::InlineAsmParser	(	const llvm::TCETargetMachine &	tm,
		const llvm::Mangler &	mangler
	)

Definition at line 68 of file InlineAsmParser.cc.

                                :
    tm_(tm), mangler_(mangler) {
    }

Member Function Documentation

addDebugInfoToInlineAsmBB()

void InlineAsmParser::addDebugInfoToInlineAsmBB ( const llvm::MachineInstr &  mi, TTAProgram::BasicBlock &  bb  )

static

Adds gebug info to moves of the parsed inline asm.

Definition at line 159 of file InlineAsmParser.cc.

                              {
 
    // TODO/FIXME For some reason the source locations for asm block are
    //            shifted, pointing to incorrect lines of the source files.
    //            This error(?) can be seen already in disll.
 
    std::string sourceFileName;
    size_t sourceLineNumber;
    std::tie(sourceFileName, sourceLineNumber) = getSourceLocationInfo(mi);
 
    if (sourceFileName.size() >
        TPEF::InstructionAnnotation::MAX_ANNOTATION_BYTES) {
        sourceFileName =
        sourceFileName.substr(
            sourceFileName.size() -
            TPEF::InstructionAnnotation::MAX_ANNOTATION_BYTES,
            TPEF::InstructionAnnotation::MAX_ANNOTATION_BYTES);
    }
    TTAProgram::ProgramAnnotation srcLineAnn(
        TTAProgram::ProgramAnnotation::ANN_DEBUG_SOURCE_CODE_LINE,
        sourceLineNumber);
    if (sourceFileName.empty()) sourceFileName = "???";
    TTAProgram::ProgramAnnotation srcFileAnn(
        TTAProgram::ProgramAnnotation::ANN_DEBUG_SOURCE_CODE_PATH,
        sourceFileName);
 
    for (int i = 0; i < bb.instructionCount(); i++) {
        TTAProgram::Instruction& instr = bb.instructionAtIndex(i);
        for (int m = 0; m < instr.moveCount(); m++) {
            TTAProgram::Move& move = instr.move(m);
            move.addAnnotation(srcLineAnn);
            move.addAnnotation(srcFileAnn);
        }
    }
}

References TTAProgram::AnnotatedInstructionElement::addAnnotation(), TTAProgram::ProgramAnnotation::ANN_DEBUG_SOURCE_CODE_LINE, TTAProgram::ProgramAnnotation::ANN_DEBUG_SOURCE_CODE_PATH, getSourceLocationInfo(), TTAProgram::CodeSnippet::instructionAtIndex(), TTAProgram::CodeSnippet::instructionCount(), TPEF::InstructionAnnotation::MAX_ANNOTATION_BYTES, TTAProgram::Instruction::move(), and TTAProgram::Instruction::moveCount().

Referenced by parse().

Here is the call graph for this function:

addLiveRangeData()

void InlineAsmParser::addLiveRangeData	(	const llvm::MachineInstr &	mi,
		TTAProgram::BasicBlock &	bb
	)

Fills live range data structure.

This method only fills inlineAsmX_ fields in the structure. Data dependency graph builder handles the fields later on and build the proper live range data.

Definition at line 205 of file InlineAsmParser.cc.

                              {
 
    if (!bb.liveRangeData_) {
        bb.liveRangeData_ = new LiveRangeData();
    }
 
    auto& liveRangeData = *bb.liveRangeData_;
    AsmOperandMap asmOperandMap = getInlineAsmOperands(mi);
    for (auto& opds : asmOperandMap) {
        auto asmOpdKind = std::get<0>(opds.second);
        auto& asmOpdNodes = std::get<1>(opds.second);
        TCEString reg;
        switch (asmOpdKind) {
        default:
            break;
        case InlineAsm::Kind_RegUse:
            assert(asmOpdNodes.size() == 1);
            reg = registerName(*asmOpdNodes.at(0));
            liveRangeData.inlineAsmRegUses_.insert(reg);
            break;
        case InlineAsm::Kind_RegDefEarlyClobber:
        case InlineAsm::Kind_RegDef:
            assert(asmOpdNodes.size() == 1);
            reg = registerName(*asmOpdNodes.at(0));
            liveRangeData.inlineAsmRegDefs_.insert(reg);
            break;
        case InlineAsm::Kind_Clobber:
            assert(asmOpdNodes.size() == 1);
            reg = registerName(*asmOpdNodes.at(0));
            liveRangeData.inlineAsmClobbers_.insert(reg);
            break;
        }
    }
}

References assert, getInlineAsmOperands(), TTAProgram::BasicBlock::liveRangeData_, and registerName().

Referenced by parse().

Here is the call graph for this function:

copyInstructions()

void InlineAsmParser::copyInstructions ( TTAProgram::Program &  prog, TTAProgram::BasicBlock &  targetBB, TTAProgram::InstructionReferenceManager &  irm  )

staticprivate

Definition at line 502 of file InlineAsmParser.cc.

                                                {
 
    using namespace TTAProgram;
 
    auto procCount = from.procedureCount();
    // There should be only one default procedure from parsed inline asm.
    // However, file-level inline asm could have more: TODO when supported.
    assert(from.procedureCount() == 1
        && "Procedures are not allowed in non-file-level inline asm.");
 
    // A map for fixing instruction references. Old instr -> copied instr.
    std::map<const TTAProgram::Instruction*, TTAProgram::Instruction*>
        instrCopyMap;
    for (decltype(procCount) i = 0; i < procCount; i++) {
        const auto& proc = from.procedureAtIndex(i);
        auto instrCount = proc.instructionCount();
        for (decltype(instrCount) i = 0; i < instrCount; i++) {
            const auto& oldInstr = proc.instructionAtIndex(i);
            auto newInstr = oldInstr.copy();
            targetBB.add(newInstr);
            instrCopyMap.insert({&oldInstr, newInstr});
        }
    }
 
    for (auto& pair : instrCopyMap) {
        auto& newInstr = *pair.second;
        for (auto& refTerm : getInstructionReferenceTerminals(newInstr)) {
            auto& oldRefInstr = refTerm->instructionReference().instruction();
            assert(instrCopyMap.count(&oldRefInstr));
            auto newRefInstr = instrCopyMap.at(&oldRefInstr);
            auto newRef = irm.createReference(*newRefInstr);
            refTerm->setInstructionReference(newRef);
        }
    }
}

References TTAProgram::CodeSnippet::add(), assert, TTAProgram::InstructionReferenceManager::createReference(), getInstructionReferenceTerminals(), TTAProgram::CodeSnippet::instructionCount(), TTAProgram::Program::procedureAtIndex(), and TTAProgram::Program::procedureCount().

Referenced by parse().

Here is the call graph for this function:

diagnostics()

const AssemblyParserDiagnostic & InlineAsmParser::diagnostics ( ) const

inline

Definition at line 99 of file InlineAsmParser.hh.

                                                        {
        return parserDiagnostic_;
    }

References parserDiagnostic_.

Referenced by llvm::LLVMTCEBuilder::emitInlineAsm().

isInlineAsm()

bool InlineAsmParser::isInlineAsm ( const llvm::MachineInstr &  mi )

static

Returns true if the instruction represents an inline asm block recognized by this parser.

Definition at line 450 of file InlineAsmParser.cc.

                                                       {
    if (mi.isInlineAsm()) {
        std::string amsStr(
            mi.getOperand(InlineAsm::MIOp_AsmString).getSymbolName());
        return amsStr.find_first_of("->;") != std::string::npos;
    }
    return false;
}

Referenced by llvm::LLVMTCEBuilder::isInlineAsm(), and substituteAsmString().

operator=()

InlineAsmParser & InlineAsmParser::operator= ( const InlineAsmParser &  )

delete

parse()

bool InlineAsmParser::parse	(	const llvm::MachineInstr &	inlineAsmMI,
		const std::map< std::string, unsigned > &	symbolTable,
		TTAProgram::BasicBlock &	bb,
		TTAProgram::InstructionReferenceManager &	irm
	)

Parses the given inline assembly instruction to POM basic block.

After call parser diagnostic object is populated with encountered warning and error reports if any. The object is received via diagnostics() function. The object is cleared next time this method is called.

Parameters

inlineAsmMI	The Instruction holding an inline asm block.
bb	The basic block to add parsed code into.
irm	The manager in where instruction references are copied to.

Returns

False if any errors in parsing. Otherwise returns true;

Definition at line 87 of file InlineAsmParser.cc.

                                                {
 
#ifdef DEBUG_INLINE_ASM_PARSER
    std::cerr << "*** before position string substitution:" << std::endl;
    inlineAsmMI.print(llvm::dbgs());
#endif
 
    std::string asmString = substituteAsmString(
        inlineAsmMI, symbolTable, mangler_);
 
#ifdef DEBUG_INLINE_ASM_PARSER
    std::cerr << "*** before inline asm parsing:" << std::endl
              << asmString << std::endl; //DEBUG
#endif
 
    // Parse inline asm.
    parserDiagnostic_.reset(std::make_shared<std::string>(asmString));
    std::unique_ptr<TPEF::Binary> bin(new TPEF::Binary());
    const TTAMachine::Machine& mach = tm_.ttaMachine();
    AssemblerParser parser(
        *bin, mach, &parserDiagnostic_, /* codeLinesOnly = */ true);
 
    try {
        if (!parser.compile(asmString)) {
            reportError(
                parser.errorLine(), "Syntax error in inline assembly.");
            return false;
        }
        parser.finalize(mach.isLittleEndian());
    } catch (CompileError& e) {
        reportError(parser.errorLine(), e.errorMessage());
        return false;
    } catch (Exception& e) {
        reportError(parser.errorLine(), e.errorMessage());
        return false;
    }
 
    // Convert to POM.
    std::unique_ptr<TTAProgram::Program> prog;
    try {
        // TODO Add universal machine for sequential code.
        TTAProgram::TPEFProgramFactory tpefFactory(*bin, mach);
        prog.reset(tpefFactory.build());
    } catch (Exception& e) {
        reportError(e.errorMessage());
        return false;
    }
 
    assert(prog);
 
    copyInstructions(*prog, bb, irm);
    addDebugInfoToInlineAsmBB(inlineAsmMI, bb);
    addLiveRangeData(inlineAsmMI, bb);
 
    if (!sanityChecks(inlineAsmMI, bb)) return false;
 
#ifdef DEBUG_INLINE_ASM_PARSER
    std::cerr << "*** After inline asm parsing:" << std::endl
              << bb.toString() << std::endl;
#endif
 
    return true;
}

References addDebugInfoToInlineAsmBB(), addLiveRangeData(), assert, TTAProgram::TPEFProgramFactory::build(), AssemblerParser::compile(), copyInstructions(), AssemblerParser::errorLine(), Exception::errorMessage(), AssemblerParser::finalize(), TTAMachine::Machine::isLittleEndian(), mangler_, parserDiagnostic_, reportError(), AssemblyParserDiagnostic::reset(), sanityChecks(), substituteAsmString(), tm_, TTAProgram::CodeSnippet::toString(), and llvm::TCETargetMachine::ttaMachine().

Referenced by llvm::LLVMTCEBuilder::emitInlineAsm().

Here is the call graph for this function:

registerName()

std::string InlineAsmParser::registerName

(

const llvm::MachineOperand &

mo

)

const

Returns register name of the machine operand (of reg type).

Definition at line 268 of file InlineAsmParser.cc.

                                                                {
    assert(mo.isReg());
    return tm_.registerName(mo.getReg());
}

References assert, llvm::TCETargetMachine::registerName(), and tm_.

Referenced by addLiveRangeData().

Here is the call graph for this function:

reportError() [1/2]

void InlineAsmParser::reportError ( const std::string &  errorMsg )

private

Definition at line 468 of file InlineAsmParser.cc.

                                                      {
    parserDiagnostic_.addError(errorMsg);
}

References AssemblyParserDiagnostic::addError(), and parserDiagnostic_.

Here is the call graph for this function:

reportError() [2/2]

void InlineAsmParser::reportError ( size_t  lineNum, const std::string &  errorMsg  )

private

Definition at line 463 of file InlineAsmParser.cc.

                                                                      {
    parserDiagnostic_.addError(lineNum, errorMsg);
}

References AssemblyParserDiagnostic::addError(), and parserDiagnostic_.

Referenced by parse().

Here is the call graph for this function:

sanityChecks()

bool InlineAsmParser::sanityChecks	(	const llvm::MachineInstr &	mi,
		TTAProgram::BasicBlock &	bb
	)		const

Performs sanity checks of parsed inline asm snippet.

The method reports issues to the diagnostic object.

Returns

True if no errors were encountered beside some warnings. Otherwise, returns false on any error.

Definition at line 251 of file InlineAsmParser.cc.

                                 {
 
    // Check unintended input register overwrite. //
    // TODO
 
    // Checks no input operands are clobbered. //
    // TODO
 
    return true;
}

Referenced by parse().

substituteAsmString()

std::string InlineAsmParser::substituteAsmString	(	const llvm::MachineInstr &	mi,
		const std::map< std::string, unsigned > &	symbolTable,
		const llvm::Mangler &	mangler
	)

Returns substituted assembly string.

Parameters

mi	The instruction holding the inline asm.
symbolTable	Table to traslate mangled names to addresses.
mangler	The name mangler.

Definition at line 281 of file InlineAsmParser.cc.

                                {
 
 
    assert(mi.isInlineAsm() && "MI must hold inline asm.");
    std::string result = mi.getOperand(
        InlineAsm::MIOp_AsmString).getSymbolName();
    assert(!result.empty());
 
    // If TCE operation macro - the _TCE_<operation> kinds.
    if (!InlineAsmParser::isInlineAsm(mi)) return result;
 
    auto mangledNameFn = [&mangler](const GlobalValue* gv) -> std::string {
        SmallString<256> Buffer;
        mangler.getNameWithPrefix(Buffer, gv, false);
        std::string name(Buffer.c_str());
 
        return name;
    };
 
    // Maps template strings to the assigned operand. e.g "$0" => "RF.5".
    std::map<std::string, std::string> templateStringMap;
 
    const std::string tmplPrefix = "$";
    std::string unhandledKind;
    AsmOperandMap opdMap = getInlineAsmOperands(mi);
    for (auto& asmOpd : opdMap) {
        unsigned asmOpdPos = asmOpd.first;
        unsigned asmOpdKind = std::get<0>(asmOpd.second);
        std::vector<const llvm::MachineOperand*>& flagOpds =
            std::get<1>(asmOpd.second);
        unsigned numAsmOpds = flagOpds.size();
        switch (asmOpdKind) {
        case InlineAsm::Kind_Mem:
            if (unhandledKind.empty()) unhandledKind = "mem";
            // fall-through
        default:
            if (unhandledKind.empty()) unhandledKind = "??";
            if (Application::spamVerbose()) {
                std::cerr << "substituteAsmString():"
                          << " Ignoring asm operand kind: "
                          << unhandledKind << std::endl;
            }
            unhandledKind.clear();
            break;
 
        case InlineAsm::Kind_RegDefEarlyClobber:
        case InlineAsm::Kind_RegDef:
        case InlineAsm::Kind_RegUse:
            assert(numAsmOpds == 1);
            templateStringMap.insert(std::make_pair(
                tmplPrefix + std::to_string(asmOpdPos),
                tm_.registerName(flagOpds.at(0)->getReg())));
            break;
 
        case InlineAsm::Kind_Imm:
            assert(numAsmOpds == 1);
            if (flagOpds.at(0)->isImm()) {
                templateStringMap.insert(std::make_pair(
                    tmplPrefix + std::to_string(asmOpdPos),
                    std::to_string(flagOpds.at(0)->getImm())));
            } else if (flagOpds.at(0)->isGlobal()) {
                std::string name = mangledNameFn(flagOpds.at(0)->getGlobal());
                unsigned address = 0;
                if (symbolTable.find(name) != symbolTable.end()) {
                    address = symbolTable.at(name)
                        + flagOpds.at(0)->getOffset();
                // TODO: could be address to function. Can not handle that
                //       yet.
                } else {
                    THROW_EXCEPTION(
                        CompileError,
                        "Could not determine address of symbol '"
                        + name + "'. \nNote: Functions as inline asm "
                        "operands are not supported.");
                }
 
                templateStringMap.insert(std::make_pair(
                    tmplPrefix + std::to_string(asmOpdPos),
                    std::to_string(address)));
            } else {
                assert(false);
            }
            break;
        case InlineAsm::Kind_Clobber:
            break; // No need to handle.
        }
    }
 
    // Searches for "$<num>" string. Returns tuple of (position, length)
    // if found. Returns (string::npos, 0) if not found.
    auto findTemplateStrFn = [](const std::string& str, size_t pos)
        -> std::tuple<size_t, size_t> {
            if (pos > str.size())  {
                return std::make_tuple(std::string::npos, 0);
            }
            size_t len = 0;
            while ((pos = str.find("$", pos)) != std::string::npos) {
                size_t endPos = str.find_first_not_of("0123456789", pos+1);
                if (endPos == std::string::npos) {
                    // Check template string at end of string, e.g '$4<EOF>'
                    if (str.size()-pos > 1) {
                        return std::make_tuple(pos, str.size()-pos);
                    }
                    pos = std::string::npos;
                    break;
                }
                len = endPos-pos;
                if (len > 1) break; // Ignores "$$" and "${:uid}" strings.
                pos += len;
            }
            return std::make_tuple(pos, len);
        };
 
    size_t pos = 0;
    size_t len = 0;
    std::set<std::string> replacedTemplStrs;
    while (true) {
        std::tie(pos, len) = findTemplateStrFn(result, pos);
        if (pos == std::string::npos) break;
        const std::string& templStr = result.substr(pos, len);
        replacedTemplStrs.insert(templStr);
        result.replace(pos, len, templateStringMap.at(templStr));
        pos += len;
    }
 
    // Unreferenced template string, especially for output operands, may break
    // semantics of a program code.
    for (auto& tmplStrPair : templateStringMap) {
        const std::string& tmplStr = tmplStrPair.first;
        if (replacedTemplStrs.count(tmplStr)) continue;
        std::string msg;
        try {
            auto opdIdx = Conversion::toInt(tmplStr.substr(1))+1;
            msg = std::to_string(opdIdx) + ". operand is unreferenced";
        } catch (NumberFormatException&) {
            msg = "There is unreferenced operand";
        }
        std::string srcFile;
        size_t srcLine;
        std::tie(srcFile, srcLine) = getSourceLocationInfo(mi);
        std::string srcLoc;
        if (!srcFile.empty()) {
            srcLoc = srcFile + ":" + std::to_string(srcLine) + ": ";
        }
        std::cerr << srcLoc << "Warning: " << msg
                  << " in an inline asm block."
                  << std::endl;
    }
 
    // Replace "%=" template strings (redubbed  as "${:uid}" in LLVM).
    std::string uidTmplStr = "${:uid}";
    auto uid = std::to_string(asmId_++);
    pos = 0;
    while ((pos = result.find(uidTmplStr, pos)) != std::string::npos) {
        result.replace(pos, uidTmplStr.size(), uid);
        pos += uid.size();
    }
    assert(!result.empty());
    return result;
}

References asmId_, assert, getInlineAsmOperands(), getSourceLocationInfo(), isInlineAsm(), llvm::TCETargetMachine::registerName(), Application::spamVerbose(), THROW_EXCEPTION, tm_, and Conversion::toInt().

Referenced by parse().

Here is the call graph for this function:

Member Data Documentation

asmId_

unsigned InlineAsmParser::asmId_ = 0

private

The unique id for "%=" template strings. Each parse() call increases the count.

Definition at line 125 of file InlineAsmParser.hh.

Referenced by substituteAsmString().

mangler_

const llvm::Mangler& InlineAsmParser::mangler_

private

The symbol name mangler for MIs' symbolic references.

Definition at line 119 of file InlineAsmParser.hh.

Referenced by parse().

parserDiagnostic_

AssemblyParserDiagnostic InlineAsmParser::parserDiagnostic_

private

The diagnostic object to report parse and compile warnings and errors to.

Definition at line 122 of file InlineAsmParser.hh.

Referenced by diagnostics(), parse(), reportError(), and reportError().

tm_

const llvm::TCETargetMachine& InlineAsmParser::tm_

private

The target machine parsing context.

Definition at line 117 of file InlineAsmParser.hh.

Referenced by parse(), registerName(), and substituteAsmString().

---

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

• InlineAsmParser.hh
• InlineAsmParser.cc