#!/usr/bin/perl
## --------------------------------------------------------------------------
##
## Copyright 1996-2018 The NASM Authors - All Rights Reserved
## See the file AUTHORS included with the NASM distribution for
## the specific copyright holders.
##
## Redistribution and use in source and binary forms, with or without
## modification, are permitted provided that the following
## conditions are met:
##
## * Redistributions of source code must retain the above copyright
## notice, this list of conditions and the following disclaimer.
## * Redistributions in binary form must reproduce the above
## copyright notice, this list of conditions and the following
## disclaimer in the documentation and/or other materials provided
## with the distribution.
##
## THIS SOFTWARE IS 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 THE COPYRIGHT OWNER OR
## 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 THIS SOFTWARE,
## EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
##
## --------------------------------------------------------------------------
#
# Instruction template flags. These specify which processor
# targets the instruction is eligible for, whether it is
# privileged or undocumented, and also specify extra error
# checking on the matching of the instruction.
#
# IF_SM stands for Size Match: any operand whose size is not
# explicitly specified by the template is `really' intended to be
# the same size as the first size-specified operand.
# Non-specification is tolerated in the input instruction, but
# _wrong_ specification is not.
#
# IF_SM2 invokes Size Match on only the first _two_ operands, for
# three-operand instructions such as SHLD: it implies that the
# first two operands must match in size, but that the third is
# required to be _unspecified_.
#
# IF_SB invokes Size Byte: operands with unspecified size in the
# template are really bytes, and so no non-byte specification in
# the input instruction will be tolerated. IF_SW similarly invokes
# Size Word, and IF_SD invokes Size Doubleword.
#
# (The default state if neither IF_SM nor IF_SM2 is specified is
# that any operand with unspecified size in the template is
# required to have unspecified size in the instruction too...)
#
# iflag_t is defined to store these flags.
#
# The order does matter here. We use some predefined masks to quick test
# for a set of flags, so be careful moving bits (and
# don't forget to update C code generation then).
#
sub dword_align($) {
my($n) = @_;
$$n = ($$n + 31) & ~31;
return $n;
}
my $f = 0;
my %insns_flag_bit = (
#
# dword bound, index 0 - specific flags
#
"SM" => [$f++, "Size match"],
"SM2" => [$f++, "Size match first two operands"],
"SB" => [$f++, "Unsized operands can't be non-byte"],
"SW" => [$f++, "Unsized operands can't be non-word"],
"SD" => [$f++, "Unsized operands can't be non-dword"],
"SQ" => [$f++, "Unsized operands can't be non-qword"],
"SO" => [$f++, "Unsized operands can't be non-oword"],
"SY" => [$f++, "Unsized operands can't be non-yword"],
"SZ" => [$f++, "Unsized operands can't be non-zword"],
"SIZE" => [$f++, "Unsized operands must match the bitsize"],
"SX" => [$f++, "Unsized operands not allowed"],
"AR0" => [$f++, "SB, SW, SD applies to argument 0"],
"AR1" => [$f++, "SB, SW, SD applies to argument 1"],
"AR2" => [$f++, "SB, SW, SD applies to argument 2"],
"AR3" => [$f++, "SB, SW, SD applies to argument 3"],
"AR4" => [$f++, "SB, SW, SD applies to argument 4"],
"OPT" => [$f++, "Optimizing assembly only"],
#
# dword bound - instruction filtering flags
#
"PRIV" => [${dword_align(\$f)}++, "Privileged instruction"],
"SMM" => [$f++, "Only valid in SMM"],
"PROT" => [$f++, "Protected mode only"],
"LOCK" => [$f++, "Lockable if operand 0 is memory"],
"NOLONG" => [$f++, "Not available in long mode"],
"LONG" => [$f++, "Long mode"],
"NOHLE" => [$f++, "HLE prefixes forbidden"],
"MIB" => [$f++, "disassemble with split EA"],
"BND" => [$f++, "BND (0xF2) prefix available"],
"UNDOC" => [$f++, "Undocumented"],
"HLE" => [$f++, "HLE prefixed"],
"FPU" => [$f++, "FPU"],
"MMX" => [$f++, "MMX"],
"3DNOW" => [$f++, "3DNow!"],
"SSE" => [$f++, "SSE (KNI, MMX2)"],
"SSE2" => [$f++, "SSE2"],
"SSE3" => [$f++, "SSE3 (PNI)"],
"VMX" => [$f++, "VMX"],
"SSSE3" => [$f++, "SSSE3"],
"SSE4A" => [$f++, "AMD SSE4a"],
"SSE41" => [$f++, "SSE4.1"],
"SSE42" => [$f++, "SSE4.2"],
"SSE5" => [$f++, "SSE5"],
"AVX" => [$f++, "AVX (256-bit floating point)"],
"AVX2" => [$f++, "AVX2 (256-bit integer)"],
"FMA" => [$f++, ""],
"BMI1" => [$f++, ""],
"BMI2" => [$f++, ""],
"TBM" => [$f++, ""],
"RTM" => [$f++, ""],
"INVPCID" => [$f++, ""],
"AVX512" => [$f++, "AVX-512F (512-bit base architecture)"],
"AVX512CD" => [$f++, "AVX-512 Conflict Detection"],
"AVX512ER" => [$f++, "AVX-512 Exponential and Reciprocal"],
"AVX512PF" => [$f++, "AVX-512 Prefetch"],
"MPX" => [$f++, "MPX"],
"SHA" => [$f++, "SHA"],
"PREFETCHWT1" => [$f++, "PREFETCHWT1"],
"AVX512VL" => [$f++, "AVX-512 Vector Length Orthogonality"],
"AVX512DQ" => [$f++, "AVX-512 Dword and Qword"],
"AVX512BW" => [$f++, "AVX-512 Byte and Word"],
"AVX512IFMA" => [$f++, "AVX-512 IFMA instructions"],
"AVX512VBMI" => [$f++, "AVX-512 VBMI instructions"],
"AES" => [$f++, "AES instructions"],
"VAES" => [$f++, "AES AVX instructions"],
"VPCLMULQDQ" => [$f++, "AVX Carryless Multiplication"],
"GFNI" => [$f++, "Galois Field instructions"],
"AVX512VBMI2" => [$f++, "AVX-512 VBMI2 instructions"],
"AVX512VNNI" => [$f++, "AVX-512 VNNI instructions"],
"AVX512BITALG" => [$f++, "AVX-512 Bit Algorithm instructions"],
"AVX512VPOPCNTDQ" => [$f++, "AVX-512 VPOPCNTD/VPOPCNTQ"],
"AVX5124FMAPS" => [$f++, "AVX-512 4-iteration multiply-add"],
"AVX5124VNNIW" => [$f++, "AVX-512 4-iteration dot product"],
"SGX" => [$f++, "Intel Software Guard Extensions (SGX)"],
# Put these last
"OBSOLETE" => [$f++, "Instruction removed from architecture"],
"VEX" => [$f++, "VEX or XOP encoded instruction"],
"EVEX" => [$f++, "EVEX encoded instruction"],
#
# dword bound - cpu type flags
#
# The CYRIX and AMD flags should have the highest bit values; the
# disassembler selection algorithm depends on it.
#
"8086" => [${dword_align(\$f)}++, "8086"],
"186" => [$f++, "186+"],
"286" => [$f++, "286+"],
"386" => [$f++, "386+"],
"486" => [$f++, "486+"],
"PENT" => [$f++, "Pentium"],
"P6" => [$f++, "P6"],
"KATMAI" => [$f++, "Katmai"],
"WILLAMETTE" => [$f++, "Willamette"],
"PRESCOTT" => [$f++, "Prescott"],
"X86_64" => [$f++, "x86-64 (long or legacy mode)"],
"NEHALEM" => [$f++, "Nehalem"],
"WESTMERE" => [$f++, "Westmere"],
"SANDYBRIDGE" => [$f++, "Sandy Bridge"],
"FUTURE" => [$f++, "Future processor (not yet disclosed)"],
"IA64" => [$f++, "IA64 (in x86 mode)"],
# Put these last
"CYRIX" => [$f++, "Cyrix-specific"],
"AMD" => [$f++, "AMD-specific"],
);
my %insns_flag_hash = ();
my @insns_flag_values = ();
my $iflag_words;
sub get_flag_words() {
my $max = -1;
foreach my $vp (values(%insns_flag_bit)) {
if ($vp->[0] > $max) {
$max = $vp->[0];
}
}
return int($max/32)+1;
}
sub insns_flag_index(@) {
return undef if $_[0] eq "ignore";
my @prekey = sort(@_);
my $key = join("", @prekey);
if (not defined($insns_flag_hash{$key})) {
my @newkey = (0) x $iflag_words;
for my $i (@prekey) {
die "No key for $i\n" if not defined($insns_flag_bit{$i});
$newkey[$insns_flag_bit{$i}[0]/32] |=
(1 << ($insns_flag_bit{$i}[0] % 32));
}
my $str = join(',', map { sprintf("UINT32_C(0x%08x)",$_) } @newkey);
push @insns_flag_values, $str;
$insns_flag_hash{$key} = $#insns_flag_values;
}
return $insns_flag_hash{$key};
}
sub write_iflaggen_h() {
print STDERR "Writing $oname...\n";
open(N, '>', $oname) or die "$0: $!\n";
print N "/* This file is auto-generated. Don't edit. */\n";
print N "#ifndef NASM_IFLAGGEN_H\n";
print N "#define NASM_IFLAGGEN_H 1\n\n";
my @flagnames = keys(%insns_flag_bit);
@flagnames = sort {
$insns_flag_bit{$a}->[0] <=> $insns_flag_bit{$b}->[0]
} @flagnames;
my $next = 0;
foreach my $key (@flagnames) {
my $v = $insns_flag_bit{$key};
if ($v->[0] > $next) {
printf N "%-31s /* %-64s */\n", '',
($next != $v->[0]-1) ?
sprintf("%d...%d unused", $next, $v->[0]-1) :
sprintf("%d unused", $next);
}
print N sprintf("#define IF_%-16s %3d /* %-64s */\n",
$key, $v->[0], $v->[1]);
$next = $v->[0] + 1;
}
print N "\n";
printf N "#define IF_FIELD_COUNT %d\n", $iflag_words;
print N "typedef struct {\n";
print N " uint32_t field[IF_FIELD_COUNT];\n";
print N "} iflag_t;\n";
print N "\n";
printf N "extern const iflag_t insns_flags[%d];\n\n",
$#insns_flag_values + 1;
print N "#endif /* NASM_IFLAGGEN_H */\n";
close N;
}
sub write_iflag_c() {
print STDERR "Writing $oname...\n";
open(N, '>', $oname) or die "$0: $!\n";
print N "/* This file is auto-generated. Don't edit. */\n";
print N "#include \"iflag.h\"\n\n";
print N "/* Global flags referenced from instruction templates */\n";
printf N "const iflag_t insns_flags[%d] = {\n",
$#insns_flag_values + 1;
foreach my $i (0 .. $#insns_flag_values) {
print N sprintf(" /* %4d */ {{ %s }},\n", $i, $insns_flag_values[$i]);
}
print N "};\n\n";
close N;
}
$iflag_words = get_flag_words();
1;