tceopgen.cc File Reference

#include <iostream>
#include <fstream>
#include <set>
#include <assert.h>
#include "OperationPool.hh"
#include "Operation.hh"
#include "Conversion.hh"
#include "OperationIndex.hh"
#include "Operand.hh"
#include "Application.hh"

Include dependency graph for tceopgen.cc:

Go to the source code of this file.

Enumerations
enum	mode { NORMAL, FU_ADDRESSABLE, ADDRESSPACE, RISCV }

Functions
std::string	operandTypeCString (const Operand &operand)
void	writeCustomOpMacro (std::ostream &os, std::string &opName, const Operation &op, mode macroMode, bool legacy)
void	writeCustomOpMacros (std::ostream &os)
int	main (int argc, char *argv[])

Enumeration Type Documentation

mode

enum mode

TCE custom op macro header generator for LLVM TCE backend.

Author

Veli-Pekka Jääskeläinen 2007 (vjaaskel-no.spam-cs.tut.fi)

Pekka Jääskeläinen 2009 (pjaaskel-no.spam-cs.tut.fi)

Note

rating: red

Enumerator
NORMAL
FU_ADDRESSABLE
ADDRESSPACE
RISCV

Definition at line 45 of file tceopgen.cc.

{ NORMAL, FU_ADDRESSABLE, ADDRESSPACE, RISCV };

Function Documentation

main()

int main	(	int	argc,
		char *	argv[]
	)

tceopgen main function.

Generates plugin sourcecode files using TDGen.

Definition at line 315 of file tceopgen.cc.

                                 {
 
    if (!(argc == 1 || argc == 3) ||
        (argc == 3 && Conversion::toString(argv[1]) != std::string("-o"))) {
 
        std::cout << "Usage: tceopgen" << std::endl
                  << "   -o Output File." << std::endl;
        return EXIT_FAILURE;
    }
 
    if (argc == 1) {
        writeCustomOpMacros(std::cout);
    } else if (argc == 3) {
        std::ofstream customops;
        customops.open(argv[2]);
        if (!customops.good()) {
            std::cerr << "Error opening '" << argv[2]
                      << "' for writing." << std::endl;
            return EXIT_FAILURE;
        }       
        writeCustomOpMacros(customops);
        customops.close();
    } else   {
        assert(false);
    }
 
    return EXIT_SUCCESS;   
}

References assert, Conversion::toString(), and writeCustomOpMacros().

Here is the call graph for this function:

operandTypeCString()

std::string operandTypeCString

(

const Operand &

operand

)

Returns a C type string for the given operand type.

Definition at line 50 of file tceopgen.cc.

                                           {
    switch (operand.type()) {
    default:
    case Operand::SINT_WORD:
        return "int";
        break;
    case Operand::UINT_WORD:
        return "unsigned";
        break;
    case Operand::FLOAT_WORD:
        return "float";
        break;
    case Operand::DOUBLE_WORD:
        return "double";
        break;
    case Operand::RAW_DATA:
        return "";
        break;
    case Operand::SLONG_WORD:
        return "long";
        break;
    case Operand::ULONG_WORD:
        return "unsigned long";
        break;
    }
    // TODO: it never comes here!
    // half floats take the "default".
    return "unsigned";
}

References Operand::DOUBLE_WORD, Operand::FLOAT_WORD, Operand::RAW_DATA, Operand::SINT_WORD, Operand::SLONG_WORD, Operand::type(), Operand::UINT_WORD, and Operand::ULONG_WORD.

Referenced by writeCustomOpMacro().

Here is the call graph for this function:

writeCustomOpMacro()

void writeCustomOpMacro	(	std::ostream &	os,
		std::string &	opName,
		const Operation &	op,
		mode	macroMode,
		bool	legacy
	)

Produces the _TCE_OPNAME or _TCEFU_OPNAME macro that can be written to the tceops.h header file from the given operation.

Definition at line 85 of file tceopgen.cc.

                                 {
    // Only generate valid RISC-V R-format intrinsics
    if (macroMode == RISCV) {
        if (op.numberOfInputs() != 2) {
            return;
        }
        if (op.numberOfOutputs() != 1) {
            return;
        }
    }
 
    if (op.numberOfInputs() + op.numberOfOutputs() == 0)
        return;
 
    if (legacy) {
        os << "#define _TCE";
    } else {
        os << "#define _OA";
    }
 
    const std::string outputOperandName =
        legacy ? "__tce_op_output_" : "__oa_op_output_";
 
    switch (macroMode) {
        case RISCV:
            os << "_RV_" << opName << "(";
            break;
        case FU_ADDRESSABLE:
            os << "FU_" << opName << "(FU, ";
            break;
        case ADDRESSPACE:
            os << "AS_" << opName << "(AS, ";
            break;
        default:
            os << "_" << opName << "(";
    }
 
    int seenInputs = 0;
    int seenOutputs = 0;
    for (int i = 1; 
         i < (op.numberOfInputs() + op.numberOfOutputs() + 1);
         i++) {
 
        const Operand& operand = op.operand(i);
        if (i > 1)
            os << ", ";
        if (operand.isInput()) {
            seenInputs++;
            os << "i" << seenInputs;
        } else {
            seenOutputs++;
            os << "o" << seenOutputs;
        }
    }
 
    os << ") do { ";
 
    /* Generate temporary variables to ensure casting to
     a correct value from the inline assembly statement.
 
     Without this, LLVM inline assembly used i8 for the
     output register type in case a char was used to
     read the value. This produced strange errors due
     to the value produced by the inline asm not being
     masked to the char size (in case the output is really
     larger than i8 in this case).
 
     In this bug (#35), after the char was written to
     a larger variable, the upper bits (produced by the custom op)
     were visible which is not expected behavior (writing int
     to char should zero out the upper bits). Forcing
     writing to int ensures the inline asm has 32 bit
     reg for the register thus LLVM produced correct
     masking/cast operations when writing the value to a smaller
     variable.
 
     Use do {} while(0) block instead of {} to allow using the
     custom ops as statements which end with ; etc.
 
     NOTE: we cannot add "memory" to the clobber list with
     operations that write to memory because it seems to crash
     (some versions of) gcc. Thus, they are marked 'volatile'.
     */
 
    for (int out = 1; out < op.numberOfOutputs() + 1; out++) {
        const Operand& operand = op.output(out - 1);
        std::string operandTypeString = operandTypeCString(operand);
        if (operandTypeString != "" && !operand.isVector()) {
            os << operandTypeCString(operand) << " " << outputOperandName
               << out << " = (" << operandTypeCString(operand) << ")0; ";
        }
    }
 
    std::string volatileKeyword = "";
    if (op.writesMemory() || op.hasSideEffects() ||
            op.affectsCount() > 0 || op.affectedByCount() > 0) {
        volatileKeyword = "volatile ";
    }
 
    os << "asm " << volatileKeyword << "(";
 
    switch (macroMode) {
        case RISCV: {
            os << "\"//" << opName << " ";
            int iterations = 0;
            for (iterations = 0; iterations < op.numberOfInputs();
                 iterations++) {
                os << "\\%" << std::to_string(iterations) << " ";
            }
            for (int i = 0; i < op.numberOfOutputs(); i++) {
                os << "\\%" << std::to_string(iterations + i);
            }
        } break;
    case FU_ADDRESSABLE:
        os << "FU\".";
        break;
    case ADDRESSPACE:
        os << "\"_AS.\" AS\".";
        break;
    default:
        os << "\"";
        break;
    }
 
    if (macroMode != RISCV) {
        os << opName;
    }
    os << "\":";
 
    for (int out = 1; out < op.numberOfOutputs() + 1; out++) {
        const Operand& operand = op.output(out - 1);
 
        if (out > 1)
            os << ", ";
        if (operandTypeCString(operand) != "" && !operand.isVector()) {
            os << "\"=r\"( " << outputOperandName << out << ")";
        } else {
            os << "\"=r\"(o" << out << ")";
        }
    }
    os << ":";
 
    for (int in = 1; in < op.numberOfInputs() + 1; in++) {
        const Operand& operand = op.input(in - 1);
 
        if (in > 1)
            os << ", ";
        // Only register inputs for RISC-V
        if (macroMode == RISCV) {
            if (operandTypeCString(operand) != "") {
                os << "\"r\"((" << operandTypeCString(operand) << ")(i" << in
                << "))";
            } else {
                os << "\"r\"(i" << in << ")";
            }
        } else if (operandTypeCString(operand) != "" && !operand.isVector()) {
            os << "\"ir\"((" << operandTypeCString(operand)
               << ")(i" << in << "))";
        } else {
            if (operand.isVector()) {
                os << "\"r\"(i" << in << ")";
            } else {
                os << "\"ir\"(i" << in << ")";
            }
        }
    }
 
    os << "); ";
 
    // write the results from the temps to the output variables
    for (int out = 1; out < op.numberOfOutputs() + 1; out++) {
        const Operand& operand = op.output(out - 1);
        if (operandTypeCString(operand) != "" && !operand.isVector()) {
            os << "o" << out << " = " << outputOperandName << out << ";";
        }
    }
 
    os << "} while(0) " << std::endl;
}

References ADDRESSPACE, Operation::affectedByCount(), Operation::affectsCount(), FU_ADDRESSABLE, Operation::hasSideEffects(), Operation::input(), Operand::isInput(), Operand::isVector(), Operation::numberOfInputs(), Operation::numberOfOutputs(), Operation::operand(), operandTypeCString(), Operation::output(), RISCV, and Operation::writesMemory().

Referenced by writeCustomOpMacros().

Here is the call graph for this function:

writeCustomOpMacros()

void writeCustomOpMacros

(

std::ostream &

os

)

Produces the _TCE_OPNAME and _TCEFU_OPNAME macros that can be written to the tceops.h header file.

Definition at line 272 of file tceopgen.cc.

                                    {
 
    OperationPool pool;
    OperationIndex& index = pool.index();
    std::set<std::string> operations;
 
    for (int m = 0; m < index.moduleCount(); m++) {
        OperationModule& mod = index.module(m);
        try {
            int opCount = index.operationCount(mod);
            for (int o = 0; o < opCount; o++) {
 
                std::string opName = index.operationName(o, mod);
                if (operations.count(opName) > 0) {
                    continue;
                }
                const Operation& op = pool.operation(opName.c_str());
                operations.insert(opName);
                // Write both legacy and new macros
                writeCustomOpMacro(os, opName, op, NORMAL, true);
                writeCustomOpMacro(os, opName, op, NORMAL, false);
                writeCustomOpMacro(os, opName, op, RISCV, true);
                writeCustomOpMacro(os, opName, op, RISCV, false);
                writeCustomOpMacro(os, opName, op, FU_ADDRESSABLE, true);
                writeCustomOpMacro(os, opName, op, FU_ADDRESSABLE, false);
                if (op.usesMemory()) {
                    writeCustomOpMacro(os, opName, op, ADDRESSPACE, true);
                    writeCustomOpMacro(os, opName, op, ADDRESSPACE, false);
                }
            }
        } catch (const Exception& e) {
            Application::errorStream()
                << "ERROR: " << e.errorMessage() << std::endl;
            continue;
        }
    }
}

References ADDRESSPACE, Exception::errorMessage(), Application::errorStream(), FU_ADDRESSABLE, OperationPool::index(), OperationIndex::module(), OperationIndex::moduleCount(), NORMAL, OperationPool::operation(), OperationIndex::operationCount(), OperationIndex::operationName(), RISCV, Operation::usesMemory(), and writeCustomOpMacro().

Referenced by main().

Here is the call graph for this function: