Subversion Repositories lxp32

/*
 * Copyright (c) 2016 by Alex I. Kuznetsov.
 *
 * Part of the LXP32 CPU IP core.
 *
 * Main translation unit for the LXP32 assembler/linker.
 */
 
#include "assembler.h"
#include "linker.h"
#include "utils.h"
 
#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <exception>
#include <utility>
#include <memory>
#include <cstdlib>
#include <cstring>
#include <cassert>
 
struct Options {
	enum OutputFormat {Bin,Textio,Dec,Hex};
 
	bool compileOnly=false;
	std::string outputFileName;
	std::string mapFileName;
	std::vector<std::string> includeSearchDirs;
	LinkableObject::Word base=0;
	std::size_t align=4;
	std::size_t imageSize=0;
	OutputFormat fmt=Bin;
};
 
static void displayUsage(std::ostream &os,const char *program) {
	os<<std::endl;
	os<<"Usage:"<<std::endl;
	os<<"    "<<program<<" [ option(s) | input file(s) ]"<<std::endl<<std::endl;
 
	os<<"Options:"<<std::endl;
	os<<"    -a <align>   Object alignment (default: 4)"<<std::endl;
	os<<"    -b <addr>    Base address (default: 0)"<<std::endl;
	os<<"    -c           Compile only (don't link)"<<std::endl;
	os<<"    -f <fmt>     Output file format (see below)"<<std::endl;
	os<<"    -h, --help   Display a short help message"<<std::endl;
	os<<"    -i <dir>     Add directory to the list of directories used to search"<<std::endl;
	os<<"                 for included files (multiple directories can be specified)"<<std::endl;
	os<<"    -m <file>    Generate map file"<<std::endl;
	os<<"    -o <file>    Output file name"<<std::endl;
	os<<"    -s <size>    Output image size"<<std::endl;
	os<<"    --           Do not interpret subsequent arguments as options"<<std::endl;
	os<<std::endl;
	os<<"Object alignment must be a power of two and can't be less than 4."<<std::endl;
	os<<"Base address must be a multiple of object alignment."<<std::endl;
	os<<"Image size must be a multiple of 4."<<std::endl;
	os<<std::endl;
 
	os<<"Output file formats:"<<std::endl;
	os<<"    bin          Raw binary image (default)"<<std::endl;
	os<<"    textio       Text representation of binary data. Supported by"<<std::endl;
	os<<"                 std.textio (VHDL) and $readmemb (Verilog)"<<std::endl;
	os<<"    dec          Text format, one word per line (decimal)"<<std::endl;
	os<<"    hex          Text format, one word per line (hexadecimal)"<<std::endl;
}
 
static bool isLinkableObject(const std::string &filename) {
	static const char *id="LinkableObject";
	static std::size_t idSize=std::strlen(id);
 
	std::ifstream in(filename,std::ios_base::in);
	if(!in) return false;
	if(in.tellg()==static_cast<std::ifstream::pos_type>(-1))
		return false; // the stream is not seekable
 
	std::vector<char> buf(idSize);
	in.read(buf.data(),idSize);
	if(static_cast<std::size_t>(in.gcount())!=idSize) return false;
	if(std::memcmp(buf.data(),id,idSize)) return false;
	return true;
}
 
int main(int argc,char *argv[]) try {
	std::vector<std::string> inputFiles;
	Options options;
	bool alignmentSpecified=false;
	bool baseSpecified=false;
	bool formatSpecified=false;
	bool noMoreOptions=false;
 
	std::cout<<"LXP32 Platform Assembler and Linker"<<std::endl;
	std::cout<<"Copyright (c) 2016-2019 by Alex I. Kuznetsov"<<std::endl;
 
	if(argc<=1) {
		displayUsage(std::cout,argv[0]);
		return 0;
	}
 
	for(int i=1;i<argc;i++) {
		if(argv[i][0]!='-'||noMoreOptions) inputFiles.push_back(argv[i]);
		else if(!strcmp(argv[i],"--")) noMoreOptions=true;
		else if(!strcmp(argv[i],"-a")) {
			if(++i==argc) {
				displayUsage(std::cerr,argv[0]);
				return EXIT_FAILURE;
			}
			try {
				options.align=std::stoul(argv[i],nullptr,0);
				if(!Utils::isPowerOf2(options.align)) throw std::exception();
				if(options.align<4) throw std::exception();
				alignmentSpecified=true;
			}
			catch(std::exception &) {
				throw std::runtime_error("Invalid object alignment");
			}
		}
		else if(!strcmp(argv[i],"-b")) {
			if(++i==argc) {
				displayUsage(std::cerr,argv[0]);
				return EXIT_FAILURE;
			}
			try {
				options.base=std::stoul(argv[i],nullptr,0);
				baseSpecified=true;
			}
			catch(std::exception &) {
				throw std::runtime_error("Invalid base address");
			}
		}
		else if(!strcmp(argv[i],"-c")) {
			options.compileOnly=true;
		}
		else if(!strcmp(argv[i],"-f")) {
			if(++i==argc) {
				displayUsage(std::cerr,argv[0]);
				return EXIT_FAILURE;
			}
			if(!strcmp(argv[i],"bin")) options.fmt=Options::Bin;
			else if(!strcmp(argv[i],"textio")) options.fmt=Options::Textio;
			else if(!strcmp(argv[i],"dec")) options.fmt=Options::Dec;
			else if(!strcmp(argv[i],"hex")) options.fmt=Options::Hex;
			else throw std::runtime_error("Unrecognized output format");
			formatSpecified=true;
		}
		else if(!strcmp(argv[i],"-h")||!strcmp(argv[i],"--help")) {
			displayUsage(std::cout,argv[0]);
			return 0;
		}
		else if(!strcmp(argv[i],"-i")) {
			if(++i==argc) {
				displayUsage(std::cerr,argv[0]);
				return EXIT_FAILURE;
			}
			options.includeSearchDirs.push_back(argv[i]);
		}
		else if(!strcmp(argv[i],"-m")) {
			if(++i==argc) {
				displayUsage(std::cerr,argv[0]);
				return EXIT_FAILURE;
			}
			options.mapFileName=argv[i];
		}
		else if(!strcmp(argv[i],"-o")) {
			if(++i==argc) {
				displayUsage(std::cerr,argv[0]);
				return EXIT_FAILURE;
			}
			options.outputFileName=argv[i];
		}
		else if(!strcmp(argv[i],"-s")) {
			if(++i==argc) {
				displayUsage(std::cerr,argv[0]);
				return EXIT_FAILURE;
			}
			try {
				options.imageSize=std::stoul(argv[i],nullptr,0);
				if(options.imageSize%4!=0||options.imageSize==0) throw std::exception();
			}
			catch(std::exception &) {
				throw std::runtime_error("Invalid image size");
			}
		}
		else throw std::runtime_error(std::string("Unrecognized option: \"")+argv[i]+"\"");
	}
 
	if(options.base%options.align!=0)
		throw std::runtime_error("Base address must be a multiple of object alignment");
 
	if(options.compileOnly) {
		if(alignmentSpecified)
			std::cerr<<"Warning: Object alignment is ignored in compile-only mode"<<std::endl;
		if(baseSpecified)
			std::cerr<<"Warning: Base address is ignored in compile-only mode"<<std::endl;
		if(formatSpecified)
			std::cerr<<"Warning: Output format is ignored in compile-only mode"<<std::endl;
		if(options.imageSize>0)
			std::cerr<<"Warning: Image size is ignored in compile-only mode"<<std::endl;
		if(!options.mapFileName.empty())
			std::cerr<<"Warning: Map file is not generated in compile-only mode"<<std::endl;
	}
 
	if(inputFiles.empty())
		throw std::runtime_error("No input files were specified");
 
	if(options.compileOnly&&inputFiles.size()>1&&!options.outputFileName.empty())
		throw std::runtime_error("Output file name cannot be specified "
			"for multiple files in compile-only mode");
 
	std::vector<Assembler> assemblers;
	std::vector<LinkableObject> rawObjects;
 
	for(auto const &filename: inputFiles) {
		if(options.compileOnly||!isLinkableObject(filename)) {
			Assembler as;
			for(auto const &dir: options.includeSearchDirs) as.addIncludeSearchDir(dir);
			try {
				as.processFile(filename);
			}
			catch(std::exception &ex) {
				std::cerr<<"Assembler error in "<<as.currentFileName();
				if(as.line()>0) std::cerr<<":"<<as.line();
				std::cerr<<": "<<ex.what()<<std::endl;
				return EXIT_FAILURE;
			}
			if(!options.compileOnly) assemblers.push_back(std::move(as));
			else {
				std::string outputFileName=options.outputFileName;
				if(outputFileName.empty()) {
					outputFileName=filename;
					auto pos=outputFileName.find_last_of('.');
					if(pos!=std::string::npos) outputFileName.erase(pos);
					outputFileName+=".lo";
				}
				as.object().serialize(outputFileName);
			}
		}
		else {
			LinkableObject lo;
			try {
				lo.deserialize(filename);
			}
			catch(std::exception &ex) {
				std::cerr<<"Error reading object file "<<filename<<": "<<ex.what()<<std::endl;
				return EXIT_FAILURE;
			}
			rawObjects.push_back(std::move(lo));
		}
	}
 
	if(options.compileOnly) return 0;
 
	Linker linker;
	for(auto &lo: rawObjects) linker.addObject(lo);
	for(auto &as: assemblers) linker.addObject(as.object());
	linker.setBase(options.base);
	linker.setAlignment(options.align);
	linker.setImageSize(options.imageSize);
 
	std::string outputFileName=options.outputFileName;
	if(outputFileName.empty()) {
		outputFileName=inputFiles[0];
		auto pos=outputFileName.find_last_of('.');
		if(pos!=std::string::npos) outputFileName.erase(pos);
		if(options.fmt==Options::Bin) outputFileName+=".bin";
		else outputFileName+=".txt";
	}
 
	std::unique_ptr<OutputWriter> writer;
 
	switch(options.fmt) {
	case Options::Bin:
		writer=std::unique_ptr<OutputWriter>(new BinaryOutputWriter(outputFileName));
		break;
	case Options::Textio:
		writer=std::unique_ptr<OutputWriter>(new TextOutputWriter(outputFileName,TextOutputWriter::Bin));
		break;
	case Options::Dec:
		writer=std::unique_ptr<OutputWriter>(new TextOutputWriter(outputFileName,TextOutputWriter::Dec));
		break;
	case Options::Hex:
		writer=std::unique_ptr<OutputWriter>(new TextOutputWriter(outputFileName,TextOutputWriter::Hex));
		break;
	default:
		assert(false);
	}
 
	try {
		linker.link(*writer);
	}
	catch(std::exception &ex) {
		writer->abort();
		std::cerr<<"Linker error: "<<ex.what()<<std::endl;
		return EXIT_FAILURE;
	}
 
	std::cout<<writer->size()/4<<" words written"<<std::endl;
 
	if(!options.mapFileName.empty()) {
		std::ofstream out(options.mapFileName);
		if(!out) throw std::runtime_error("Cannot open file \""+options.mapFileName+"\" for writing");
		linker.generateMap(out);
	}
}
catch(std::exception &ex) {
	std::cerr<<"Error: "<<ex.what()<<std::endl;
	return EXIT_FAILURE;
}