This commit was generated by cvs2svn to track changes on a CVS vendor
[external/binutils.git] / sim / igen / ld-insn.h
1 /*  This file is part of the program psim.
2
3     Copyright (C) 1994-1998 Andrew Cagney <cagney@highland.com.au>
4
5     This program is free software; you can redistribute it and/or modify
6     it under the terms of the GNU General Public License as published by
7     the Free Software Foundation; either version 2 of the License, or
8     (at your option) any later version.
9
10     This program is distributed in the hope that it will be useful,
11     but WITHOUT ANY WARRANTY; without even the implied warranty of
12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13     GNU General Public License for more details.
14  
15     You should have received a copy of the GNU General Public License
16     along with this program; if not, write to the Free Software
17     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18  
19     */
20
21
22
23 typedef unsigned64 insn_uint;
24
25
26 /* Common among most entries:
27
28    All non instruction records have the format:
29
30    <...> ::=
31        ":" <record-name>
32        ":" <filter-flags>
33        ":" <filter-models>
34        ":" ...
35    
36  */
37
38 enum {
39   record_type_field = 1,
40   old_record_type_field = 2,
41   record_filter_flags_field = 2,
42   record_filter_models_field = 3,
43 };
44
45
46 /* Include:
47
48    Include the specified file.
49
50    <include> ::=
51        ":" "include"
52        ":" <filter-flags>
53        ":" <filter-models>
54        ":" <filename>
55        <nl>
56        ;
57
58    */
59
60 enum {
61   include_filename_field = 4,
62   nr_include_fields,
63 };
64
65
66
67 /* Options:
68
69    Valid options are: hi-bit-nr (default 0), insn-bit-size (default
70    32), insn-specifying-widths (default true), multi-sim (default false).
71
72    <option> ::=
73        ":" "option"
74        ":" <filter-flags>
75        ":" <filter-models>
76        ":" <option-name>
77        ":" <option-value>
78        <nl>
79        ;
80
81    <option-name> ::=
82        "insn-bit-size"
83        | "insn-specifying-widths"
84        | "hi-bit-nr"
85        | "flags-filter"
86        | "model-filter"
87        | "multi-sim"
88        | "format-names"
89        ;
90
91    <option-value> ::=
92        "true"
93        | "false"
94        | <integer>
95        | <list>
96        ;
97
98
99    These update the global options structure. */       
100
101
102 enum {
103   option_name_field = 4,
104   option_value_field,
105   nr_option_fields,
106 };
107
108
109
110 /* Macro definitions:
111
112    <insn-macro> ::=
113        <expression>
114        ":" ( "define" | "undef" )
115        ":" <filter-flags>
116        ":" <filter-models>
117        ":" <name>
118        <nl>
119        ;
120
121    Macro define/undef is currently unimplemented. */
122
123
124 /* Functions and internal routins:
125
126    NB: <filter-models> and <function-models> are the equivalent.
127
128
129    <function> ::=
130        ":" "function"
131        <function-spec>
132        ;
133
134    <internal> ::=
135        ":" "internal"
136        <function-spec>
137        ;
138
139    <format> ::=
140        ":" ( "%s" | ... )
141        <function-spec>
142        ;
143
144    <function-model> ::=
145        "*" [ <processor-list> ]
146        ":"
147        <nl>
148        ;
149
150    <function-spec> ::=
151        ":" <filter-flags>
152        ":" <filter-models>
153        ":" <typedef>
154        ":" <name>
155        [ ":" <parameter-list> ]
156        <nl>
157        [ <function-model> ]
158        <code-block>
159        ;
160
161    */
162
163 enum {
164   function_typedef_field = 4,
165   function_name_field,
166   function_param_field,
167   nr_function_fields,
168 };
169
170 enum {
171   function_model_name_field = 0,
172   nr_function_model_fields = 1,
173 };
174
175 enum {
176   old_function_typedef_field = 0,
177   old_function_type_field = 2,
178   old_function_name_field = 4,
179   old_function_param_field = 5,
180   nr_old_function_fields = 5, /* parameter-list is optional */
181 };
182
183
184 typedef struct _function_entry function_entry;
185 struct _function_entry {
186   line_ref *line;
187   filter *flags;
188   filter *models;
189   char *type;
190   char *name;
191   char *param;
192   table_entry *code;
193   int is_internal;
194   function_entry *next;
195 };
196
197
198 typedef void function_entry_handler
199 (lf *file,
200  function_entry *function,
201  void *data);
202
203 extern void function_entry_traverse
204 (lf *file,
205  function_entry *functions,
206  function_entry_handler *handler,
207  void *data);
208
209
210 /* cache-macro:
211
212    <cache-macro> ::=
213        ":" <macro-type>
214        ":" <filter-flags>
215        ":" <filter-models>
216        ":" <typedef>
217        ":" <name>
218        ":" <field-name> { "," <field-name> }
219        ":" <expression>
220        <nl>
221        ;
222
223    <cache-macro-type> ::=
224        "scratch"
225        | "cache"
226        | "compute"
227        ;
228
229    <name> ::=
230        <ident>
231        | <ident> "_is_" <integer>
232        ;
233
234    A cache entry is defined (for an instruction) when all
235    <field-name>s are present as named opcode fields within the
236    instructions format.
237
238    SCRATCH and CACHE macros are defined during the cache fill stage
239    while CACHE and COMPUTE macros are defined during the instruction
240    execution stage.
241
242    */
243
244 enum {
245   cache_typedef_field = 4,
246   cache_name_field,
247   cache_original_fields_field,
248   cache_expression_field,
249   nr_cache_fields,
250 };
251
252 typedef enum {
253   scratch_value,
254   cache_value,
255   compute_value,
256 } cache_entry_type;
257
258 typedef struct _cache_entry cache_entry;
259 struct _cache_entry {
260   line_ref *line;
261   filter *flags;
262   filter *models;
263   cache_entry_type entry_type;
264   char *name;
265   filter *original_fields;
266   char *type;
267   char *expression;
268   cache_entry *next;
269 };
270
271
272
273 /* Model specs:
274
275    <model-processor> ::=
276        ":" "model"
277        ":" <filter-flags>
278        ":" <filter-models>
279        ":" <processor>
280        ":" <BFD-processor>
281        ":" <function-unit-data>
282        <nl>
283        ;
284
285    <model-macro> ::=
286        ":" "model-macro"
287        ":" <filter-flags>
288        ":" <filter-models>
289        <nl>
290        <code-block>
291        ;
292
293    <model-data> ::=
294        ":" "model-data"
295        ":" <filter-flags>
296        ":" <filter-models>
297        <nl>
298        <code-block>
299        ;
300
301    <model-static> ::=
302        ":" "model-static"
303        <function-spec>
304        ;
305
306    <model-internal> ::=
307        ":" "model-internal"
308        <function-spec>
309        ;
310
311    <model-function> ::=
312        ":" "model-internal"
313        <function-spec>
314        ;
315
316  */
317
318 enum {
319   nr_model_macro_fields = 4,
320   nr_model_data_fields = 4,
321   nr_model_static_fields = nr_function_fields,
322   nr_model_internal_fields = nr_function_fields,
323   nr_model_function_fields = nr_function_fields,
324 };
325
326 typedef struct _model_data model_data;
327 struct _model_data {
328   line_ref *line;
329   filter *flags;
330   table_entry *entry;
331   table_entry *code;
332   model_data *next;
333 };
334
335 enum {
336   model_name_field = 4,
337   model_full_name_field,
338   model_unit_data_field,
339   nr_model_processor_fields,
340 };
341
342 typedef struct _model_entry model_entry;
343 struct _model_entry {
344   line_ref *line;
345   filter *flags;
346   char *name;
347   char *full_name;
348   char *unit_data;
349   model_entry *next;
350 };
351
352
353 typedef struct _model_table model_table;
354 struct _model_table {
355   filter *processors;
356   int nr_models;
357   model_entry *models;
358   model_data *macros;
359   model_data *data;
360   function_entry *statics;
361   function_entry *internals;
362   function_entry *functions;
363 };
364
365
366
367 /* Instruction format:
368
369    An instruction is composed of a sequence of N bit instruction
370    words.  Each word broken into a number of instruction fields.
371    Those fields being constant (ex. an opcode) or variable (register
372    spec).
373
374    <insn-word> ::=
375        <insn-field> { "," <insn-field> } ;
376
377    <insn-word> ::=
378        ( <binary-value-implying-width>
379        | <field-name-implying-width>
380        | [ <start-or-width> "." ] <field> 
381        )
382        { "!" <excluded-value> }
383        ;
384
385    <field> ::=
386          { "*" }+
387        | { "/" }+
388        | <field-name>
389        | "0x" <hex-value>
390        | "0b" <binary-value>
391        | "0" <octal-value>
392        | <integer-value> ;
393
394 */
395
396 typedef struct _insn_field_exclusion insn_field_exclusion;
397 struct _insn_field_exclusion {
398   char *string;
399   insn_uint value;
400   insn_field_exclusion *next;
401 };
402
403 typedef enum {
404   insn_field_int,
405   insn_field_reserved,
406   insn_field_wild,
407   insn_field_string,
408 } insn_field_type;
409
410 typedef struct _insn_field_entry insn_field_entry;
411 struct _insn_field_entry {
412   int first;
413   int last;
414   int width;
415   int word_nr;
416   insn_field_type type;
417   insn_uint val_int;
418   char *pos_string;
419   char *val_string;
420   insn_field_exclusion *exclusions;
421   insn_field_entry *next;
422   insn_field_entry *prev;
423 };
424
425 typedef struct _insn_bit_entry insn_bit_entry;
426 struct _insn_bit_entry {
427   int value;
428   int mask;
429   insn_field_entry *field;
430 };
431
432
433
434
435 typedef struct _insn_entry insn_entry; /* forward */
436
437 typedef struct _insn_word_entry insn_word_entry;
438 struct _insn_word_entry {
439   /* list of sub-fields making up the instruction.  bit provides
440      faster access to the field data for bit N.  */
441   insn_field_entry *first;
442   insn_field_entry *last;
443   insn_bit_entry *bit[max_insn_bit_size];
444   /* set of all the string fields */
445   filter *field_names;
446   /* For multi-word instructions, The Nth word (from zero). */
447   insn_word_entry *next;
448 };
449
450
451
452 /* Instruction model:
453
454    Provides scheduling and other data for the code modeling the
455    instruction unit.
456
457    <insn-model> ::=
458        "*" [ <processor-list> ]
459        ":" [ <function-unit-data> ]
460        <nl>
461        ;
462
463    <processor-list> ::=
464        <processor> { "," <processor>" }
465        ;
466
467    If the <processor-list> is empty, the model is made the default for
468    this instruction.
469
470    */
471
472 enum {
473   insn_model_name_field = 0,
474   insn_model_unit_data_field = 1,
475   nr_insn_model_fields = 1,
476 };
477
478 typedef struct _insn_model_entry insn_model_entry;
479 struct _insn_model_entry {
480   line_ref *line;
481   insn_entry *insn;
482   filter *names;
483   char *full_name;
484   char *unit_data;
485   insn_model_entry *next;
486 };
487
488
489
490 /* Instruction mnemonic:
491
492    List of assembler mnemonics for the instruction.
493
494    <insn-mnenonic> ::=
495        "\"" <assembler-mnemonic> "\""
496        [ ":" <conditional-expression> ]
497        <nl>
498        ;
499
500    An assembler mnemonic string has the syntax:
501
502    <assembler-mnemonic>  ::=
503        ( [ "%" <format-spec> ] "<" <func> [ "#" <param-list> ] ">"
504        | "%%"
505        | <other-letter>
506        )+
507
508     Where, for instance, the text is translated into a printf format
509     and argument pair:
510
511        "<FUNC>"         : "%ld", (long) FUNC
512        "%<FUNC>..."     : "%...", FUNC
513        "%s<FUNC>"       : "%s", <%s>FUNC (SD_, FUNC)
514        "%s<FUNC#P1,P2>" : "%s", <%s>FUNC (SD_, P1,P2)
515        "%lx<FUNC>"      : "%lx", (unsigned long) FUNC
516        "%08lx<FUNC>"    : "%08lx", (unsigned long) FUNC
517
518     And "<%s>FUNC" denotes a function declared using the "%s" record
519     specifier.
520
521
522
523        ;
524
525    */
526
527 enum {
528   insn_mnemonic_format_field = 0,
529   insn_mnemonic_condition_field = 1,
530   nr_insn_mnemonic_fields = 1,
531 };
532
533 typedef struct _insn_mnemonic_entry insn_mnemonic_entry;
534 struct _insn_mnemonic_entry {
535   line_ref *line;
536   insn_entry *insn;
537   char *format;
538   char *condition;
539   insn_mnemonic_entry *next;
540 };
541
542
543
544 /* Instruction:
545
546    <insn> ::=
547        <insn-word> { "+" <insn-word> }
548        ":" <format-name>
549        ":" <filter-flags>
550        ":" <options>
551        ":" <name>
552        <nl>
553        { <insn-model> }
554        { <insn-mnemonic> }
555        <code-block>
556
557  */
558
559 enum {
560   insn_word_field = 0,
561   insn_format_name_field = 1,
562   insn_filter_flags_field = 2,
563   insn_options_field = 3,
564   insn_name_field = 4,
565   nr_insn_fields = 5,
566 };
567
568
569 /* typedef struct _insn_entry insn_entry; */
570 struct _insn_entry {
571   line_ref *line;
572   filter *flags; /* filtered by options.filters */
573   char *format_name;
574   filter *options;
575   char *name;
576   /* the words that make up the instruction. Word provides direct
577      access to word N. Pseudo instructions can be identified by
578      nr_words == 0. */
579   int nr_words;
580   insn_word_entry *words;
581   insn_word_entry **word;
582   /* a set of all the fields from all the words */
583   filter *field_names;
584   /* an array of processor models, missing models are NULL! */
585   int nr_models;
586   insn_model_entry *models;
587   insn_model_entry **model;
588   filter *processors;
589   /* list of assember formats */
590   int nr_mnemonics;
591   insn_mnemonic_entry *mnemonics;
592   /* code body */
593   table_entry *code;
594   insn_entry *next;
595 };
596
597
598 /* Instruction table:
599
600  */
601
602 typedef struct _insn_table insn_table;
603 struct _insn_table {
604   cache_entry *caches;
605   int max_nr_words;
606   int nr_insns;
607   insn_entry *insns;
608   function_entry *functions;
609   insn_entry *illegal_insn;
610   model_table *model;
611   filter *options;
612   filter *flags;
613 };
614
615 extern insn_table *load_insn_table
616 (char *file_name,
617  cache_entry *cache);
618
619 typedef void insn_entry_handler
620 (lf *file,
621  insn_table *isa,
622  insn_entry *insn,
623  void *data);
624
625 extern void insn_table_traverse_insn
626 (lf *file,
627  insn_table *isa,
628  insn_entry_handler *handler,
629  void *data);
630
631
632
633 /* Printing */
634
635 extern void print_insn_words
636 (lf *file,
637  insn_entry *insn);
638
639
640
641 /* Debugging */
642
643 void
644 dump_insn_field
645 (lf *file,
646  char *prefix,
647  insn_field_entry *field,
648  char *suffix);
649
650 void
651 dump_insn_word_entry
652 (lf *file,
653  char *prefix,
654  insn_word_entry *word,
655  char *suffix);
656
657 void
658 dump_insn_entry
659 (lf *file,
660  char *prefix,
661  insn_entry *insn,
662  char *suffix);
663
664 void
665 dump_cache_entries
666 (lf *file,
667  char *prefix,
668  cache_entry *entry,
669  char *suffix);
670
671 void
672 dump_insn_table
673 (lf *file,
674  char *prefix,
675  insn_table *isa,
676  char *suffix);