You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
474 lines
13 KiB
474 lines
13 KiB
#!/usr/local/bin/perl -w
|
|
|
|
|
|
##
|
|
## Copyright (c) 2000, Intel Corporation
|
|
## All rights reserved.
|
|
##
|
|
## WARRANTY DISCLAIMER
|
|
##
|
|
## THESE MATERIALS ARE PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
## "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
## LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
## A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL OR ITS
|
|
## CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
## EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
## PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
|
## PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
|
## OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR TORT (INCLUDING
|
|
## NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THESE
|
|
## MATERIALS, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
##
|
|
## Intel Corporation is the author of the Materials, and requests that all
|
|
## problem reports or change requests be submitted to it directly at
|
|
## http://developer.intel.com/opensource.
|
|
##
|
|
|
|
$GenDir = shift(@ARGV);
|
|
$EmdbDir = shift(@ARGV);
|
|
|
|
|
|
### This script reads dec_emdb.tab, which holds for each inst_id its format,
|
|
### major opcode, and template_role. It creates builder_info.c which contains
|
|
### two initialized arrays:
|
|
### - square_formats[] - the list of formats in each square
|
|
### - square_emdb_lines[] - the list of inst_id's in each square
|
|
### - format_emdb_lines[] - the list of inst_id's in each format
|
|
### - format_extension_masks[] - extension mask from each format
|
|
### - LOG2[] - an array which hold the log2 value foreach number
|
|
### between 0 and 2^11-1
|
|
### It also creates builder_info.h which contains the relevant typedefs.
|
|
|
|
open(EMDB, "$GenDir/dec_ign_emdb.tab") || die "Can't open dec_ign_emdb.tab\n";
|
|
open(OUT_C, ">$GenDir/builder_info.c") || die "Can't open builder_info.c\n";
|
|
open(OUT_H, ">$GenDir/builder_info.h") || die "Can't open builder_info.h\n";
|
|
#if ($ENV{HOSTTYPE} eq "WINNT")
|
|
#{
|
|
# open(FORMAT, "$EmdbDir/emdb_formats.txt") ||
|
|
# die "Can't open emdb_formats.txt\n";
|
|
#}
|
|
#else
|
|
|
|
{
|
|
open(FORMAT, "$EmdbDir/emdb_formats.txt") ||
|
|
die "Can't open emdb_formats.txt\n";
|
|
}
|
|
|
|
require "EM_perl.h";
|
|
|
|
$MAX_FORMATS_IN_SQUARE = 1;
|
|
$MAX_EMDB_LINES_IN_SQUARE = 1;
|
|
$MAX_EMDB_LINES_IN_FORMAT = 1;
|
|
|
|
### create all 64 initial squares
|
|
@template_roles = ("INT", "MEM", "FP", "BR", "LONG");
|
|
for ($i = 0; $i < $EM_NUM_OF_MAJOR_OPCODES; $i++)
|
|
{
|
|
for ($j = 0; $j <= $#template_roles; $j++)
|
|
{
|
|
$square = sprintf("0x%x_%s", $i, $template_roles[$j]);
|
|
$square =~ tr/[a-z]/[A-Z]/;
|
|
push (@square_enum, $square);
|
|
}
|
|
}
|
|
|
|
|
|
### major opcodes 0x3 and 0x6 of BRANCH instructions are ignored
|
|
|
|
$emdb_lines_in_square{"0X3_BR"} = 1;
|
|
$square_emdb_lines{"0X3_BR"} = "EM_IGNOP";
|
|
|
|
$emdb_lines_in_square{"0X6_BR"} = 1;
|
|
$square_emdb_lines{"0X6_BR"} = "EM_IGNOP";
|
|
|
|
|
|
### add each emdb line to calculated square and format
|
|
while (<EMDB>)
|
|
{
|
|
if (/^EM/)
|
|
{
|
|
/(EM_\w+),(\w+),(\w+),(\w+),/;
|
|
$inst_id = $1;
|
|
$format = $2;
|
|
$major_opcode = $3;
|
|
$template_role[0] = $4;
|
|
$template_role[1] = "";
|
|
|
|
# if ($template_role[0] eq "LONG")
|
|
# {
|
|
# $template_role[0] = "INT";
|
|
# }
|
|
|
|
|
|
# if ($template_role[0] eq "BR2")
|
|
# {
|
|
# $template_role[0] = "BR";
|
|
# }
|
|
|
|
if ($template_role[0] eq "ALU")
|
|
{
|
|
$template_role[0] = "INT";
|
|
$template_role[1] = "MEM";
|
|
}
|
|
|
|
|
|
# if ($inst_id =~ /EM_MOVL_/) ### movl case
|
|
# {
|
|
# $template_role[0] = "LONG";
|
|
# }
|
|
|
|
$tr_no = 0;
|
|
|
|
while ($template_role[$tr_no])
|
|
{
|
|
$square = $major_opcode . "_" . $template_role[$tr_no];
|
|
$square =~ tr/[a-z]/[A-Z]/;
|
|
|
|
if ($format ne "NONE")
|
|
{
|
|
$index = -1;
|
|
for ($i = 0; $i <= $#square_enum; $i++)
|
|
{
|
|
if ($square eq $square_enum[$i])
|
|
{
|
|
$index = $i;
|
|
}
|
|
}
|
|
if ($index == -1)
|
|
{
|
|
die "$square not known\n";
|
|
}
|
|
|
|
$format = "EM_FORMAT_" . $format;
|
|
if (!defined $square_formats{$square})
|
|
{
|
|
$square_formats{$square} = $format;
|
|
$formats_in_square{$square} = 1;
|
|
}
|
|
else
|
|
{
|
|
if (!defined $format_emdb_lines{$format})
|
|
{
|
|
$formats_in_square{$square} += 1;
|
|
if ($formats_in_square{$square} > $MAX_FORMATS_IN_SQUARE)
|
|
{
|
|
$MAX_FORMATS_IN_SQUARE = $formats_in_square{$square};
|
|
}
|
|
$square_formats{$square} .= "," . $format;
|
|
}
|
|
}
|
|
|
|
if (!defined $format_emdb_lines{$format})
|
|
{
|
|
$emdb_lines_in_format{$format} = 1;
|
|
$format_emdb_lines{$format} = $inst_id;
|
|
}
|
|
else
|
|
{
|
|
$format_emdb_lines{$format} .= "," . $inst_id;
|
|
$emdb_lines_in_format{$format} += 1;
|
|
if ($emdb_lines_in_format{$format} >
|
|
$MAX_EMDB_LINES_IN_FORMAT)
|
|
{
|
|
$MAX_EMDB_LINES_IN_FORMAT =
|
|
$emdb_lines_in_format{$format};
|
|
}
|
|
}
|
|
|
|
if (!defined $square_emdb_lines{$square})
|
|
{
|
|
$emdb_lines_in_square{$square} = 1;
|
|
$square_emdb_lines{$square} = $inst_id;
|
|
}
|
|
else
|
|
{
|
|
$emdb_lines_in_square{$square} += 1;
|
|
if ($emdb_lines_in_square{$square} >
|
|
$MAX_EMDB_LINES_IN_SQUARE)
|
|
{
|
|
$MAX_EMDB_LINES_IN_SQUARE =
|
|
$emdb_lines_in_square{$square};
|
|
}
|
|
$square_emdb_lines{$square} .= "," . $inst_id;
|
|
}
|
|
}
|
|
$tr_no++;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
### check that there are no instructions with ignored major opcodes
|
|
|
|
if ($emdb_lines_in_square{"0X3_BR"} != 1 || $emdb_lines_in_square{"0X6_BR"} != 1)
|
|
{
|
|
print STDERR "ERROR: Exist EM_OPROLE_BR instructions with
|
|
ignored major opcode (0x3 or 0x6) !!!\n";
|
|
}
|
|
|
|
|
|
################################################
|
|
### Calculate extension bit mask for each format
|
|
################################################
|
|
push(@format_enum, "EM_FORMAT_NONE");
|
|
$mask{"EM_FORMAT_NONE"} = "IEL_CONST64(0, 0)";
|
|
$ext{"EM_FORMAT_NONE"} = "{0,0}";
|
|
for ($i=1; $i < $MAX_EXTENSION; $i++)
|
|
{
|
|
$ext{"EM_FORMAT_NONE"} .= ",{0,0}";
|
|
}
|
|
|
|
while(<FORMAT>)
|
|
{
|
|
if (/^(EM_FORMAT_\w+)/)
|
|
{
|
|
@format_line = split(/\s+/, $_);
|
|
$format_name = $1;
|
|
push (@format_enum, $format_name);
|
|
# $mask{$format_name} = 0;
|
|
$mask_low = 0;
|
|
$mask_high = 0;
|
|
$ext{$format_name} = "";
|
|
for ($i = 1; $i <= $MAX_EXTENSION; $i++)
|
|
{
|
|
$format_line[$i] =~ /(\d+).(\d+)/;
|
|
$pos = $1;
|
|
$size = $2;
|
|
$ext{$format_name} .= "\{$pos,$size\}";
|
|
$ext{$format_name} .= "," unless ($i == $MAX_EXTENSION);
|
|
if ($size != 0)
|
|
{
|
|
$pos -= $EM_PREDICATE_BITS; #position relative to the end of qp field
|
|
|
|
if ($pos < 0) #bit mask contribution in bits 0-5
|
|
{
|
|
$mask_low |= ((1 << $size) - 1) << ($pos + $EM_PREDICATE_BITS);
|
|
}
|
|
else #bit mask contribution in bits 6-36
|
|
{
|
|
$mask_high |= ((1 << $size) - 1) << $pos;
|
|
}
|
|
}
|
|
}
|
|
|
|
###combine low and high masks into U64 integer
|
|
$mask_low |= ($mask_high << $EM_PREDICATE_BITS);
|
|
$mask_high >>= (32 - $EM_PREDICATE_BITS);
|
|
$mask{$format_name} = sprintf("IEL_CONST64(0x%x, 0x%x)", $mask_low, $mask_high);
|
|
|
|
}
|
|
}
|
|
|
|
########################
|
|
### Write builder_info.h
|
|
########################
|
|
|
|
select (OUT_H);
|
|
print ("#ifndef _BUILDER_INFO_H\n");
|
|
print ("#define _BUILDER_INFO_H\n\n");
|
|
print ("#include \"emdb_types.h\"\n\n");
|
|
print ("#include \"inst_ids.h\"\n\n");
|
|
print ("#include \"inst_ign_ids.h\"\n\n");
|
|
print ("#include \"iel.h\"\n\n");
|
|
|
|
### print constants
|
|
print ("#define MAX_FORMATS_IN_SQUARE $MAX_FORMATS_IN_SQUARE\n\n");
|
|
if ($MAX_EMDB_LINES_IN_SQUARE > $MAX_EMDB_LINES_IN_FORMAT)
|
|
{
|
|
$MAX_EMDB_LINES = $MAX_EMDB_LINES_IN_SQUARE;
|
|
print ("#define MAX_EMDB_LINES $MAX_EMDB_LINES\n\n");
|
|
}
|
|
else
|
|
{
|
|
$MAX_EMDB_LINES = $MAX_EMDB_LINES_IN_FORMAT;
|
|
print ("#define MAX_EMDB_LINES $MAX_EMDB_LINES\n\n");
|
|
}
|
|
print("#define MAX_NUM_OF_EXT $MAX_EXTENSION\n\n");
|
|
|
|
### print square enumeration
|
|
printf("\n\ntypedef enum {\n");
|
|
printf(" EM_SQUARE_FIRST = 0,\n");
|
|
for ($i = 0; $i <= $#square_enum; $i++)
|
|
{
|
|
if ($i == 0)
|
|
{
|
|
printf(" EM_SQUARE_$square_enum[0] = EM_SQUARE_FIRST,\n");
|
|
}
|
|
else
|
|
{
|
|
printf(" EM_SQUARE_$square_enum[$i],\n");
|
|
}
|
|
}
|
|
printf(" EM_SQUARE_LAST\n");
|
|
print("} Square_t;\n\n");
|
|
|
|
print("typedef struct Ext_s\n");
|
|
print("{\n");
|
|
print(" int pos;\n");
|
|
print(" int size;\n");
|
|
print("} Ext_t;\n\n");
|
|
|
|
print("typedef Ext_t Ex_t[MAX_NUM_OF_EXT];\n\n");
|
|
|
|
#print("typedef struct Format_list_s\n");
|
|
#print("{\n");
|
|
#print(" int num_of_formats;\n");
|
|
#print(" Format_t formats[MAX_FORMATS_IN_SQUARE];\n");
|
|
#print("} Format_list_t;\n\n");
|
|
|
|
print("typedef struct Inst_id_list_s\n");
|
|
print("{\n");
|
|
print(" int num_of_lines;\n");
|
|
print(" Inst_id_t inst_ids[MAX_EMDB_LINES];\n");
|
|
print("} Inst_id_list_t;\n\n");
|
|
|
|
print "extern Ex_t format_extensions\[\];\n";
|
|
#print "extern Format_list_t square_formats\[\];\n";
|
|
print "extern Inst_id_list_t square_emdb_lines\[\];\n";
|
|
#print "extern Inst_id_list_t format_emdb_lines\[\];\n";
|
|
print "extern U64 format_extension_masks[];\n";
|
|
print "extern int LOG2[];\n\n";
|
|
|
|
print("#endif /* _BUILDER_INFO_H */\n");
|
|
|
|
########################
|
|
### Write builder_info.c
|
|
########################
|
|
|
|
select(OUT_C);
|
|
|
|
print ("/***************************************/\n");
|
|
print ("/***** BUILDER INFO *****/\n");
|
|
print ("/***************************************/\n");
|
|
|
|
print ("\n\n#include \"builder_info.h\"\n");
|
|
|
|
### Print info arrays
|
|
|
|
### format_extensions[]
|
|
printf("\n\nEx_t format_extensions[] = {\n");
|
|
for ($i = 0; $i <= $#format_enum; $i++)
|
|
{
|
|
printf ("\/\* $format_enum[$i] \*\/ \{$ext{$format_enum[$i]}\}");
|
|
print "," unless ($i == $#format_enum);
|
|
print "\n";
|
|
}
|
|
print "};\n";
|
|
|
|
### square_formats[]
|
|
#printf("\n\nFormat_list_t square_formats[] = {\n");
|
|
#for ($i = 0; $i <= $#square_enum; $i++)
|
|
#{
|
|
# if (defined $square_formats{$square_enum[$i]})
|
|
# {
|
|
# $formats_line = $square_formats{$square_enum[$i]};
|
|
# for ($j = $formats_in_square{$square_enum[$i]};
|
|
# $j < $MAX_FORMATS_IN_SQUARE; $j++)
|
|
# {
|
|
# $formats_line .= "," . "EM_FORMAT_NONE";
|
|
# }
|
|
# }
|
|
# else
|
|
# {
|
|
# $formats_in_square{$square_enum[$i]} = 0;
|
|
# $formats_line = "EM_FORMAT_NONE";
|
|
# for ($j = 1; $j < $MAX_FORMATS_IN_SQUARE; $j++)
|
|
# {
|
|
# $formats_line .= "," . "EM_FORMAT_NONE";
|
|
# }
|
|
# }
|
|
# print "\/\* $square_enum[$i] \*\/ \{$formats_in_square{$square_enum[$i]}, \{$formats_line\}\}";
|
|
# print "," unless ($i == $#square_enum);
|
|
# print "\n";
|
|
#}
|
|
#print "};\n";
|
|
|
|
### square_emdb_lines[]
|
|
printf("\n\nInst_id_list_t square_emdb_lines[] = {\n");
|
|
for ($i = 0; $i <= $#square_enum; $i++)
|
|
{
|
|
if (defined $square_emdb_lines{$square_enum[$i]})
|
|
{
|
|
$emdb_line = $square_emdb_lines{$square_enum[$i]};
|
|
for ($j = $emdb_lines_in_square{$square_enum[$i]};
|
|
$j < $MAX_EMDB_LINES; $j++)
|
|
{
|
|
$emdb_line .= "," . "EM_INST_NONE";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
$emdb_lines_in_square{$square_enum[$i]} = 0;
|
|
$emdb_line = "EM_INST_NONE";
|
|
for ($j = 1; $j < $MAX_EMDB_LINES; $j++)
|
|
{
|
|
$emdb_line .= "," . "EM_INST_NONE";
|
|
}
|
|
}
|
|
print "\/\* $square_enum[$i] \*\/ \{$emdb_lines_in_square{$square_enum[$i]}, \{$emdb_line\}\}";
|
|
print "," unless ($i == $#square_enum);
|
|
print "\n";
|
|
}
|
|
print "};\n";
|
|
|
|
### format_extension_masks[]
|
|
printf("\n\nU64 format_extension_masks[] = {\n");
|
|
for ($i = 0; $i <= $#format_enum; $i++)
|
|
{
|
|
printf ("\/\* $format_enum[$i] \*\/ $mask{$format_enum[$i]}");
|
|
print "," unless ($i == $#format_enum);
|
|
print "\n";
|
|
}
|
|
print "};\n";
|
|
|
|
### format_emdb_lines[]
|
|
#printf("\n\nInst_id_list_t format_emdb_lines[] = {\n");
|
|
#for ($i = 0; $i <= $#format_enum; $i++)
|
|
#{
|
|
# $emdb_line = $format_emdb_lines{$format_enum[$i]};
|
|
# if (!defined $emdb_lines_in_format{$format_enum[$i]})
|
|
# {
|
|
# $emdb_lines_in_format{$format_enum[$i]} = 0;
|
|
# $emdb_line = "EM_INST_NONE";
|
|
# for ($j = 1; $j < $MAX_EMDB_LINES; $j++)
|
|
# {
|
|
# $emdb_line .= "," . "EM_INST_NONE";
|
|
# }
|
|
# }
|
|
# else
|
|
# {
|
|
# for ($j = $emdb_lines_in_format{$format_enum[$i]};
|
|
# $j < $MAX_EMDB_LINES; $j++)
|
|
# {
|
|
# $emdb_line .= "," . "EM_INST_NONE";
|
|
# }
|
|
# }
|
|
# print "\/\* $format_enum[$i] \*\/ \{$emdb_lines_in_format{$format_enum[$i]}, \{$emdb_line\}\}";
|
|
# print "," unless ($i == $#format_enum);
|
|
# print "\n";
|
|
#}
|
|
#print "};\n";
|
|
|
|
### LOG2[]
|
|
printf("\n\nint LOG2[] = {\n");
|
|
print " -1,\n"; # LOG2[0] == -1
|
|
for ($i = 0; $i <= 10; $i++)
|
|
{
|
|
print " ";
|
|
for ($j = 1; $j <= 2 ** $i; $j++)
|
|
{
|
|
print $i;
|
|
print "," unless ($i == 10 && $j == 2 ** $i);
|
|
}
|
|
print "\n";
|
|
}
|
|
print "};\n";
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|