Subversion Repositories theia_gpu

#!/usr/bin/perl

################################################################

#Theia, Ray Cast Programable graphic Processing Unit.

#Copyright (C) 2010  Diego Valverde (diego.valverde.g@gmail.com)

#

#This program is free software; you can redistribute it and/or

#modify it under the terms of the GNU General Public License

#as published by the Free Software Foundation; either version 2

#of the License, or (at your option) any later version.

#

#This program is distributed in the hope that it will be useful,

#but WITHOUT ANY WARRANTY; without even the implied warranty of

#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

#GNU General Public License for more details.

#

#You should have received a copy of the GNU General Public #License

#along with this program; if not, write to the Free Software

#Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  #02110-1301, USA.

################################################################

$CodePath = $ARGV[0];

$DefsPath = "aDefinitions.v";

print

"

---------------------------------------------------------------

 _/_/_/_/_/  _/                  _/

   _/      _/_/_/      _/_/          _/_/_/

  _/      _/    _/  _/_/_/_/  _/  _/    _/

 _/      _/    _/  _/        _/  _/    _/

_/      _/    _/    _/_/_/  _/    _/_/_/

---------------------------------------------------------------

Compiling file '$CodePath'

";

$Line = 0;

%Registers;

%Instructions;

%Labels;

%EntryPoints;

@EntryKeys;

$OutputFile = "Instructions.mem";

open OUT, ">$OutputFile" or die "Can't open output file for R/W\n";

PopulateRegistersAndInstructionSet();

GenerateLabels();

ParseCode();

print

"

Output file: '$OutputFile'

** Compilation successful! **

---------------------------------------------------------------

";

close OUT;

exit(0);

#-------------------------------------------------------------------

sub PopulateRegistersAndInstructionSet()

{

   open DEFINITIONS, $DefsPath or die "'$DefsPath' : $!\n";

   while ()

   {

      #skip comments and empty lines

      next if (m/^([\s|\t]*\/\/)|^(\s*\n).*/);

       if (m/`define\s*(ENTRYPOINT_ADRR_\S*)[\s|\t]+.*\'d(\d+)/)

       {

         push @EntryKeys, $1;

         $EntryPoints{$1}= sprintf('%08X',$2);

         next;

       }

       if (m/\`define\s*([C|O]REG\_\S*)[\s|\t]+.*\'d(\d+)/ ||

          m/\`define\s*([R|C]\d+)[\s|\t]+.*\'d(\d+)/)

       {

          $Registers{$1} = sprintf('%X', $2);

          next;

       }

       if (m/\`define\s*(\S*)[\s|\t]+\`INSTRUCTION_OP_LENGTH\'b([0|1|\_]+)/)

       {

       $Instructions{$1} = $2;

       $key = $1;

       #get rid of the '_' characters

       $Instructions{$key} =~ s/\_//g;

       #convert to hexadecimal

       $Instructions{$key}= sprintf('%X', oct("0b$Instructions{$key}"));

       next;

      }

      if (m/\`define\s*(\S*)[\s|\t]+32\'d(\d+)/)

      {

          $Registers{$1} = $2;

      }

   }

   $InstructionCount = 0;

   close DEFINITIONS;

   #Ok, add some extra stuff

   $Registers{'VOID'} = 0;

   $Registers{'RT_TRUE'} = 1;

   $Registers{'RT_FALSE'} = 0;

}

#-------------------------------------------------------------------

sub GenerateLabels()

{

   my $IP = 0;

   open CODE, $CodePath or die "'$CodePath': $!\n";

   while ()

   {

      #skip comments and empty lines

      next if (m/^([\s|\t]*\/\/)|^(\s*\n).*/);

      $Line++;

      #print "$_ &&&& $IP\n";

      if (m/^(ENTRYPOINT_ADRR_\S+)\:.*\n/)

      {

         #print "$1\n";

         die "Error line $Line: Entry point not defined $1\n" if  (not defined $EntryPoints{$1});

          $EntryPoints{$1} = sprintf("%06X",$IP | 0x8000);#sprintf("%08X",$Line-1 | 0x8000);

          print "Implemented @ 0x$EntryPoints{$1} --> $1\n";

         next;

      }

       if (m/[\s|\t]*(\S+)\:.*\n/)

       {

          # print "$1 " . sprintf("%08X",$InstructionCount | 0x8000) . "\n";

           $Labels{$1} = ($IP | 0x8000);#(($Line-1) | 0x8000); #sprintf("%08X",$Line-1 | 0x8000)

         #  print "$1 =  $Labels{$1}\n";

           next;

       }

      $IP++;

      $InstructionCount++;

   }

   close CODE;

   $Line = 0;

}

#-------------------------------------------------------------------

sub DecodeInstruction

{

   my ($Line,$EntryAddrCount,$OP,@Tokens) = @_;

   my @D_Tokens;

    if ( defined $Instructions{$OP}) {  $D_OP = hex $Instructions{$OP};

    } else {

       die "Error Line $Line: undefined instruction '$OP'\n";

    }

   foreach $Token (@Tokens)

   {

      next if ($Token eq '');

      if ($Token =~ m/(RT_TRUE|RT_FALSE)/)

      {

         push @D_Tokens,0;

         push @D_Tokens,0;

         push @D_Tokens,$Registers{$Token};

      } elsif ($Token =~ m/SWIZZLE.*/){

          push @D_Tokens,0;

          push @D_Tokens,$Registers{$Token};

      } elsif (defined  $Registers{$Token} ){

         push @D_Tokens,  hex $Registers{$Token};

      } elsif (defined  $Labels{$Token})

      {

        # print "$Labels{$Token}\n";

         push @D_Tokens, ($Labels{$Token}+$EntryAddrCount);

          }elsif (defined  $EntryPoints{$Token}){

             push @D_Tokens,hex $EntryPoints{$Token};

      } elsif ($Token =~ m/32\'h(.*)/) {

         #if this is inmmediate value of 32 bits, then insert 0 and then the value

         push  @D_Tokens,0;

         push  @D_Tokens, hex $1;

      } else {

         die "Error Line $Line: undefined token '$Token'\n"

      }

   }

   return ($D_OP,@D_Tokens);

}

#-------------------------------------------------------------------

sub ParseCode()

{

my $ByteCount = ($InstructionCount+$#EntryKeys+1)*2;

print OUT "$ByteCount //Number of ioctects in file\n";

print OUT "//--------------------------------------\n";

print OUT "//Subroutine Entry Point Table\n";

my $IP = 0;

for my $k ( @EntryKeys )

{

   my $foo =  (oct("0x$EntryPoints{$k}") & 0x8000) ?

   sprintf("%08X", oct("0x$EntryPoints{$k}")+$#EntryKeys+1) :

   sprintf("%08X", oct("0x$EntryPoints{$k}")) ;

    print OUT "00000000 $foo\t//$k\n";

   $IP++;

}

print OUT "//--------------------------------------\n";

open CODE, $CodePath or die "$CodePath: $!\n";

while ()

{

      $Line++;

       #skip comments and empty lines

       next if (m/^([\s|\t]*\/\/)|^(\s*\n).*/);

       #skip labels

       next if (m/(\S+\:).*\n/);

       #get rid of comments in the same line

       s/\/\/.*\n/\n/g;

       my $OpcodeH,$OpcodeL;

       ($OP,$DST,$R1,$R2) = ("","","","");

      #Handle OP DST R1 R2

      if (m/^[\s|\t]*(\S+)\s+(\S+)\s*(\S*)\s*(\S*).*\n/)

      {

         ($OP,$DST,$R1,$R2) = ($1,$2,$3,$4);

         my @D = DecodeInstruction($Line,$#EntryKeys+1,$OP,($DST,$R1,$R2) );

         $OpcodeH = ($D[0] << 16) + $D[1];

         $OpcodeL = ($D[2] << 16) + $D[3];

      } else {

          die "Error: line $Line: incorrect statement '$_'\n";

      }

       printf OUT "%08X",$OpcodeH;

       printf OUT " %08X",$OpcodeL;

      print OUT "\t\t//  ".sprintf("IP %06X",$IP | 0x8000) . " ($IP): $OP $DST $R1 $R2\n"; $IP++;

}

close CLOSE;

}

#-------------------------------------------------------------------