x86/insns-iflags.ph - chromium/deps/nasm - Git at Google

 #!/usr/bin/perl
 # SPDX-License-Identifier: BSD-2-Clause
 # Copyright 1996-2024 The NASM Authors - All Rights Reserved

 #
 # 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 $n_iflags = 0;
 my %flag_byname;
 my @flag_bynum;
 my @flag_fields;
 my $iflag_words;
 my $no_word_break = 0;
 my $current_group;
 our $NOBREAK = 0;

 # This should be generated automatically, really...
 our $MAX_OPERANDS = 5;

 sub if_($$) {
     my($name, $def) = @_;
     my $num = $n_iflags++;

     $name = uc($name);
     if (defined($flag_byname{$name})) {
 	die "iflags: flag $name defined more than once\n";
     }

     my $v = [$num, $name, $def];

     if (!($n_iflags & 31) && $no_word_break) {
 	die "iflags: group $current_group has disallowed dword break\n";
     }

     $flag_byname{$name}  = $v;
     $flag_bynum[$num] = $v;

     return 1;
 }
 sub if_break_ok(;$) {
     my($ok) = @_;
     $no_word_break = defined($ok) && !$ok;
 }
 sub if_align($;$) {
     my($name, $break_ok) = @_;

     if_break_ok($break_ok);

     if ($#flag_fields >= 0) {
 	$flag_fields[$#flag_fields]->[2] = $n_iflags-1;
     }
     $n_iflags = ($n_iflags + 31) & ~31;

     if (defined($name)) {
 	$current_group = $name;
 	push(@flag_fields, [$name, $n_iflags, undef]);
     }

     return 1;
 }

 sub if_end() {
     if_align(undef);
     $iflag_words = $n_iflags >> 5;
 }

 # The actual flags definitions
 require 'x86/iflags.ph';
 if_end();

 # Remove non-flags
 sub clean_flags($) {
     my($flags) = @_;

     delete $flags->{''};
     delete $flags->{'0'};
     delete $flags->{'IGNORE'};
 }

 # Adjust flags which imply each other
 sub set_implied_flags($;$) {
     my($flags, $oprs) = @_;
     $oprs = $MAX_OPERANDS unless (defined($oprs));

     clean_flags($flags);

     # If no ARx flags, make all operands ARx if a size is present
     # flag is present
     if (!opr_flags($flags, 'AR', $oprs)) {
 	if (defined(size_flag($flags))) {
 	    for (my $i = 0; $i < $oprs; $i++) {
 		$flags->{"AR$i"}++;
 	    }
 	}
     }

     # Convert the SM flag to all possible SMx flags
     if ($flags->{'SM'}) {
 	delete $flags->{'SM'};
 	for (my $i = 0; $i < $oprs; $i++) {
 	    $flags->{"SM$i"}++;
 	}
     }

     # Delete SMx and ARx flags for nonexistent operands
     foreach my $as ('AR', 'SM') {
 	for (my $i = $oprs; $i < $MAX_OPERANDS; $i++) {
 	    delete $flags->{"$as$i"};
 	}
     }

     $flags->{'LONG'}++     if ($flags->{'APX'});
     $flags->{'NOREX'}++    if ($flags->{'NOLONG'});
     $flags->{'NOAPX'}++    if ($flags->{'NOREX'});
     $flags->{'X86_64'}++   if ($flags->{'LONG'});
     $flags->{'PROT'}++     if ($flags->{'LONG'}); # LONG mode is a submode of PROT
     $flags->{'PROT'}++     if ($flags->{'EVEX'}); # EVEX not supported in real/v86 mode
     $flags->{'OBSOLETE'}++ if ($flags->{'NEVER'});
     $flags->{'NF'}++ if ($flags->{'NF_R'} || $flags->{'NF_E'});
     $flags->{'ZU'}++ if ($flags->{'ZU_R'} || $flags->{'ZU_E'});

     # Retain only the highest CPU level flag
     # CPU levels really need to be replaced with feature sets.
     my $found = $flags->{'PSEUDO'}; # Pseudo-ops don't have a CPU level
     for (my $i = $flag_byname{'ANY'}->[0]; $i >= $flag_byname{'8086'}->[0]; $i--) {
 	my $f = $flag_bynum[$i]->[1];
 	if ($found) {
 	    delete $flags->{$f};
 	} else {
 	    $found = $flags->{$f};
 	}
     }
     if (!$found) {
 	# No CPU level flag at all; tag it FUTURE
 	$flags->{'FUTURE'}++;
     }
 }

 # Return the value of any assume-size flag if one exists;
 # SX, ANYSIZE or SIZE return 0 as they are size flags but
 # don't have a known value at compile time.
 sub size_flag($) {
     my %sflags = ( 'SB' => 8, 'SW' => 16, 'SD' => 32, 'SQ' => 64,
 		   'ST' => 80, 'SO' => 128, 'SY' => 256, 'SZ' => 512,
 		   'SX' => 0, 'OSIZE' => 0, 'ASIZE' => 0, 'ANYSIZE' => 0 );
     my($flags) = @_;

     foreach my $fl (keys(%sflags)) {
 	if ($flags->{$fl}) {
 	    return $sflags{$fl};
 	}
     }

     return undef;
 }

 # Find any per-operand flags
 sub opr_flags($$;$) {
     my($flags, $name, $oprs) = @_;
     $oprs = $MAX_OPERANDS unless (defined($oprs));
     my $nfl = 0;
     for (my $i = 0; $i < $oprs; $i++) {
 	if ($flags->{"$name$i"}) {
 	    $nfl |= 1 << $i;
 	}
     }
     return $nfl;
 }

 # Split a flags field, returns a hash
 sub split_flags($) {
     my($flagstr) = @_;
     my %flags = ();

     $flagstr = uc($flagstr);

     foreach my $flag (split(',', $flagstr)) {
 	next if ($flag =~ /^\s*$/); # Null flag

 	# Somewhat nicer syntax for required flags (NF! -> NF_R)
 	$flag =~ s/\!$/_R/;
 	# Ditto for weak flags (SX- -> SX_W)
 	$flag =~ s/\-$/_W/;

 	if ($flag =~ /^(.*)(([0-9]+[+-])+[0-9]+)$/) {
 	    my $pref = $1;
 	    my @rang = split(/([-+])/, "+$2");
 	    shift(@rang);	# Drop empty entry at beginning
 	    my $eor;
 	    while (defined(my $sep = shift(@rang))) {
 		my $nxt = shift(@rang) + 0;

 		$eor = $nxt if ($sep eq '+');
 		for (my $i = $eor; $i <= $nxt; $i++) {
 		    $flags{"$pref$i"}++;
 		}
 		$eor = $nxt;
 	    }
 	} else {
 	    $flags{$flag}++;
 	}
     }

     clean_flags(\%flags);
     return %flags;
 }

 # Merge a flags field and strip flags with leading !
 sub merge_flags($;$) {
     my($flags, $human) = @_;

     clean_flags(\%flags);

     my @flagslist = sort { $flag_byname{$a} <=> $flag_byname{$b} }
 	grep { !/^(\s*|\!.*)$/ } keys(%$flags);

     if ($human) {
 	# For possibe human consumption. Merge subsequent SM and AR
 	# flags back into ranges.
 	my @ofl = @flagslist;
 	@flagslist = ();

 	while (defined(my $fl = shift(@ofl))) {
 	    if ($fl =~ /^(SM|AR)([0-9]+)$/) {
 		my $pfx = $1;
 		my $mask = 1 << $2;

 		while ($ofl[0] =~ /^${pfx}([0-9]+)$/) {
 		    $mask |= 1 << $1;
 		    shift(@ofl);
 		}

 		my $n = 0;
 		my $nstr;
 		while ($mask) {
 		    if ($mask & 1) {
 			$nstr .= '+'.$n;
 			if ($mask & 2) {
 			    $nstr .= '-';
 			    while ($mask & 2) {
 				$n++;
 				$mask >>= 1;
 			    }
 			    $nstr .= $n;
 			}
 		    }
 		    $n++;
 		    $mask >>= 1;
 		}

 		$nstr =~ s/^\+/$pfx/;
 		push(@flagslist, $nstr);
 	    } else {
 		push(@flagslist, $fl);
 	    }
 	}
     }

     return scalar(@flagslist) ? join(',', @flagslist) : $human ? 'ignore' : '0';
 }

 # Compute the combinations of instruction flags actually used in templates

 my %insns_flag_hash = ();
 my @insns_flag_values = ();
 my @insns_flag_lists = ();

 sub insns_flag_index($) {
     my($flags) = @_;

     my $key = merge_flags($flags);
     my @prekey = sort(keys %$flags);

     my $flag_index = $insns_flag_hash{$key};

     unless (defined($flag_index)) {
         my @newkey = (0) x $iflag_words;

         foreach my $i (@prekey) {
 	    my $flag = $flag_byname{$i};
             die "No key for $i (in $key)\n" if not defined($flag);
 	    $newkey[$flag->[0] >> 5] |= (1 << ($flag->[0] & 31));
         }

 	my $str = join(',', map { sprintf("UINT32_C(0x%08x)",$_) } @newkey);

         push @insns_flag_values, $str;
 	push @insns_flag_lists, $key;
         $insns_flag_hash{$key} = $flag_index = $#insns_flag_values;
     }

     return $flag_index;
 }

 #
 # Show the iflags corresponding to a specific iflags set extracted from
 # a code sequence in human-readable form.
 #
 sub get_iflags($) {
     my($n) = @_;
     return $insns_flag_lists[$n];
 }

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

     # The flag numbers; the <= in the loop is intentional

     my $next = 0;
     for ($i = 0; $i <= $n_iflags; $i++) {
 	if ((defined($flag_bynum[$i]) || $i >= $n_iflags) &&
 	    $next != $i) {
 	    printf N "%-31s /* %-64s */\n", '',
 		($next < $i-1) ?
 		sprintf("%d...%d reserved", $next-1, $i-1) :
 		sprintf("%d reserved", $i-1);
 	}

 	if (defined($flag_bynum[$i])) {
 	    printf N "#define IF_%-16s %3d /* %-64s */\n",
 		$flag_bynum[$i]->[1], $i, $flag_bynum[$i]->[2];
 	    $next = $i+1;
 	}
     }
     print N "\n";

     # The flag masks for individual bits

     $next = 0;
     for ($i = 0; $i < $n_iflags; $i++) {
 	if (($i & 31) == 0) {
 	    printf N "/* Mask bits for field %d : %d...%d */\n",
 		$i >> 5, $i, $i+31;
 	}
 	if (defined(my $v = $flag_bynum[$i])) {
 	    printf N "#define IFM_%-15s UINT32_C(0x%08x)     /* %3d */\n",
 		$v->[1], 1 << ($i & 31), $i;
 	    $next = $i+1;
 	}
     }
     print N "\n";

     # The names of flag groups

     for ($i = 0; $i <= $#flag_fields; $i++) {
 	printf N "/* IF_%s (%d) ... IF_%s (%d) */\n",
 		    $flag_bynum[$flag_fields[$i]->[1]]->[1],
 		    $flag_bynum[$flag_fields[$i]->[1]]->[0],
 		    $flag_bynum[$flag_fields[$i]->[2]]->[1],
 		    $flag_bynum[$flag_fields[$i]->[2]]->[0];

 	# Bit definitions
 	printf N "#define %-19s %3d\n",
 	    'IF_'.$flag_fields[$i]->[0].'_FIRST',
 	    $flag_fields[$i]->[1];
 	printf N "#define %-19s %3d\n",
 	    'IF_'.$flag_fields[$i]->[0].'_COUNT',
 	    ($flag_fields[$i]->[2] - $flag_fields[$i]->[1] + 1);

 	# Field (uint32) definitions
 	printf N "#define %-19s %3d\n",
 	    'IF_'.$flag_fields[$i]->[0].'_FIELD',
 	    $flag_fields[$i]->[1] >> 5;
 	printf N "#define %-19s %3d\n",
 	    'IF_'.$flag_fields[$i]->[0].'_NFIELDS',
 	    ($flag_fields[$i]->[2] - $flag_fields[$i]->[1] + 31) >> 5;
 	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";
     print N "/* All combinations of instruction flags used in instruction patterns */\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 "/* All combinations of instruction flags used in instruction patterns */\n";
     printf N "const iflag_t insns_flags[%d] = {\n",
         $#insns_flag_values + 1;
     foreach my $i (0 .. $#insns_flag_values) {
         printf N "    {{%s}}, /* %3d : %s */\n",
 	    $insns_flag_values[$i], $i, $insns_flag_lists[$i];
     }
     print N "};\n";
     close N;
 }

 1;
	#!/usr/bin/perl
	# SPDX-License-Identifier: BSD-2-Clause
	# Copyright 1996-2024 The NASM Authors - All Rights Reserved

	#
	# 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 $n_iflags = 0;
	my %flag_byname;
	my @flag_bynum;
	my @flag_fields;
	my $iflag_words;
	my $no_word_break = 0;
	my $current_group;
	our $NOBREAK = 0;

	# This should be generated automatically, really...
	our $MAX_OPERANDS = 5;

	sub if_($$) {
	my($name, $def) = @_;
	my $num = $n_iflags++;

	$name = uc($name);
	if (defined($flag_byname{$name})) {
	die "iflags: flag $name defined more than once\n";
	}

	my $v = [$num, $name, $def];

	if (!($n_iflags & 31) && $no_word_break) {
	die "iflags: group $current_group has disallowed dword break\n";
	}

	$flag_byname{$name} = $v;
	$flag_bynum[$num] = $v;

	return 1;
	}
	sub if_break_ok(;$) {
	my($ok) = @_;
	$no_word_break = defined($ok) && !$ok;
	}
	sub if_align($;$) {
	my($name, $break_ok) = @_;

	if_break_ok($break_ok);

	if ($#flag_fields >= 0) {
	$flag_fields[$#flag_fields]->[2] = $n_iflags-1;
	}
	$n_iflags = ($n_iflags + 31) & ~31;

	if (defined($name)) {
	$current_group = $name;
	push(@flag_fields, [$name, $n_iflags, undef]);
	}

	return 1;
	}

	sub if_end() {
	if_align(undef);
	$iflag_words = $n_iflags >> 5;
	}

	# The actual flags definitions
	require 'x86/iflags.ph';
	if_end();

	# Remove non-flags
	sub clean_flags($) {
	my($flags) = @_;

	delete $flags->{''};
	delete $flags->{'0'};
	delete $flags->{'IGNORE'};
	}

	# Adjust flags which imply each other
	sub set_implied_flags($;$) {
	my($flags, $oprs) = @_;
	$oprs = $MAX_OPERANDS unless (defined($oprs));

	clean_flags($flags);

	# If no ARx flags, make all operands ARx if a size is present
	# flag is present
	if (!opr_flags($flags, 'AR', $oprs)) {
	if (defined(size_flag($flags))) {
	for (my $i = 0; $i < $oprs; $i++) {
	$flags->{"AR$i"}++;
	}
	}
	}

	# Convert the SM flag to all possible SMx flags
	if ($flags->{'SM'}) {
	delete $flags->{'SM'};
	for (my $i = 0; $i < $oprs; $i++) {
	$flags->{"SM$i"}++;
	}
	}

	# Delete SMx and ARx flags for nonexistent operands
	foreach my $as ('AR', 'SM') {
	for (my $i = $oprs; $i < $MAX_OPERANDS; $i++) {
	delete $flags->{"$as$i"};
	}
	}

	$flags->{'LONG'}++ if ($flags->{'APX'});
	$flags->{'NOREX'}++ if ($flags->{'NOLONG'});
	$flags->{'NOAPX'}++ if ($flags->{'NOREX'});
	$flags->{'X86_64'}++ if ($flags->{'LONG'});
	$flags->{'PROT'}++ if ($flags->{'LONG'}); # LONG mode is a submode of PROT
	$flags->{'PROT'}++ if ($flags->{'EVEX'}); # EVEX not supported in real/v86 mode
	$flags->{'OBSOLETE'}++ if ($flags->{'NEVER'});
	$flags->{'NF'}++ if ($flags->{'NF_R'} \|\| $flags->{'NF_E'});
	$flags->{'ZU'}++ if ($flags->{'ZU_R'} \|\| $flags->{'ZU_E'});

	# Retain only the highest CPU level flag
	# CPU levels really need to be replaced with feature sets.
	my $found = $flags->{'PSEUDO'}; # Pseudo-ops don't have a CPU level
	for (my $i = $flag_byname{'ANY'}->[0]; $i >= $flag_byname{'8086'}->[0]; $i--) {
	my $f = $flag_bynum[$i]->[1];
	if ($found) {
	delete $flags->{$f};
	} else {
	$found = $flags->{$f};
	}
	}
	if (!$found) {
	# No CPU level flag at all; tag it FUTURE
	$flags->{'FUTURE'}++;
	}
	}

	# Return the value of any assume-size flag if one exists;
	# SX, ANYSIZE or SIZE return 0 as they are size flags but
	# don't have a known value at compile time.
	sub size_flag($) {
	my %sflags = ( 'SB' => 8, 'SW' => 16, 'SD' => 32, 'SQ' => 64,
	'ST' => 80, 'SO' => 128, 'SY' => 256, 'SZ' => 512,
	'SX' => 0, 'OSIZE' => 0, 'ASIZE' => 0, 'ANYSIZE' => 0 );
	my($flags) = @_;

	foreach my $fl (keys(%sflags)) {
	if ($flags->{$fl}) {
	return $sflags{$fl};
	}
	}

	return undef;
	}

	# Find any per-operand flags
	sub opr_flags($$;$) {
	my($flags, $name, $oprs) = @_;
	$oprs = $MAX_OPERANDS unless (defined($oprs));
	my $nfl = 0;
	for (my $i = 0; $i < $oprs; $i++) {
	if ($flags->{"$name$i"}) {
	$nfl \|= 1 << $i;
	}
	}
	return $nfl;
	}

	# Split a flags field, returns a hash
	sub split_flags($) {
	my($flagstr) = @_;
	my %flags = ();

	$flagstr = uc($flagstr);

	foreach my $flag (split(',', $flagstr)) {
	next if ($flag =~ /^\s*$/); # Null flag

	# Somewhat nicer syntax for required flags (NF! -> NF_R)
	$flag =~ s/\!$/_R/;
	# Ditto for weak flags (SX- -> SX_W)
	$flag =~ s/\-$/_W/;

	if ($flag =~ /^(.*)(([0-9]+[+-])+[0-9]+)$/) {
	my $pref = $1;
	my @rang = split(/([-+])/, "+$2");
	shift(@rang); # Drop empty entry at beginning
	my $eor;
	while (defined(my $sep = shift(@rang))) {
	my $nxt = shift(@rang) + 0;

	$eor = $nxt if ($sep eq '+');
	for (my $i = $eor; $i <= $nxt; $i++) {
	$flags{"$pref$i"}++;
	}
	$eor = $nxt;
	}
	} else {
	$flags{$flag}++;
	}
	}

	clean_flags(\%flags);
	return %flags;
	}

	# Merge a flags field and strip flags with leading !
	sub merge_flags($;$) {
	my($flags, $human) = @_;

	clean_flags(\%flags);

	my @flagslist = sort { $flag_byname{$a} <=> $flag_byname{$b} }
	grep { !/^(\s\|\!.)$/ } keys(%$flags);

	if ($human) {
	# For possibe human consumption. Merge subsequent SM and AR
	# flags back into ranges.
	my @ofl = @flagslist;
	@flagslist = ();

	while (defined(my $fl = shift(@ofl))) {
	if ($fl =~ /^(SM\|AR)([0-9]+)$/) {
	my $pfx = $1;
	my $mask = 1 << $2;

	while ($ofl[0] =~ /^${pfx}([0-9]+)$/) {
	$mask \|= 1 << $1;
	shift(@ofl);
	}

	my $n = 0;
	my $nstr;
	while ($mask) {
	if ($mask & 1) {
	$nstr .= '+'.$n;
	if ($mask & 2) {
	$nstr .= '-';
	while ($mask & 2) {
	$n++;
	$mask >>= 1;
	}
	$nstr .= $n;
	}
	}
	$n++;
	$mask >>= 1;
	}

	$nstr =~ s/^\+/$pfx/;
	push(@flagslist, $nstr);
	} else {
	push(@flagslist, $fl);
	}
	}
	}

	return scalar(@flagslist) ? join(',', @flagslist) : $human ? 'ignore' : '0';
	}

	# Compute the combinations of instruction flags actually used in templates

	my %insns_flag_hash = ();
	my @insns_flag_values = ();
	my @insns_flag_lists = ();

	sub insns_flag_index($) {
	my($flags) = @_;

	my $key = merge_flags($flags);
	my @prekey = sort(keys %$flags);

	my $flag_index = $insns_flag_hash{$key};

	unless (defined($flag_index)) {
	my @newkey = (0) x $iflag_words;

	foreach my $i (@prekey) {
	my $flag = $flag_byname{$i};
	die "No key for $i (in $key)\n" if not defined($flag);
	$newkey[$flag->[0] >> 5] \|= (1 << ($flag->[0] & 31));
	}

	my $str = join(',', map { sprintf("UINT32_C(0x%08x)",$_) } @newkey);

	push @insns_flag_values, $str;
	push @insns_flag_lists, $key;
	$insns_flag_hash{$key} = $flag_index = $#insns_flag_values;
	}

	return $flag_index;
	}

	#
	# Show the iflags corresponding to a specific iflags set extracted from
	# a code sequence in human-readable form.
	#
	sub get_iflags($) {
	my($n) = @_;
	return $insns_flag_lists[$n];
	}

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

	# The flag numbers; the <= in the loop is intentional

	my $next = 0;
	for ($i = 0; $i <= $n_iflags; $i++) {
	if ((defined($flag_bynum[$i]) \|\| $i >= $n_iflags) &&
	$next != $i) {
	printf N "%-31s /* %-64s */\n", '',
	($next < $i-1) ?
	sprintf("%d...%d reserved", $next-1, $i-1) :
	sprintf("%d reserved", $i-1);
	}

	if (defined($flag_bynum[$i])) {
	printf N "#define IF_%-16s %3d /* %-64s */\n",
	$flag_bynum[$i]->[1], $i, $flag_bynum[$i]->[2];
	$next = $i+1;
	}
	}
	print N "\n";

	# The flag masks for individual bits

	$next = 0;
	for ($i = 0; $i < $n_iflags; $i++) {
	if (($i & 31) == 0) {
	printf N "/* Mask bits for field %d : %d...%d */\n",
	$i >> 5, $i, $i+31;
	}
	if (defined(my $v = $flag_bynum[$i])) {
	printf N "#define IFM_%-15s UINT32_C(0x%08x) /* %3d */\n",
	$v->[1], 1 << ($i & 31), $i;
	$next = $i+1;
	}
	}
	print N "\n";

	# The names of flag groups

	for ($i = 0; $i <= $#flag_fields; $i++) {
	printf N "/* IF_%s (%d) ... IF_%s (%d) */\n",
	$flag_bynum[$flag_fields[$i]->[1]]->[1],
	$flag_bynum[$flag_fields[$i]->[1]]->[0],
	$flag_bynum[$flag_fields[$i]->[2]]->[1],
	$flag_bynum[$flag_fields[$i]->[2]]->[0];

	# Bit definitions
	printf N "#define %-19s %3d\n",
	'IF_'.$flag_fields[$i]->[0].'_FIRST',
	$flag_fields[$i]->[1];
	printf N "#define %-19s %3d\n",
	'IF_'.$flag_fields[$i]->[0].'_COUNT',
	($flag_fields[$i]->[2] - $flag_fields[$i]->[1] + 1);

	# Field (uint32) definitions
	printf N "#define %-19s %3d\n",
	'IF_'.$flag_fields[$i]->[0].'_FIELD',
	$flag_fields[$i]->[1] >> 5;
	printf N "#define %-19s %3d\n",
	'IF_'.$flag_fields[$i]->[0].'_NFIELDS',
	($flag_fields[$i]->[2] - $flag_fields[$i]->[1] + 31) >> 5;
	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";
	print N "/* All combinations of instruction flags used in instruction patterns */\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 "/* All combinations of instruction flags used in instruction patterns */\n";
	printf N "const iflag_t insns_flags[%d] = {\n",
	$#insns_flag_values + 1;
	foreach my $i (0 .. $#insns_flag_values) {
	printf N " {{%s}}, /* %3d : %s */\n",
	$insns_flag_values[$i], $i, $insns_flag_lists[$i];
	}
	print N "};\n";
	close N;
	}

	1;