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";

$Line = 0;

%Registers;

%Instructions;

%Labels;

%EntryPoints;

@EntryKeys;

open OUT, ">Instructions.mem" or die "Can't open output file for R/W\n";

PopulateRegistersAndInstructionSet();

GenerateLabels();

ParseCode();

print

"

** Compilation successful! **

The output has been written to 'Code.mem' file.

Please make to copy this file under the same folder

where the simulation executable is, and edit the

'Creg.mem' let the RTL executable know that it

should use the shader.

Have a nice one!

";

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 ">> $EntryPoints{$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 ($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;

}

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