LLVMTCE.cc File Reference

#include <iostream>
#include "Application.hh"
#include "LLVMBackend.hh"
#include "LLVMTCECmdLineOptions.hh"
#include "Program.hh"
#include "ADFSerializer.hh"
#include "FileSystem.hh"
#include "InterPassData.hh"
#include "Machine.hh"
#include "CompilerWarnings.hh"
#include <llvm/Support/CommandLine.h>

Include dependency graph for LLVMTCE.cc:

Go to the source code of this file.

Macros
#define	__STDC_LIMIT_MACROS

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

Variables
POP_COMPILER_DIAGS const std::string	DEFAULT_OUTPUT_FILENAME = "out.tpef"
const int	DEFAULT_OPT_LEVEL = 2

Detailed Description

LLVM/TCE compiler command line interface.

Author

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

Note

rating: red

Definition in file LLVMTCE.cc.

Macro Definition Documentation

__STDC_LIMIT_MACROS

#define __STDC_LIMIT_MACROS

Definition at line 46 of file LLVMTCE.cc.

Function Documentation

main()

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

Main function of the CLI.

Checks command line options and runs compiler accordingly.

Parameters

argc	Argument count.
argv	Command line arguments.

Returns

Exit status code for the OS.

Definition at line 65 of file LLVMTCE.cc.

                             {
 
    Application::initialize(argc, argv);
 
    LLVMTCECmdLineOptions* options = new LLVMTCECmdLineOptions();
 
    // Parse command line options.
    try {
        options->parse(argv, argc);
    } catch (ParserStopRequest const&) {
        return EXIT_SUCCESS;
    } catch (const IllegalCommandLine& e) {
        std::cerr << e.errorMessageStack() << std::endl;
        return EXIT_FAILURE;
    }
 
    if (options->numberOfArguments() != 1) {
        options->printHelp();
        return EXIT_FAILURE;
    }
 
    if (options->tempDir() == "") {
        Application::errorStream() 
            << "Temporary directory required." << std::endl;
        options->printHelp();
        return EXIT_FAILURE;
    }
 
    Application::setCmdLineOptions(options);
 
    if (options->isVerboseSwitchDefined()) {
        Application::setVerboseLevel(Application::VERBOSE_LEVEL_INCREASED);
    }
 
    // --- Target ADF ---
    if (!options->isMachineFileDefined()) {
        std::cerr << "ERROR: No target architecture (.adf) defined."
                  << std::endl;
 
        return EXIT_FAILURE;
    }
 
    TTAMachine::Machine* mach = NULL;
    std::string targetADF = options->machineFile();
 
    if (!FileSystem::fileExists(targetADF) ||
        !FileSystem::fileIsReadable(targetADF) ||
        FileSystem::fileIsDirectory(targetADF)) {
 
        std::cerr << "ERROR: Target architecture file '"
                  << targetADF << "' doesn't exist or isn't readable."
                  << std::endl;
 
        return EXIT_FAILURE;
    }
 
    try {
        ADFSerializer serializer;
        serializer.setSourceFile(targetADF);
        mach = serializer.readMachine();
    } catch (Exception& e) {
        std::cerr << "Error loading target architecture file '"
                  << targetADF << "':" << std::endl
                  << e.errorMessageStack() << std::endl;
 
        return EXIT_FAILURE;
    }
 
    // --- Output file name ---
    std::string outputFileName = DEFAULT_OUTPUT_FILENAME;
    if (options->isOutputFileDefined()) {
        // Test if output file can be opened
        outputFileName = options->outputFile();
    }
    if (!FileSystem::fileIsWritable(outputFileName) &&
        !FileSystem::fileIsCreatable(outputFileName)) {
        std::cerr << "Output file '"
            << outputFileName << "' can not be opened for writing!"
            << std::endl;
        return EXIT_FAILURE;
    }
 
    // --- optimization level ---
    int optLevel = DEFAULT_OPT_LEVEL;
    if (options->isOptLevelDefined()) {
        optLevel = options->optLevel();
    }
 
    std::string bytecodeFile = options->argument(1);
 
    bool debug = options->debugFlag();
    
    //--- check if program was ran in src dir or from install dir ---
    std::string runPath = std::string(argv[0]);
 
    bool useInstalledVersion = Application::isInstalled();
    
    // All emulation code which cannot be linked in before last global dce is
    // executed, for emulation of instructions which are generated during 
    // lowering. Unnecessary functions are removed by the MachineDCE pass.
    std::string emulationCode;    
    if (options->isStandardEmulationLibDefined()) {
        emulationCode = options->standardEmulationLib();
    }
            
    // ---- Run compiler ----
    try {
        InterPassData* ipData = new InterPassData;
        int argc = 0;
        std::string argv = options->getLLVMargv();
        if (options->isVerboseSpamSwitchDefined()) {
            std::cout << "llvm args = " << argv << std::endl;
        }
        // Convert to char**
        std::vector<char*> argv_array;
        std::istringstream iss(argv);
        std::string token;
        while (iss >> token) {
            char* arg = new char[token.size() + 1];
            copy(token.begin(), token.end(), arg);
            arg[token.size()] = '\0';
            argv_array.push_back(arg);
            argc++;
        }
        argv_array.push_back(0);
        llvm::cl::ParseCommandLineOptions(
            argc, argv_array.data(), "llvm flags\n");
 
        LLVMBackend compiler(useInstalledVersion, options->tempDir());
        compiler.setMachine(*mach);
        TTAProgram::Program* seqProg =
            compiler.compile(
                bytecodeFile, emulationCode, optLevel, debug, ipData);
 
        TTAProgram::Program::writeToTPEF(*seqProg, outputFileName);
        delete seqProg;
        seqProg = NULL;
 
        delete ipData;
        ipData = NULL;
 
    } catch (const CompileError& e) {
        // CompilerErrors are related to the user program input and
        // should be communicated to the programmer in a clean fashion.
        Application::errorStream() << e.errorMessage() << std::endl;
    } catch (const Exception& e) {
        // Assume other Exceptions are due to like lack of more
        // user friendly CompilerError or actual internal compiler errors.
        std::cerr << "Error compiling '" << bytecodeFile << "':" << std::endl
                  << e.errorMessageStack() << std::endl;
 
        return EXIT_FAILURE;
    }
 
    delete mach;
    mach = NULL;
 
    return EXIT_SUCCESS;
}

References CmdLineParser::argument(), LLVMBackend::compile(), DEFAULT_OPT_LEVEL, DEFAULT_OUTPUT_FILENAME, Exception::errorMessage(), Exception::errorMessageStack(), Application::errorStream(), FileSystem::fileExists(), FileSystem::fileIsCreatable(), FileSystem::fileIsDirectory(), FileSystem::fileIsReadable(), FileSystem::fileIsWritable(), Application::initialize(), Application::isInstalled(), CmdLineOptions::isVerboseSpamSwitchDefined(), CmdLineOptions::isVerboseSwitchDefined(), CmdLineParser::numberOfArguments(), options, outputFileName(), CmdLineOptions::parse(), MachInfoCmdLineOptions::printHelp(), ADFSerializer::readMachine(), Application::setCmdLineOptions(), LLVMBackend::setMachine(), XMLSerializer::setSourceFile(), Application::setVerboseLevel(), Application::VERBOSE_LEVEL_INCREASED, and TTAProgram::Program::writeToTPEF().

Here is the call graph for this function:

Variable Documentation

DEFAULT_OPT_LEVEL

const int DEFAULT_OPT_LEVEL = 2

Definition at line 53 of file LLVMTCE.cc.

Referenced by main().

DEFAULT_OUTPUT_FILENAME

POP_COMPILER_DIAGS const std::string DEFAULT_OUTPUT_FILENAME = "out.tpef"

Definition at line 52 of file LLVMTCE.cc.

Referenced by main().