gas/

2007-09-08  H.J. Lu  <hongjiu.lu@intel.com>

	* configure.in (AC_CHECK_HEADERS): Add limits.h.
	* configure: Regenerated.
	* config.in: Likewise.

	* config/tc-i386.c: Include "opcodes/i386-init.h".
	(_i386_insn): Use i386_operand_type for types.
	(cpu_arch_flags): Updated to new types with bitfield.
	(cpu_arch_tune_flags): Likewise.
	(cpu_arch_isa_flags): Likewise.
	(cpu_arch): Likewise.
	(i386_align_code): Likewise.
	(set_code_flag): Likewise.
	(set_16bit_gcc_code_flag): Likewise.
	(set_cpu_arch): Likewise.
	(md_assemble): Likewise.
	(parse_insn): Likewise.
	(process_operands): Likewise.
	(output_branch): Likewise.
	(output_jump): Likewise.
	(parse_real_register): Likewise.
	(mode_from_disp_size): Likewise.
	(smallest_imm_type): Likewise.
	(pi): Likewise.
	(type_names): Likewise.
	(pt): Likewise.
	(pte): Likewise.
	(swap_2_operands): Likewise.
	(optimize_imm): Likewise.
	(optimize_disp): Likewise.
	(match_template): Likewise.
	(check_string): Likewise.
	(process_suffix): Likewise.
	(check_byte_reg): Likewise.
	(check_long_reg): Likewise.
	(check_qword_reg): Likewise.
	(check_word_reg): Likewise.
	(finalize_imm): Likewise.
	(build_modrm_byte): Likewise.
	(output_insn): Likewise.
	(disp_size): Likewise.
	(imm_size): Likewise.
	(output_disp): Likewise.
	(output_imm): Likewise.
	(gotrel): Likewise.
	(i386_immediate): Likewise.
	(i386_displacement): Likewise.
	(i386_index_check): Likewise.
	(i386_operand): Likewise.
	(parse_real_register): Likewise.
	(i386_intel_operand): Likewise.
	(intel_e09): Likewise.
	(intel_bracket_expr): Likewise.
	(intel_e11): Likewise.
	(cpu_arch_flags_not): New.
	(cpu_flags_check_x64): Likewise.
	(cpu_flags_all_zero): Likewise.
	(cpu_flags_not): Likewise.
	(i386_cpu_flags_biop): Likewise.
	(cpu_flags_biop): Likewise.
	(cpu_flags_match); Likewise.
	(acc32): New.
	(acc64): Likewise.
	(control): Likewise.
	(reg16_inoutportreg): Likewise.
	(disp16): Likewise.
	(disp32): Likewise.
	(disp32s): Likewise.
	(disp16_32): Likewise.
	(anydisp): Likewise.
	(baseindex): Likewise.
	(regxmm): Likewise.
	(imm8): Likewise.
	(imm8s): Likewise.
	(imm16): Likewise.
	(imm32): Likewise.
	(imm32s): Likewise.
	(imm64): Likewise.
	(imm16_32): Likewise.
	(imm16_32s): Likewise.
	(imm16_32_32s): Likewise.
	(operand_type): Likewise.
	(operand_type_check): Likewise.
	(operand_type_match): Likewise.
	(operand_type_register_match): Likewise.
	(update_imm): Likewise.
	(set_code_flag): Also update cpu_arch_flags_not.
	(set_16bit_gcc_code_flag): Likewise.
	(md_begin): Likewise.
	(parse_insn): Use cpu_flags_check_x64 to check 64bit support.
	Use cpu_flags_match to match instructions.
	(i386_target_format): Update cpu_arch_isa_flags and
	cpu_arch_tune_flags to i386_cpu_flags type with bitfield.
	(smallest_imm_type): Check cpu_arch_tune to tune for i486.
	(match_template): Don't initialize overlap0, overlap1,
	overlap2, overlap3 and operand_types.
	(process_suffix): Handle crc32 with 64bit register.
	(MATCH): Removed.
	(CONSISTENT_REGISTER_MATCH): Likewise.

	* config/tc-i386.h (arch_entry): Updated to i386_cpu_flags
	type.

opcodes/

2007-09-08  H.J. Lu  <hongjiu.lu@intel.com>

	* configure.in (AC_CHECK_HEADERS): Add limits.h.
	* configure: Regenerated.
	* config.in: Likewise.

	* i386-gen.c: Include "sysdep.h" instead of <stdlib.h> and
	<string.h>.  Use xstrerror instead of strerror.
	(initializer): New.
	(cpu_flag_init): Likewise.
	(bitfield): Likewise.
	(BITFIELD): New.
	(cpu_flags): Likewise.
	(opcode_modifiers): Likewise.
	(operand_types): Likewise.
	(compare): Likewise.
	(set_cpu_flags): Likewise.
	(output_cpu_flags): Likewise.
	(process_i386_cpu_flags): Likewise.
	(output_opcode_modifier): Likewise.
	(process_i386_opcode_modifier): Likewise.
	(output_operand_type): Likewise.
	(process_i386_operand_type): Likewise.
	(set_bitfield): Likewise.
	(operand_type_init): Likewise.
	(process_i386_initializers): Likewise.
	(process_i386_opcodes): Call process_i386_opcode_modifier to
	process opcode_modifier.  Call process_i386_operand_type to
	process operand_types.
	(process_i386_registers): Call process_i386_operand_type to
	process reg_type.
	(main): Check unused bits in i386_cpu_flags and i386_operand_type.
	Sort cpu_flags, opcode_modifiers and operand_types.  Call
	process_i386_initializers.

	* i386-init.h: New.
	* i386-tbl.h: Regenerated.

	* i386-opc.h: Include <limits.h>.
	(CHAR_BIT): Define as 8 if not defined.
	(Cpu186): Changed to position of bitfiled.
	(Cpu286): Likewise.
	(Cpu386): Likewise.
	(Cpu486): Likewise.
	(Cpu586): Likewise.
	(Cpu686): Likewise.
	(CpuP4): Likewise.
	(CpuK6): Likewise.
	(CpuK8): Likewise.
	(CpuMMX): Likewise.
	(CpuMMX2): Likewise.
	(CpuSSE): Likewise.
	(CpuSSE2): Likewise.
	(Cpu3dnow): Likewise.
	(Cpu3dnowA): Likewise.
	(CpuSSE3): Likewise.
	(CpuPadLock): Likewise.
	(CpuSVME): Likewise.
	(CpuVMX): Likewise.
	(CpuSSSE3): Likewise.
	(CpuSSE4a): Likewise.
	(CpuABM): Likewise.
	(CpuSSE4_1): Likewise.
	(CpuSSE4_2): Likewise.
	(Cpu64): Likewise.
	(CpuNo64): Likewise.
	(D): Likewise.
	(W): Likewise.
	(Modrm): Likewise.
	(ShortForm): Likewise.
	(Jump): Likewise.
	(JumpDword): Likewise.
	(JumpByte): Likewise.
	(JumpInterSegment): Likewise.
	(FloatMF): Likewise.
	(FloatR): Likewise.
	(FloatD): Likewise.
	(Size16): Likewise.
	(Size32): Likewise.
	(Size64): Likewise.
	(IgnoreSize): Likewise.
	(DefaultSize): Likewise.
	(No_bSuf): Likewise.
	(No_wSuf): Likewise.
	(No_lSuf): Likewise.
	(No_sSuf): Likewise.
	(No_qSuf): Likewise.
	(No_xSuf): Likewise.
	(FWait): Likewise.
	(IsString): Likewise.
	(RegKludge): Likewise.
	(IsPrefix): Likewise.
	(ImmExt): Likewise.
	(NoRex64): Likewise.
	(Rex64): Likewise.
	(Ugh): Likewise.
	(Reg8): Likewise.
	(Reg16): Likewise.
	(Reg32): Likewise.
	(Reg64): Likewise.
	(FloatReg): Likewise.
	(RegMMX): Likewise.
	(RegXMM): Likewise.
	(Imm8): Likewise.
	(Imm8S): Likewise.
	(Imm16): Likewise.
	(Imm32): Likewise.
	(Imm32S): Likewise.
	(Imm64): Likewise.
	(Imm1): Likewise.
	(BaseIndex): Likewise.
	(Disp8): Likewise.
	(Disp16): Likewise.
	(Disp32): Likewise.
	(Disp32S): Likewise.
	(Disp64): Likewise.
	(InOutPortReg): Likewise.
	(ShiftCount): Likewise.
	(Control): Likewise.
	(Debug): Likewise.
	(Test): Likewise.
	(SReg2): Likewise.
	(SReg3): Likewise.
	(Acc): Likewise.
	(FloatAcc): Likewise.
	(JumpAbsolute): Likewise.
	(EsSeg): Likewise.
	(RegMem): Likewise.
	(OTMax): Likewise.
	(Reg): Commented out.
	(WordReg): Likewise.
	(ImplicitRegister): Likewise.
	(Imm): Likewise.
	(EncImm): Likewise.
	(Disp): Likewise.
	(AnyMem): Likewise.
	(LLongMem): Likewise.
	(LongMem): Likewise.
	(ShortMem): Likewise.
	(WordMem): Likewise.
	(ByteMem): Likewise.
	(CpuMax): New
	(CpuLM): Likewise.
	(CpuNumOfUints): Likewise.
	(CpuNumOfBits): Likewise.
	(CpuUnused): Likewise.
	(OTNumOfUints): Likewise.
	(OTNumOfBits): Likewise.
	(OTUnused): Likewise.
	(i386_cpu_flags): New type.
	(i386_operand_type): Likewise.
	(i386_opcode_modifier): Likewise.
	(CpuSledgehammer): Removed.
	(CpuSSE4): Likewise.
	(CpuUnknownFlags): Likewise.
	(Reg): Likewise.
	(WordReg): Likewise.
	(ImplicitRegister): Likewise.
	(Imm): Likewise.
	(EncImm): Likewise.
	(Disp): Likewise.
	(AnyMem): Likewise.
	(LLongMem): Likewise.
	(LongMem): Likewise.
	(ShortMem): Likewise.
	(WordMem): Likewise.
	(ByteMem): Likewise.
	(template): Use i386_cpu_flags for cpu_flags, use
	i386_opcode_modifier for opcode_modifier, use
	i386_operand_type for operand_types.
	(reg_entry): Use i386_operand_type for reg_type.

	* Makefile.am (HFILES): Add i386-init.h.
	($(srcdir)/i386-init.h): New rule.
	($(srcdir)/i386-tbl.h): Depend on $(srcdir)/i386-init.h
	instead.
	* Makefile.in: Regenerated.

1 files changed, 546 insertions, 16 deletions

diff --git a/opcodes/i386-gen.c b/opcodes/i386-gen.c
index 2451d0e..44bf052 100644
--- a/opcodes/i386-gen.c
+++ b/opcodes/i386-gen.c
@@ -17,9 +17,8 @@
    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
    MA 02110-1301, USA.  */
 
+#include "sysdep.h"
 #include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
 #include <errno.h>
 #include "getopt.h"
 #include "libiberty.h"
@@ -33,6 +32,300 @@
 static const char *program_name = NULL;
 static int debug = 0;
 
+typedef struct initializer
+{
+  const char *name;
+  const char *init;
+} initializer;
+
+static initializer cpu_flag_init [] =
+{
+  { "CPU_UNKNOWN_FLAGS",
+    "unknown" },
+  { "CPU_GENERIC32_FLAGS",
+    "Cpu186|Cpu286|Cpu386" },
+  { "CPU_GENERIC64_FLAGS", 
+    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuP4|CpuMMX|CpuMMX2|CpuSSE|CpuSSE2" },
+  { "CPU_NONE_FLAGS",
+   "0" },
+  { "CPU_I186_FLAGS",
+    "Cpu186" },
+  { "CPU_I286_FLAGS",
+    "Cpu186|Cpu286" },
+  { "CPU_I386_FLAGS",
+    "Cpu186|Cpu286|Cpu386" },
+  { "CPU_I486_FLAGS",
+    "Cpu186|Cpu286|Cpu386|Cpu486" },
+  { "CPU_I586_FLAGS",
+    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586" },
+  { "CPU_I686_FLAGS",
+    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686" },
+  { "CPU_P2_FLAGS",
+    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuMMX" },
+  { "CPU_P3_FLAGS",
+    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuMMX|CpuMMX2|CpuSSE" },
+  { "CPU_P4_FLAGS",
+    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuP4|CpuMMX|CpuMMX2|CpuSSE|CpuSSE2" },
+  { "CPU_NOCONA_FLAGS",
+    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuP4|CpuMMX|CpuMMX2|CpuSSE|CpuSSE2|CpuSSE3|CpuLM" },
+  { "CPU_CORE_FLAGS",
+    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuP4|CpuMMX|CpuMMX2|CpuSSE|CpuSSE2|CpuSSE3" },
+  { "CPU_CORE2_FLAGS",
+    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuP4|CpuMMX|CpuMMX2|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuLM" },
+  { "CPU_K6_FLAGS",
+    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|CpuK6|CpuMMX" },
+  { "CPU_K6_2_FLAGS",
+    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|CpuK6|CpuMMX|Cpu3dnow" },
+  { "CPU_ATHLON_FLAGS",
+    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuK6|CpuMMX|CpuMMX2|Cpu3dnow|Cpu3dnowA" },
+  { "CPU_K8_FLAGS",
+    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuK6|CpuK8|CpuMMX|CpuMMX2|Cpu3dnow|Cpu3dnowA|CpuSSE|CpuSSE2|CpuLM" },
+  { "CPU_AMDFAM10_FLAGS",
+    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuK6|CpuK8|CpuMMX|CpuMMX2|Cpu3dnow|Cpu3dnowA|CpuSSE|CpuSSE2|CpuSSE3|CpuSSE4a|CpuABM|CpuLM" },
+  { "CPU_MMX_FLAGS",
+    "CpuMMX" },
+  { "CPU_SSE_FLAGS",
+    "CpuMMX|CpuMMX2|CpuSSE" },
+  { "CPU_SSE2_FLAGS",
+    "CpuMMX|CpuMMX2|CpuSSE|CpuSSE2" },
+  { "CPU_SSE3_FLAGS",
+    "CpuMMX|CpuMMX2|CpuSSE|CpuSSE2|CpuSSE3" },
+  { "CPU_SSSE3_FLAGS",
+    "CpuMMX|CpuMMX2|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3" },
+  { "CPU_SSE4_1_FLAGS",
+    "CpuMMX|CpuMMX2|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1" },
+  { "CPU_SSE4_2_FLAGS",
+    "CpuMMX|CpuMMX2|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1|CpuSSE4_2" },
+  { "CPU_3DNOW_FLAGS",
+    "CpuMMX|Cpu3dnow" },
+  { "CPU_3DNOWA_FLAGS",
+    "CpuMMX|CpuMMX2|Cpu3dnow|Cpu3dnowA" },
+  { "CPU_PADLOCK_FLAGS",
+    "CpuPadLock" },
+  { "CPU_SVME_FLAGS",
+    "CpuSVME" },
+  { "CPU_SSE4A_FLAGS",
+    "CpuMMX|CpuMMX2|CpuSSE|CpuSSE2|CpuSSE3|CpuSSE4a" },
+  { "CPU_ABM_FLAGS",
+    "CpuABM" }
+};
+
+static initializer operand_type_init [] =
+{
+  { "OPERAND_TYPE_NONE",
+    "0" },
+  { "OPERAND_TYPE_REG8",
+    "Reg8" },
+  { "OPERAND_TYPE_REG16",
+    "Reg16" },
+  { "OPERAND_TYPE_REG32",
+    "Reg32" },
+  { "OPERAND_TYPE_REG64",
+    "Reg64" },
+  { "OPERAND_TYPE_IMM1",
+    "Imm1" },
+  { "OPERAND_TYPE_IMM8",
+    "Imm8" },
+  { "OPERAND_TYPE_IMM8S",
+    "Imm8S" },
+  { "OPERAND_TYPE_IMM16",
+    "Imm16" },
+  { "OPERAND_TYPE_IMM32",
+    "Imm32" },
+  { "OPERAND_TYPE_IMM32S",
+    "Imm32S" },
+  { "OPERAND_TYPE_IMM64",
+    "Imm64" },
+  { "OPERAND_TYPE_BASEINDEX",
+    "BaseIndex" },
+  { "OPERAND_TYPE_DISP8",
+    "Disp8" },
+  { "OPERAND_TYPE_DISP16",
+    "Disp16" },
+  { "OPERAND_TYPE_DISP32",
+    "Disp32" },
+  { "OPERAND_TYPE_DISP32S",
+    "Disp32S" },
+  { "OPERAND_TYPE_DISP64",
+    "Disp64" },
+  { "OPERAND_TYPE_INOUTPORTREG",
+    "InOutPortReg" },
+  { "OPERAND_TYPE_SHIFTCOUNT",
+    "ShiftCount" },
+  { "OPERAND_TYPE_CONTROL",
+    "Control" },
+  { "OPERAND_TYPE_TEST",
+    "Test" },
+  { "OPERAND_TYPE_DEBUG",
+    "FloatReg" },
+  { "OPERAND_TYPE_FLOATREG",
+    "FloatReg" },
+  { "OPERAND_TYPE_FLOATACC",
+    "FloatAcc" },
+  { "OPERAND_TYPE_SREG2",
+    "SReg2" },
+  { "OPERAND_TYPE_SREG3",
+    "SReg3" },
+  { "OPERAND_TYPE_ACC",
+    "Acc" },
+  { "OPERAND_TYPE_JUMPABSOLUTE",
+    "JumpAbsolute" },
+  { "OPERAND_TYPE_REGMMX",
+    "RegMMX" },
+  { "OPERAND_TYPE_REGXMM",
+    "RegXMM" },
+  { "OPERAND_TYPE_ESSEG",
+    "EsSeg" },
+  { "OPERAND_TYPE_ACC32",
+    "Reg32|Acc" },
+  { "OPERAND_TYPE_ACC64",
+    "Reg64|Acc" },
+  { "OPERAND_TYPE_REG16_INOUTPORTREG",
+    "Reg16|InOutPortReg" },
+  { "OPERAND_TYPE_DISP16_32",
+    "Disp16|Disp32" },
+  { "OPERAND_TYPE_ANYDISP",
+    "Disp8|Disp16|Disp32|Disp32S|Disp64" },
+  { "OPERAND_TYPE_IMM16_32",
+    "Imm16|Imm32" },
+  { "OPERAND_TYPE_IMM16_32S",
+    "Imm16|Imm32S" },
+  { "OPERAND_TYPE_IMM16_32_32S",
+    "Imm16|Imm32|Imm32S" },
+  { "OPERAND_TYPE_IMM32_32S_DISP32",
+    "Imm32|Imm32S|Disp32" },
+  { "OPERAND_TYPE_IMM64_DISP64",
+    "Imm64|Disp64" },
+  { "OPERAND_TYPE_IMM32_32S_64_DISP32",
+    "Imm32|Imm32S|Imm64|Disp32" },
+  { "OPERAND_TYPE_IMM32_32S_64_DISP32_64",
+    "Imm32|Imm32S|Imm64|Disp32|Disp64" },
+};
+
+typedef struct bitfield
+{
+  int position;
+  int value;
+  const char *name;
+} bitfield;
+
+#define BITFIELD(n) { n, 0, #n }
+
+static bitfield cpu_flags[] =
+{
+  BITFIELD (Cpu186),
+  BITFIELD (Cpu286),
+  BITFIELD (Cpu386),
+  BITFIELD (Cpu486),
+  BITFIELD (Cpu586),
+  BITFIELD (Cpu686),
+  BITFIELD (CpuP4),
+  BITFIELD (CpuK6),
+  BITFIELD (CpuK8),
+  BITFIELD (CpuMMX),
+  BITFIELD (CpuMMX2),
+  BITFIELD (CpuSSE),
+  BITFIELD (CpuSSE2),
+  BITFIELD (CpuSSE3),
+  BITFIELD (CpuSSSE3),
+  BITFIELD (CpuSSE4_1),
+  BITFIELD (CpuSSE4_2),
+  BITFIELD (CpuSSE4a),
+  BITFIELD (Cpu3dnow),
+  BITFIELD (Cpu3dnowA),
+  BITFIELD (CpuPadLock),
+  BITFIELD (CpuSVME),
+  BITFIELD (CpuVMX),
+  BITFIELD (CpuABM),
+  BITFIELD (CpuLM),
+  BITFIELD (Cpu64),
+  BITFIELD (CpuNo64),
+#ifdef CpuUnused
+  BITFIELD (CpuUnused),
+#endif
+};
+
+static bitfield opcode_modifiers[] =
+{
+  BITFIELD (D),
+  BITFIELD (W),
+  BITFIELD (Modrm),
+  BITFIELD (ShortForm),
+  BITFIELD (Jump),
+  BITFIELD (JumpDword),
+  BITFIELD (JumpByte),
+  BITFIELD (JumpInterSegment),
+  BITFIELD (FloatMF),
+  BITFIELD (FloatR),
+  BITFIELD (FloatD),
+  BITFIELD (Size16),
+  BITFIELD (Size32),
+  BITFIELD (Size64),
+  BITFIELD (IgnoreSize),
+  BITFIELD (DefaultSize),
+  BITFIELD (No_bSuf),
+  BITFIELD (No_wSuf),
+  BITFIELD (No_lSuf),
+  BITFIELD (No_sSuf),
+  BITFIELD (No_qSuf),
+  BITFIELD (No_xSuf),
+  BITFIELD (FWait),
+  BITFIELD (IsString),
+  BITFIELD (RegKludge),
+  BITFIELD (IsPrefix),
+  BITFIELD (ImmExt),
+  BITFIELD (NoRex64),
+  BITFIELD (Rex64),
+  BITFIELD (Ugh),
+};
+
+static bitfield operand_types[] =
+{
+  BITFIELD (Reg8),
+  BITFIELD (Reg16),
+  BITFIELD (Reg32),
+  BITFIELD (Reg64),
+  BITFIELD (FloatReg),
+  BITFIELD (RegMMX),
+  BITFIELD (RegXMM),
+  BITFIELD (Imm8),
+  BITFIELD (Imm8S),
+  BITFIELD (Imm16),
+  BITFIELD (Imm32),
+  BITFIELD (Imm32S),
+  BITFIELD (Imm64),
+  BITFIELD (Imm1),
+  BITFIELD (BaseIndex),
+  BITFIELD (Disp8),
+  BITFIELD (Disp16),
+  BITFIELD (Disp32),
+  BITFIELD (Disp32S),
+  BITFIELD (Disp64),
+  BITFIELD (InOutPortReg),
+  BITFIELD (ShiftCount),
+  BITFIELD (Control),
+  BITFIELD (Debug),
+  BITFIELD (Test),
+  BITFIELD (SReg2),
+  BITFIELD (SReg3),
+  BITFIELD (Acc),
+  BITFIELD (FloatAcc),
+  BITFIELD (JumpAbsolute),
+  BITFIELD (EsSeg),
+  BITFIELD (RegMem),
+#ifdef OTUnused
+  BITFIELD (OTUnused),
+#endif
+};
+
+static int
+compare (const void *x, const void *y)
+{
+  const bitfield *xp = (const bitfield *) x;
+  const bitfield *yp = (const bitfield *) y;
+  return xp->position - yp->position;
+}
+
 static void
 fail (const char *message, ...)
 {
@@ -120,6 +413,171 @@ next_field (char *str, char sep, char **next)
 }
 
 static void
+set_bitfield (const char *f, bitfield *array, unsigned int size)
+{
+  unsigned int i;
+
+  if (strcmp (f, "CpuSledgehammer") == 0)
+    f= "CpuK8";
+
+  for (i = 0; i < size; i++)
+    if (strcasecmp (array[i].name, f) == 0)
+      {
+	array[i].value = 1;
+	return;
+      }
+
+  printf ("Unknown bitfield: %s\n", f);
+  abort ();
+}
+
+static void
+output_cpu_flags (FILE *table, bitfield *flags, unsigned int size,
+		  int macro, const char *comma, const char *indent)
+{
+  unsigned int i;
+
+  fprintf (table, "%s{ { ", indent);
+
+  for (i = 0; i < size - 1; i++)
+    {
+      fprintf (table, "%d, ", flags[i].value);
+      if (((i + 1) % 20) == 0)
+	{
+	  /* We need \\ for macro.  */
+	  if (macro)
+	    fprintf (table, " \\\n    %s", indent);
+	  else
+	    fprintf (table, "\n    %s", indent);
+	}
+    }
+
+  fprintf (table, "%d } }%s\n", flags[i].value, comma);
+}
+
+static void
+process_i386_cpu_flag (FILE *table, char *flag, int macro,
+		       const char *comma, const char *indent)
+{
+  char *str, *next, *last;
+  bitfield flags [ARRAY_SIZE (cpu_flags)];
+
+  /* Copy the default cpu flags.  */
+  memcpy (flags, cpu_flags, sizeof (cpu_flags));
+
+  if (strcasecmp (flag, "unknown") == 0)
+    {
+      unsigned int i;
+
+      /* We turn on everything except for cpu64 in case of
+	 CPU_UNKNOWN_FLAGS. */
+      for (i = 0; i < ARRAY_SIZE (flags); i++)
+	if (flags[i].position != Cpu64)
+	  flags[i].value = 1;
+    }
+  else if (strcmp (flag, "0"))
+    {
+      last = flag + strlen (flag);
+      for (next = flag; next && next < last; )
+	{
+	  str = next_field (next, '|', &next);
+	  if (str)
+	    set_bitfield (str, flags, ARRAY_SIZE (flags));
+	}
+    }
+
+  output_cpu_flags (table, flags, ARRAY_SIZE (flags), macro,
+		    comma, indent);
+}
+
+static void
+output_opcode_modifier (FILE *table, bitfield *modifier, unsigned int size)
+{
+  unsigned int i;
+
+  fprintf (table, "    { ");
+
+  for (i = 0; i < size - 1; i++)
+    {
+      fprintf (table, "%d, ", modifier[i].value);
+      if (((i + 1) % 20) == 0)
+	fprintf (table, "\n      ");
+    }
+
+  fprintf (table, "%d },\n", modifier[i].value);
+}
+
+static void
+process_i386_opcode_modifier (FILE *table, char *mod)
+{
+  char *str, *next, *last;
+  bitfield modifiers [ARRAY_SIZE (opcode_modifiers)];
+
+  /* Copy the default opcode modifier.  */
+  memcpy (modifiers, opcode_modifiers, sizeof (modifiers));
+
+  if (strcmp (mod, "0"))
+    {
+      last = mod + strlen (mod);
+      for (next = mod; next && next < last; )
+	{
+	  str = next_field (next, '|', &next);
+	  if (str)
+	    set_bitfield (str, modifiers, ARRAY_SIZE (modifiers));
+	}
+    }
+  output_opcode_modifier (table, modifiers, ARRAY_SIZE (modifiers));
+}
+
+static void
+output_operand_type (FILE *table, bitfield *types, unsigned int size,
+		     int macro, const char *indent)
+{
+  unsigned int i;
+
+  fprintf (table, "{ { ");
+
+  for (i = 0; i < size - 1; i++)
+    {
+      fprintf (table, "%d, ", types[i].value);
+      if (((i + 1) % 20) == 0)
+	{
+	  /* We need \\ for macro.  */
+	  if (macro)
+	    fprintf (table, "\\\n%s", indent);
+	  else
+	    fprintf (table, "\n%s", indent);
+	}
+    }
+
+  fprintf (table, "%d } }", types[i].value);
+}
+
+static void
+process_i386_operand_type (FILE *table, char *op, int macro,
+			   const char *indent)
+{
+  char *str, *next, *last;
+  bitfield types [ARRAY_SIZE (operand_types)];
+
+  /* Copy the default operand type.  */
+  memcpy (types, operand_types, sizeof (types));
+
+  if (strcmp (op, "0"))
+    {
+      last = op + strlen (op);
+      for (next = op; next && next < last; )
+	{
+	  str = next_field (next, '|', &next);
+	  if (str)
+	    set_bitfield (str, types, ARRAY_SIZE (types));
+	}
+    }
+  output_operand_type (table, types, ARRAY_SIZE (types), macro,
+		       indent);
+}
+
+static void
 process_i386_opcodes (FILE *table)
 {
   FILE *fp = fopen ("i386-opc.tbl", "r");
@@ -131,7 +589,7 @@ process_i386_opcodes (FILE *table)
 
   if (fp == NULL)
     fail (_("can't find i386-opc.tbl for reading, errno = %s\n"),
-	  strerror (errno));
+	  xstrerror (errno));
 
   fprintf (table, "\n/* i386 opcode table.  */\n\n");
   fprintf (table, "const template i386_optab[] =\n{\n");
@@ -243,11 +701,12 @@ process_i386_opcodes (FILE *table)
 	    }
 	}
 
-      fprintf (table, "  { \"%s\", %s, %s, %s, %s,\n",
-	       name, operands, base_opcode, extension_opcode,
-	       cpu_flags);
+      fprintf (table, "  { \"%s\", %s, %s, %s,\n",
+	       name, operands, base_opcode, extension_opcode);
+
+      process_i386_cpu_flag (table, cpu_flags, 0, ",", "    ");
 
-      fprintf (table, "    %s,\n", opcode_modifier);
+      process_i386_opcode_modifier (table, opcode_modifier);
 
       fprintf (table, "    { ");
 
@@ -257,21 +716,31 @@ process_i386_opcodes (FILE *table)
 	      || *operand_types[i] == '0')
 	    {
 	      if (i == 0)
-		fprintf (table, "0");
+		process_i386_operand_type (table, "0", 0, "\t  ");
 	      break;
 	    }
 
 	  if (i != 0)
 	    fprintf (table, ",\n      ");
 
-	  fprintf (table, "%s", operand_types[i]);
+	  process_i386_operand_type (table, operand_types[i], 0,
+				     "\t  ");
 	}
       fprintf (table, " } },\n");
     }
 
   fclose (fp);
 
-  fprintf (table, "  { NULL, 0, 0, 0, 0, 0, { 0 } }\n");
+  fprintf (table, "  { NULL, 0, 0, 0,\n");
+
+  process_i386_cpu_flag (table, "0", 0, ",", "    ");
+
+  process_i386_opcode_modifier (table, "0");
+ 
+  fprintf (table, "    { ");
+  process_i386_operand_type (table, "0", 0, "\t  ");
+  fprintf (table, " } }\n");
+
   fprintf (table, "};\n");
 }
 
@@ -285,7 +754,7 @@ process_i386_registers (FILE *table)
 
   if (fp == NULL)
     fail (_("can't find i386-reg.tbl for reading, errno = %s\n"),
-	  strerror (errno));
+	  xstrerror (errno));
 
   fprintf (table, "\n/* i386 register table.  */\n\n");
   fprintf (table, "const reg_entry i386_regtab[] =\n{\n");
@@ -339,8 +808,11 @@ process_i386_registers (FILE *table)
       /* Find reg_num.  */
       reg_num = next_field (str, ',', &str);
 
-      fprintf (table, "  { \"%s\", %s, %s, %s },\n",
-	       reg_name, reg_type, reg_flags, reg_num);
+      fprintf (table, "  { \"%s\",\n    ", reg_name);
+
+      process_i386_operand_type (table, reg_type, 0, "\t");
+
+      fprintf (table, ",\n    %s, %s },\n", reg_flags, reg_num);
     }
 
   fclose (fp);
@@ -350,6 +822,39 @@ process_i386_registers (FILE *table)
   fprintf (table, "\nconst unsigned int i386_regtab_size = ARRAY_SIZE (i386_regtab);\n");
 }
 
+static void
+process_i386_initializers (void)
+{
+  unsigned int i;
+  FILE *fp = fopen ("i386-init.h", "w");
+  char *init;
+
+  if (fp == NULL)
+    fail (_("can't create i386-init.h, errno = %s\n"),
+	  xstrerror (errno));
+
+  process_copyright (fp);
+
+  for (i = 0; i < ARRAY_SIZE (cpu_flag_init); i++)
+    {
+      fprintf (fp, "\n#define %s \\\n", cpu_flag_init[i].name);
+      init = xstrdup (cpu_flag_init[i].init);
+      process_i386_cpu_flag (fp, init, 1, "", "  ");
+      free (init);
+    }
+
+  for (i = 0; i < ARRAY_SIZE (operand_type_init); i++)
+    {
+      fprintf (fp, "\n\n#define %s \\\n  ", operand_type_init[i].name);
+      init = xstrdup (operand_type_init[i].init);
+      process_i386_operand_type (fp, init, 1, "      ");
+      free (init);
+    }
+  fprintf (fp, "\n");
+
+  fclose (fp);
+}
+
 /* Program options.  */
 #define OPTION_SRCDIR	200
 
@@ -382,7 +887,7 @@ main (int argc, char **argv)
 {
   extern int chdir (char *);
   char *srcdir = NULL;
-  int c;
+  int c, unused;
   FILE *table;
   
   program_name = *argv;
@@ -415,16 +920,41 @@ main (int argc, char **argv)
   if (srcdir != NULL) 
     if (chdir (srcdir) != 0)
       fail (_("unable to change directory to \"%s\", errno = %s\n"),
-	    srcdir, strerror (errno));
+	    srcdir, xstrerror (errno));
+
+  /* Check the unused bitfield in i386_cpu_flags.  */
+#ifndef CpuUnused
+  unused = CpuNumOfBits - CpuMax - 1;
+  if (unused)
+    fail (_("%d unused bits in i386_cpu_flags.\n"), unused);
+#endif
+
+  /* Check the unused bitfield in i386_operand_type.  */
+#ifndef OTUnused
+  unused = OTNumOfBits - OTMax - 1;
+  if (unused)
+    fail (_("%d unused bits in i386_operand_type.\n"), unused);
+#endif
+
+  qsort (cpu_flags, ARRAY_SIZE (cpu_flags), sizeof (cpu_flags [0]),
+	 compare);
+
+  qsort (opcode_modifiers, ARRAY_SIZE (opcode_modifiers),
+	 sizeof (opcode_modifiers [0]), compare);
+
+  qsort (operand_types, ARRAY_SIZE (operand_types),
+	 sizeof (operand_types [0]), compare);
 
   table = fopen ("i386-tbl.h", "w");
   if (table == NULL)
-    fail (_("can't create i386-tbl.h, errno = %s\n"), strerror (errno));
+    fail (_("can't create i386-tbl.h, errno = %s\n"),
+	  xstrerror (errno));
 
   process_copyright (table);
 
   process_i386_opcodes (table);
   process_i386_registers (table);
+  process_i386_initializers ();
 
   fclose (table);