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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [bfd/] [xtensa-isa.c] - Blame information for rev 24

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

Line No. Rev Author Line
1 24 jeremybenn
/* Configurable Xtensa ISA support.
2
   Copyright 2003, 2004, 2005, 2007 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 3 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., 51 Franklin Street - Fifth Floor, Boston,
19
   MA 02110-1301, USA.  */
20
 
21
#include "sysdep.h"
22
#include "bfd.h"
23
#include "libbfd.h"
24
#include "xtensa-isa.h"
25
#include "xtensa-isa-internal.h"
26
 
27
xtensa_isa_status xtisa_errno;
28
char xtisa_error_msg[1024];
29
 
30
 
31
xtensa_isa_status
32
xtensa_isa_errno (xtensa_isa isa __attribute__ ((unused)))
33
{
34
  return xtisa_errno;
35
}
36
 
37
 
38
char *
39
xtensa_isa_error_msg (xtensa_isa isa __attribute__ ((unused)))
40
{
41
  return xtisa_error_msg;
42
}
43
 
44
 
45
#define CHECK_ALLOC(MEM,ERRVAL) \
46
  do { \
47
    if ((MEM) == 0) \
48
      { \
49
        xtisa_errno = xtensa_isa_out_of_memory; \
50
        strcpy (xtisa_error_msg, "out of memory"); \
51
        return (ERRVAL); \
52
      } \
53
  } while (0)
54
 
55
#define CHECK_ALLOC_FOR_INIT(MEM,ERRVAL,ERRNO_P,ERROR_MSG_P) \
56
  do { \
57
    if ((MEM) == 0) \
58
      { \
59
        xtisa_errno = xtensa_isa_out_of_memory; \
60
        strcpy (xtisa_error_msg, "out of memory"); \
61
        if (ERRNO_P) *(ERRNO_P) = xtisa_errno; \
62
        if (ERROR_MSG_P) *(ERROR_MSG_P) = xtisa_error_msg; \
63
        return (ERRVAL); \
64
      } \
65
  } while (0)
66
 
67
 
68
 
69
/* Instruction buffers.  */
70
 
71
int
72
xtensa_insnbuf_size (xtensa_isa isa)
73
{
74
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
75
  return intisa->insnbuf_size;
76
}
77
 
78
 
79
xtensa_insnbuf
80
xtensa_insnbuf_alloc (xtensa_isa isa)
81
{
82
  xtensa_insnbuf result = (xtensa_insnbuf)
83
    malloc (xtensa_insnbuf_size (isa) * sizeof (xtensa_insnbuf_word));
84
  CHECK_ALLOC (result, 0);
85
  return result;
86
}
87
 
88
 
89
void
90
xtensa_insnbuf_free (xtensa_isa isa __attribute__ ((unused)),
91
                     xtensa_insnbuf buf)
92
{
93
  free (buf);
94
}
95
 
96
 
97
/* Given <byte_index>, the index of a byte in a xtensa_insnbuf, our
98
   internal representation of a xtensa instruction word, return the index of
99
   its word and the bit index of its low order byte in the xtensa_insnbuf.  */
100
 
101
static inline int
102
byte_to_word_index (int byte_index)
103
{
104
  return byte_index / sizeof (xtensa_insnbuf_word);
105
}
106
 
107
 
108
static inline int
109
byte_to_bit_index (int byte_index)
110
{
111
  return (byte_index & 0x3) * 8;
112
}
113
 
114
 
115
/* Copy an instruction in the 32-bit words pointed at by "insn" to
116
   characters pointed at by "cp".  This is more complicated than you
117
   might think because we want 16-bit instructions in bytes 2 & 3 for
118
   big-endian configurations.  This function allows us to specify
119
   which byte in "insn" to start with and which way to increment,
120
   allowing trivial implementation for both big- and little-endian
121
   configurations....and it seems to make pretty good code for
122
   both.  */
123
 
124
int
125
xtensa_insnbuf_to_chars (xtensa_isa isa,
126
                         const xtensa_insnbuf insn,
127
                         unsigned char *cp,
128
                         int num_chars)
129
{
130
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
131
  int insn_size = xtensa_isa_maxlength (isa);
132
  int fence_post, start, increment, i, byte_count;
133
  xtensa_format fmt;
134
 
135
  if (num_chars == 0)
136
    num_chars = insn_size;
137
 
138
  if (intisa->is_big_endian)
139
    {
140
      start = insn_size - 1;
141
      increment = -1;
142
    }
143
  else
144
    {
145
      start = 0;
146
      increment = 1;
147
    }
148
 
149
  /* Find the instruction format.  Do nothing if the buffer does not contain
150
     a valid instruction since we need to know how many bytes to copy.  */
151
  fmt = xtensa_format_decode (isa, insn);
152
  if (fmt == XTENSA_UNDEFINED)
153
    return XTENSA_UNDEFINED;
154
 
155
  byte_count = xtensa_format_length (isa, fmt);
156
  if (byte_count == XTENSA_UNDEFINED)
157
    return XTENSA_UNDEFINED;
158
 
159
  if (byte_count > num_chars)
160
    {
161
      xtisa_errno = xtensa_isa_buffer_overflow;
162
      strcpy (xtisa_error_msg, "output buffer too small for instruction");
163
      return XTENSA_UNDEFINED;
164
    }
165
 
166
  fence_post = start + (byte_count * increment);
167
 
168
  for (i = start; i != fence_post; i += increment, ++cp)
169
    {
170
      int word_inx = byte_to_word_index (i);
171
      int bit_inx = byte_to_bit_index (i);
172
 
173
      *cp = (insn[word_inx] >> bit_inx) & 0xff;
174
    }
175
 
176
  return byte_count;
177
}
178
 
179
 
180
/* Inward conversion from byte stream to xtensa_insnbuf.  See
181
   xtensa_insnbuf_to_chars for a discussion of why this is complicated
182
   by endianness.  */
183
 
184
void
185
xtensa_insnbuf_from_chars (xtensa_isa isa,
186
                           xtensa_insnbuf insn,
187
                           const unsigned char *cp,
188
                           int num_chars)
189
{
190
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
191
  int max_size, insn_size, fence_post, start, increment, i;
192
 
193
  max_size = xtensa_isa_maxlength (isa);
194
 
195
  /* Decode the instruction length so we know how many bytes to read.  */
196
  insn_size = (intisa->length_decode_fn) (cp);
197
  if (insn_size == XTENSA_UNDEFINED)
198
    {
199
      /* This should never happen when the byte stream contains a
200
         valid instruction.  Just read the maximum number of bytes....  */
201
      insn_size = max_size;
202
    }
203
 
204
  if (num_chars == 0 || num_chars > insn_size)
205
    num_chars = insn_size;
206
 
207
  if (intisa->is_big_endian)
208
    {
209
      start = max_size - 1;
210
      increment = -1;
211
    }
212
  else
213
    {
214
      start = 0;
215
      increment = 1;
216
    }
217
 
218
  fence_post = start + (num_chars * increment);
219
  memset (insn, 0, xtensa_insnbuf_size (isa) * sizeof (xtensa_insnbuf_word));
220
 
221
  for (i = start; i != fence_post; i += increment, ++cp)
222
    {
223
      int word_inx = byte_to_word_index (i);
224
      int bit_inx = byte_to_bit_index (i);
225
 
226
      insn[word_inx] |= (*cp & 0xff) << bit_inx;
227
    }
228
}
229
 
230
 
231
 
232
/* ISA information.  */
233
 
234
extern xtensa_isa_internal xtensa_modules;
235
 
236
xtensa_isa
237
xtensa_isa_init (xtensa_isa_status *errno_p, char **error_msg_p)
238
{
239
  xtensa_isa_internal *isa = &xtensa_modules;
240
  int n, is_user;
241
 
242
  /* Set up the opcode name lookup table.  */
243
  isa->opname_lookup_table =
244
    bfd_malloc (isa->num_opcodes * sizeof (xtensa_lookup_entry));
245
  CHECK_ALLOC_FOR_INIT (isa->opname_lookup_table, NULL, errno_p, error_msg_p);
246
  for (n = 0; n < isa->num_opcodes; n++)
247
    {
248
      isa->opname_lookup_table[n].key = isa->opcodes[n].name;
249
      isa->opname_lookup_table[n].u.opcode = n;
250
    }
251
  qsort (isa->opname_lookup_table, isa->num_opcodes,
252
         sizeof (xtensa_lookup_entry), xtensa_isa_name_compare);
253
 
254
  /* Set up the state name lookup table.  */
255
  isa->state_lookup_table =
256
    bfd_malloc (isa->num_states * sizeof (xtensa_lookup_entry));
257
  CHECK_ALLOC_FOR_INIT (isa->state_lookup_table, NULL, errno_p, error_msg_p);
258
  for (n = 0; n < isa->num_states; n++)
259
    {
260
      isa->state_lookup_table[n].key = isa->states[n].name;
261
      isa->state_lookup_table[n].u.state = n;
262
    }
263
  qsort (isa->state_lookup_table, isa->num_states,
264
         sizeof (xtensa_lookup_entry), xtensa_isa_name_compare);
265
 
266
  /* Set up the sysreg name lookup table.  */
267
  isa->sysreg_lookup_table =
268
    bfd_malloc (isa->num_sysregs * sizeof (xtensa_lookup_entry));
269
  CHECK_ALLOC_FOR_INIT (isa->sysreg_lookup_table, NULL, errno_p, error_msg_p);
270
  for (n = 0; n < isa->num_sysregs; n++)
271
    {
272
      isa->sysreg_lookup_table[n].key = isa->sysregs[n].name;
273
      isa->sysreg_lookup_table[n].u.sysreg = n;
274
    }
275
  qsort (isa->sysreg_lookup_table, isa->num_sysregs,
276
         sizeof (xtensa_lookup_entry), xtensa_isa_name_compare);
277
 
278
  /* Set up the user & system sysreg number tables.  */
279
  for (is_user = 0; is_user < 2; is_user++)
280
    {
281
      isa->sysreg_table[is_user] =
282
        bfd_malloc ((isa->max_sysreg_num[is_user] + 1)
283
                    * sizeof (xtensa_sysreg));
284
      CHECK_ALLOC_FOR_INIT (isa->sysreg_table[is_user], NULL,
285
                            errno_p, error_msg_p);
286
 
287
      for (n = 0; n <= isa->max_sysreg_num[is_user]; n++)
288
        isa->sysreg_table[is_user][n] = XTENSA_UNDEFINED;
289
    }
290
  for (n = 0; n < isa->num_sysregs; n++)
291
    {
292
      xtensa_sysreg_internal *sreg = &isa->sysregs[n];
293
      is_user = sreg->is_user;
294
 
295
      isa->sysreg_table[is_user][sreg->number] = n;
296
    }
297
 
298
  /* Set up the interface lookup table.  */
299
  isa->interface_lookup_table =
300
    bfd_malloc (isa->num_interfaces * sizeof (xtensa_lookup_entry));
301
  CHECK_ALLOC_FOR_INIT (isa->interface_lookup_table, NULL, errno_p,
302
                        error_msg_p);
303
  for (n = 0; n < isa->num_interfaces; n++)
304
    {
305
      isa->interface_lookup_table[n].key = isa->interfaces[n].name;
306
      isa->interface_lookup_table[n].u.intf = n;
307
    }
308
  qsort (isa->interface_lookup_table, isa->num_interfaces,
309
         sizeof (xtensa_lookup_entry), xtensa_isa_name_compare);
310
 
311
  /* Set up the funcUnit lookup table.  */
312
  isa->funcUnit_lookup_table =
313
    bfd_malloc (isa->num_funcUnits * sizeof (xtensa_lookup_entry));
314
  CHECK_ALLOC_FOR_INIT (isa->funcUnit_lookup_table, NULL, errno_p,
315
                        error_msg_p);
316
  for (n = 0; n < isa->num_funcUnits; n++)
317
    {
318
      isa->funcUnit_lookup_table[n].key = isa->funcUnits[n].name;
319
      isa->funcUnit_lookup_table[n].u.fun = n;
320
    }
321
  qsort (isa->funcUnit_lookup_table, isa->num_funcUnits,
322
         sizeof (xtensa_lookup_entry), xtensa_isa_name_compare);
323
 
324
  isa->insnbuf_size = ((isa->insn_size + sizeof (xtensa_insnbuf_word) - 1) /
325
                       sizeof (xtensa_insnbuf_word));
326
 
327
  return (xtensa_isa) isa;
328
}
329
 
330
 
331
void
332
xtensa_isa_free (xtensa_isa isa)
333
{
334
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
335
  int n;
336
 
337
  /* With this version of the code, the xtensa_isa structure is not
338
     dynamically allocated, so this function is not essential.  Free
339
     the memory allocated by xtensa_isa_init and restore the xtensa_isa
340
     structure to its initial state.  */
341
 
342
  if (intisa->opname_lookup_table)
343
    {
344
      free (intisa->opname_lookup_table);
345
      intisa->opname_lookup_table = 0;
346
    }
347
 
348
  if (intisa->state_lookup_table)
349
    {
350
      free (intisa->state_lookup_table);
351
      intisa->state_lookup_table = 0;
352
    }
353
 
354
  if (intisa->sysreg_lookup_table)
355
    {
356
      free (intisa->sysreg_lookup_table);
357
      intisa->sysreg_lookup_table = 0;
358
    }
359
  for (n = 0; n < 2; n++)
360
    {
361
      if (intisa->sysreg_table[n])
362
        {
363
          free (intisa->sysreg_table[n]);
364
          intisa->sysreg_table[n] = 0;
365
        }
366
    }
367
 
368
  if (intisa->interface_lookup_table)
369
    {
370
      free (intisa->interface_lookup_table);
371
      intisa->interface_lookup_table = 0;
372
    }
373
 
374
  if (intisa->funcUnit_lookup_table)
375
    {
376
      free (intisa->funcUnit_lookup_table);
377
      intisa->funcUnit_lookup_table = 0;
378
    }
379
}
380
 
381
 
382
int
383
xtensa_isa_name_compare (const void *v1, const void *v2)
384
{
385
  xtensa_lookup_entry *e1 = (xtensa_lookup_entry *) v1;
386
  xtensa_lookup_entry *e2 = (xtensa_lookup_entry *) v2;
387
 
388
  return strcasecmp (e1->key, e2->key);
389
}
390
 
391
 
392
int
393
xtensa_isa_maxlength (xtensa_isa isa)
394
{
395
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
396
  return intisa->insn_size;
397
}
398
 
399
 
400
int
401
xtensa_isa_length_from_chars (xtensa_isa isa, const unsigned char *cp)
402
{
403
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
404
  return (intisa->length_decode_fn) (cp);
405
}
406
 
407
 
408
int
409
xtensa_isa_num_pipe_stages (xtensa_isa isa)
410
{
411
  xtensa_opcode opcode;
412
  xtensa_funcUnit_use *use;
413
  int num_opcodes, num_uses;
414
  int i, stage, max_stage = XTENSA_UNDEFINED;
415
 
416
  num_opcodes = xtensa_isa_num_opcodes (isa);
417
  for (opcode = 0; opcode < num_opcodes; opcode++)
418
    {
419
      num_uses = xtensa_opcode_num_funcUnit_uses (isa, opcode);
420
      for (i = 0; i < num_uses; i++)
421
        {
422
          use = xtensa_opcode_funcUnit_use (isa, opcode, i);
423
          stage = use->stage;
424
          if (stage > max_stage)
425
            max_stage = stage;
426
        }
427
    }
428
 
429
  return max_stage + 1;
430
}
431
 
432
 
433
int
434
xtensa_isa_num_formats (xtensa_isa isa)
435
{
436
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
437
  return intisa->num_formats;
438
}
439
 
440
 
441
int
442
xtensa_isa_num_opcodes (xtensa_isa isa)
443
{
444
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
445
  return intisa->num_opcodes;
446
}
447
 
448
 
449
int
450
xtensa_isa_num_regfiles (xtensa_isa isa)
451
{
452
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
453
  return intisa->num_regfiles;
454
}
455
 
456
 
457
int
458
xtensa_isa_num_states (xtensa_isa isa)
459
{
460
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
461
  return intisa->num_states;
462
}
463
 
464
 
465
int
466
xtensa_isa_num_sysregs (xtensa_isa isa)
467
{
468
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
469
  return intisa->num_sysregs;
470
}
471
 
472
 
473
int
474
xtensa_isa_num_interfaces (xtensa_isa isa)
475
{
476
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
477
  return intisa->num_interfaces;
478
}
479
 
480
 
481
int
482
xtensa_isa_num_funcUnits (xtensa_isa isa)
483
{
484
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
485
  return intisa->num_funcUnits;
486
}
487
 
488
 
489
 
490
/* Instruction formats.  */
491
 
492
 
493
#define CHECK_FORMAT(INTISA,FMT,ERRVAL) \
494
  do { \
495
    if ((FMT) < 0 || (FMT) >= (INTISA)->num_formats) \
496
      { \
497
        xtisa_errno = xtensa_isa_bad_format; \
498
        strcpy (xtisa_error_msg, "invalid format specifier"); \
499
        return (ERRVAL); \
500
      } \
501
  } while (0)
502
 
503
 
504
#define CHECK_SLOT(INTISA,FMT,SLOT,ERRVAL) \
505
  do { \
506
    if ((SLOT) < 0 || (SLOT) >= (INTISA)->formats[FMT].num_slots) \
507
      { \
508
        xtisa_errno = xtensa_isa_bad_slot; \
509
        strcpy (xtisa_error_msg, "invalid slot specifier"); \
510
        return (ERRVAL); \
511
      } \
512
  } while (0)
513
 
514
 
515
const char *
516
xtensa_format_name (xtensa_isa isa, xtensa_format fmt)
517
{
518
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
519
  CHECK_FORMAT (intisa, fmt, NULL);
520
  return intisa->formats[fmt].name;
521
}
522
 
523
 
524
xtensa_format
525
xtensa_format_lookup (xtensa_isa isa, const char *fmtname)
526
{
527
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
528
  int fmt;
529
 
530
  if (!fmtname || !*fmtname)
531
    {
532
      xtisa_errno = xtensa_isa_bad_format;
533
      strcpy (xtisa_error_msg, "invalid format name");
534
      return XTENSA_UNDEFINED;
535
    }
536
 
537
  for (fmt = 0; fmt < intisa->num_formats; fmt++)
538
    {
539
      if (strcasecmp (fmtname, intisa->formats[fmt].name) == 0)
540
        return fmt;
541
    }
542
 
543
  xtisa_errno = xtensa_isa_bad_format;
544
  sprintf (xtisa_error_msg, "format \"%s\" not recognized", fmtname);
545
  return XTENSA_UNDEFINED;
546
}
547
 
548
 
549
xtensa_format
550
xtensa_format_decode (xtensa_isa isa, const xtensa_insnbuf insn)
551
{
552
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
553
  xtensa_format fmt;
554
 
555
  fmt = (intisa->format_decode_fn) (insn);
556
  if (fmt != XTENSA_UNDEFINED)
557
    return fmt;
558
 
559
  xtisa_errno = xtensa_isa_bad_format;
560
  strcpy (xtisa_error_msg, "cannot decode instruction format");
561
  return XTENSA_UNDEFINED;
562
}
563
 
564
 
565
int
566
xtensa_format_encode (xtensa_isa isa, xtensa_format fmt, xtensa_insnbuf insn)
567
{
568
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
569
  CHECK_FORMAT (intisa, fmt, -1);
570
  (*intisa->formats[fmt].encode_fn) (insn);
571
  return 0;
572
}
573
 
574
 
575
int
576
xtensa_format_length (xtensa_isa isa, xtensa_format fmt)
577
{
578
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
579
  CHECK_FORMAT (intisa, fmt, XTENSA_UNDEFINED);
580
  return intisa->formats[fmt].length;
581
}
582
 
583
 
584
int
585
xtensa_format_num_slots (xtensa_isa isa, xtensa_format fmt)
586
{
587
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
588
  CHECK_FORMAT (intisa, fmt, XTENSA_UNDEFINED);
589
  return intisa->formats[fmt].num_slots;
590
}
591
 
592
 
593
xtensa_opcode
594
xtensa_format_slot_nop_opcode (xtensa_isa isa, xtensa_format fmt, int slot)
595
{
596
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
597
  int slot_id;
598
 
599
  CHECK_FORMAT (intisa, fmt, XTENSA_UNDEFINED);
600
  CHECK_SLOT (intisa, fmt, slot, XTENSA_UNDEFINED);
601
 
602
  slot_id = intisa->formats[fmt].slot_id[slot];
603
  return xtensa_opcode_lookup (isa, intisa->slots[slot_id].nop_name);
604
}
605
 
606
 
607
int
608
xtensa_format_get_slot (xtensa_isa isa, xtensa_format fmt, int slot,
609
                        const xtensa_insnbuf insn, xtensa_insnbuf slotbuf)
610
{
611
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
612
  int slot_id;
613
 
614
  CHECK_FORMAT (intisa, fmt, -1);
615
  CHECK_SLOT (intisa, fmt, slot, -1);
616
 
617
  slot_id = intisa->formats[fmt].slot_id[slot];
618
  (*intisa->slots[slot_id].get_fn) (insn, slotbuf);
619
  return 0;
620
}
621
 
622
 
623
int
624
xtensa_format_set_slot (xtensa_isa isa, xtensa_format fmt, int slot,
625
                        xtensa_insnbuf insn, const xtensa_insnbuf slotbuf)
626
{
627
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
628
  int slot_id;
629
 
630
  CHECK_FORMAT (intisa, fmt, -1);
631
  CHECK_SLOT (intisa, fmt, slot, -1);
632
 
633
  slot_id = intisa->formats[fmt].slot_id[slot];
634
  (*intisa->slots[slot_id].set_fn) (insn, slotbuf);
635
  return 0;
636
}
637
 
638
 
639
 
640
/* Opcode information.  */
641
 
642
 
643
#define CHECK_OPCODE(INTISA,OPC,ERRVAL) \
644
  do { \
645
    if ((OPC) < 0 || (OPC) >= (INTISA)->num_opcodes) \
646
      { \
647
        xtisa_errno = xtensa_isa_bad_opcode; \
648
        strcpy (xtisa_error_msg, "invalid opcode specifier"); \
649
        return (ERRVAL); \
650
      } \
651
  } while (0)
652
 
653
 
654
xtensa_opcode
655
xtensa_opcode_lookup (xtensa_isa isa, const char *opname)
656
{
657
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
658
  xtensa_lookup_entry entry, *result = 0;
659
 
660
  if (!opname || !*opname)
661
    {
662
      xtisa_errno = xtensa_isa_bad_opcode;
663
      strcpy (xtisa_error_msg, "invalid opcode name");
664
      return XTENSA_UNDEFINED;
665
    }
666
 
667
  if (intisa->num_opcodes != 0)
668
    {
669
      entry.key = opname;
670
      result = bsearch (&entry, intisa->opname_lookup_table,
671
                        intisa->num_opcodes, sizeof (xtensa_lookup_entry),
672
                        xtensa_isa_name_compare);
673
    }
674
 
675
  if (!result)
676
    {
677
      xtisa_errno = xtensa_isa_bad_opcode;
678
      sprintf (xtisa_error_msg, "opcode \"%s\" not recognized", opname);
679
      return XTENSA_UNDEFINED;
680
    }
681
 
682
  return result->u.opcode;
683
}
684
 
685
 
686
xtensa_opcode
687
xtensa_opcode_decode (xtensa_isa isa, xtensa_format fmt, int slot,
688
                      const xtensa_insnbuf slotbuf)
689
{
690
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
691
  int slot_id;
692
  xtensa_opcode opc;
693
 
694
  CHECK_FORMAT (intisa, fmt, XTENSA_UNDEFINED);
695
  CHECK_SLOT (intisa, fmt, slot, XTENSA_UNDEFINED);
696
 
697
  slot_id = intisa->formats[fmt].slot_id[slot];
698
 
699
  opc = (intisa->slots[slot_id].opcode_decode_fn) (slotbuf);
700
  if (opc != XTENSA_UNDEFINED)
701
    return opc;
702
 
703
  xtisa_errno = xtensa_isa_bad_opcode;
704
  strcpy (xtisa_error_msg, "cannot decode opcode");
705
  return XTENSA_UNDEFINED;
706
}
707
 
708
 
709
int
710
xtensa_opcode_encode (xtensa_isa isa, xtensa_format fmt, int slot,
711
                      xtensa_insnbuf slotbuf, xtensa_opcode opc)
712
{
713
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
714
  int slot_id;
715
  xtensa_opcode_encode_fn encode_fn;
716
 
717
  CHECK_FORMAT (intisa, fmt, -1);
718
  CHECK_SLOT (intisa, fmt, slot, -1);
719
  CHECK_OPCODE (intisa, opc, -1);
720
 
721
  slot_id = intisa->formats[fmt].slot_id[slot];
722
  encode_fn = intisa->opcodes[opc].encode_fns[slot_id];
723
  if (!encode_fn)
724
    {
725
      xtisa_errno = xtensa_isa_wrong_slot;
726
      sprintf (xtisa_error_msg,
727
               "opcode \"%s\" is not allowed in slot %d of format \"%s\"",
728
               intisa->opcodes[opc].name, slot, intisa->formats[fmt].name);
729
      return -1;
730
    }
731
  (*encode_fn) (slotbuf);
732
  return 0;
733
}
734
 
735
 
736
const char *
737
xtensa_opcode_name (xtensa_isa isa, xtensa_opcode opc)
738
{
739
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
740
  CHECK_OPCODE (intisa, opc, NULL);
741
  return intisa->opcodes[opc].name;
742
}
743
 
744
 
745
int
746
xtensa_opcode_is_branch (xtensa_isa isa, xtensa_opcode opc)
747
{
748
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
749
  CHECK_OPCODE (intisa, opc, XTENSA_UNDEFINED);
750
  if ((intisa->opcodes[opc].flags & XTENSA_OPCODE_IS_BRANCH) != 0)
751
    return 1;
752
  return 0;
753
}
754
 
755
 
756
int
757
xtensa_opcode_is_jump (xtensa_isa isa, xtensa_opcode opc)
758
{
759
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
760
  CHECK_OPCODE (intisa, opc, XTENSA_UNDEFINED);
761
  if ((intisa->opcodes[opc].flags & XTENSA_OPCODE_IS_JUMP) != 0)
762
    return 1;
763
  return 0;
764
}
765
 
766
 
767
int
768
xtensa_opcode_is_loop (xtensa_isa isa, xtensa_opcode opc)
769
{
770
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
771
  CHECK_OPCODE (intisa, opc, XTENSA_UNDEFINED);
772
  if ((intisa->opcodes[opc].flags & XTENSA_OPCODE_IS_LOOP) != 0)
773
    return 1;
774
  return 0;
775
}
776
 
777
 
778
int
779
xtensa_opcode_is_call (xtensa_isa isa, xtensa_opcode opc)
780
{
781
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
782
  CHECK_OPCODE (intisa, opc, XTENSA_UNDEFINED);
783
  if ((intisa->opcodes[opc].flags & XTENSA_OPCODE_IS_CALL) != 0)
784
    return 1;
785
  return 0;
786
}
787
 
788
 
789
int
790
xtensa_opcode_num_operands (xtensa_isa isa, xtensa_opcode opc)
791
{
792
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
793
  int iclass_id;
794
 
795
  CHECK_OPCODE (intisa, opc, XTENSA_UNDEFINED);
796
  iclass_id = intisa->opcodes[opc].iclass_id;
797
  return intisa->iclasses[iclass_id].num_operands;
798
}
799
 
800
 
801
int
802
xtensa_opcode_num_stateOperands (xtensa_isa isa, xtensa_opcode opc)
803
{
804
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
805
  int iclass_id;
806
 
807
  CHECK_OPCODE (intisa, opc, XTENSA_UNDEFINED);
808
  iclass_id = intisa->opcodes[opc].iclass_id;
809
  return intisa->iclasses[iclass_id].num_stateOperands;
810
}
811
 
812
 
813
int
814
xtensa_opcode_num_interfaceOperands (xtensa_isa isa, xtensa_opcode opc)
815
{
816
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
817
  int iclass_id;
818
 
819
  CHECK_OPCODE (intisa, opc, XTENSA_UNDEFINED);
820
  iclass_id = intisa->opcodes[opc].iclass_id;
821
  return intisa->iclasses[iclass_id].num_interfaceOperands;
822
}
823
 
824
 
825
int
826
xtensa_opcode_num_funcUnit_uses (xtensa_isa isa, xtensa_opcode opc)
827
{
828
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
829
  CHECK_OPCODE (intisa, opc, XTENSA_UNDEFINED);
830
  return intisa->opcodes[opc].num_funcUnit_uses;
831
}
832
 
833
 
834
xtensa_funcUnit_use *
835
xtensa_opcode_funcUnit_use (xtensa_isa isa, xtensa_opcode opc, int u)
836
{
837
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
838
  CHECK_OPCODE (intisa, opc, NULL);
839
  if (u < 0 || u >= intisa->opcodes[opc].num_funcUnit_uses)
840
    {
841
      xtisa_errno = xtensa_isa_bad_funcUnit;
842
      sprintf (xtisa_error_msg, "invalid functional unit use number (%d); "
843
               "opcode \"%s\" has %d", u, intisa->opcodes[opc].name,
844
               intisa->opcodes[opc].num_funcUnit_uses);
845
      return NULL;
846
    }
847
  return &intisa->opcodes[opc].funcUnit_uses[u];
848
}
849
 
850
 
851
 
852
/* Operand information.  */
853
 
854
 
855
#define CHECK_OPERAND(INTISA,OPC,ICLASS,OPND,ERRVAL) \
856
  do { \
857
    if ((OPND) < 0 || (OPND) >= (ICLASS)->num_operands) \
858
      { \
859
        xtisa_errno = xtensa_isa_bad_operand; \
860
        sprintf (xtisa_error_msg, "invalid operand number (%d); " \
861
                 "opcode \"%s\" has %d operands", (OPND), \
862
                 (INTISA)->opcodes[(OPC)].name, (ICLASS)->num_operands); \
863
        return (ERRVAL); \
864
      } \
865
  } while (0)
866
 
867
 
868
static xtensa_operand_internal *
869
get_operand (xtensa_isa_internal *intisa, xtensa_opcode opc, int opnd)
870
{
871
  xtensa_iclass_internal *iclass;
872
  int iclass_id, operand_id;
873
 
874
  CHECK_OPCODE (intisa, opc, NULL);
875
  iclass_id = intisa->opcodes[opc].iclass_id;
876
  iclass = &intisa->iclasses[iclass_id];
877
  CHECK_OPERAND (intisa, opc, iclass, opnd, NULL);
878
  operand_id = iclass->operands[opnd].u.operand_id;
879
  return &intisa->operands[operand_id];
880
}
881
 
882
 
883
const char *
884
xtensa_operand_name (xtensa_isa isa, xtensa_opcode opc, int opnd)
885
{
886
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
887
  xtensa_operand_internal *intop;
888
 
889
  intop = get_operand (intisa, opc, opnd);
890
  if (!intop) return NULL;
891
  return intop->name;
892
}
893
 
894
 
895
int
896
xtensa_operand_is_visible (xtensa_isa isa, xtensa_opcode opc, int opnd)
897
{
898
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
899
  xtensa_iclass_internal *iclass;
900
  int iclass_id, operand_id;
901
  xtensa_operand_internal *intop;
902
 
903
  CHECK_OPCODE (intisa, opc, XTENSA_UNDEFINED);
904
  iclass_id = intisa->opcodes[opc].iclass_id;
905
  iclass = &intisa->iclasses[iclass_id];
906
  CHECK_OPERAND (intisa, opc, iclass, opnd, XTENSA_UNDEFINED);
907
 
908
  /* Special case for "sout" operands.  */
909
  if (iclass->operands[opnd].inout == 's')
910
    return 0;
911
 
912
  operand_id = iclass->operands[opnd].u.operand_id;
913
  intop = &intisa->operands[operand_id];
914
 
915
  if ((intop->flags & XTENSA_OPERAND_IS_INVISIBLE) == 0)
916
    return 1;
917
  return 0;
918
}
919
 
920
 
921
char
922
xtensa_operand_inout (xtensa_isa isa, xtensa_opcode opc, int opnd)
923
{
924
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
925
  xtensa_iclass_internal *iclass;
926
  int iclass_id;
927
  char inout;
928
 
929
  CHECK_OPCODE (intisa, opc, 0);
930
  iclass_id = intisa->opcodes[opc].iclass_id;
931
  iclass = &intisa->iclasses[iclass_id];
932
  CHECK_OPERAND (intisa, opc, iclass, opnd, 0);
933
  inout = iclass->operands[opnd].inout;
934
 
935
  /* Special case for "sout" operands.  */
936
  if (inout == 's')
937
    return 'o';
938
 
939
  return inout;
940
}
941
 
942
 
943
int
944
xtensa_operand_get_field (xtensa_isa isa, xtensa_opcode opc, int opnd,
945
                          xtensa_format fmt, int slot,
946
                          const xtensa_insnbuf slotbuf, uint32 *valp)
947
{
948
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
949
  xtensa_operand_internal *intop;
950
  int slot_id;
951
  xtensa_get_field_fn get_fn;
952
 
953
  intop = get_operand (intisa, opc, opnd);
954
  if (!intop) return -1;
955
 
956
  CHECK_FORMAT (intisa, fmt, -1);
957
  CHECK_SLOT (intisa, fmt, slot, -1);
958
 
959
  slot_id = intisa->formats[fmt].slot_id[slot];
960
  if (intop->field_id == XTENSA_UNDEFINED)
961
    {
962
      xtisa_errno = xtensa_isa_no_field;
963
      strcpy (xtisa_error_msg, "implicit operand has no field");
964
      return -1;
965
    }
966
  get_fn = intisa->slots[slot_id].get_field_fns[intop->field_id];
967
  if (!get_fn)
968
    {
969
      xtisa_errno = xtensa_isa_wrong_slot;
970
      sprintf (xtisa_error_msg,
971
               "operand \"%s\" does not exist in slot %d of format \"%s\"",
972
               intop->name, slot, intisa->formats[fmt].name);
973
      return -1;
974
    }
975
  *valp = (*get_fn) (slotbuf);
976
  return 0;
977
}
978
 
979
 
980
int
981
xtensa_operand_set_field (xtensa_isa isa, xtensa_opcode opc, int opnd,
982
                          xtensa_format fmt, int slot,
983
                          xtensa_insnbuf slotbuf, uint32 val)
984
{
985
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
986
  xtensa_operand_internal *intop;
987
  int slot_id;
988
  xtensa_set_field_fn set_fn;
989
 
990
  intop = get_operand (intisa, opc, opnd);
991
  if (!intop) return -1;
992
 
993
  CHECK_FORMAT (intisa, fmt, -1);
994
  CHECK_SLOT (intisa, fmt, slot, -1);
995
 
996
  slot_id = intisa->formats[fmt].slot_id[slot];
997
  if (intop->field_id == XTENSA_UNDEFINED)
998
    {
999
      xtisa_errno = xtensa_isa_no_field;
1000
      strcpy (xtisa_error_msg, "implicit operand has no field");
1001
      return -1;
1002
    }
1003
  set_fn = intisa->slots[slot_id].set_field_fns[intop->field_id];
1004
  if (!set_fn)
1005
    {
1006
      xtisa_errno = xtensa_isa_wrong_slot;
1007
      sprintf (xtisa_error_msg,
1008
               "operand \"%s\" does not exist in slot %d of format \"%s\"",
1009
               intop->name, slot, intisa->formats[fmt].name);
1010
      return -1;
1011
    }
1012
  (*set_fn) (slotbuf, val);
1013
  return 0;
1014
}
1015
 
1016
 
1017
int
1018
xtensa_operand_encode (xtensa_isa isa, xtensa_opcode opc, int opnd,
1019
                       uint32 *valp)
1020
{
1021
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1022
  xtensa_operand_internal *intop;
1023
  uint32 test_val, orig_val;
1024
 
1025
  intop = get_operand (intisa, opc, opnd);
1026
  if (!intop) return -1;
1027
 
1028
  if (!intop->encode)
1029
    {
1030
      /* This is a default operand for a field.  How can we tell if the
1031
         value fits in the field?  Write the value into the field,
1032
         read it back, and then make sure we get the same value.  */
1033
 
1034
      xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1035
      static xtensa_insnbuf tmpbuf = 0;
1036
      int slot_id;
1037
 
1038
      if (!tmpbuf)
1039
        {
1040
          tmpbuf = xtensa_insnbuf_alloc (isa);
1041
          CHECK_ALLOC (tmpbuf, -1);
1042
        }
1043
 
1044
      /* A default operand is always associated with a field,
1045
         but check just to be sure....  */
1046
      if (intop->field_id == XTENSA_UNDEFINED)
1047
        {
1048
          xtisa_errno = xtensa_isa_internal_error;
1049
          strcpy (xtisa_error_msg, "operand has no field");
1050
          return -1;
1051
        }
1052
 
1053
      /* Find some slot that includes the field.  */
1054
      for (slot_id = 0; slot_id < intisa->num_slots; slot_id++)
1055
        {
1056
          xtensa_get_field_fn get_fn =
1057
            intisa->slots[slot_id].get_field_fns[intop->field_id];
1058
          xtensa_set_field_fn set_fn =
1059
            intisa->slots[slot_id].set_field_fns[intop->field_id];
1060
 
1061
          if (get_fn && set_fn)
1062
            {
1063
              (*set_fn) (tmpbuf, *valp);
1064
              return ((*get_fn) (tmpbuf) != *valp);
1065
            }
1066
        }
1067
 
1068
      /* Couldn't find any slot containing the field....  */
1069
      xtisa_errno = xtensa_isa_no_field;
1070
      strcpy (xtisa_error_msg, "field does not exist in any slot");
1071
      return -1;
1072
    }
1073
 
1074
  /* Encode the value.  In some cases, the encoding function may detect
1075
     errors, but most of the time the only way to determine if the value
1076
     was successfully encoded is to decode it and check if it matches
1077
     the original value.  */
1078
  orig_val = *valp;
1079
  if ((*intop->encode) (valp) ||
1080
      (test_val = *valp, (*intop->decode) (&test_val)) ||
1081
      test_val != orig_val)
1082
    {
1083
      xtisa_errno = xtensa_isa_bad_value;
1084
      sprintf (xtisa_error_msg, "cannot encode operand value 0x%08x", *valp);
1085
      return -1;
1086
    }
1087
 
1088
  return 0;
1089
}
1090
 
1091
 
1092
int
1093
xtensa_operand_decode (xtensa_isa isa, xtensa_opcode opc, int opnd,
1094
                       uint32 *valp)
1095
{
1096
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1097
  xtensa_operand_internal *intop;
1098
 
1099
  intop = get_operand (intisa, opc, opnd);
1100
  if (!intop) return -1;
1101
 
1102
  /* Use identity function for "default" operands.  */
1103
  if (!intop->decode)
1104
    return 0;
1105
 
1106
  if ((*intop->decode) (valp))
1107
    {
1108
      xtisa_errno = xtensa_isa_bad_value;
1109
      sprintf (xtisa_error_msg, "cannot decode operand value 0x%08x", *valp);
1110
      return -1;
1111
    }
1112
  return 0;
1113
}
1114
 
1115
 
1116
int
1117
xtensa_operand_is_register (xtensa_isa isa, xtensa_opcode opc, int opnd)
1118
{
1119
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1120
  xtensa_operand_internal *intop;
1121
 
1122
  intop = get_operand (intisa, opc, opnd);
1123
  if (!intop) return XTENSA_UNDEFINED;
1124
 
1125
  if ((intop->flags & XTENSA_OPERAND_IS_REGISTER) != 0)
1126
    return 1;
1127
  return 0;
1128
}
1129
 
1130
 
1131
xtensa_regfile
1132
xtensa_operand_regfile (xtensa_isa isa, xtensa_opcode opc, int opnd)
1133
{
1134
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1135
  xtensa_operand_internal *intop;
1136
 
1137
  intop = get_operand (intisa, opc, opnd);
1138
  if (!intop) return XTENSA_UNDEFINED;
1139
 
1140
  return intop->regfile;
1141
}
1142
 
1143
 
1144
int
1145
xtensa_operand_num_regs (xtensa_isa isa, xtensa_opcode opc, int opnd)
1146
{
1147
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1148
  xtensa_operand_internal *intop;
1149
 
1150
  intop = get_operand (intisa, opc, opnd);
1151
  if (!intop) return XTENSA_UNDEFINED;
1152
 
1153
  return intop->num_regs;
1154
}
1155
 
1156
 
1157
int
1158
xtensa_operand_is_known_reg (xtensa_isa isa, xtensa_opcode opc, int opnd)
1159
{
1160
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1161
  xtensa_operand_internal *intop;
1162
 
1163
  intop = get_operand (intisa, opc, opnd);
1164
  if (!intop) return XTENSA_UNDEFINED;
1165
 
1166
  if ((intop->flags & XTENSA_OPERAND_IS_UNKNOWN) == 0)
1167
    return 1;
1168
  return 0;
1169
}
1170
 
1171
 
1172
int
1173
xtensa_operand_is_PCrelative (xtensa_isa isa, xtensa_opcode opc, int opnd)
1174
{
1175
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1176
  xtensa_operand_internal *intop;
1177
 
1178
  intop = get_operand (intisa, opc, opnd);
1179
  if (!intop) return XTENSA_UNDEFINED;
1180
 
1181
  if ((intop->flags & XTENSA_OPERAND_IS_PCRELATIVE) != 0)
1182
    return 1;
1183
  return 0;
1184
}
1185
 
1186
 
1187
int
1188
xtensa_operand_do_reloc (xtensa_isa isa, xtensa_opcode opc, int opnd,
1189
                         uint32 *valp, uint32 pc)
1190
{
1191
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1192
  xtensa_operand_internal *intop;
1193
 
1194
  intop = get_operand (intisa, opc, opnd);
1195
  if (!intop) return -1;
1196
 
1197
  if ((intop->flags & XTENSA_OPERAND_IS_PCRELATIVE) == 0)
1198
    return 0;
1199
 
1200
  if (!intop->do_reloc)
1201
    {
1202
      xtisa_errno = xtensa_isa_internal_error;
1203
      strcpy (xtisa_error_msg, "operand missing do_reloc function");
1204
      return -1;
1205
    }
1206
 
1207
  if ((*intop->do_reloc) (valp, pc))
1208
    {
1209
      xtisa_errno = xtensa_isa_bad_value;
1210
      sprintf (xtisa_error_msg,
1211
               "do_reloc failed for value 0x%08x at PC 0x%08x", *valp, pc);
1212
      return -1;
1213
    }
1214
 
1215
  return 0;
1216
}
1217
 
1218
 
1219
int
1220
xtensa_operand_undo_reloc (xtensa_isa isa, xtensa_opcode opc, int opnd,
1221
                           uint32 *valp, uint32 pc)
1222
{
1223
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1224
  xtensa_operand_internal *intop;
1225
 
1226
  intop = get_operand (intisa, opc, opnd);
1227
  if (!intop) return -1;
1228
 
1229
  if ((intop->flags & XTENSA_OPERAND_IS_PCRELATIVE) == 0)
1230
    return 0;
1231
 
1232
  if (!intop->undo_reloc)
1233
    {
1234
      xtisa_errno = xtensa_isa_internal_error;
1235
      strcpy (xtisa_error_msg, "operand missing undo_reloc function");
1236
      return -1;
1237
    }
1238
 
1239
  if ((*intop->undo_reloc) (valp, pc))
1240
    {
1241
      xtisa_errno = xtensa_isa_bad_value;
1242
      sprintf (xtisa_error_msg,
1243
               "undo_reloc failed for value 0x%08x at PC 0x%08x", *valp, pc);
1244
      return -1;
1245
    }
1246
 
1247
  return 0;
1248
}
1249
 
1250
 
1251
 
1252
/* State Operands.  */
1253
 
1254
 
1255
#define CHECK_STATE_OPERAND(INTISA,OPC,ICLASS,STOP,ERRVAL) \
1256
  do { \
1257
    if ((STOP) < 0 || (STOP) >= (ICLASS)->num_stateOperands) \
1258
      { \
1259
        xtisa_errno = xtensa_isa_bad_operand; \
1260
        sprintf (xtisa_error_msg, "invalid state operand number (%d); " \
1261
                 "opcode \"%s\" has %d state operands", (STOP), \
1262
                 (INTISA)->opcodes[(OPC)].name, (ICLASS)->num_stateOperands); \
1263
        return (ERRVAL); \
1264
      } \
1265
  } while (0)
1266
 
1267
 
1268
xtensa_state
1269
xtensa_stateOperand_state (xtensa_isa isa, xtensa_opcode opc, int stOp)
1270
{
1271
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1272
  xtensa_iclass_internal *iclass;
1273
  int iclass_id;
1274
 
1275
  CHECK_OPCODE (intisa, opc, XTENSA_UNDEFINED);
1276
  iclass_id = intisa->opcodes[opc].iclass_id;
1277
  iclass = &intisa->iclasses[iclass_id];
1278
  CHECK_STATE_OPERAND (intisa, opc, iclass, stOp, XTENSA_UNDEFINED);
1279
  return iclass->stateOperands[stOp].u.state;
1280
}
1281
 
1282
 
1283
char
1284
xtensa_stateOperand_inout (xtensa_isa isa, xtensa_opcode opc, int stOp)
1285
{
1286
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1287
  xtensa_iclass_internal *iclass;
1288
  int iclass_id;
1289
 
1290
  CHECK_OPCODE (intisa, opc, 0);
1291
  iclass_id = intisa->opcodes[opc].iclass_id;
1292
  iclass = &intisa->iclasses[iclass_id];
1293
  CHECK_STATE_OPERAND (intisa, opc, iclass, stOp, 0);
1294
  return iclass->stateOperands[stOp].inout;
1295
}
1296
 
1297
 
1298
 
1299
/* Interface Operands.  */
1300
 
1301
 
1302
#define CHECK_INTERFACE_OPERAND(INTISA,OPC,ICLASS,IFOP,ERRVAL) \
1303
  do { \
1304
    if ((IFOP) < 0 || (IFOP) >= (ICLASS)->num_interfaceOperands) \
1305
      { \
1306
        xtisa_errno = xtensa_isa_bad_operand; \
1307
        sprintf (xtisa_error_msg, "invalid interface operand number (%d); " \
1308
                 "opcode \"%s\" has %d interface operands", (IFOP), \
1309
                 (INTISA)->opcodes[(OPC)].name, \
1310
                 (ICLASS)->num_interfaceOperands); \
1311
        return (ERRVAL); \
1312
      } \
1313
  } while (0)
1314
 
1315
 
1316
xtensa_interface
1317
xtensa_interfaceOperand_interface (xtensa_isa isa, xtensa_opcode opc,
1318
                                   int ifOp)
1319
{
1320
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1321
  xtensa_iclass_internal *iclass;
1322
  int iclass_id;
1323
 
1324
  CHECK_OPCODE (intisa, opc, XTENSA_UNDEFINED);
1325
  iclass_id = intisa->opcodes[opc].iclass_id;
1326
  iclass = &intisa->iclasses[iclass_id];
1327
  CHECK_INTERFACE_OPERAND (intisa, opc, iclass, ifOp, XTENSA_UNDEFINED);
1328
  return iclass->interfaceOperands[ifOp];
1329
}
1330
 
1331
 
1332
 
1333
/* Register Files.  */
1334
 
1335
 
1336
#define CHECK_REGFILE(INTISA,RF,ERRVAL) \
1337
  do { \
1338
    if ((RF) < 0 || (RF) >= (INTISA)->num_regfiles) \
1339
      { \
1340
        xtisa_errno = xtensa_isa_bad_regfile; \
1341
        strcpy (xtisa_error_msg, "invalid regfile specifier"); \
1342
        return (ERRVAL); \
1343
      } \
1344
  } while (0)
1345
 
1346
 
1347
xtensa_regfile
1348
xtensa_regfile_lookup (xtensa_isa isa, const char *name)
1349
{
1350
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1351
  int n;
1352
 
1353
  if (!name || !*name)
1354
    {
1355
      xtisa_errno = xtensa_isa_bad_regfile;
1356
      strcpy (xtisa_error_msg, "invalid regfile name");
1357
      return XTENSA_UNDEFINED;
1358
    }
1359
 
1360
  /* The expected number of regfiles is small; use a linear search.  */
1361
  for (n = 0; n < intisa->num_regfiles; n++)
1362
    {
1363
      if (!strcmp (intisa->regfiles[n].name, name))
1364
        return n;
1365
    }
1366
 
1367
  xtisa_errno = xtensa_isa_bad_regfile;
1368
  sprintf (xtisa_error_msg, "regfile \"%s\" not recognized", name);
1369
  return XTENSA_UNDEFINED;
1370
}
1371
 
1372
 
1373
xtensa_regfile
1374
xtensa_regfile_lookup_shortname (xtensa_isa isa, const char *shortname)
1375
{
1376
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1377
  int n;
1378
 
1379
  if (!shortname || !*shortname)
1380
    {
1381
      xtisa_errno = xtensa_isa_bad_regfile;
1382
      strcpy (xtisa_error_msg, "invalid regfile shortname");
1383
      return XTENSA_UNDEFINED;
1384
    }
1385
 
1386
  /* The expected number of regfiles is small; use a linear search.  */
1387
  for (n = 0; n < intisa->num_regfiles; n++)
1388
    {
1389
      /* Ignore regfile views since they always have the same shortnames
1390
         as their parents.  */
1391
      if (intisa->regfiles[n].parent != n)
1392
        continue;
1393
      if (!strcmp (intisa->regfiles[n].shortname, shortname))
1394
        return n;
1395
    }
1396
 
1397
  xtisa_errno = xtensa_isa_bad_regfile;
1398
  sprintf (xtisa_error_msg, "regfile shortname \"%s\" not recognized",
1399
           shortname);
1400
  return XTENSA_UNDEFINED;
1401
}
1402
 
1403
 
1404
const char *
1405
xtensa_regfile_name (xtensa_isa isa, xtensa_regfile rf)
1406
{
1407
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1408
  CHECK_REGFILE (intisa, rf, NULL);
1409
  return intisa->regfiles[rf].name;
1410
}
1411
 
1412
 
1413
const char *
1414
xtensa_regfile_shortname (xtensa_isa isa, xtensa_regfile rf)
1415
{
1416
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1417
  CHECK_REGFILE (intisa, rf, NULL);
1418
  return intisa->regfiles[rf].shortname;
1419
}
1420
 
1421
 
1422
xtensa_regfile
1423
xtensa_regfile_view_parent (xtensa_isa isa, xtensa_regfile rf)
1424
{
1425
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1426
  CHECK_REGFILE (intisa, rf, XTENSA_UNDEFINED);
1427
  return intisa->regfiles[rf].parent;
1428
}
1429
 
1430
 
1431
int
1432
xtensa_regfile_num_bits (xtensa_isa isa, xtensa_regfile rf)
1433
{
1434
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1435
  CHECK_REGFILE (intisa, rf, XTENSA_UNDEFINED);
1436
  return intisa->regfiles[rf].num_bits;
1437
}
1438
 
1439
 
1440
int
1441
xtensa_regfile_num_entries (xtensa_isa isa, xtensa_regfile rf)
1442
{
1443
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1444
  CHECK_REGFILE (intisa, rf, XTENSA_UNDEFINED);
1445
  return intisa->regfiles[rf].num_entries;
1446
}
1447
 
1448
 
1449
 
1450
/* Processor States.  */
1451
 
1452
 
1453
#define CHECK_STATE(INTISA,ST,ERRVAL) \
1454
  do { \
1455
    if ((ST) < 0 || (ST) >= (INTISA)->num_states) \
1456
      { \
1457
        xtisa_errno = xtensa_isa_bad_state; \
1458
        strcpy (xtisa_error_msg, "invalid state specifier"); \
1459
        return (ERRVAL); \
1460
      } \
1461
  } while (0)
1462
 
1463
 
1464
xtensa_state
1465
xtensa_state_lookup (xtensa_isa isa, const char *name)
1466
{
1467
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1468
  xtensa_lookup_entry entry, *result = 0;
1469
 
1470
  if (!name || !*name)
1471
    {
1472
      xtisa_errno = xtensa_isa_bad_state;
1473
      strcpy (xtisa_error_msg, "invalid state name");
1474
      return XTENSA_UNDEFINED;
1475
    }
1476
 
1477
  if (intisa->num_states != 0)
1478
    {
1479
      entry.key = name;
1480
      result = bsearch (&entry, intisa->state_lookup_table, intisa->num_states,
1481
                        sizeof (xtensa_lookup_entry), xtensa_isa_name_compare);
1482
    }
1483
 
1484
  if (!result)
1485
    {
1486
      xtisa_errno = xtensa_isa_bad_state;
1487
      sprintf (xtisa_error_msg, "state \"%s\" not recognized", name);
1488
      return XTENSA_UNDEFINED;
1489
    }
1490
 
1491
  return result->u.state;
1492
}
1493
 
1494
 
1495
const char *
1496
xtensa_state_name (xtensa_isa isa, xtensa_state st)
1497
{
1498
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1499
  CHECK_STATE (intisa, st, NULL);
1500
  return intisa->states[st].name;
1501
}
1502
 
1503
 
1504
int
1505
xtensa_state_num_bits (xtensa_isa isa, xtensa_state st)
1506
{
1507
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1508
  CHECK_STATE (intisa, st, XTENSA_UNDEFINED);
1509
  return intisa->states[st].num_bits;
1510
}
1511
 
1512
 
1513
int
1514
xtensa_state_is_exported (xtensa_isa isa, xtensa_state st)
1515
{
1516
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1517
  CHECK_STATE (intisa, st, XTENSA_UNDEFINED);
1518
  if ((intisa->states[st].flags & XTENSA_STATE_IS_EXPORTED) != 0)
1519
    return 1;
1520
  return 0;
1521
}
1522
 
1523
 
1524
 
1525
/* Sysregs.  */
1526
 
1527
 
1528
#define CHECK_SYSREG(INTISA,SYSREG,ERRVAL) \
1529
  do { \
1530
    if ((SYSREG) < 0 || (SYSREG) >= (INTISA)->num_sysregs) \
1531
      { \
1532
        xtisa_errno = xtensa_isa_bad_sysreg; \
1533
        strcpy (xtisa_error_msg, "invalid sysreg specifier"); \
1534
        return (ERRVAL); \
1535
      } \
1536
  } while (0)
1537
 
1538
 
1539
xtensa_sysreg
1540
xtensa_sysreg_lookup (xtensa_isa isa, int num, int is_user)
1541
{
1542
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1543
 
1544
  if (is_user != 0)
1545
    is_user = 1;
1546
 
1547
  if (num < 0 || num > intisa->max_sysreg_num[is_user]
1548
      || intisa->sysreg_table[is_user][num] == XTENSA_UNDEFINED)
1549
    {
1550
      xtisa_errno = xtensa_isa_bad_sysreg;
1551
      strcpy (xtisa_error_msg, "sysreg not recognized");
1552
      return XTENSA_UNDEFINED;
1553
    }
1554
 
1555
  return intisa->sysreg_table[is_user][num];
1556
}
1557
 
1558
 
1559
xtensa_sysreg
1560
xtensa_sysreg_lookup_name (xtensa_isa isa, const char *name)
1561
{
1562
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1563
  xtensa_lookup_entry entry, *result = 0;
1564
 
1565
  if (!name || !*name)
1566
    {
1567
      xtisa_errno = xtensa_isa_bad_sysreg;
1568
      strcpy (xtisa_error_msg, "invalid sysreg name");
1569
      return XTENSA_UNDEFINED;
1570
    }
1571
 
1572
  if (intisa->num_sysregs != 0)
1573
    {
1574
      entry.key = name;
1575
      result = bsearch (&entry, intisa->sysreg_lookup_table,
1576
                        intisa->num_sysregs, sizeof (xtensa_lookup_entry),
1577
                        xtensa_isa_name_compare);
1578
    }
1579
 
1580
  if (!result)
1581
    {
1582
      xtisa_errno = xtensa_isa_bad_sysreg;
1583
      sprintf (xtisa_error_msg, "sysreg \"%s\" not recognized", name);
1584
      return XTENSA_UNDEFINED;
1585
    }
1586
 
1587
  return result->u.sysreg;
1588
}
1589
 
1590
 
1591
const char *
1592
xtensa_sysreg_name (xtensa_isa isa, xtensa_sysreg sysreg)
1593
{
1594
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1595
  CHECK_SYSREG (intisa, sysreg, NULL);
1596
  return intisa->sysregs[sysreg].name;
1597
}
1598
 
1599
 
1600
int
1601
xtensa_sysreg_number (xtensa_isa isa, xtensa_sysreg sysreg)
1602
{
1603
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1604
  CHECK_SYSREG (intisa, sysreg, XTENSA_UNDEFINED);
1605
  return intisa->sysregs[sysreg].number;
1606
}
1607
 
1608
 
1609
int
1610
xtensa_sysreg_is_user (xtensa_isa isa, xtensa_sysreg sysreg)
1611
{
1612
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1613
  CHECK_SYSREG (intisa, sysreg, XTENSA_UNDEFINED);
1614
  if (intisa->sysregs[sysreg].is_user)
1615
    return 1;
1616
  return 0;
1617
}
1618
 
1619
 
1620
 
1621
/* Interfaces.  */
1622
 
1623
 
1624
#define CHECK_INTERFACE(INTISA,INTF,ERRVAL) \
1625
  do { \
1626
    if ((INTF) < 0 || (INTF) >= (INTISA)->num_interfaces) \
1627
      { \
1628
        xtisa_errno = xtensa_isa_bad_interface; \
1629
        strcpy (xtisa_error_msg, "invalid interface specifier"); \
1630
        return (ERRVAL); \
1631
      } \
1632
  } while (0)
1633
 
1634
 
1635
xtensa_interface
1636
xtensa_interface_lookup (xtensa_isa isa, const char *ifname)
1637
{
1638
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1639
  xtensa_lookup_entry entry, *result = 0;
1640
 
1641
  if (!ifname || !*ifname)
1642
    {
1643
      xtisa_errno = xtensa_isa_bad_interface;
1644
      strcpy (xtisa_error_msg, "invalid interface name");
1645
      return XTENSA_UNDEFINED;
1646
    }
1647
 
1648
  if (intisa->num_interfaces != 0)
1649
    {
1650
      entry.key = ifname;
1651
      result = bsearch (&entry, intisa->interface_lookup_table,
1652
                        intisa->num_interfaces, sizeof (xtensa_lookup_entry),
1653
                        xtensa_isa_name_compare);
1654
    }
1655
 
1656
  if (!result)
1657
    {
1658
      xtisa_errno = xtensa_isa_bad_interface;
1659
      sprintf (xtisa_error_msg, "interface \"%s\" not recognized", ifname);
1660
      return XTENSA_UNDEFINED;
1661
    }
1662
 
1663
  return result->u.intf;
1664
}
1665
 
1666
 
1667
const char *
1668
xtensa_interface_name (xtensa_isa isa, xtensa_interface intf)
1669
{
1670
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1671
  CHECK_INTERFACE (intisa, intf, NULL);
1672
  return intisa->interfaces[intf].name;
1673
}
1674
 
1675
 
1676
int
1677
xtensa_interface_num_bits (xtensa_isa isa, xtensa_interface intf)
1678
{
1679
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1680
  CHECK_INTERFACE (intisa, intf, XTENSA_UNDEFINED);
1681
  return intisa->interfaces[intf].num_bits;
1682
}
1683
 
1684
 
1685
char
1686
xtensa_interface_inout (xtensa_isa isa, xtensa_interface intf)
1687
{
1688
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1689
  CHECK_INTERFACE (intisa, intf, 0);
1690
  return intisa->interfaces[intf].inout;
1691
}
1692
 
1693
 
1694
int
1695
xtensa_interface_has_side_effect (xtensa_isa isa, xtensa_interface intf)
1696
{
1697
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1698
  CHECK_INTERFACE (intisa, intf, XTENSA_UNDEFINED);
1699
  if ((intisa->interfaces[intf].flags & XTENSA_INTERFACE_HAS_SIDE_EFFECT) != 0)
1700
    return 1;
1701
  return 0;
1702
}
1703
 
1704
 
1705
int
1706
xtensa_interface_class_id (xtensa_isa isa, xtensa_interface intf)
1707
{
1708
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1709
  CHECK_INTERFACE (intisa, intf, XTENSA_UNDEFINED);
1710
  return intisa->interfaces[intf].class_id;
1711
}
1712
 
1713
 
1714
 
1715
/* Functional Units.  */
1716
 
1717
 
1718
#define CHECK_FUNCUNIT(INTISA,FUN,ERRVAL) \
1719
  do { \
1720
    if ((FUN) < 0 || (FUN) >= (INTISA)->num_funcUnits) \
1721
      { \
1722
        xtisa_errno = xtensa_isa_bad_funcUnit; \
1723
        strcpy (xtisa_error_msg, "invalid functional unit specifier"); \
1724
        return (ERRVAL); \
1725
      } \
1726
  } while (0)
1727
 
1728
 
1729
xtensa_funcUnit
1730
xtensa_funcUnit_lookup (xtensa_isa isa, const char *fname)
1731
{
1732
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1733
  xtensa_lookup_entry entry, *result = 0;
1734
 
1735
  if (!fname || !*fname)
1736
    {
1737
      xtisa_errno = xtensa_isa_bad_funcUnit;
1738
      strcpy (xtisa_error_msg, "invalid functional unit name");
1739
      return XTENSA_UNDEFINED;
1740
    }
1741
 
1742
  if (intisa->num_funcUnits != 0)
1743
    {
1744
      entry.key = fname;
1745
      result = bsearch (&entry, intisa->funcUnit_lookup_table,
1746
                        intisa->num_funcUnits, sizeof (xtensa_lookup_entry),
1747
                        xtensa_isa_name_compare);
1748
    }
1749
 
1750
  if (!result)
1751
    {
1752
      xtisa_errno = xtensa_isa_bad_funcUnit;
1753
      sprintf (xtisa_error_msg,
1754
               "functional unit \"%s\" not recognized", fname);
1755
      return XTENSA_UNDEFINED;
1756
    }
1757
 
1758
  return result->u.fun;
1759
}
1760
 
1761
 
1762
const char *
1763
xtensa_funcUnit_name (xtensa_isa isa, xtensa_funcUnit fun)
1764
{
1765
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1766
  CHECK_FUNCUNIT (intisa, fun, NULL);
1767
  return intisa->funcUnits[fun].name;
1768
}
1769
 
1770
 
1771
int
1772
xtensa_funcUnit_num_copies (xtensa_isa isa, xtensa_funcUnit fun)
1773
{
1774
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
1775
  CHECK_FUNCUNIT (intisa, fun, XTENSA_UNDEFINED);
1776
  return intisa->funcUnits[fun].num_copies;
1777
}
1778
 

powered by: WebSVN 2.1.0

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