1 %{
2 /* Parser for i386 CPU description.
3 Copyright (C) 2004, 2005, 2007, 2008, 2009 Red Hat, Inc.
4 Written by Ulrich Drepper <drepper@redhat.com>, 2004.
5
6 Red Hat elfutils is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by the
8 Free Software Foundation; version 2 of the License.
9
10 Red Hat elfutils is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 General Public License for more details.
14
15 You should have received a copy of the GNU General Public License along
16 with Red Hat elfutils; if not, write to the Free Software Foundation,
17 Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA.
18
19 Red Hat elfutils is an included package of the Open Invention Network.
20 An included package of the Open Invention Network is a package for which
21 Open Invention Network licensees cross-license their patents. No patent
22 license is granted, either expressly or impliedly, by designation as an
23 included package. Should you wish to participate in the Open Invention
24 Network licensing program, please visit www.openinventionnetwork.com
25 <http://www.openinventionnetwork.com>. */
26
27 #ifdef HAVE_CONFIG_H
28 # include <config.h>
29 #endif
30
31 #include <assert.h>
32 #include <ctype.h>
33 #include <errno.h>
34 #include <error.h>
35 #include <inttypes.h>
36 #include <libintl.h>
37 #include <math.h>
38 #include <obstack.h>
39 #include <search.h>
40 #include <stdbool.h>
41 #include <stdio.h>
42 #include <stdlib.h>
43 #include <string.h>
44 #include <sys/param.h>
45
46 #include <system.h>
47
48 #define obstack_chunk_alloc xmalloc
49 #define obstack_chunk_free free
50
51 /* The error handler. */
52 static void yyerror (const char *s);
53
54 extern int yylex (void);
55 extern int i386_lineno;
56 extern char *infname;
57
58
59 struct known_bitfield
60 {
61 char *name;
62 unsigned long int bits;
63 int tmp;
64 };
65
66
67 struct bitvalue
68 {
69 enum bittype { zeroone, field, failure } type;
70 union
71 {
72 unsigned int value;
73 struct known_bitfield *field;
74 };
75 struct bitvalue *next;
76 };
77
78
79 struct argname
80 {
81 enum nametype { string, nfield } type;
82 union
83 {
84 char *str;
85 struct known_bitfield *field;
86 };
87 struct argname *next;
88 };
89
90
91 struct argument
92 {
93 struct argname *name;
94 struct argument *next;
95 };
96
97
98 struct instruction
99 {
100 /* The byte encoding. */
101 struct bitvalue *bytes;
102
103 /* Prefix possible. */
104 int repe;
105 int rep;
106
107 /* Mnemonic. */
108 char *mnemonic;
109
110 /* Suffix. */
111 enum { suffix_none = 0, suffix_w, suffix_w0, suffix_W, suffix_tttn,
112 suffix_w1, suffix_W1, suffix_D } suffix;
113
114 /* Flag set if modr/m is used. */
115 int modrm;
116
117 /* Operands. */
118 struct operand
119 {
120 char *fct;
121 char *str;
122 int off1;
123 int off2;
124 int off3;
125 } operands[3];
126
127 struct instruction *next;
128 };
129
130
131 struct synonym
132 {
133 char *from;
134 char *to;
135 };
136
137
138 struct suffix
139 {
140 char *name;
141 int idx;
142 };
143
144
145 struct argstring
146 {
147 char *str;
148 int idx;
149 int off;
150 };
151
152
153 static struct known_bitfield ax_reg =
154 {
155 .name = "ax", .bits = 0, .tmp = 0
156 };
157
158 static struct known_bitfield dx_reg =
159 {
160 .name = "dx", .bits = 0, .tmp = 0
161 };
162
163 static struct known_bitfield di_reg =
164 {
165 .name = "es_di", .bits = 0, .tmp = 0
166 };
167
168 static struct known_bitfield si_reg =
169 {
170 .name = "ds_si", .bits = 0, .tmp = 0
171 };
172
173 static struct known_bitfield bx_reg =
174 {
175 .name = "ds_bx", .bits = 0, .tmp = 0
176 };
177
178
179 static int bitfield_compare (const void *p1, const void *p2);
180 static void new_bitfield (char *name, unsigned long int num);
181 static void check_bits (struct bitvalue *value);
182 static int check_duplicates (struct bitvalue *val);
183 static int check_argsdef (struct bitvalue *bitval, struct argument *args);
184 static int check_bitsused (struct bitvalue *bitval,
185 struct known_bitfield *suffix,
186 struct argument *args);
187 static struct argname *combine (struct argname *name);
188 static void fillin_arg (struct bitvalue *bytes, struct argname *name,
189 struct instruction *instr, int n);
190 static void find_numbers (void);
191 static int compare_syn (const void *p1, const void *p2);
192 static int compare_suf (const void *p1, const void *p2);
193 static void instrtable_out (void);
194 #if 0
195 static void create_mnemonic_table (void);
196 #endif
197
198 static void *bitfields;
199 static struct instruction *instructions;
200 static size_t ninstructions;
201 static void *synonyms;
202 static void *suffixes;
203 static int nsuffixes;
204 static void *mnemonics;
205 size_t nmnemonics;
206 extern FILE *outfile;
207
208 /* Number of bits used mnemonics. */
209 #if 0
210 static size_t best_mnemonic_bits;
211 #endif
212 %}
213
214 %union {
215 unsigned long int num;
216 char *str;
217 char ch;
218 struct known_bitfield *field;
219 struct bitvalue *bit;
220 struct argname *name;
221 struct argument *arg;
222 }
223
224 %token kMASK
225 %token kPREFIX
226 %token kSUFFIX
227 %token kSYNONYM
228 %token <str> kID
229 %token <num> kNUMBER
230 %token kPERCPERC
231 %token <str> kBITFIELD
232 %token <ch> kCHAR
233 %token kSPACE
234
235 %type <bit> bit byte bytes
236 %type <field> bitfieldopt
237 %type <name> argcomp arg
238 %type <arg> args optargs
239
240 %defines
241
242 %%
243
244 spec: masks kPERCPERC '\n' instrs
245 {
246 if (error_message_count != 0)
247 error (EXIT_FAILURE, 0,
248 "terminated due to previous error");
249
250 instrtable_out ();
251 }
252 ;
253
254 masks: masks '\n' mask
255 | mask
256 ;
257
258 mask: kMASK kBITFIELD kNUMBER
259 { new_bitfield ($2, $3); }
260 | kPREFIX kBITFIELD
261 { new_bitfield ($2, -1); }
262 | kSUFFIX kBITFIELD
263 { new_bitfield ($2, -2); }
264 | kSYNONYM kBITFIELD kBITFIELD
265 {
266 struct synonym *newp = xmalloc (sizeof (*newp));
267 newp->from = $2;
268 newp->to = $3;
269 if (tfind (newp, &synonyms, compare_syn) != NULL)
270 error (0, 0,
271 "%d: duplicate definition for synonym '%s'",
272 i386_lineno, $2);
273 else if (tsearch ( newp, &synonyms, compare_syn) == NULL)
274 error (EXIT_FAILURE, 0, "tsearch");
275 }
276 |
277 ;
278
279 instrs: instrs '\n' instr
280 | instr
281 ;
282
283 instr: bytes ':' bitfieldopt kID bitfieldopt optargs
284 {
285 if ($3 != NULL && strcmp ($3->name, "RE") != 0
286 && strcmp ($3->name, "R") != 0)
287 {
288 error (0, 0, "%d: only 'R' and 'RE' prefix allowed",
289 i386_lineno - 1);
290 }
291 if (check_duplicates ($1) == 0
292 && check_argsdef ($1, $6) == 0
293 && check_bitsused ($1, $5, $6) == 0)
294 {
295 struct instruction *newp = xcalloc (sizeof (*newp),
296 1);
297 if ($3 != NULL)
298 {
299 if (strcmp ($3->name, "RE") == 0)
300 newp->repe = 1;
301 else if (strcmp ($3->name, "R") == 0)
302 newp->rep = 1;
303 }
304
305 newp->bytes = $1;
306 newp->mnemonic = $4;
307 if (newp->mnemonic != (void *) -1l
308 && tfind ($4, &mnemonics,
309 (comparison_fn_t) strcmp) == NULL)
310 {
311 if (tsearch ($4, &mnemonics,
312 (comparison_fn_t) strcmp) == NULL)
313 error (EXIT_FAILURE, errno, "tsearch");
314 ++nmnemonics;
315 }
316
317 if ($5 != NULL)
318 {
319 if (strcmp ($5->name, "w") == 0)
320 newp->suffix = suffix_w;
321 else if (strcmp ($5->name, "w0") == 0)
322 newp->suffix = suffix_w0;
323 else if (strcmp ($5->name, "tttn") == 0)
324 newp->suffix = suffix_tttn;
325 else if (strcmp ($5->name, "w1") == 0)
326 newp->suffix = suffix_w1;
327 else if (strcmp ($5->name, "W") == 0)
328 newp->suffix = suffix_W;
329 else if (strcmp ($5->name, "W1") == 0)
330 newp->suffix = suffix_W1;
331 else if (strcmp ($5->name, "D") == 0)
332 newp->suffix = suffix_D;
333 else
334 error (EXIT_FAILURE, 0,
335 "%s: %d: unknown suffix '%s'",
336 infname, i386_lineno - 1, $5->name);
337
338 struct suffix search = { .name = $5->name };
339 if (tfind (&search, &suffixes, compare_suf)
340 == NULL)
341 {
342 struct suffix *ns = xmalloc (sizeof (*ns));
343 ns->name = $5->name;
344 ns->idx = ++nsuffixes;
345 if (tsearch (ns, &suffixes, compare_suf)
346 == NULL)
347 error (EXIT_FAILURE, errno, "tsearch");
348 }
349 }
350
351 struct argument *args = $6;
352 int n = 0;
353 while (args != NULL)
354 {
355 fillin_arg ($1, args->name, newp, n);
356
357 args = args->next;
358 ++n;
359 }
360
361 newp->next = instructions;
362 instructions = newp;
363 ++ninstructions;
364 }
365 }
366 |
367 ;
368
369 bitfieldopt: kBITFIELD
370 {
371 struct known_bitfield search;
372 search.name = $1;
373 struct known_bitfield **res;
374 res = tfind (&search, &bitfields, bitfield_compare);
375 if (res == NULL)
376 {
377 error (0, 0, "%d: unknown bitfield '%s'",
378 i386_lineno, search.name);
379 $$ = NULL;
380 }
381 else
382 $$ = *res;
383 }
384 |
385 { $$ = NULL; }
386 ;
387
388 bytes: bytes ',' byte
389 {
390 check_bits ($3);
391
392 struct bitvalue *runp = $1;
393 while (runp->next != NULL)
394 runp = runp->next;
395 runp->next = $3;
396 $$ = $1;
397 }
398 | byte
399 {
400 check_bits ($1);
401 $$ = $1;
402 }
403 ;
404
405 byte: byte bit
406 {
407 struct bitvalue *runp = $1;
408 while (runp->next != NULL)
409 runp = runp->next;
410 runp->next = $2;
411 $$ = $1;
412 }
413 | bit
414 { $$ = $1; }
415 ;
416
417 bit: '0'
418 {
419 $$ = xmalloc (sizeof (struct bitvalue));
420 $$->type = zeroone;
421 $$->value = 0;
422 $$->next = NULL;
423 }
424 | '1'
425 {
426 $$ = xmalloc (sizeof (struct bitvalue));
427 $$->type = zeroone;
428 $$->value = 1;
429 $$->next = NULL;
430 }
431 | kBITFIELD
432 {
433 $$ = xmalloc (sizeof (struct bitvalue));
434 struct known_bitfield search;
435 search.name = $1;
436 struct known_bitfield **res;
437 res = tfind (&search, &bitfields, bitfield_compare);
438 if (res == NULL)
439 {
440 error (0, 0, "%d: unknown bitfield '%s'",
441 i386_lineno, search.name);
442 $$->type = failure;
443 }
444 else
445 {
446 $$->type = field;
447 $$->field = *res;
448 }
449 $$->next = NULL;
450 }
451 ;
452
453 optargs: kSPACE args
454 { $$ = $2; }
455 |
456 { $$ = NULL; }
457 ;
458
459 args: args ',' arg
460 {
461 struct argument *runp = $1;
462 while (runp->next != NULL)
463 runp = runp->next;
464 runp->next = xmalloc (sizeof (struct argument));
465 runp->next->name = combine ($3);
466 runp->next->next = NULL;
467 $$ = $1;
468 }
469 | arg
470 {
471 $$ = xmalloc (sizeof (struct argument));
472 $$->name = combine ($1);
473 $$->next = NULL;
474 }
475 ;
476
477 arg: arg argcomp
478 {
479 struct argname *runp = $1;
480 while (runp->next != NULL)
481 runp = runp->next;
482 runp->next = $2;
483 $$ = $1;
484 }
485 | argcomp
486 { $$ = $1; }
487 ;
488 argcomp: kBITFIELD
489 {
490 $$ = xmalloc (sizeof (struct argname));
491 $$->type = nfield;
492 $$->next = NULL;
493
494 struct known_bitfield search;
495 search.name = $1;
496 struct known_bitfield **res;
497 res = tfind (&search, &bitfields, bitfield_compare);
498 if (res == NULL)
499 {
500 if (strcmp ($1, "ax") == 0)
501 $$->field = &ax_reg;
502 else if (strcmp ($1, "dx") == 0)
503 $$->field = &dx_reg;
504 else if (strcmp ($1, "es_di") == 0)
505 $$->field = &di_reg;
506 else if (strcmp ($1, "ds_si") == 0)
507 $$->field = &si_reg;
508 else if (strcmp ($1, "ds_bx") == 0)
509 $$->field = &bx_reg;
510 else
511 {
512 error (0, 0, "%d: unknown bitfield '%s'",
513 i386_lineno, search.name);
514 $$->field = NULL;
515 }
516 }
517 else
518 $$->field = *res;
519 }
520 | kCHAR
521 {
522 $$ = xmalloc (sizeof (struct argname));
523 $$->type = string;
524 $$->next = NULL;
525 $$->str = xmalloc (2);
526 $$->str[0] = $1;
527 $$->str[1] = '\0';
528 }
529 | kID
530 {
531 $$ = xmalloc (sizeof (struct argname));
532 $$->type = string;
533 $$->next = NULL;
534 $$->str = $1;
535 }
536 | ':'
537 {
538 $$ = xmalloc (sizeof (struct argname));
539 $$->type = string;
540 $$->next = NULL;
541 $$->str = xmalloc (2);
542 $$->str[0] = ':';
543 $$->str[1] = '\0';
544 }
545 ;
546
547 %%
548
549 static void
550 yyerror (const char *s)
551 {
552 error (0, 0, gettext ("while reading i386 CPU description: %s at line %d"),
553 gettext (s), i386_lineno);
554 }
555
556
557 static int
bitfield_compare(const void * p1,const void * p2)558 bitfield_compare (const void *p1, const void *p2)
559 {
560 struct known_bitfield *f1 = (struct known_bitfield *) p1;
561 struct known_bitfield *f2 = (struct known_bitfield *) p2;
562
563 return strcmp (f1->name, f2->name);
564 }
565
566
567 static void
new_bitfield(char * name,unsigned long int num)568 new_bitfield (char *name, unsigned long int num)
569 {
570 struct known_bitfield *newp = xmalloc (sizeof (struct known_bitfield));
571 newp->name = name;
572 newp->bits = num;
573 newp->tmp = 0;
574
575 if (tfind (newp, &bitfields, bitfield_compare) != NULL)
576 {
577 error (0, 0, "%d: duplicated definition of bitfield '%s'",
578 i386_lineno, name);
579 free (name);
580 return;
581 }
582
583 if (tsearch (newp, &bitfields, bitfield_compare) == NULL)
584 error (EXIT_FAILURE, errno, "%d: cannot insert new bitfield '%s'",
585 i386_lineno, name);
586 }
587
588
589 /* Check that the number of bits is a multiple of 8. */
590 static void
check_bits(struct bitvalue * val)591 check_bits (struct bitvalue *val)
592 {
593 struct bitvalue *runp = val;
594 unsigned int total = 0;
595
596 while (runp != NULL)
597 {
598 if (runp->type == zeroone)
599 ++total;
600 else if (runp->field == NULL)
601 /* No sense doing anything, the field is not known. */
602 return;
603 else
604 total += runp->field->bits;
605
606 runp = runp->next;
607 }
608
609 if (total % 8 != 0)
610 {
611 struct obstack os;
612 obstack_init (&os);
613
614 while (val != NULL)
615 {
616 if (val->type == zeroone)
617 obstack_printf (&os, "%u", val->value);
618 else
619 obstack_printf (&os, "{%s}", val->field->name);
620 val = val->next;
621 }
622 obstack_1grow (&os, '\0');
623
624 error (0, 0, "%d: field '%s' not a multiple of 8 bits in size",
625 i386_lineno, (char *) obstack_finish (&os));
626
627 obstack_free (&os, NULL);
628 }
629 }
630
631
632 static int
check_duplicates(struct bitvalue * val)633 check_duplicates (struct bitvalue *val)
634 {
635 static int testcnt;
636 ++testcnt;
637
638 int result = 0;
639 while (val != NULL)
640 {
641 if (val->type == field && val->field != NULL)
642 {
643 if (val->field->tmp == testcnt)
644 {
645 error (0, 0, "%d: bitfield '%s' used more than once",
646 i386_lineno - 1, val->field->name);
647 result = 1;
648 }
649 val->field->tmp = testcnt;
650 }
651
652 val = val->next;
653 }
654
655 return result;
656 }
657
658
659 static int
check_argsdef(struct bitvalue * bitval,struct argument * args)660 check_argsdef (struct bitvalue *bitval, struct argument *args)
661 {
662 int result = 0;
663
664 while (args != NULL)
665 {
666 for (struct argname *name = args->name; name != NULL; name = name->next)
667 if (name->type == nfield && name->field != NULL
668 && name->field != &ax_reg && name->field != &dx_reg
669 && name->field != &di_reg && name->field != &si_reg
670 && name->field != &bx_reg)
671 {
672 struct bitvalue *runp = bitval;
673
674 while (runp != NULL)
675 if (runp->type == field && runp->field == name->field)
676 break;
677 else
678 runp = runp->next;
679
680 if (runp == NULL)
681 {
682 error (0, 0, "%d: unknown bitfield '%s' used in output format",
683 i386_lineno - 1, name->field->name);
684 result = 1;
685 }
686 }
687
688 args = args->next;
689 }
690
691 return result;
692 }
693
694
695 static int
check_bitsused(struct bitvalue * bitval,struct known_bitfield * suffix,struct argument * args)696 check_bitsused (struct bitvalue *bitval, struct known_bitfield *suffix,
697 struct argument *args)
698 {
699 int result = 0;
700
701 while (bitval != NULL)
702 {
703 if (bitval->type == field && bitval->field != NULL
704 && bitval->field != suffix
705 /* {w} is handled special. */
706 && strcmp (bitval->field->name, "w") != 0)
707 {
708 struct argument *runp;
709 for (runp = args; runp != NULL; runp = runp->next)
710 {
711 struct argname *name = runp->name;
712
713 while (name != NULL)
714 if (name->type == nfield && name->field == bitval->field)
715 break;
716 else
717 name = name->next;
718
719 if (name != NULL)
720 break;
721 }
722
723 #if 0
724 if (runp == NULL)
725 {
726 error (0, 0, "%d: bitfield '%s' not used",
727 i386_lineno - 1, bitval->field->name);
728 result = 1;
729 }
730 #endif
731 }
732
733 bitval = bitval->next;
734 }
735
736 return result;
737 }
738
739
740 static struct argname *
combine(struct argname * name)741 combine (struct argname *name)
742 {
743 struct argname *last_str = NULL;
744 for (struct argname *runp = name; runp != NULL; runp = runp->next)
745 {
746 if (runp->type == string)
747 {
748 if (last_str == NULL)
749 last_str = runp;
750 else
751 {
752 last_str->str = xrealloc (last_str->str,
753 strlen (last_str->str)
754 + strlen (runp->str) + 1);
755 strcat (last_str->str, runp->str);
756 last_str->next = runp->next;
757 }
758 }
759 else
760 last_str = NULL;
761 }
762 return name;
763 }
764
765
766 #define obstack_grow_str(ob, str) obstack_grow (ob, str, strlen (str))
767
768
769 static void
fillin_arg(struct bitvalue * bytes,struct argname * name,struct instruction * instr,int n)770 fillin_arg (struct bitvalue *bytes, struct argname *name,
771 struct instruction *instr, int n)
772 {
773 static struct obstack ob;
774 static int initialized;
775 if (! initialized)
776 {
777 initialized = 1;
778 obstack_init (&ob);
779 }
780
781 struct argname *runp = name;
782 int cnt = 0;
783 while (runp != NULL)
784 {
785 /* We ignore strings in the function name. */
786 if (runp->type == string)
787 {
788 if (instr->operands[n].str != NULL)
789 error (EXIT_FAILURE, 0,
790 "%d: cannot have more than one string parameter",
791 i386_lineno - 1);
792
793 instr->operands[n].str = runp->str;
794 }
795 else
796 {
797 assert (runp->type == nfield);
798
799 /* Construct the function name. */
800 if (cnt++ > 0)
801 obstack_1grow (&ob, '$');
802
803 if (runp->field == NULL)
804 /* Add some string which contains invalid characters. */
805 obstack_grow_str (&ob, "!!!INVALID!!!");
806 else
807 {
808 char *fieldname = runp->field->name;
809
810 struct synonym search = { .from = fieldname };
811
812 struct synonym **res = tfind (&search, &synonyms, compare_syn);
813 if (res != NULL)
814 fieldname = (*res)->to;
815
816 obstack_grow_str (&ob, fieldname);
817 }
818
819 /* Now compute the bit offset of the field. */
820 struct bitvalue *b = bytes;
821 int bitoff = 0;
822 if (runp->field != NULL)
823 while (b != NULL)
824 {
825 if (b->type == field && b->field != NULL)
826 {
827 if (strcmp (b->field->name, runp->field->name) == 0)
828 break;
829 bitoff += b->field->bits;
830 }
831 else
832 ++bitoff;
833
834 b = b->next;
835 }
836 if (instr->operands[n].off1 == 0)
837 instr->operands[n].off1 = bitoff;
838 else if (instr->operands[n].off2 == 0)
839 instr->operands[n].off2 = bitoff;
840 else if (instr->operands[n].off3 == 0)
841 instr->operands[n].off3 = bitoff;
842 else
843 error (EXIT_FAILURE, 0,
844 "%d: cannot have more than three fields in parameter",
845 i386_lineno - 1);
846
847 if (runp->field != NULL
848 && strncasecmp (runp->field->name, "mod", 3) == 0)
849 instr->modrm = 1;
850 }
851
852 runp = runp->next;
853 }
854 if (obstack_object_size (&ob) == 0)
855 obstack_grow_str (&ob, "string");
856 obstack_1grow (&ob, '\0');
857 char *fct = obstack_finish (&ob);
858
859 instr->operands[n].fct = fct;
860 }
861
862
863 #if 0
864 static void
865 nameout (const void *nodep, VISIT value, int level)
866 {
867 if (value == leaf || value == postorder)
868 printf (" %s\n", *(const char **) nodep);
869 }
870 #endif
871
872
873 static int
compare_argstring(const void * p1,const void * p2)874 compare_argstring (const void *p1, const void *p2)
875 {
876 const struct argstring *a1 = (const struct argstring *) p1;
877 const struct argstring *a2 = (const struct argstring *) p2;
878
879 return strcmp (a1->str, a2->str);
880 }
881
882
883 static int maxoff[3][3];
884 static int minoff[3][3] = { { 1000, 1000, 1000 },
885 { 1000, 1000, 1000 },
886 { 1000, 1000, 1000 } };
887 static int nbitoff[3][3];
888 static void *fct_names[3];
889 static int nbitfct[3];
890 static int nbitsuf;
891 static void *strs[3];
892 static int nbitstr[3];
893 static int total_bits = 2; // Already counted the rep/repe bits.
894
895 static void
find_numbers(void)896 find_numbers (void)
897 {
898 int nfct_names[3] = { 0, 0, 0 };
899 int nstrs[3] = { 0, 0, 0 };
900
901 /* We reverse the order of the instruction list while processing it.
902 Later phases need it in the order in which the input file has
903 them. */
904 struct instruction *reversed = NULL;
905
906 struct instruction *runp = instructions;
907 while (runp != NULL)
908 {
909 for (int i = 0; i < 3; ++i)
910 if (runp->operands[i].fct != NULL)
911 {
912 struct argstring search = { .str = runp->operands[i].fct };
913 if (tfind (&search, &fct_names[i], compare_argstring) == NULL)
914 {
915 struct argstring *newp = xmalloc (sizeof (*newp));
916 newp->str = runp->operands[i].fct;
917 newp->idx = 0;
918 if (tsearch (newp, &fct_names[i], compare_argstring) == NULL)
919 error (EXIT_FAILURE, errno, "tsearch");
920 ++nfct_names[i];
921 }
922
923 if (runp->operands[i].str != NULL)
924 {
925 search.str = runp->operands[i].str;
926 if (tfind (&search, &strs[i], compare_argstring) == NULL)
927 {
928 struct argstring *newp = xmalloc (sizeof (*newp));
929 newp->str = runp->operands[i].str;
930 newp->idx = 0;
931 if (tsearch (newp, &strs[i], compare_argstring) == NULL)
932 error (EXIT_FAILURE, errno, "tsearch");
933 ++nstrs[i];
934 }
935 }
936
937 maxoff[i][0] = MAX (maxoff[i][0], runp->operands[i].off1);
938 maxoff[i][1] = MAX (maxoff[i][1], runp->operands[i].off2);
939 maxoff[i][2] = MAX (maxoff[i][2], runp->operands[i].off3);
940
941 if (runp->operands[i].off1 > 0)
942 minoff[i][0] = MIN (minoff[i][0], runp->operands[i].off1);
943 if (runp->operands[i].off2 > 0)
944 minoff[i][1] = MIN (minoff[i][1], runp->operands[i].off2);
945 if (runp->operands[i].off3 > 0)
946 minoff[i][2] = MIN (minoff[i][2], runp->operands[i].off3);
947 }
948
949 struct instruction *old = runp;
950 runp = runp->next;
951
952 old->next = reversed;
953 reversed = old;
954 }
955 instructions = reversed;
956
957 int d;
958 int c;
959 for (int i = 0; i < 3; ++i)
960 {
961 // printf ("min1 = %d, min2 = %d, min3 = %d\n", minoff[i][0], minoff[i][1], minoff[i][2]);
962 // printf ("max1 = %d, max2 = %d, max3 = %d\n", maxoff[i][0], maxoff[i][1], maxoff[i][2]);
963
964 if (minoff[i][0] == 1000)
965 nbitoff[i][0] = 0;
966 else
967 {
968 nbitoff[i][0] = 1;
969 d = maxoff[i][0] - minoff[i][0];
970 c = 1;
971 while (c < d)
972 {
973 ++nbitoff[i][0];
974 c *= 2;
975 }
976 total_bits += nbitoff[i][0];
977 }
978
979 if (minoff[i][1] == 1000)
980 nbitoff[i][1] = 0;
981 else
982 {
983 nbitoff[i][1] = 1;
984 d = maxoff[i][1] - minoff[i][1];
985 c = 1;
986 while (c < d)
987 {
988 ++nbitoff[i][1];
989 c *= 2;
990 }
991 total_bits += nbitoff[i][1];
992 }
993
994 if (minoff[i][2] == 1000)
995 nbitoff[i][2] = 0;
996 else
997 {
998 nbitoff[i][2] = 1;
999 d = maxoff[i][2] - minoff[i][2];
1000 c = 1;
1001 while (c < d)
1002 {
1003 ++nbitoff[i][2];
1004 c *= 2;
1005 }
1006 total_bits += nbitoff[i][2];
1007 }
1008 // printf ("off1 = %d, off2 = %d, off3 = %d\n", nbitoff[i][0], nbitoff[i][1], nbitoff[i][2]);
1009
1010 nbitfct[i] = 1;
1011 d = nfct_names[i];
1012 c = 1;
1013 while (c < d)
1014 {
1015 ++nbitfct[i];
1016 c *= 2;
1017 }
1018 total_bits += nbitfct[i];
1019 // printf ("%d fct[%d], %d bits\n", nfct_names[i], i, nbitfct[i]);
1020
1021 if (nstrs[i] != 0)
1022 {
1023 nbitstr[i] = 1;
1024 d = nstrs[i];
1025 c = 1;
1026 while (c < d)
1027 {
1028 ++nbitstr[i];
1029 c *= 2;
1030 }
1031 total_bits += nbitstr[i];
1032 }
1033
1034 // twalk (fct_names[i], nameout);
1035 }
1036
1037 nbitsuf = 0;
1038 d = nsuffixes;
1039 c = 1;
1040 while (c < d)
1041 {
1042 ++nbitsuf;
1043 c *= 2;
1044 }
1045 total_bits += nbitsuf;
1046 // printf ("%d suffixes, %d bits\n", nsuffixes, nbitsuf);
1047 }
1048
1049
1050 static int
compare_syn(const void * p1,const void * p2)1051 compare_syn (const void *p1, const void *p2)
1052 {
1053 const struct synonym *s1 = (const struct synonym *) p1;
1054 const struct synonym *s2 = (const struct synonym *) p2;
1055
1056 return strcmp (s1->from, s2->from);
1057 }
1058
1059
1060 static int
compare_suf(const void * p1,const void * p2)1061 compare_suf (const void *p1, const void *p2)
1062 {
1063 const struct suffix *s1 = (const struct suffix *) p1;
1064 const struct suffix *s2 = (const struct suffix *) p2;
1065
1066 return strcmp (s1->name, s2->name);
1067 }
1068
1069
1070 static int count_op_str;
1071 static int off_op_str;
1072 static void
print_op_str(const void * nodep,VISIT value,int level)1073 print_op_str (const void *nodep, VISIT value,
1074 int level __attribute__ ((unused)))
1075 {
1076 if (value == leaf || value == postorder)
1077 {
1078 const char *str = (*(struct argstring **) nodep)->str;
1079 fprintf (outfile, "%s\n \"%s",
1080 count_op_str == 0 ? "" : "\\0\"", str);
1081 (*(struct argstring **) nodep)->idx = ++count_op_str;
1082 (*(struct argstring **) nodep)->off = off_op_str;
1083 off_op_str += strlen (str) + 1;
1084 }
1085 }
1086
1087
1088 static void
print_op_str_idx(const void * nodep,VISIT value,int level)1089 print_op_str_idx (const void *nodep, VISIT value,
1090 int level __attribute__ ((unused)))
1091 {
1092 if (value == leaf || value == postorder)
1093 printf (" %d,\n", (*(struct argstring **) nodep)->off);
1094 }
1095
1096
1097 static void
print_op_fct(const void * nodep,VISIT value,int level)1098 print_op_fct (const void *nodep, VISIT value,
1099 int level __attribute__ ((unused)))
1100 {
1101 if (value == leaf || value == postorder)
1102 {
1103 fprintf (outfile, " FCT_%s,\n", (*(struct argstring **) nodep)->str);
1104 (*(struct argstring **) nodep)->idx = ++count_op_str;
1105 }
1106 }
1107
1108
1109 #if NMNES < 2
1110 # error "bogus NMNES value"
1111 #endif
1112
1113 static void
instrtable_out(void)1114 instrtable_out (void)
1115 {
1116 find_numbers ();
1117
1118 #if 0
1119 create_mnemonic_table ();
1120
1121 fprintf (outfile, "#define MNEMONIC_BITS %zu\n", best_mnemonic_bits);
1122 #else
1123 fprintf (outfile, "#define MNEMONIC_BITS %ld\n",
1124 lrint (ceil (log2 (NMNES))));
1125 #endif
1126 fprintf (outfile, "#define SUFFIX_BITS %d\n", nbitsuf);
1127 for (int i = 0; i < 3; ++i)
1128 {
1129 fprintf (outfile, "#define FCT%d_BITS %d\n", i + 1, nbitfct[i]);
1130 if (nbitstr[i] != 0)
1131 fprintf (outfile, "#define STR%d_BITS %d\n", i + 1, nbitstr[i]);
1132 fprintf (outfile, "#define OFF%d_1_BITS %d\n", i + 1, nbitoff[i][0]);
1133 fprintf (outfile, "#define OFF%d_1_BIAS %d\n", i + 1, minoff[i][0]);
1134 if (nbitoff[i][1] != 0)
1135 {
1136 fprintf (outfile, "#define OFF%d_2_BITS %d\n", i + 1, nbitoff[i][1]);
1137 fprintf (outfile, "#define OFF%d_2_BIAS %d\n", i + 1, minoff[i][1]);
1138 }
1139 if (nbitoff[i][2] != 0)
1140 {
1141 fprintf (outfile, "#define OFF%d_3_BITS %d\n", i + 1, nbitoff[i][2]);
1142 fprintf (outfile, "#define OFF%d_3_BIAS %d\n", i + 1, minoff[i][2]);
1143 }
1144 }
1145
1146 fputs ("\n#include <i386_data.h>\n\n", outfile);
1147
1148
1149 #define APPEND(a, b) APPEND_ (a, b)
1150 #define APPEND_(a, b) a##b
1151 #define EMIT_SUFFIX(suf) \
1152 fprintf (outfile, "#define suffix_%s %d\n", #suf, APPEND (suffix_, suf))
1153 EMIT_SUFFIX (none);
1154 EMIT_SUFFIX (w);
1155 EMIT_SUFFIX (w0);
1156 EMIT_SUFFIX (W);
1157 EMIT_SUFFIX (tttn);
1158 EMIT_SUFFIX (D);
1159 EMIT_SUFFIX (w1);
1160 EMIT_SUFFIX (W1);
1161
1162 fputc_unlocked ('\n', outfile);
1163
1164 for (int i = 0; i < 3; ++i)
1165 {
1166 /* Functions. */
1167 count_op_str = 0;
1168 fprintf (outfile, "static const opfct_t op%d_fct[] =\n{\n NULL,\n",
1169 i + 1);
1170 twalk (fct_names[i], print_op_fct);
1171 fputs ("};\n", outfile);
1172
1173 /* The operand strings. */
1174 if (nbitstr[i] != 0)
1175 {
1176 count_op_str = 0;
1177 off_op_str = 0;
1178 fprintf (outfile, "static const char op%d_str[] =", i + 1);
1179 twalk (strs[i], print_op_str);
1180 fputs ("\";\n", outfile);
1181
1182 fprintf (outfile, "static const uint8_t op%d_str_idx[] = {\n",
1183 i + 1);
1184 twalk (strs[i], print_op_str_idx);
1185 fputs ("};\n", outfile);
1186 }
1187 }
1188
1189
1190 fputs ("static const struct instr_enc instrtab[] =\n{\n", outfile);
1191 struct instruction *instr;
1192 for (instr = instructions; instr != NULL; instr = instr->next)
1193 {
1194 fputs (" {", outfile);
1195 if (instr->mnemonic == (void *) -1l)
1196 fputs (" .mnemonic = MNE_INVALID,", outfile);
1197 else
1198 fprintf (outfile, " .mnemonic = MNE_%s,", instr->mnemonic);
1199 fprintf (outfile, " .rep = %d,", instr->rep);
1200 fprintf (outfile, " .repe = %d,", instr->repe);
1201 fprintf (outfile, " .suffix = %d,", instr->suffix);
1202 fprintf (outfile, " .modrm = %d,", instr->modrm);
1203
1204 for (int i = 0; i < 3; ++i)
1205 {
1206 int idx = 0;
1207 if (instr->operands[i].fct != NULL)
1208 {
1209 struct argstring search = { .str = instr->operands[i].fct };
1210 struct argstring **res = tfind (&search, &fct_names[i],
1211 compare_argstring);
1212 assert (res != NULL);
1213 idx = (*res)->idx;
1214 }
1215 fprintf (outfile, " .fct%d = %d,", i + 1, idx);
1216
1217 idx = 0;
1218 if (instr->operands[i].str != NULL)
1219 {
1220 struct argstring search = { .str = instr->operands[i].str };
1221 struct argstring **res = tfind (&search, &strs[i],
1222 compare_argstring);
1223 assert (res != NULL);
1224 idx = (*res)->idx;
1225 }
1226 if (nbitstr[i] != 0)
1227 fprintf (outfile, " .str%d = %d,", i + 1, idx);
1228
1229 fprintf (outfile, " .off%d_1 = %d,", i + 1,
1230 MAX (0, instr->operands[i].off1 - minoff[i][0]));
1231
1232 if (nbitoff[i][1] != 0)
1233 fprintf (outfile, " .off%d_2 = %d,", i + 1,
1234 MAX (0, instr->operands[i].off2 - minoff[i][1]));
1235
1236 if (nbitoff[i][2] != 0)
1237 fprintf (outfile, " .off%d_3 = %d,", i + 1,
1238 MAX (0, instr->operands[i].off3 - minoff[i][2]));
1239 }
1240
1241 fputs (" },\n", outfile);
1242 }
1243 fputs ("};\n", outfile);
1244
1245 fputs ("static const uint8_t match_data[] =\n{\n", outfile);
1246 size_t cnt = 0;
1247 for (instr = instructions; instr != NULL; instr = instr->next, ++cnt)
1248 {
1249 /* First count the number of bytes. */
1250 size_t totalbits = 0;
1251 size_t zerobits = 0;
1252 bool leading_p = true;
1253 size_t leadingbits = 0;
1254 struct bitvalue *b = instr->bytes;
1255 while (b != NULL)
1256 {
1257 if (b->type == zeroone)
1258 {
1259 ++totalbits;
1260 zerobits = 0;
1261 if (leading_p)
1262 ++leadingbits;
1263 }
1264 else
1265 {
1266 totalbits += b->field->bits;
1267 /* We must always count the mod/rm byte. */
1268 if (strncasecmp (b->field->name, "mod", 3) == 0)
1269 zerobits = 0;
1270 else
1271 zerobits += b->field->bits;
1272 leading_p = false;
1273 }
1274 b = b->next;
1275 }
1276 size_t nbytes = (totalbits - zerobits + 7) / 8;
1277 assert (nbytes > 0);
1278 size_t leadingbytes = leadingbits / 8;
1279
1280 fprintf (outfile, " %#zx,", nbytes | (leadingbytes << 4));
1281
1282 /* Now create the mask and byte values. */
1283 uint8_t byte = 0;
1284 uint8_t mask = 0;
1285 int nbits = 0;
1286 b = instr->bytes;
1287 while (b != NULL)
1288 {
1289 if (b->type == zeroone)
1290 {
1291 byte = (byte << 1) | b->value;
1292 mask = (mask << 1) | 1;
1293 if (++nbits == 8)
1294 {
1295 if (leadingbytes > 0)
1296 {
1297 assert (mask == 0xff);
1298 fprintf (outfile, " %#" PRIx8 ",", byte);
1299 --leadingbytes;
1300 }
1301 else
1302 fprintf (outfile, " %#" PRIx8 ", %#" PRIx8 ",",
1303 mask, byte);
1304 byte = mask = nbits = 0;
1305 if (--nbytes == 0)
1306 break;
1307 }
1308 }
1309 else
1310 {
1311 assert (leadingbytes == 0);
1312
1313 unsigned long int remaining = b->field->bits;
1314 while (nbits + remaining > 8)
1315 {
1316 fprintf (outfile, " %#" PRIx8 ", %#" PRIx8 ",",
1317 mask << (8 - nbits), byte << (8 - nbits));
1318 remaining = nbits + remaining - 8;
1319 byte = mask = nbits = 0;
1320 if (--nbytes == 0)
1321 break;
1322 }
1323 byte <<= remaining;
1324 mask <<= remaining;
1325 nbits += remaining;
1326 if (nbits == 8)
1327 {
1328 fprintf (outfile, " %#" PRIx8 ", %#" PRIx8 ",", mask, byte);
1329 byte = mask = nbits = 0;
1330 if (--nbytes == 0)
1331 break;
1332 }
1333 }
1334 b = b->next;
1335 }
1336
1337 fputc_unlocked ('\n', outfile);
1338 }
1339 fputs ("};\n", outfile);
1340 }
1341
1342
1343 #if 0
1344 static size_t mnemonic_maxlen;
1345 static size_t mnemonic_minlen;
1346 static size_t
1347 which_chars (const char *str[], size_t nstr)
1348 {
1349 char used_char[256];
1350 memset (used_char, '\0', sizeof (used_char));
1351 mnemonic_maxlen = 0;
1352 mnemonic_minlen = 10000;
1353 for (size_t cnt = 0; cnt < nstr; ++cnt)
1354 {
1355 const unsigned char *cp = (const unsigned char *) str[cnt];
1356 mnemonic_maxlen = MAX (mnemonic_maxlen, strlen ((char *) cp));
1357 mnemonic_minlen = MIN (mnemonic_minlen, strlen ((char *) cp));
1358 do
1359 used_char[*cp++] = 1;
1360 while (*cp != '\0');
1361 }
1362 size_t nused_char = 0;
1363 for (size_t cnt = 0; cnt < 256; ++cnt)
1364 if (used_char[cnt] != 0)
1365 ++nused_char;
1366 return nused_char;
1367 }
1368
1369
1370 static const char **mnemonic_strs;
1371 static size_t nmnemonic_strs;
1372 static void
1373 add_mnemonics (const void *nodep, VISIT value,
1374 int level __attribute__ ((unused)))
1375 {
1376 if (value == leaf || value == postorder)
1377 mnemonic_strs[nmnemonic_strs++] = *(const char **) nodep;
1378 }
1379
1380
1381 struct charfreq
1382 {
1383 char ch;
1384 int freq;
1385 };
1386 static struct charfreq pfxfreq[256];
1387 static struct charfreq sfxfreq[256];
1388
1389
1390 static int
1391 compare_freq (const void *p1, const void *p2)
1392 {
1393 const struct charfreq *c1 = (const struct charfreq *) p1;
1394 const struct charfreq *c2 = (const struct charfreq *) p2;
1395
1396 if (c1->freq > c2->freq)
1397 return -1;
1398 if (c1->freq < c2->freq)
1399 return 1;
1400 return 0;
1401 }
1402
1403
1404 static size_t
1405 compute_pfxfreq (const char *str[], size_t nstr)
1406 {
1407 memset (pfxfreq, '\0', sizeof (pfxfreq));
1408
1409 for (size_t i = 0; i < nstr; ++i)
1410 pfxfreq[i].ch = i;
1411
1412 for (size_t i = 0; i < nstr; ++i)
1413 ++pfxfreq[*((const unsigned char *) str[i])].freq;
1414
1415 qsort (pfxfreq, 256, sizeof (struct charfreq), compare_freq);
1416
1417 size_t n = 0;
1418 while (n < 256 && pfxfreq[n].freq != 0)
1419 ++n;
1420 return n;
1421 }
1422
1423
1424 struct strsnlen
1425 {
1426 const char *str;
1427 size_t len;
1428 };
1429
1430 static size_t
1431 compute_sfxfreq (size_t nstr, struct strsnlen *strsnlen)
1432 {
1433 memset (sfxfreq, '\0', sizeof (sfxfreq));
1434
1435 for (size_t i = 0; i < nstr; ++i)
1436 sfxfreq[i].ch = i;
1437
1438 for (size_t i = 0; i < nstr; ++i)
1439 ++sfxfreq[((const unsigned char *) strchrnul (strsnlen[i].str, '\0'))[-1]].freq;
1440
1441 qsort (sfxfreq, 256, sizeof (struct charfreq), compare_freq);
1442
1443 size_t n = 0;
1444 while (n < 256 && sfxfreq[n].freq != 0)
1445 ++n;
1446 return n;
1447 }
1448
1449
1450 static void
1451 create_mnemonic_table (void)
1452 {
1453 mnemonic_strs = xmalloc (nmnemonics * sizeof (char *));
1454
1455 twalk (mnemonics, add_mnemonics);
1456
1457 (void) which_chars (mnemonic_strs, nmnemonic_strs);
1458
1459 size_t best_so_far = 100000000;
1460 char *best_prefix = NULL;
1461 char *best_suffix = NULL;
1462 char *best_table = NULL;
1463 size_t best_table_size = 0;
1464 size_t best_table_bits = 0;
1465 size_t best_prefix_bits = 0;
1466
1467 /* We can precompute the prefix characters. */
1468 size_t npfx_char = compute_pfxfreq (mnemonic_strs, nmnemonic_strs);
1469
1470 /* Compute best size for string representation including explicit NUL. */
1471 for (size_t pfxbits = 0; (1u << pfxbits) < 2 * npfx_char; ++pfxbits)
1472 {
1473 char prefix[1 << pfxbits];
1474 size_t i;
1475 for (i = 0; i < (1u << pfxbits) - 1; ++i)
1476 prefix[i] = pfxfreq[i].ch;
1477 prefix[i] = '\0';
1478
1479 struct strsnlen strsnlen[nmnemonic_strs];
1480
1481 for (i = 0; i < nmnemonic_strs; ++i)
1482 {
1483 if (strchr (prefix, *mnemonic_strs[i]) != NULL)
1484 strsnlen[i].str = mnemonic_strs[i] + 1;
1485 else
1486 strsnlen[i].str = mnemonic_strs[i];
1487 strsnlen[i].len = strlen (strsnlen[i].str);
1488 }
1489
1490 /* With the prefixes gone, try to combine strings. */
1491 size_t nstrsnlen = 1;
1492 for (i = 1; i < nmnemonic_strs; ++i)
1493 {
1494 size_t j;
1495 for (j = 0; j < nstrsnlen; ++j)
1496 if (strsnlen[i].len > strsnlen[j].len
1497 && strcmp (strsnlen[j].str,
1498 strsnlen[i].str + (strsnlen[i].len
1499 - strsnlen[j].len)) == 0)
1500 {
1501 strsnlen[j] = strsnlen[i];
1502 break;
1503 }
1504 else if (strsnlen[i].len < strsnlen[j].len
1505 && strcmp (strsnlen[i].str,
1506 strsnlen[j].str + (strsnlen[j].len
1507 - strsnlen[i].len)) == 0)
1508 break;
1509 ;
1510 if (j == nstrsnlen)
1511 strsnlen[nstrsnlen++] = strsnlen[i];
1512 }
1513
1514 size_t nsfx_char = compute_sfxfreq (nstrsnlen, strsnlen);
1515
1516 for (size_t sfxbits = 0; (1u << sfxbits) < 2 * nsfx_char; ++sfxbits)
1517 {
1518 char suffix[1 << sfxbits];
1519
1520 for (i = 0; i < (1u << sfxbits) - 1; ++i)
1521 suffix[i] = sfxfreq[i].ch;
1522 suffix[i] = '\0';
1523
1524 size_t newlen[nstrsnlen];
1525
1526 for (i = 0; i < nstrsnlen; ++i)
1527 if (strchr (suffix, strsnlen[i].str[strsnlen[i].len - 1]) != NULL)
1528 newlen[i] = strsnlen[i].len - 1;
1529 else
1530 newlen[i] = strsnlen[i].len;
1531
1532 char charused[256];
1533 memset (charused, '\0', sizeof (charused));
1534 size_t ncharused = 0;
1535
1536 const char *tablestr[nstrsnlen];
1537 size_t ntablestr = 1;
1538 tablestr[0] = strsnlen[0].str;
1539 size_t table = newlen[0] + 1;
1540 for (i = 1; i < nstrsnlen; ++i)
1541 {
1542 size_t j;
1543 for (j = 0; j < ntablestr; ++j)
1544 if (newlen[i] > newlen[j]
1545 && memcmp (tablestr[j],
1546 strsnlen[i].str + (newlen[i] - newlen[j]),
1547 newlen[j]) == 0)
1548 {
1549 table += newlen[i] - newlen[j];
1550 tablestr[j] = strsnlen[i].str;
1551 newlen[j] = newlen[i];
1552 break;
1553 }
1554 else if (newlen[i] < newlen[j]
1555 && memcmp (strsnlen[i].str,
1556 tablestr[j] + (newlen[j] - newlen[i]),
1557 newlen[i]) == 0)
1558 break;
1559
1560 if (j == ntablestr)
1561 {
1562 table += newlen[i] + 1;
1563 tablestr[ntablestr] = strsnlen[i].str;
1564 newlen[ntablestr] = newlen[i];
1565
1566 ++ntablestr;
1567 }
1568
1569 for (size_t x = 0; x < newlen[j]; ++x)
1570 if (charused[((const unsigned char *) tablestr[j])[x]]++ == 0)
1571 ++ncharused;
1572 }
1573
1574 size_t ncharused_bits = 0;
1575 i = 1;
1576 while (i < ncharused)
1577 {
1578 i *= 2;
1579 ++ncharused_bits;
1580 }
1581
1582 size_t table_bits = 0;
1583 i = 1;
1584 while (i < table)
1585 {
1586 i *= 2;
1587 ++table_bits;
1588 }
1589
1590 size_t mnemonic_bits = table_bits + pfxbits + sfxbits;
1591 size_t new_total = (((table + 7) / 8) * ncharused_bits + ncharused
1592 + (pfxbits == 0 ? 0 : (1 << pfxbits) - 1)
1593 + (sfxbits == 0 ? 0 : (1 << sfxbits) - 1)
1594 + (((total_bits + mnemonic_bits + 7) / 8)
1595 * ninstructions));
1596
1597 if (new_total < best_so_far)
1598 {
1599 best_so_far = new_total;
1600 best_mnemonic_bits = mnemonic_bits;
1601
1602 free (best_suffix);
1603 best_suffix = xstrdup (suffix);
1604
1605 free (best_prefix);
1606 best_prefix = xstrdup (prefix);
1607 best_prefix_bits = pfxbits;
1608
1609 best_table_size = table;
1610 best_table_bits = table_bits;
1611 char *cp = best_table = xrealloc (best_table, table);
1612 for (i = 0; i < ntablestr; ++i)
1613 {
1614 assert (cp + newlen[i] + 1 <= best_table + table);
1615 cp = mempcpy (cp, tablestr[i], newlen[i]);
1616 *cp++ = '\0';
1617 }
1618 assert (cp == best_table + table);
1619 }
1620 }
1621 }
1622
1623 fputs ("static const char mnemonic_table[] =\n\"", outfile);
1624 for (size_t i = 0; i < best_table_size; ++i)
1625 {
1626 if (((i + 1) % 60) == 0)
1627 fputs ("\"\n\"", outfile);
1628 if (!isascii (best_table[i]) || !isprint (best_table[i]))
1629 fprintf (outfile, "\\%03o", best_table[i]);
1630 else
1631 fputc (best_table[i], outfile);
1632 }
1633 fputs ("\";\n", outfile);
1634
1635 if (best_prefix[0] != '\0')
1636 fprintf (outfile,
1637 "static const char prefix[%zu] = \"%s\";\n"
1638 "#define PREFIXCHAR_BITS %zu\n",
1639 strlen (best_prefix), best_prefix, best_prefix_bits);
1640 else
1641 fputs ("#define NO_PREFIX\n", outfile);
1642
1643 if (best_suffix[0] != '\0')
1644 fprintf (outfile, "static const char suffix[%zu] = \"%s\";\n",
1645 strlen (best_suffix), best_suffix);
1646 else
1647 fputs ("#define NO_SUFFIX\n", outfile);
1648
1649 for (size_t i = 0; i < nmnemonic_strs; ++i)
1650 {
1651 const char *mne = mnemonic_strs[i];
1652
1653 size_t pfxval = 0;
1654 char *cp = strchr (best_prefix, *mne);
1655 if (cp != NULL)
1656 {
1657 pfxval = 1 + (cp - best_prefix);
1658 ++mne;
1659 }
1660
1661 size_t l = strlen (mne);
1662
1663 size_t sfxval = 0;
1664 cp = strchr (best_suffix, mne[l - 1]);
1665 if (cp != NULL)
1666 {
1667 sfxval = 1 + (cp - best_suffix);
1668 --l;
1669 }
1670
1671 char *off = memmem (best_table, best_table_size, mne, l);
1672 while (off[l] != '\0')
1673 {
1674 off = memmem (off + 1, best_table_size, mne, l);
1675 assert (off != NULL);
1676 }
1677
1678 fprintf (outfile, "#define MNE_%s %#zx\n",
1679 mnemonic_strs[i],
1680 (off - best_table)
1681 + ((pfxval + (sfxval << best_prefix_bits)) << best_table_bits));
1682 }
1683 }
1684 #endif
1685