Subversion Repositories openfire_core

#!/usr/bin/perl
############################################################
# openfire_util
#
# Provides compilation functions for OpenFire.
#
# Stephen Douglas Craven
# 1/17/2006
# Configurable Computing Lab
# Virginia Tech
############################################################
 
# Globals
use vars qw/ %opt /;
 
# Command line options processing
sub init()
{
    use Getopt::Std;
    my $opt_string = 'hcmd:f:a:p:n:';
    getopts( "$opt_string", \%opt ) or usage();
    usage() if ($opt{h} or !$opt{f} or ($opt{d} and !$opt{a}) or $opt{C});
}
 
# Message about this program and how to use it
sub usage()
{
    print STDERR << "EOF";
 
This program compiles a MicroBlze C program and converts the resulting
ELF file into a memory image (.ROM file) for use by openfire_sim and 
verilog simlulators.
 
NOTE: XMD must be installed and in the user's path.
 
usage: $0 [-h] -f file <-d data_file address> -p <XPS project directory>
 
 -h		    : this (help) message
 -d data	    : optional data file -- MUST be paired with -a flag
 -a address	    : optional hex address (0x####) for data file
 -f file	    : MicroBlaze C file
 -c                 : create a rom file (.rom) for openfire_sim and verilog sim
 -p directory       : XPS project directory: make -f system.make libs must be already run!
 -m                 : use hardware multiplier
 -n master_name     : name of master MicroBlaze (default: microblaze_0)
 
example: $0 -f file.c -d data.dat -a 0x1234
 
EOF
exit;
}
 
init();
 
# Fill in default values
if($opt{n}) {
	$microblaze_name = $opt{n};
} else {
	$microblaze_name = microblaze_0;
}
 
# Parse path to file to get filename
$_ = $opt{f};
@path = split(/\//);
@htap = reverse(@path);
$_ = $htap[0];
($filename, $extension) = split(/\./);
# Make sure its a C file first
usage() if ($extension ne "c");
 
# If file doesn't exist, raise error
unless (-e $opt{f}) {
	print STDERR $opt{f}." NOT Found!\n";
	exit;
}
 
# Create GCC command to compile C program
# Requires that libraries are previously compiled
$gcc_command = "mb-gcc ".$opt{f}." -O2 -o of_executable.elf \\\n";
$gcc_command = $gcc_command."  -I".$opt{p}."/".$microblaze_name."/include/ -I".$opt{p}."/code/ \\\n";
# If we have a HW multiplier, use it
if($opt{m}) {
	$gcc_command = $gcc_command."  -mno-xl-soft-mul \\\n";
}
$gcc_command = $gcc_command."  -L".$opt{p}."/".$microblaze_name."/lib/ -xl-mode-executable";
 
print $gcc_command."\n";
# Compile code
system($gcc_command);
 
# Make sure compilation succeeded
unless (-e "of_executable.elf") {
	print STDERR "of_executable.elf NOT Found! Compilation Failed!\n";
	exit;
}
 
# Stop here, unless user wants a ROM file as well for simulation
unless($opt{c}) {exit(0);}
 
####################################################################################
# A ROM file is a simple file showing the hex value of each memory location on 
#    a separate line.  This is useful for Verilog simulators, which can read
#    this format with a $readmemh.  The openfire_sim C simulator also reads
#    this format.
#
# Sample ROM file:
# A123B456
# C321D654
# and so on
####################################################################################
 
# If the user wants to add data to the ROM file, examine the file to determine size
if ($opt{d}) {
	if (-e $opt{d})
	{
		( $dev, $ino, $mode, $nlink,
		  $uid, $gid, $rdev, $size,
		  $atime, $mtime, $ctime,
		  $blksize, $blocks )       = stat($opt{d});
	} else {
		print STDERR "File ".$opt{d}." NOT Found!\n";
		exit;
	}
}
 
# We need the maximum memory size, so convert provided address from hex to decimal
#     and add the size of the data file (found above) to that
if ($opt{a}) {
	$max_mem = oct($opt{a}) + $size + 10;
} else { # no address / data file provided; base size of ROM file on executable
	( $dev, $ino, $mode, $nlink,
	  $uid, $gid, $rdev, $size,
	  $atime, $mtime, $ctime,
	  $blksize, $blocks )       = stat("of_executable.elf");
	  $max_mem = $size/2; # guestimate on program size based on ELF size
}
 
####################################################################################
# The ROM file is created by loading the ELF file into the XMD MicroBlaze simulator.
#    The memory of the simulator is then dumped into a text file.  This is sort of 
#    a hack, but it is much easier than parsing the ELF file myself -- I am certain
#    not to make mistakes about where text and data sections go.
####################################################################################
# Create a TCL script for XMD
open(tcl_file, ">tmp666.tcl");
print tcl_file "xconnect mb sim\n";
print tcl_file "xdownload 0 of_executable.elf\n";
print tcl_file "xdownload 0 -data ".$opt{d}." ".$opt{a}."\n" if $opt{d};
print tcl_file "set hope [xrmem 0 0 ".$max_mem."]\n";
print tcl_file "puts \$hope\n";
close(tcl_file);
 
# Execute the TCL script, capturing the output
$xmd_cmd = "xmd -tcl tmp666.tcl";
$xmd_output = `$xmd_cmd`;
 
# Parse the output to just capture the memory data
##################################################################
# WARNING! This is likely to change with different XMD versions! #
##################################################################
$flag = 0;
foreach $_ (split(/\n/, $xmd_output)){
        if ($flag){
                @output = split(/ /, $_);
        }
        if ( $_ =~/Setting PC/) {$flag = 1;}
}
 
# Open a file to write results
binmode rom_file;
open(rom_file, ">$filename.rom");
 
# Print memory contents in hex
$count = 0;
foreach $number (@output) {
        if ($number =~/\d/) {
                $hex[$count] = sprintf("%X", $number);
                if($number < 16) {
                        $hex[$count] = "0".$hex[$count];
                }
                $count++;
        }
        if ($count == 4) {
                $count = 0;
                printf rom_file $hex[0].$hex[1].$hex[2].$hex[3]."\n";
        }
}
close(rom_file);
 
# Remove the TCL script we created
system("rm tmp666.tcl");
exit;
 
# Stuff below is old for making COE coregen files
# Needs rework
if($opt{c} | $opt{C}) {
	open(coe_file, ">$filename.coe");
	open(rom_file, "$filename.rom");
	print coe_file "memory_initialization_radix=16;\n";
	$reset = 1;
	while(<rom_file>){
        	if ($reset > 0) {
                	chomp($_);
	                print coe_file "memory_initialization_vector= $_";
        	}
	        else    {
        	        chomp($_);
                	print coe_file ", ".$_;
	        }
        	$reset = 0;
	}
	print coe_file ";\n";
	close(coe_file);
	close(rom_file);
}