Subversion Repositories fwrisc

/*

 * AsmTestCompiler.cpp

 *

 *

 * Copyright 2018 Matthew Ballance

 *

 * Licensed under the Apache License, Version 2.0 (the

 * "License"); you may not use this file except in

 * compliance with the License.  You may obtain a copy of

 * the License at

 *

 * http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in

 * writing, software distributed under the License is

 * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR

 * CONDITIONS OF ANY KIND, either express or implied.  See

 * the License for the specific language governing

 * permissions and limitations under the License.

 *

 *  Created on: Oct 28, 2018

 *      Author: ballance

 */

#include "AsmTestCompiler.h"

#include <stdlib.h>

#include <stdio.h>

#include <vector>

#include <ctype.h>

#include <string.h>

AsmTestCompiler::AsmTestCompiler(

                const std::string       &basename,

                const std::string       &program,

                const std::string       &out) {

        m_basename = basename;

        m_program = program;

        m_out = out;

}

AsmTestCompiler::~AsmTestCompiler() {

        // TODO Auto-generated destructor stub

}

bool AsmTestCompiler::compile(

                const std::string       &basename,

                const std::string       &program,

                const std::string       &out) {

        AsmTestCompiler compiler(basename, program, out);

        return compiler.compile();

}

bool AsmTestCompiler::compile() {

        std::string full_program = R"(

                .section .text.init;

                .globl _start

                _start:

                        j               test_program

                done:

                        j               done

                test_program:   //

        )";

        full_program += m_program;

        std::string cmd;

        std::string filename;

        FILE *fh;

        filename = m_basename + ".link.ld";

        fh = fopen(filename.c_str(), "wb");

        fputs(R"(

                OUTPUT_ARCH("riscv")

                ENTRY(_start)

                SECTIONS

                {

                        . = 0x00000000;

                        .text.init : { *(.text.init) }

                        . = ALIGN(0x1000);

                        _end = .;

                }

        )", fh);

        fclose(fh);

        filename = m_basename + ".test.S";

        fh = fopen(filename.c_str(), "wb");

        if (!fh) {

                fprintf(stdout, "Error: failed to open file \"%s\"\n", filename.c_str());

                return false;

        }

        fputs(full_program.c_str(), fh);

        fclose(fh);

        cmd = "riscv32-unknown-elf-gcc -march=rv32i -mabi=ilp32 -o ";

        cmd += m_basename + ".test.elf ";

        cmd += "-static -mcmodel=medany -fvisibility=hidden ";

        cmd += "-nostdlib -nostartfiles ";

        cmd += m_basename + ".test.S ";

        cmd += "-T ";

        cmd += m_basename + ".link.ld";

        if (system(cmd.c_str()) != 0) {

                fprintf(stdout, "compile failed\n");

                return false;

        }

        cmd = "riscv32-unknown-elf-objcopy ";

        cmd += m_basename + ".test.elf ";

        cmd += "-O verilog ";

        cmd += m_basename + ".test.vlog";

        if (system(cmd.c_str()) != 0) {

                fprintf(stdout, "objcopy failed\n");

                return false;

        }

        if (!tohex(m_basename + ".test.vlog", m_out)) {

                fprintf(stdout, "tohex failed\n");

                return false;

        }

        return true;

}

bool AsmTestCompiler::tohex(

                const std::string &file_vlog,

                const std::string &file_hex) {

        char tmp[1024];

        bool ret = true;

        FILE *fh_vlog = fopen(file_vlog.c_str(), "rb");

        FILE *fh_hex = fopen(file_hex.c_str(), "wb");

        if (!fh_vlog || !fh_hex) {

                fprintf(stdout, "Error: failed to open files\n");

                return false;

        }

        // Prime the pump

        fgets(tmp, sizeof(tmp), fh_vlog);

        while (true) {

                uint32_t wordaddr;

                if (tmp[0] != '@') {

                        fprintf(stdout, "Error: unknown record: %s", tmp);

                        ret = false;

                        break;

                }

                wordaddr = strtoul(&tmp[1], 0, 16);

                wordaddr /= 4;

                fprintf(fh_hex, "@%08x\n", wordaddr);

                while (fgets(tmp, sizeof(tmp), fh_vlog)) {

                        if (tmp[0] != '@') {

                                std::vector<std::string> bytes;

                                uint32_t len = strlen(tmp);

                                uint32_t i=0;

                                while (i<len) {

                                        std::string byte;

                                        // Skip whitespace

                                        while (i < len && isspace(tmp[i])) {

                                                i++;

                                        }

                                        // Stuff non-whitespace into a byte

                                        while (i < len && !isspace(tmp[i])) {

                                                byte.push_back(tmp[i]);

                                                i++;

                                        }

                                        if (byte.size() > 0) {

                                                bytes.push_back(byte);

                                        }

                                }

                                for (i=0; i<bytes.size(); i+=4) {

                                        for (int j=4-1; j>=0; j--) {

                                                if (i+j < bytes.size()) {

                                                        fprintf(fh_hex, "%s", bytes.at(i+j).c_str());

                                                } else {

                                                        fprintf(fh_hex, "00");

                                                }

                                        }

                                        fprintf(fh_hex, "\n");

                                }

                        } else {

                                break;

                        }

                }

                if (feof(fh_vlog)) {

                        break;

                }

        }

        fclose(fh_vlog);

        fclose(fh_hex);

        return ret;

}