* cpu-arm.c (arm_check_note): Warning fix.
[external/binutils.git] / bfd / xtensa-isa.c
1 /* Configurable Xtensa ISA support.
2    Copyright 2003 Free Software Foundation, Inc.
3
4    This file is part of BFD, the Binary File Descriptor library.
5
6    This program 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 2 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
19
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <sys/types.h>
23 #include <string.h>
24
25 #include "xtensa-isa.h"
26 #include "xtensa-isa-internal.h"
27
28 xtensa_isa xtensa_default_isa = NULL;
29
30 static int
31 opname_lookup_compare (const void *v1, const void *v2)
32 {
33   opname_lookup_entry *e1 = (opname_lookup_entry *)v1;
34   opname_lookup_entry *e2 = (opname_lookup_entry *)v2;
35
36   return strcmp (e1->key, e2->key);
37 }
38
39
40 xtensa_isa
41 xtensa_isa_init (void)
42 {
43   xtensa_isa isa;
44   int mod;
45
46   isa = xtensa_load_isa (0);
47   if (isa == 0)
48     {
49       fprintf (stderr, "Failed to initialize Xtensa base ISA module\n");
50       return NULL;
51     }
52
53   for (mod = 1; xtensa_isa_modules[mod].get_num_opcodes_fn; mod++)
54     {
55       if (!xtensa_extend_isa (isa, mod))
56         {
57           fprintf (stderr, "Failed to initialize Xtensa TIE ISA module\n");
58           return NULL;
59         }
60     }
61
62   return isa;
63 }
64
65 /* ISA information.  */
66
67 static int
68 xtensa_check_isa_config (xtensa_isa_internal *isa,
69                          struct config_struct *config_table)
70 {
71   int i, j;
72
73   if (!config_table)
74     {
75       fprintf (stderr, "Error: Empty configuration table in ISA DLL\n");
76       return 0;
77     }
78
79   /* For the first module, save a pointer to the table and record the
80      specified endianness and availability of the density option.  */
81
82   if (isa->num_modules == 0)
83     {
84       int found_memory_order = 0;
85
86       isa->config = config_table;
87       isa->has_density = 1;  /* Default to have density option.  */
88
89       for (i = 0; config_table[i].param_name; i++)
90         {
91           if (!strcmp (config_table[i].param_name, "IsaMemoryOrder"))
92             {
93               isa->is_big_endian =
94                 (strcmp (config_table[i].param_value, "BigEndian") == 0);
95               found_memory_order = 1;
96             }
97           if (!strcmp (config_table[i].param_name, "IsaUseDensityInstruction"))
98             {
99               isa->has_density = atoi (config_table[i].param_value);
100             }
101         }
102       if (!found_memory_order)
103         {
104           fprintf (stderr, "Error: \"IsaMemoryOrder\" missing from "
105                    "configuration table in ISA DLL\n");
106           return 0;
107         }
108
109       return 1;
110     }
111
112   /* For subsequent modules, check that the parameters match.  Note: This
113      code is sufficient to handle the current model where there are never
114      more than 2 modules; we might at some point want to handle cases where
115      module N > 0 specifies some parameters not included in the base table,
116      and we would then add those to isa->config so that subsequent modules
117      would check against them. */
118
119   for (i = 0; config_table[i].param_name; i++)
120     {
121       for (j = 0; isa->config[j].param_name; j++)
122         {
123           if (!strcmp (config_table[i].param_name, isa->config[j].param_name))
124             {
125               int mismatch;
126               if (!strcmp (config_table[i].param_name, "IsaCoprocessorCount"))
127                 {
128                   /* Only require the coprocessor count to be <= the base.  */
129                   int tiecnt = atoi (config_table[i].param_value);
130                   int basecnt = atoi (isa->config[j].param_value);
131                   mismatch = (tiecnt > basecnt);
132                 }
133               else
134                 mismatch = strcmp (config_table[i].param_value,
135                                    isa->config[j].param_value);
136               if (mismatch)
137                 {
138 #define MISMATCH_MESSAGE \
139 "Error: Configuration mismatch in the \"%s\" parameter:\n\
140 the configuration used when the TIE file was compiled had a value of\n\
141 \"%s\", while the current configuration has a value of\n\
142 \"%s\". Please rerun the TIE compiler with a matching\n\
143 configuration.\n"
144                   fprintf (stderr, MISMATCH_MESSAGE,
145                            config_table[i].param_name,
146                            config_table[i].param_value,
147                            isa->config[j].param_value);
148                   return 0;
149                 }
150               break;
151             }
152         }
153     }
154
155   return 1;
156 }
157
158
159 static int
160 xtensa_add_isa (xtensa_isa_internal *isa, libisa_module_specifier libisa)
161 {
162   int (*get_num_opcodes_fn) (void);
163   struct config_struct *(*get_config_table_fn) (void);
164   xtensa_opcode_internal **(*get_opcodes_fn) (void);
165   int (*decode_insn_fn) (const xtensa_insnbuf);
166   xtensa_opcode_internal **opcodes;
167   int opc, insn_size, prev_num_opcodes, new_num_opcodes, this_module;
168
169   get_num_opcodes_fn = xtensa_isa_modules[libisa].get_num_opcodes_fn;
170   get_opcodes_fn = xtensa_isa_modules[libisa].get_opcodes_fn;
171   decode_insn_fn = xtensa_isa_modules[libisa].decode_insn_fn;
172   get_config_table_fn = xtensa_isa_modules[libisa].get_config_table_fn;
173
174   if (!get_num_opcodes_fn || !get_opcodes_fn || !decode_insn_fn
175       || (!get_config_table_fn && isa->num_modules == 0))
176     return 0;
177
178   if (get_config_table_fn
179       && !xtensa_check_isa_config (isa, get_config_table_fn ()))
180     return 0;
181
182   prev_num_opcodes = isa->num_opcodes;
183   new_num_opcodes = (*get_num_opcodes_fn) ();
184
185   isa->num_opcodes += new_num_opcodes;
186   isa->opcode_table = (xtensa_opcode_internal **)
187     realloc (isa->opcode_table, isa->num_opcodes *
188              sizeof (xtensa_opcode_internal *));
189   isa->opname_lookup_table = (opname_lookup_entry *)
190     realloc (isa->opname_lookup_table, isa->num_opcodes *
191              sizeof (opname_lookup_entry));
192
193   opcodes = (*get_opcodes_fn) ();
194
195   insn_size = isa->insn_size;
196   for (opc = 0; opc < new_num_opcodes; opc++)
197     {
198       xtensa_opcode_internal *intopc = opcodes[opc];
199       int newopc = prev_num_opcodes + opc;
200       isa->opcode_table[newopc] = intopc;
201       isa->opname_lookup_table[newopc].key = intopc->name;
202       isa->opname_lookup_table[newopc].opcode = newopc;
203       if (intopc->length > insn_size)
204         insn_size = intopc->length;
205     }
206
207   isa->insn_size = insn_size;
208   isa->insnbuf_size = ((isa->insn_size + sizeof (xtensa_insnbuf_word) - 1) /
209                        sizeof (xtensa_insnbuf_word));
210
211   qsort (isa->opname_lookup_table, isa->num_opcodes,
212          sizeof (opname_lookup_entry), opname_lookup_compare);
213
214   /* Check for duplicate opcode names.  */
215   for (opc = 1; opc < isa->num_opcodes; opc++)
216     {
217       if (!opname_lookup_compare (&isa->opname_lookup_table[opc-1],
218                                   &isa->opname_lookup_table[opc]))
219         {
220           fprintf (stderr, "Error: Duplicate TIE opcode \"%s\"\n",
221                    isa->opname_lookup_table[opc].key);
222           return 0;
223         }
224     }
225
226   this_module = isa->num_modules;
227   isa->num_modules += 1;
228
229   isa->module_opcode_base = (int *) realloc (isa->module_opcode_base,
230                                              isa->num_modules * sizeof (int));
231   isa->module_decode_fn = (xtensa_insn_decode_fn *)
232     realloc (isa->module_decode_fn, isa->num_modules *
233              sizeof (xtensa_insn_decode_fn));
234
235   isa->module_opcode_base[this_module] = prev_num_opcodes;
236   isa->module_decode_fn[this_module] = decode_insn_fn;
237
238   xtensa_default_isa = isa;
239
240   return 1;     /* Library was successfully added.  */
241 }
242
243
244 xtensa_isa
245 xtensa_load_isa (libisa_module_specifier libisa)
246 {
247   xtensa_isa_internal *isa;
248
249   isa = (xtensa_isa_internal *) malloc (sizeof (xtensa_isa_internal));
250   memset (isa, 0, sizeof (xtensa_isa_internal));
251   if (!xtensa_add_isa (isa, libisa))
252     {
253       xtensa_isa_free (isa);
254       return NULL;
255     }
256   return (xtensa_isa) isa;
257 }
258
259
260 int
261 xtensa_extend_isa (xtensa_isa isa, libisa_module_specifier libisa)
262 {
263   xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
264   return xtensa_add_isa (intisa, libisa);
265 }
266
267
268 void
269 xtensa_isa_free (xtensa_isa isa)
270 {
271   xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
272   if (intisa->opcode_table)
273     free (intisa->opcode_table);
274   if (intisa->opname_lookup_table)
275     free (intisa->opname_lookup_table);
276   if (intisa->module_opcode_base)
277     free (intisa->module_opcode_base);
278   if (intisa->module_decode_fn)
279     free (intisa->module_decode_fn);
280   free (intisa);
281 }
282
283
284 int
285 xtensa_insn_maxlength (xtensa_isa isa)
286 {
287   xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
288   return intisa->insn_size;
289 }
290
291
292 int
293 xtensa_insnbuf_size (xtensa_isa isa)
294 {
295   xtensa_isa_internal *intisa = (xtensa_isa_internal *)isa;
296   return intisa->insnbuf_size;
297 }
298
299
300 int
301 xtensa_num_opcodes (xtensa_isa isa)
302 {
303   xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
304   return intisa->num_opcodes;
305 }
306
307
308 xtensa_opcode
309 xtensa_opcode_lookup (xtensa_isa isa, const char *opname)
310 {
311   xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
312   opname_lookup_entry entry, *result;
313
314   entry.key = opname;
315   result = bsearch (&entry, intisa->opname_lookup_table, intisa->num_opcodes,
316                     sizeof (opname_lookup_entry), opname_lookup_compare);
317   if (!result) return XTENSA_UNDEFINED;
318   return result->opcode;
319 }
320
321
322 xtensa_opcode
323 xtensa_decode_insn (xtensa_isa isa, const xtensa_insnbuf insn)
324 {
325   xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
326   int n, opc;
327   for (n = 0; n < intisa->num_modules; n++) {
328     opc = (intisa->module_decode_fn[n]) (insn);
329     if (opc != XTENSA_UNDEFINED)
330       return intisa->module_opcode_base[n] + opc;
331   }
332   return XTENSA_UNDEFINED;
333 }
334
335
336 /* Opcode information.  */
337
338 void
339 xtensa_encode_insn (xtensa_isa isa, xtensa_opcode opc, xtensa_insnbuf insn)
340 {
341   xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
342   xtensa_insnbuf template = intisa->opcode_table[opc]->template();
343   int len = intisa->opcode_table[opc]->length;
344   int n;
345
346   /* Convert length to 32-bit words.  */
347   len = (len + 3) / 4;
348
349   /* Copy the template.  */
350   for (n = 0; n < len; n++)
351     insn[n] = template[n];
352
353   /* Fill any unused buffer space with zeros.  */
354   for ( ; n < intisa->insnbuf_size; n++)
355     insn[n] = 0;
356 }
357
358
359 const char *
360 xtensa_opcode_name (xtensa_isa isa, xtensa_opcode opc)
361 {
362   xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
363   return intisa->opcode_table[opc]->name;
364 }
365
366
367 int
368 xtensa_insn_length (xtensa_isa isa, xtensa_opcode opc)
369 {
370   xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
371   return intisa->opcode_table[opc]->length;
372 }
373
374
375 int
376 xtensa_insn_length_from_first_byte (xtensa_isa isa, char first_byte)
377 {
378   xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
379   int is_density = (first_byte & (intisa->is_big_endian ? 0x80 : 0x08)) != 0;
380   return (intisa->has_density && is_density ? 2 : 3);
381 }
382
383
384 int
385 xtensa_num_operands (xtensa_isa isa, xtensa_opcode opc)
386 {
387   xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
388   return intisa->opcode_table[opc]->iclass->num_operands;
389 }
390
391
392 xtensa_operand
393 xtensa_get_operand (xtensa_isa isa, xtensa_opcode opc, int opnd)
394 {
395   xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
396   xtensa_iclass_internal *iclass = intisa->opcode_table[opc]->iclass;
397   if (opnd >= iclass->num_operands)
398     return NULL;
399   return (xtensa_operand) iclass->operands[opnd];
400 }
401
402
403 /* Operand information.  */
404
405 char *
406 xtensa_operand_kind (xtensa_operand opnd)
407 {
408   xtensa_operand_internal *intop = (xtensa_operand_internal *) opnd;
409   return intop->operand_kind;
410 }
411
412
413 char
414 xtensa_operand_inout (xtensa_operand opnd)
415 {
416   xtensa_operand_internal *intop = (xtensa_operand_internal *) opnd;
417   return intop->inout;
418 }
419
420
421 uint32
422 xtensa_operand_get_field (xtensa_operand opnd, const xtensa_insnbuf insn)
423 {
424   xtensa_operand_internal *intop = (xtensa_operand_internal *) opnd;
425   return (*intop->get_field) (insn);
426 }
427
428
429 void
430 xtensa_operand_set_field (xtensa_operand opnd, xtensa_insnbuf insn, uint32 val)
431 {
432   xtensa_operand_internal *intop = (xtensa_operand_internal *) opnd;
433   return (*intop->set_field) (insn, val);
434 }
435
436
437 xtensa_encode_result
438 xtensa_operand_encode (xtensa_operand opnd, uint32 *valp)
439 {
440   xtensa_operand_internal *intop = (xtensa_operand_internal *) opnd;
441   return (*intop->encode) (valp);
442 }
443
444
445 uint32
446 xtensa_operand_decode (xtensa_operand opnd, uint32 val)
447 {
448   xtensa_operand_internal *intop = (xtensa_operand_internal *) opnd;
449   return (*intop->decode) (val);
450 }
451
452
453 int
454 xtensa_operand_isPCRelative (xtensa_operand opnd)
455 {
456   xtensa_operand_internal *intop = (xtensa_operand_internal *) opnd;
457   return intop->isPCRelative;
458 }
459
460
461 uint32
462 xtensa_operand_do_reloc (xtensa_operand opnd, uint32 addr, uint32 pc)
463 {
464   xtensa_operand_internal *intop = (xtensa_operand_internal *) opnd;
465   if (!intop->isPCRelative)
466     return addr;
467   return (*intop->do_reloc) (addr, pc);
468 }
469
470
471 uint32
472 xtensa_operand_undo_reloc (xtensa_operand opnd, uint32 offset, uint32 pc)
473 {
474   xtensa_operand_internal *intop = (xtensa_operand_internal *) opnd;
475   if (!intop->isPCRelative)
476     return offset;
477   return (*intop->undo_reloc) (offset, pc);
478 }
479
480
481 /* Instruction buffers.  */
482
483 xtensa_insnbuf
484 xtensa_insnbuf_alloc (xtensa_isa isa)
485 {
486   return (xtensa_insnbuf) malloc (xtensa_insnbuf_size (isa) *
487                                   sizeof (xtensa_insnbuf_word));
488 }
489
490
491 void
492 xtensa_insnbuf_free (xtensa_insnbuf buf)
493 {
494   free( buf );
495 }
496
497
498 /* Given <byte_index>, the index of a byte in a xtensa_insnbuf, our
499    internal representation of a xtensa instruction word, return the index of
500    its word and the bit index of its low order byte in the xtensa_insnbuf.  */
501
502 static inline int
503 byte_to_word_index (int byte_index)
504 {
505   return byte_index / sizeof (xtensa_insnbuf_word);
506 }
507
508
509 static inline int
510 byte_to_bit_index (int byte_index)
511 {
512   return (byte_index & 0x3) * 8;
513 }
514
515
516 /* Copy an instruction in the 32 bit words pointed at by <insn> to characters
517    pointed at by <cp>.  This is more complicated than you might think because
518    we want 16 bit instructions in bytes 2,3 for big endian. This function
519    allows us to specify which byte in <insn> to start with and which way to
520    increment, allowing trivial implementation for both big and little endian.
521    And it seems to make pretty good code for both.  */
522
523 void
524 xtensa_insnbuf_to_chars (xtensa_isa isa, const xtensa_insnbuf insn, char *cp)
525 {
526   xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
527   int insn_size = xtensa_insn_maxlength (intisa);
528   int fence_post, start, increment, i, byte_count;
529   xtensa_opcode opc;
530
531   if (intisa->is_big_endian)
532     {
533       start = insn_size - 1;
534       increment = -1;
535     }
536   else
537     {
538       start = 0;
539       increment = 1;
540     }
541
542   /* Find the opcode; do nothing if the buffer does not contain a valid
543      instruction since we need to know how many bytes to copy.  */
544   opc = xtensa_decode_insn (isa, insn);
545   if (opc == XTENSA_UNDEFINED)
546     return;
547
548   byte_count = xtensa_insn_length (isa, opc);
549   fence_post = start + (byte_count * increment);
550
551   for (i = start; i != fence_post; i += increment, ++cp)
552     {
553       int word_inx = byte_to_word_index (i);
554       int bit_inx = byte_to_bit_index (i);
555
556       *cp = (insn[word_inx] >> bit_inx) & 0xff;
557     }
558 }
559
560 /* Inward conversion from byte stream to xtensa_insnbuf.  See
561    xtensa_insnbuf_to_chars for a discussion of why this is
562    complicated by endianness.  */
563     
564 void
565 xtensa_insnbuf_from_chars (xtensa_isa isa, xtensa_insnbuf insn, const char* cp)
566 {
567   xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
568   int insn_size = xtensa_insn_maxlength (intisa);
569   int fence_post, start, increment, i;
570
571   if (intisa->is_big_endian)
572     {
573       start = insn_size - 1;
574       increment = -1;
575     }
576   else
577     {
578       start = 0;
579       increment = 1;
580     }
581
582   fence_post = start + (insn_size * increment);
583   memset (insn, 0, xtensa_insnbuf_size (isa) * sizeof (xtensa_insnbuf_word));
584
585   for ( i = start; i != fence_post; i += increment, ++cp )
586     {
587       int word_inx = byte_to_word_index (i);
588       int bit_inx = byte_to_bit_index (i);
589
590       insn[word_inx] |= (*cp & 0xff) << bit_inx;
591     }
592 }
593