OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [binutils-2.20.1/] [opcodes/] [i386-gen.c] - Blame information for rev 854

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 205 julius 
/* Copyright 2007, 2008, 2009
2 
   Free Software Foundation, Inc.
3 
 
4 
   This file is part of the GNU opcodes library.
5 
 
6 
   This library is free software; you can redistribute it and/or modify
7 
   it under the terms of the GNU General Public License as published by
8 
   the Free Software Foundation; either version 3, or (at your option)
9 
   any later version.
10 
 
11 
   It is distributed in the hope that it will be useful, but WITHOUT
12 
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13 
   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
14 
   License for more details.
15 
 
16 
   You should have received a copy of the GNU General Public License
17 
   along with this program; if not, write to the Free Software
18 
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 
   MA 02110-1301, USA.  */
20 
 
21 
#include "sysdep.h"
22 
#include <stdio.h>
23 
#include <errno.h>
24 
#include "getopt.h"
25 
#include "libiberty.h"
26 
#include "hashtab.h"
27 
#include "safe-ctype.h"
28 
 
29 
#include "i386-opc.h"
30 
 
31 
#include <libintl.h>
32 
#define _(String) gettext (String)
33 
 
34 
static const char *program_name = NULL;
35 
static int debug = 0;
36 
 
37 
typedef struct initializer
38 
{
39 
  const char *name;
40 
  const char *init;
41 
} initializer;
42 
 
43 
static initializer cpu_flag_init[] =
44 
{
45 
  { "CPU_UNKNOWN_FLAGS",
46 
    "~CpuL1OM" },
47 
  { "CPU_GENERIC32_FLAGS",
48 
    "Cpu186|Cpu286|Cpu386" },
49 
  { "CPU_GENERIC64_FLAGS",
50 
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuClflush|Cpu387|Cpu687|CpuMMX|CpuSSE|CpuSSE2|CpuLM" },
51 
  { "CPU_NONE_FLAGS",
52 
   "0" },
53 
  { "CPU_I186_FLAGS",
54 
    "Cpu186" },
55 
  { "CPU_I286_FLAGS",
56 
    "Cpu186|Cpu286" },
57 
  { "CPU_I386_FLAGS",
58 
    "Cpu186|Cpu286|Cpu386" },
59 
  { "CPU_I486_FLAGS",
60 
    "Cpu186|Cpu286|Cpu386|Cpu486" },
61 
  { "CPU_I586_FLAGS",
62 
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu387" },
63 
  { "CPU_I686_FLAGS",
64 
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|Cpu387|Cpu687" },
65 
  { "CPU_P2_FLAGS",
66 
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|Cpu387|Cpu687|CpuMMX" },
67 
  { "CPU_P3_FLAGS",
68 
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|Cpu387|Cpu687|CpuMMX|CpuSSE" },
69 
  { "CPU_P4_FLAGS",
70 
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuClflush|Cpu387|Cpu687|CpuMMX|CpuSSE|CpuSSE2" },
71 
  { "CPU_NOCONA_FLAGS",
72 
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuClflush|Cpu387|Cpu687|CpuFISTTP|CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuLM" },
73 
  { "CPU_CORE_FLAGS",
74 
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuClflush|Cpu387|Cpu687|CpuFISTTP|CpuMMX|CpuSSE|CpuSSE2|CpuSSE3" },
75 
  { "CPU_CORE2_FLAGS",
76 
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuClflush|Cpu387|Cpu687|CpuFISTTP|CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuLM" },
77 
  { "CPU_COREI7_FLAGS",
78 
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuClflush|Cpu387|Cpu687|CpuFISTTP|CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1|CpuSSE4_2|CpuRdtscp|CpuLM" },
79 
  { "CPU_K6_FLAGS",
80 
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|CpuSYSCALL|Cpu387|CpuMMX" },
81 
  { "CPU_K6_2_FLAGS",
82 
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|CpuSYSCALL|Cpu387|CpuMMX|Cpu3dnow" },
83 
  { "CPU_ATHLON_FLAGS",
84 
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuSYSCALL|Cpu387|Cpu687|CpuMMX|Cpu3dnow|Cpu3dnowA" },
85 
  { "CPU_K8_FLAGS",
86 
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuSYSCALL|CpuRdtscp|Cpu387|Cpu687|CpuMMX|Cpu3dnow|Cpu3dnowA|CpuSSE|CpuSSE2|CpuLM" },
87 
  { "CPU_AMDFAM10_FLAGS",
88 
    "Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuSYSCALL|CpuRdtscp|Cpu387|Cpu687|CpuFISTTP|CpuMMX|Cpu3dnow|Cpu3dnowA|CpuSSE|CpuSSE2|CpuSSE3|CpuSSE4a|CpuABM|CpuLM" },
89 
  { "CPU_8087_FLAGS",
90 
    "Cpu8087" },
91 
  { "CPU_287_FLAGS",
92 
    "Cpu287" },
93 
  { "CPU_387_FLAGS",
94 
    "Cpu387" },
95 
  { "CPU_ANY87_FLAGS",
96 
    "Cpu8087|Cpu287|Cpu387|Cpu687|CpuFISTTP" },
97 
  { "CPU_CLFLUSH_FLAGS",
98 
    "CpuClflush" },
99 
  { "CPU_SYSCALL_FLAGS",
100 
    "CpuSYSCALL" },
101 
  { "CPU_MMX_FLAGS",
102 
    "CpuMMX" },
103 
  { "CPU_SSE_FLAGS",
104 
    "CpuMMX|CpuSSE" },
105 
  { "CPU_SSE2_FLAGS",
106 
    "CpuMMX|CpuSSE|CpuSSE2" },
107 
  { "CPU_SSE3_FLAGS",
108 
    "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3" },
109 
  { "CPU_SSSE3_FLAGS",
110 
    "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3" },
111 
  { "CPU_SSE4_1_FLAGS",
112 
    "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1" },
113 
  { "CPU_SSE4_2_FLAGS",
114 
    "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1|CpuSSE4_2" },
115 
  { "CPU_ANY_SSE_FLAGS",
116 
    "CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1|CpuSSE4_2|CpuSSE4a|CpuAVX" },
117 
  { "CPU_VMX_FLAGS",
118 
    "CpuVMX" },
119 
  { "CPU_SMX_FLAGS",
120 
    "CpuSMX" },
121 
  { "CPU_XSAVE_FLAGS",
122 
    "CpuXsave" },
123 
  { "CPU_AES_FLAGS",
124 
    "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1|CpuSSE4_2|CpuAES" },
125 
  { "CPU_PCLMUL_FLAGS",
126 
    "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1|CpuSSE4_2|CpuPCLMUL" },
127 
  { "CPU_FMA_FLAGS",
128 
    "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1|CpuSSE4_2|CpuAVX|CpuFMA" },
129 
  { "CPU_FMA4_FLAGS",
130 
    "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1|CpuSSE4_2|CpuAVX|CpuFMA4" },
131 
  { "CPU_MOVBE_FLAGS",
132 
    "CpuMovbe" },
133 
  { "CPU_RDTSCP_FLAGS",
134 
    "CpuRdtscp" },
135 
  { "CPU_EPT_FLAGS",
136 
    "CpuEPT" },
137 
  { "CPU_3DNOW_FLAGS",
138 
    "CpuMMX|Cpu3dnow" },
139 
  { "CPU_3DNOWA_FLAGS",
140 
    "CpuMMX|Cpu3dnow|Cpu3dnowA" },
141 
  { "CPU_PADLOCK_FLAGS",
142 
    "CpuPadLock" },
143 
  { "CPU_SVME_FLAGS",
144 
    "CpuSVME" },
145 
  { "CPU_SSE4A_FLAGS",
146 
    "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSE4a" },
147 
  { "CPU_ABM_FLAGS",
148 
    "CpuABM" },
149 
  { "CPU_AVX_FLAGS",
150 
    "CpuMMX|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1|CpuSSE4_2|CpuAVX" },
151 
  { "CPU_ANY_AVX_FLAGS",
152 
    "CpuAVX" },
153 
  { "CPU_L1OM_FLAGS",
154 
    "unknown" },
155 
};
156 
 
157 
static initializer operand_type_init[] =
158 
{
159 
  { "OPERAND_TYPE_NONE",
160 
    "0" },
161 
  { "OPERAND_TYPE_REG8",
162 
    "Reg8" },
163 
  { "OPERAND_TYPE_REG16",
164 
    "Reg16" },
165 
  { "OPERAND_TYPE_REG32",
166 
    "Reg32" },
167 
  { "OPERAND_TYPE_REG64",
168 
    "Reg64" },
169 
  { "OPERAND_TYPE_IMM1",
170 
    "Imm1" },
171 
  { "OPERAND_TYPE_IMM8",
172 
    "Imm8" },
173 
  { "OPERAND_TYPE_IMM8S",
174 
    "Imm8S" },
175 
  { "OPERAND_TYPE_IMM16",
176 
    "Imm16" },
177 
  { "OPERAND_TYPE_IMM32",
178 
    "Imm32" },
179 
  { "OPERAND_TYPE_IMM32S",
180 
    "Imm32S" },
181 
  { "OPERAND_TYPE_IMM64",
182 
    "Imm64" },
183 
  { "OPERAND_TYPE_BASEINDEX",
184 
    "BaseIndex" },
185 
  { "OPERAND_TYPE_DISP8",
186 
    "Disp8" },
187 
  { "OPERAND_TYPE_DISP16",
188 
    "Disp16" },
189 
  { "OPERAND_TYPE_DISP32",
190 
    "Disp32" },
191 
  { "OPERAND_TYPE_DISP32S",
192 
    "Disp32S" },
193 
  { "OPERAND_TYPE_DISP64",
194 
    "Disp64" },
195 
  { "OPERAND_TYPE_INOUTPORTREG",
196 
    "InOutPortReg" },
197 
  { "OPERAND_TYPE_SHIFTCOUNT",
198 
    "ShiftCount" },
199 
  { "OPERAND_TYPE_CONTROL",
200 
    "Control" },
201 
  { "OPERAND_TYPE_TEST",
202 
    "Test" },
203 
  { "OPERAND_TYPE_DEBUG",
204 
    "FloatReg" },
205 
  { "OPERAND_TYPE_FLOATREG",
206 
    "FloatReg" },
207 
  { "OPERAND_TYPE_FLOATACC",
208 
    "FloatAcc" },
209 
  { "OPERAND_TYPE_SREG2",
210 
    "SReg2" },
211 
  { "OPERAND_TYPE_SREG3",
212 
    "SReg3" },
213 
  { "OPERAND_TYPE_ACC",
214 
    "Acc" },
215 
  { "OPERAND_TYPE_JUMPABSOLUTE",
216 
    "JumpAbsolute" },
217 
  { "OPERAND_TYPE_REGMMX",
218 
    "RegMMX" },
219 
  { "OPERAND_TYPE_REGXMM",
220 
    "RegXMM" },
221 
  { "OPERAND_TYPE_REGYMM",
222 
    "RegYMM" },
223 
  { "OPERAND_TYPE_ESSEG",
224 
    "EsSeg" },
225 
  { "OPERAND_TYPE_ACC32",
226 
    "Reg32|Acc|Dword" },
227 
  { "OPERAND_TYPE_ACC64",
228 
    "Reg64|Acc|Qword" },
229 
  { "OPERAND_TYPE_INOUTPORTREG",
230 
    "InOutPortReg" },
231 
  { "OPERAND_TYPE_REG16_INOUTPORTREG",
232 
    "Reg16|InOutPortReg" },
233 
  { "OPERAND_TYPE_DISP16_32",
234 
    "Disp16|Disp32" },
235 
  { "OPERAND_TYPE_ANYDISP",
236 
    "Disp8|Disp16|Disp32|Disp32S|Disp64" },
237 
  { "OPERAND_TYPE_IMM16_32",
238 
    "Imm16|Imm32" },
239 
  { "OPERAND_TYPE_IMM16_32S",
240 
    "Imm16|Imm32S" },
241 
  { "OPERAND_TYPE_IMM16_32_32S",
242 
    "Imm16|Imm32|Imm32S" },
243 
  { "OPERAND_TYPE_IMM32_32S_DISP32",
244 
    "Imm32|Imm32S|Disp32" },
245 
  { "OPERAND_TYPE_IMM64_DISP64",
246 
    "Imm64|Disp64" },
247 
  { "OPERAND_TYPE_IMM32_32S_64_DISP32",
248 
    "Imm32|Imm32S|Imm64|Disp32" },
249 
  { "OPERAND_TYPE_IMM32_32S_64_DISP32_64",
250 
    "Imm32|Imm32S|Imm64|Disp32|Disp64" },
251 
};
252 
 
253 
typedef struct bitfield
254 
{
255 
  int position;
256 
  int value;
257 
  const char *name;
258 
} bitfield;
259 
 
260 
#define BITFIELD(n) { n, 0, #n }
261 
 
262 
static bitfield cpu_flags[] =
263 
{
264 
  BITFIELD (Cpu186),
265 
  BITFIELD (Cpu286),
266 
  BITFIELD (Cpu386),
267 
  BITFIELD (Cpu486),
268 
  BITFIELD (Cpu586),
269 
  BITFIELD (Cpu686),
270 
  BITFIELD (CpuClflush),
271 
  BITFIELD (CpuSYSCALL),
272 
  BITFIELD (Cpu8087),
273 
  BITFIELD (Cpu287),
274 
  BITFIELD (Cpu387),
275 
  BITFIELD (Cpu687),
276 
  BITFIELD (CpuFISTTP),
277 
  BITFIELD (CpuMMX),
278 
  BITFIELD (CpuSSE),
279 
  BITFIELD (CpuSSE2),
280 
  BITFIELD (CpuSSE3),
281 
  BITFIELD (CpuSSSE3),
282 
  BITFIELD (CpuSSE4_1),
283 
  BITFIELD (CpuSSE4_2),
284 
  BITFIELD (CpuAVX),
285 
  BITFIELD (CpuL1OM),
286 
  BITFIELD (CpuSSE4a),
287 
  BITFIELD (Cpu3dnow),
288 
  BITFIELD (Cpu3dnowA),
289 
  BITFIELD (CpuPadLock),
290 
  BITFIELD (CpuSVME),
291 
  BITFIELD (CpuVMX),
292 
  BITFIELD (CpuSMX),
293 
  BITFIELD (CpuABM),
294 
  BITFIELD (CpuXsave),
295 
  BITFIELD (CpuAES),
296 
  BITFIELD (CpuPCLMUL),
297 
  BITFIELD (CpuFMA),
298 
  BITFIELD (CpuFMA4),
299 
  BITFIELD (CpuLM),
300 
  BITFIELD (CpuMovbe),
301 
  BITFIELD (CpuEPT),
302 
  BITFIELD (CpuRdtscp),
303 
  BITFIELD (Cpu64),
304 
  BITFIELD (CpuNo64),
305 
#ifdef CpuUnused
306 
  BITFIELD (CpuUnused),
307 
#endif
308 
};
309 
 
310 
static bitfield opcode_modifiers[] =
311 
{
312 
  BITFIELD (D),
313 
  BITFIELD (W),
314 
  BITFIELD (S),
315 
  BITFIELD (Modrm),
316 
  BITFIELD (ShortForm),
317 
  BITFIELD (Jump),
318 
  BITFIELD (JumpDword),
319 
  BITFIELD (JumpByte),
320 
  BITFIELD (JumpInterSegment),
321 
  BITFIELD (FloatMF),
322 
  BITFIELD (FloatR),
323 
  BITFIELD (FloatD),
324 
  BITFIELD (Size16),
325 
  BITFIELD (Size32),
326 
  BITFIELD (Size64),
327 
  BITFIELD (IgnoreSize),
328 
  BITFIELD (DefaultSize),
329 
  BITFIELD (No_bSuf),
330 
  BITFIELD (No_wSuf),
331 
  BITFIELD (No_lSuf),
332 
  BITFIELD (No_sSuf),
333 
  BITFIELD (No_qSuf),
334 
  BITFIELD (No_ldSuf),
335 
  BITFIELD (FWait),
336 
  BITFIELD (IsString),
337 
  BITFIELD (RegKludge),
338 
  BITFIELD (FirstXmm0),
339 
  BITFIELD (Implicit1stXmm0),
340 
  BITFIELD (ByteOkIntel),
341 
  BITFIELD (ToDword),
342 
  BITFIELD (ToQword),
343 
  BITFIELD (AddrPrefixOp0),
344 
  BITFIELD (IsPrefix),
345 
  BITFIELD (ImmExt),
346 
  BITFIELD (NoRex64),
347 
  BITFIELD (Rex64),
348 
  BITFIELD (Ugh),
349 
  BITFIELD (Vex),
350 
  BITFIELD (Vex256),
351 
  BITFIELD (VexNDS),
352 
  BITFIELD (VexNDD),
353 
  BITFIELD (VexW0),
354 
  BITFIELD (VexW1),
355 
  BITFIELD (Vex0F),
356 
  BITFIELD (Vex0F38),
357 
  BITFIELD (Vex0F3A),
358 
  BITFIELD (Vex3Sources),
359 
  BITFIELD (VexImmExt),
360 
  BITFIELD (SSE2AVX),
361 
  BITFIELD (NoAVX),
362 
  BITFIELD (OldGcc),
363 
  BITFIELD (ATTMnemonic),
364 
  BITFIELD (ATTSyntax),
365 
  BITFIELD (IntelSyntax),
366 
};
367 
 
368 
static bitfield operand_types[] =
369 
{
370 
  BITFIELD (Reg8),
371 
  BITFIELD (Reg16),
372 
  BITFIELD (Reg32),
373 
  BITFIELD (Reg64),
374 
  BITFIELD (FloatReg),
375 
  BITFIELD (RegMMX),
376 
  BITFIELD (RegXMM),
377 
  BITFIELD (RegYMM),
378 
  BITFIELD (Imm8),
379 
  BITFIELD (Imm8S),
380 
  BITFIELD (Imm16),
381 
  BITFIELD (Imm32),
382 
  BITFIELD (Imm32S),
383 
  BITFIELD (Imm64),
384 
  BITFIELD (Imm1),
385 
  BITFIELD (BaseIndex),
386 
  BITFIELD (Disp8),
387 
  BITFIELD (Disp16),
388 
  BITFIELD (Disp32),
389 
  BITFIELD (Disp32S),
390 
  BITFIELD (Disp64),
391 
  BITFIELD (InOutPortReg),
392 
  BITFIELD (ShiftCount),
393 
  BITFIELD (Control),
394 
  BITFIELD (Debug),
395 
  BITFIELD (Test),
396 
  BITFIELD (SReg2),
397 
  BITFIELD (SReg3),
398 
  BITFIELD (Acc),
399 
  BITFIELD (FloatAcc),
400 
  BITFIELD (JumpAbsolute),
401 
  BITFIELD (EsSeg),
402 
  BITFIELD (RegMem),
403 
  BITFIELD (Mem),
404 
  BITFIELD (Byte),
405 
  BITFIELD (Word),
406 
  BITFIELD (Dword),
407 
  BITFIELD (Fword),
408 
  BITFIELD (Qword),
409 
  BITFIELD (Tbyte),
410 
  BITFIELD (Xmmword),
411 
  BITFIELD (Ymmword),
412 
  BITFIELD (Unspecified),
413 
  BITFIELD (Anysize),
414 
#ifdef OTUnused
415 
  BITFIELD (OTUnused),
416 
#endif
417 
};
418 
 
419 
static const char *filename;
420 
 
421 
static int
422 
compare (const void *x, const void *y)
423 
{
424 
  const bitfield *xp = (const bitfield *) x;
425 
  const bitfield *yp = (const bitfield *) y;
426 
  return xp->position - yp->position;
427 
}
428 
 
429 
static void
430 
fail (const char *message, ...)
431 
{
432 
  va_list args;
433 
 
434 
  va_start (args, message);
435 
  fprintf (stderr, _("%s: Error: "), program_name);
436 
  vfprintf (stderr, message, args);
437 
  va_end (args);
438 
  xexit (1);
439 
}
440 
 
441 
static void
442 
process_copyright (FILE *fp)
443 
{
444 
  fprintf (fp, "/* This file is automatically generated by i386-gen.  Do not edit!  */\n\
445 
/* Copyright 2007, 2008, 2009\n\
446 
   Free Software Foundation, Inc.\n\
447 
\n\
448 
   This file is part of the GNU opcodes library.\n\
449 
\n\
450 
   This library is free software; you can redistribute it and/or modify\n\
451 
   it under the terms of the GNU General Public License as published by\n\
452 
   the Free Software Foundation; either version 3, or (at your option)\n\
453 
   any later version.\n\
454 
\n\
455 
   It is distributed in the hope that it will be useful, but WITHOUT\n\
456 
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\n\
457 
   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public\n\
458 
   License for more details.\n\
459 
\n\
460 
   You should have received a copy of the GNU General Public License\n\
461 
   along with this program; if not, write to the Free Software\n\
462 
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,\n\
463 
   MA 02110-1301, USA.  */\n");
464 
}
465 
 
466 
/* Remove leading white spaces.  */
467 
 
468 
static char *
469 
remove_leading_whitespaces (char *str)
470 
{
471 
  while (ISSPACE (*str))
472 
    str++;
473 
  return str;
474 
}
475 
 
476 
/* Remove trailing white spaces.  */
477 
 
478 
static void
479 
remove_trailing_whitespaces (char *str)
480 
{
481 
  size_t last = strlen (str);
482 
 
483 
  if (last == 0)
484 
    return;
485 
 
486 
  do
487 
    {
488 
      last--;
489 
      if (ISSPACE (str [last]))
490 
        str[last] = '\0';
491 
      else
492 
        break;
493 
    }
494 
  while (last != 0);
495 
}
496 
 
497 
/* Find next field separated by SEP and terminate it. Return a
498 
   pointer to the one after it.  */
499 
 
500 
static char *
501 
next_field (char *str, char sep, char **next, char *last)
502 
{
503 
  char *p;
504 
 
505 
  p = remove_leading_whitespaces (str);
506 
  for (str = p; *str != sep && *str != '\0'; str++);
507 
 
508 
  *str = '\0';
509 
  remove_trailing_whitespaces (p);
510 
 
511 
  *next = str + 1;
512 
 
513 
  if (p >= last)
514 
    abort ();
515 
 
516 
  return p;
517 
}
518 
 
519 
static void
520 
set_bitfield (const char *f, bitfield *array, int value,
521 
              unsigned int size, int lineno)
522 
{
523 
  unsigned int i;
524 
 
525 
  if (strcmp (f, "CpuFP") == 0)
526 
    {
527 
      set_bitfield("Cpu387", array, value, size, lineno);
528 
      set_bitfield("Cpu287", array, value, size, lineno);
529 
      f = "Cpu8087";
530 
    }
531 
  else if (strcmp (f, "Mmword") == 0)
532 
    f= "Qword";
533 
  else if (strcmp (f, "Oword") == 0)
534 
    f= "Xmmword";
535 
 
536 
  for (i = 0; i < size; i++)
537 
    if (strcasecmp (array[i].name, f) == 0)
538 
      {
539 
        array[i].value = value;
540 
        return;
541 
      }
542 
 
543 
  if (lineno != -1)
544 
    fail (_("%s: %d: Unknown bitfield: %s\n"), filename, lineno, f);
545 
  else
546 
    fail (_("Unknown bitfield: %s\n"), f);
547 
}
548 
 
549 
static void
550 
output_cpu_flags (FILE *table, bitfield *flags, unsigned int size,
551 
                  int macro, const char *comma, const char *indent)
552 
{
553 
  unsigned int i;
554 
 
555 
  fprintf (table, "%s{ { ", indent);
556 
 
557 
  for (i = 0; i < size - 1; i++)
558 
    {
559 
      fprintf (table, "%d, ", flags[i].value);
560 
      if (((i + 1) % 20) == 0)
561 
        {
562 
          /* We need \\ for macro.  */
563 
          if (macro)
564 
            fprintf (table, " \\\n    %s", indent);
565 
          else
566 
            fprintf (table, "\n    %s", indent);
567 
        }
568 
    }
569 
 
570 
  fprintf (table, "%d } }%s\n", flags[i].value, comma);
571 
}
572 
 
573 
static void
574 
process_i386_cpu_flag (FILE *table, char *flag, int macro,
575 
                       const char *comma, const char *indent,
576 
                       int lineno)
577 
{
578 
  char *str, *next, *last;
579 
  unsigned int i;
580 
  bitfield flags [ARRAY_SIZE (cpu_flags)];
581 
 
582 
  /* Copy the default cpu flags.  */
583 
  memcpy (flags, cpu_flags, sizeof (cpu_flags));
584 
 
585 
  if (strcasecmp (flag, "unknown") == 0)
586 
    {
587 
      /* We turn on everything except for cpu64 in case of
588 
         CPU_UNKNOWN_FLAGS.  */
589 
      for (i = 0; i < ARRAY_SIZE (flags); i++)
590 
        if (flags[i].position != Cpu64)
591 
          flags[i].value = 1;
592 
    }
593 
  else if (flag[0] == '~')
594 
    {
595 
      last = flag + strlen (flag);
596 
 
597 
      if (flag[1] == '(')
598 
        {
599 
          last -= 1;
600 
          next = flag + 2;
601 
          if (*last != ')')
602 
            fail (_("%s: %d: Missing `)' in bitfield: %s\n"), filename,
603 
                  lineno, flag);
604 
          *last = '\0';
605 
        }
606 
      else
607 
        next = flag + 1;
608 
 
609 
      /* First we turn on everything except for cpu64.  */
610 
      for (i = 0; i < ARRAY_SIZE (flags); i++)
611 
        if (flags[i].position != Cpu64)
612 
          flags[i].value = 1;
613 
 
614 
      /* Turn off selective bits.  */
615 
      for (; next && next < last; )
616 
        {
617 
          str = next_field (next, '|', &next, last);
618 
          if (str)
619 
            set_bitfield (str, flags, 0, ARRAY_SIZE (flags), lineno);
620 
        }
621 
    }
622 
  else if (strcmp (flag, "0"))
623 
    {
624 
      /* Turn on selective bits.  */
625 
      last = flag + strlen (flag);
626 
      for (next = flag; next && next < last; )
627 
        {
628 
          str = next_field (next, '|', &next, last);
629 
          if (str)
630 
            set_bitfield (str, flags, 1, ARRAY_SIZE (flags), lineno);
631 
        }
632 
    }
633 
 
634 
  output_cpu_flags (table, flags, ARRAY_SIZE (flags), macro,
635 
                    comma, indent);
636 
}
637 
 
638 
static void
639 
output_opcode_modifier (FILE *table, bitfield *modifier, unsigned int size)
640 
{
641 
  unsigned int i;
642 
 
643 
  fprintf (table, "    { ");
644 
 
645 
  for (i = 0; i < size - 1; i++)
646 
    {
647 
      fprintf (table, "%d, ", modifier[i].value);
648 
      if (((i + 1) % 20) == 0)
649 
        fprintf (table, "\n      ");
650 
    }
651 
 
652 
  fprintf (table, "%d },\n", modifier[i].value);
653 
}
654 
 
655 
static void
656 
process_i386_opcode_modifier (FILE *table, char *mod, int lineno)
657 
{
658 
  char *str, *next, *last;
659 
  bitfield modifiers [ARRAY_SIZE (opcode_modifiers)];
660 
 
661 
  /* Copy the default opcode modifier.  */
662 
  memcpy (modifiers, opcode_modifiers, sizeof (modifiers));
663 
 
664 
  if (strcmp (mod, "0"))
665 
    {
666 
      last = mod + strlen (mod);
667 
      for (next = mod; next && next < last; )
668 
        {
669 
          str = next_field (next, '|', &next, last);
670 
          if (str)
671 
            set_bitfield (str, modifiers, 1, ARRAY_SIZE (modifiers),
672 
                          lineno);
673 
        }
674 
    }
675 
  output_opcode_modifier (table, modifiers, ARRAY_SIZE (modifiers));
676 
}
677 
 
678 
static void
679 
output_operand_type (FILE *table, bitfield *types, unsigned int size,
680 
                     int macro, const char *indent)
681 
{
682 
  unsigned int i;
683 
 
684 
  fprintf (table, "{ { ");
685 
 
686 
  for (i = 0; i < size - 1; i++)
687 
    {
688 
      fprintf (table, "%d, ", types[i].value);
689 
      if (((i + 1) % 20) == 0)
690 
        {
691 
          /* We need \\ for macro.  */
692 
          if (macro)
693 
            fprintf (table, "\\\n%s", indent);
694 
          else
695 
            fprintf (table, "\n%s", indent);
696 
        }
697 
    }
698 
 
699 
  fprintf (table, "%d } }", types[i].value);
700 
}
701 
 
702 
static void
703 
process_i386_operand_type (FILE *table, char *op, int macro,
704 
                           const char *indent, int lineno)
705 
{
706 
  char *str, *next, *last;
707 
  bitfield types [ARRAY_SIZE (operand_types)];
708 
 
709 
  /* Copy the default operand type.  */
710 
  memcpy (types, operand_types, sizeof (types));
711 
 
712 
  if (strcmp (op, "0"))
713 
    {
714 
      last = op + strlen (op);
715 
      for (next = op; next && next < last; )
716 
        {
717 
          str = next_field (next, '|', &next, last);
718 
          if (str)
719 
            set_bitfield (str, types, 1, ARRAY_SIZE (types), lineno);
720 
        }
721 
    }
722 
  output_operand_type (table, types, ARRAY_SIZE (types), macro,
723 
                       indent);
724 
}
725 
 
726 
static void
727 
output_i386_opcode (FILE *table, const char *name, char *str,
728 
                    char *last, int lineno)
729 
{
730 
  unsigned int i;
731 
  char *operands, *base_opcode, *extension_opcode, *opcode_length;
732 
  char *cpu_flags, *opcode_modifier, *operand_types [MAX_OPERANDS];
733 
 
734 
  /* Find number of operands.  */
735 
  operands = next_field (str, ',', &str, last);
736 
 
737 
  /* Find base_opcode.  */
738 
  base_opcode = next_field (str, ',', &str, last);
739 
 
740 
  /* Find extension_opcode.  */
741 
  extension_opcode = next_field (str, ',', &str, last);
742 
 
743 
  /* Find opcode_length.  */
744 
  opcode_length = next_field (str, ',', &str, last);
745 
 
746 
  /* Find cpu_flags.  */
747 
  cpu_flags = next_field (str, ',', &str, last);
748 
 
749 
  /* Find opcode_modifier.  */
750 
  opcode_modifier = next_field (str, ',', &str, last);
751 
 
752 
  /* Remove the first {.  */
753 
  str = remove_leading_whitespaces (str);
754 
  if (*str != '{')
755 
    abort ();
756 
  str = remove_leading_whitespaces (str + 1);
757 
 
758 
  i = strlen (str);
759 
 
760 
  /* There are at least "X}".  */
761 
  if (i < 2)
762 
    abort ();
763 
 
764 
  /* Remove trailing white spaces and }. */
765 
  do
766 
    {
767 
      i--;
768 
      if (ISSPACE (str[i]) || str[i] == '}')
769 
        str[i] = '\0';
770 
      else
771 
        break;
772 
    }
773 
  while (i != 0);
774 
 
775 
  last = str + i;
776 
 
777 
  /* Find operand_types.  */
778 
  for (i = 0; i < ARRAY_SIZE (operand_types); i++)
779 
    {
780 
      if (str >= last)
781 
        {
782 
          operand_types [i] = NULL;
783 
          break;
784 
        }
785 
 
786 
      operand_types [i] = next_field (str, ',', &str, last);
787 
      if (*operand_types[i] == '0')
788 
        {
789 
          if (i != 0)
790 
            operand_types[i] = NULL;
791 
          break;
792 
        }
793 
    }
794 
 
795 
  fprintf (table, "  { \"%s\", %s, %s, %s, %s,\n",
796 
           name, operands, base_opcode, extension_opcode,
797 
           opcode_length);
798 
 
799 
  process_i386_cpu_flag (table, cpu_flags, 0, ",", "    ", lineno);
800 
 
801 
  process_i386_opcode_modifier (table, opcode_modifier, lineno);
802 
 
803 
  fprintf (table, "    { ");
804 
 
805 
  for (i = 0; i < ARRAY_SIZE (operand_types); i++)
806 
    {
807 
      if (operand_types[i] == NULL || *operand_types[i] == '0')
808 
        {
809 
          if (i == 0)
810 
            process_i386_operand_type (table, "0", 0, "\t  ", lineno);
811 
          break;
812 
        }
813 
 
814 
      if (i != 0)
815 
        fprintf (table, ",\n      ");
816 
 
817 
      process_i386_operand_type (table, operand_types[i], 0,
818 
                                 "\t  ", lineno);
819 
    }
820 
  fprintf (table, " } },\n");
821 
}
822 
 
823 
struct opcode_hash_entry
824 
{
825 
  struct opcode_hash_entry *next;
826 
  char *name;
827 
  char *opcode;
828 
  int lineno;
829 
};
830 
 
831 
/* Calculate the hash value of an opcode hash entry P.  */
832 
 
833 
static hashval_t
834 
opcode_hash_hash (const void *p)
835 
{
836 
  struct opcode_hash_entry *entry = (struct opcode_hash_entry *) p;
837 
  return htab_hash_string (entry->name);
838 
}
839 
 
840 
/* Compare a string Q against an opcode hash entry P.  */
841 
 
842 
static int
843 
opcode_hash_eq (const void *p, const void *q)
844 
{
845 
  struct opcode_hash_entry *entry = (struct opcode_hash_entry *) p;
846 
  const char *name = (const char *) q;
847 
  return strcmp (name, entry->name) == 0;
848 
}
849 
 
850 
static void
851 
process_i386_opcodes (FILE *table)
852 
{
853 
  FILE *fp;
854 
  char buf[2048];
855 
  unsigned int i, j;
856 
  char *str, *p, *last, *name;
857 
  struct opcode_hash_entry **hash_slot, **entry, *next;
858 
  htab_t opcode_hash_table;
859 
  struct opcode_hash_entry **opcode_array;
860 
  unsigned int opcode_array_size = 1024;
861 
  int lineno = 0;
862 
 
863 
  filename = "i386-opc.tbl";
864 
  fp = fopen (filename, "r");
865 
 
866 
  if (fp == NULL)
867 
    fail (_("can't find i386-opc.tbl for reading, errno = %s\n"),
868 
          xstrerror (errno));
869 
 
870 
  i = 0;
871 
  opcode_array = (struct opcode_hash_entry **)
872 
    xmalloc (sizeof (*opcode_array) * opcode_array_size);
873 
 
874 
  opcode_hash_table = htab_create_alloc (16, opcode_hash_hash,
875 
                                         opcode_hash_eq, NULL,
876 
                                         xcalloc, free);
877 
 
878 
  fprintf (table, "\n/* i386 opcode table.  */\n\n");
879 
  fprintf (table, "const insn_template i386_optab[] =\n{\n");
880 
 
881 
  /* Put everything on opcode array.  */
882 
  while (!feof (fp))
883 
    {
884 
      if (fgets (buf, sizeof (buf), fp) == NULL)
885 
        break;
886 
 
887 
      lineno++;
888 
 
889 
      p = remove_leading_whitespaces (buf);
890 
 
891 
      /* Skip comments.  */
892 
      str = strstr (p, "//");
893 
      if (str != NULL)
894 
        str[0] = '\0';
895 
 
896 
      /* Remove trailing white spaces.  */
897 
      remove_trailing_whitespaces (p);
898 
 
899 
      switch (p[0])
900 
        {
901 
        case '#':
902 
          /* Ignore comments.  */
903 
        case '\0':
904 
          continue;
905 
          break;
906 
        default:
907 
          break;
908 
        }
909 
 
910 
      last = p + strlen (p);
911 
 
912 
      /* Find name.  */
913 
      name = next_field (p, ',', &str, last);
914 
 
915 
      /* Get the slot in hash table.  */
916 
      hash_slot = (struct opcode_hash_entry **)
917 
        htab_find_slot_with_hash (opcode_hash_table, name,
918 
                                  htab_hash_string (name),
919 
                                  INSERT);
920 
 
921 
      if (*hash_slot == NULL)
922 
        {
923 
          /* It is the new one.  Put it on opcode array.  */
924 
          if (i >= opcode_array_size)
925 
            {
926 
              /* Grow the opcode array when needed.  */
927 
              opcode_array_size += 1024;
928 
              opcode_array = (struct opcode_hash_entry **)
929 
                xrealloc (opcode_array,
930 
                          sizeof (*opcode_array) * opcode_array_size);
931 
            }
932 
 
933 
          opcode_array[i] = (struct opcode_hash_entry *)
934 
            xmalloc (sizeof (struct opcode_hash_entry));
935 
          opcode_array[i]->next = NULL;
936 
          opcode_array[i]->name = xstrdup (name);
937 
          opcode_array[i]->opcode = xstrdup (str);
938 
          opcode_array[i]->lineno = lineno;
939 
          *hash_slot = opcode_array[i];
940 
          i++;
941 
        }
942 
      else
943 
        {
944 
          /* Append it to the existing one.  */
945 
          entry = hash_slot;
946 
          while ((*entry) != NULL)
947 
            entry = &(*entry)->next;
948 
          *entry = (struct opcode_hash_entry *)
949 
            xmalloc (sizeof (struct opcode_hash_entry));
950 
          (*entry)->next = NULL;
951 
          (*entry)->name = (*hash_slot)->name;
952 
          (*entry)->opcode = xstrdup (str);
953 
          (*entry)->lineno = lineno;
954 
        }
955 
    }
956 
 
957 
  /* Process opcode array.  */
958 
  for (j = 0; j < i; j++)
959 
    {
960 
      for (next = opcode_array[j]; next; next = next->next)
961 
        {
962 
          name = next->name;
963 
          str = next->opcode;
964 
          lineno = next->lineno;
965 
          last = str + strlen (str);
966 
          output_i386_opcode (table, name, str, last, lineno);
967 
        }
968 
    }
969 
 
970 
  fclose (fp);
971 
 
972 
  fprintf (table, "  { NULL, 0, 0, 0, 0,\n");
973 
 
974 
  process_i386_cpu_flag (table, "0", 0, ",", "    ", -1);
975 
 
976 
  process_i386_opcode_modifier (table, "0", -1);
977 
 
978 
  fprintf (table, "    { ");
979 
  process_i386_operand_type (table, "0", 0, "\t  ", -1);
980 
  fprintf (table, " } }\n");
981 
 
982 
  fprintf (table, "};\n");
983 
}
984 
 
985 
static void
986 
process_i386_registers (FILE *table)
987 
{
988 
  FILE *fp;
989 
  char buf[2048];
990 
  char *str, *p, *last;
991 
  char *reg_name, *reg_type, *reg_flags, *reg_num;
992 
  char *dw2_32_num, *dw2_64_num;
993 
  int lineno = 0;
994 
 
995 
  filename = "i386-reg.tbl";
996 
  fp = fopen (filename, "r");
997 
  if (fp == NULL)
998 
    fail (_("can't find i386-reg.tbl for reading, errno = %s\n"),
999 
          xstrerror (errno));
1000 
 
1001 
  fprintf (table, "\n/* i386 register table.  */\n\n");
1002 
  fprintf (table, "const reg_entry i386_regtab[] =\n{\n");
1003 
 
1004 
  while (!feof (fp))
1005 
    {
1006 
      if (fgets (buf, sizeof (buf), fp) == NULL)
1007 
        break;
1008 
 
1009 
      lineno++;
1010 
 
1011 
      p = remove_leading_whitespaces (buf);
1012 
 
1013 
      /* Skip comments.  */
1014 
      str = strstr (p, "//");
1015 
      if (str != NULL)
1016 
        str[0] = '\0';
1017 
 
1018 
      /* Remove trailing white spaces.  */
1019 
      remove_trailing_whitespaces (p);
1020 
 
1021 
      switch (p[0])
1022 
        {
1023 
        case '#':
1024 
          fprintf (table, "%s\n", p);
1025 
        case '\0':
1026 
          continue;
1027 
          break;
1028 
        default:
1029 
          break;
1030 
        }
1031 
 
1032 
      last = p + strlen (p);
1033 
 
1034 
      /* Find reg_name.  */
1035 
      reg_name = next_field (p, ',', &str, last);
1036 
 
1037 
      /* Find reg_type.  */
1038 
      reg_type = next_field (str, ',', &str, last);
1039 
 
1040 
      /* Find reg_flags.  */
1041 
      reg_flags = next_field (str, ',', &str, last);
1042 
 
1043 
      /* Find reg_num.  */
1044 
      reg_num = next_field (str, ',', &str, last);
1045 
 
1046 
      fprintf (table, "  { \"%s\",\n    ", reg_name);
1047 
 
1048 
      process_i386_operand_type (table, reg_type, 0, "\t", lineno);
1049 
 
1050 
      /* Find 32-bit Dwarf2 register number.  */
1051 
      dw2_32_num = next_field (str, ',', &str, last);
1052 
 
1053 
      /* Find 64-bit Dwarf2 register number.  */
1054 
      dw2_64_num = next_field (str, ',', &str, last);
1055 
 
1056 
      fprintf (table, ",\n    %s, %s, { %s, %s } },\n",
1057 
               reg_flags, reg_num, dw2_32_num, dw2_64_num);
1058 
    }
1059 
 
1060 
  fclose (fp);
1061 
 
1062 
  fprintf (table, "};\n");
1063 
 
1064 
  fprintf (table, "\nconst unsigned int i386_regtab_size = ARRAY_SIZE (i386_regtab);\n");
1065 
}
1066 
 
1067 
static void
1068 
process_i386_initializers (void)
1069 
{
1070 
  unsigned int i;
1071 
  FILE *fp = fopen ("i386-init.h", "w");
1072 
  char *init;
1073 
 
1074 
  if (fp == NULL)
1075 
    fail (_("can't create i386-init.h, errno = %s\n"),
1076 
          xstrerror (errno));
1077 
 
1078 
  process_copyright (fp);
1079 
 
1080 
  for (i = 0; i < ARRAY_SIZE (cpu_flag_init); i++)
1081 
    {
1082 
      fprintf (fp, "\n#define %s \\\n", cpu_flag_init[i].name);
1083 
      init = xstrdup (cpu_flag_init[i].init);
1084 
      process_i386_cpu_flag (fp, init, 1, "", "  ", -1);
1085 
      free (init);
1086 
    }
1087 
 
1088 
  for (i = 0; i < ARRAY_SIZE (operand_type_init); i++)
1089 
    {
1090 
      fprintf (fp, "\n\n#define %s \\\n  ", operand_type_init[i].name);
1091 
      init = xstrdup (operand_type_init[i].init);
1092 
      process_i386_operand_type (fp, init, 1, "      ", -1);
1093 
      free (init);
1094 
    }
1095 
  fprintf (fp, "\n");
1096 
 
1097 
  fclose (fp);
1098 
}
1099 
 
1100 
/* Program options.  */
1101 
#define OPTION_SRCDIR   200
1102 
 
1103 
struct option long_options[] =
1104 
{
1105 
  {"srcdir",  required_argument, NULL, OPTION_SRCDIR},
1106 
  {"debug",   no_argument,       NULL, 'd'},
1107 
  {"version", no_argument,       NULL, 'V'},
1108 
  {"help",    no_argument,       NULL, 'h'},
1109 
  {0,         no_argument,       NULL, 0}
1110 
};
1111 
 
1112 
static void
1113 
print_version (void)
1114 
{
1115 
  printf ("%s: version 1.0\n", program_name);
1116 
  xexit (0);
1117 
}
1118 
 
1119 
static void
1120 
usage (FILE * stream, int status)
1121 
{
1122 
  fprintf (stream, "Usage: %s [-V | --version] [-d | --debug] [--srcdir=dirname] [--help]\n",
1123 
           program_name);
1124 
  xexit (status);
1125 
}
1126 
 
1127 
int
1128 
main (int argc, char **argv)
1129 
{
1130 
  extern int chdir (char *);
1131 
  char *srcdir = NULL;
1132 
  int c;
1133 
  FILE *table;
1134 
 
1135 
  program_name = *argv;
1136 
  xmalloc_set_program_name (program_name);
1137 
 
1138 
  while ((c = getopt_long (argc, argv, "vVdh", long_options, 0)) != EOF)
1139 
    switch (c)
1140 
      {
1141 
      case OPTION_SRCDIR:
1142 
        srcdir = optarg;
1143 
        break;
1144 
      case 'V':
1145 
      case 'v':
1146 
        print_version ();
1147 
        break;
1148 
      case 'd':
1149 
        debug = 1;
1150 
        break;
1151 
      case 'h':
1152 
      case '?':
1153 
        usage (stderr, 0);
1154 
      default:
1155 
      case 0:
1156 
        break;
1157 
      }
1158 
 
1159 
  if (optind != argc)
1160 
    usage (stdout, 1);
1161 
 
1162 
  if (srcdir != NULL)
1163 
    if (chdir (srcdir) != 0)
1164 
      fail (_("unable to change directory to \"%s\", errno = %s\n"),
1165 
            srcdir, xstrerror (errno));
1166 
 
1167 
  /* Check the unused bitfield in i386_cpu_flags.  */
1168 
#ifndef CpuUnused
1169 
  c = CpuNumOfBits - CpuMax - 1;
1170 
  if (c)
1171 
    fail (_("%d unused bits in i386_cpu_flags.\n"), c);
1172 
#endif
1173 
 
1174 
  /* Check the unused bitfield in i386_operand_type.  */
1175 
#ifndef OTUnused
1176 
  c = OTNumOfBits - OTMax - 1;
1177 
  if (c)
1178 
    fail (_("%d unused bits in i386_operand_type.\n"), c);
1179 
#endif
1180 
 
1181 
  qsort (cpu_flags, ARRAY_SIZE (cpu_flags), sizeof (cpu_flags [0]),
1182 
         compare);
1183 
 
1184 
  qsort (opcode_modifiers, ARRAY_SIZE (opcode_modifiers),
1185 
         sizeof (opcode_modifiers [0]), compare);
1186 
 
1187 
  qsort (operand_types, ARRAY_SIZE (operand_types),
1188 
         sizeof (operand_types [0]), compare);
1189 
 
1190 
  table = fopen ("i386-tbl.h", "w");
1191 
  if (table == NULL)
1192 
    fail (_("can't create i386-tbl.h, errno = %s\n"),
1193 
          xstrerror (errno));
1194 
 
1195 
  process_copyright (table);
1196 
 
1197 
  process_i386_opcodes (table);
1198 
  process_i386_registers (table);
1199 
  process_i386_initializers ();
1200 
 
1201 
  fclose (table);
1202 
 
1203 
  exit (0);
1204 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.