projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
gdb: add target_ops::supports_displaced_step
[deliverable/binutils-gdb.git] / opcodes / xc16x-ibld.c
CommitLineData
4162bb66 1/* DO NOT EDIT! -*- buffer-read-only: t -*- vi:set ro: */
d70c5fc7
NC		 2/* Instruction building/extraction support for xc16x. -*- C -*-
3
4 THIS FILE IS MACHINE GENERATED WITH CGEN: Cpu tools GENerator.
5 - the resultant file is machine generated, cgen-ibld.in isn't
6
b3adc24a 7 Copyright (C) 1996-2020 Free Software Foundation, Inc.
d70c5fc7 8
9b201bb5 9 This file is part of libopcodes.
d70c5fc7 10
9b201bb5 11 This library is free software; you can redistribute it and/or modify
d70c5fc7 12 it under the terms of the GNU General Public License as published by
9b201bb5 13 the Free Software Foundation; either version 3, or (at your option)
d70c5fc7
NC		 14 any later version.
15
9b201bb5
NC		 16 It is distributed in the hope that it will be useful, but WITHOUT
17 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
18 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
19 License for more details.
d70c5fc7
NC		 20
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software Foundation, Inc.,
23 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
24
25/* ??? Eventually more and more of this stuff can go to cpu-independent files.
26 Keep that in mind. */
27
28#include "sysdep.h"
29#include <stdio.h>
30#include "ansidecl.h"
31#include "dis-asm.h"
32#include "bfd.h"
33#include "symcat.h"
34#include "xc16x-desc.h"
35#include "xc16x-opc.h"
fe8afbc4 36#include "cgen/basic-modes.h"
d70c5fc7
NC		 37#include "opintl.h"
38#include "safe-ctype.h"
39
40#undef min
41#define min(a,b) ((a) < (b) ? (a) : (b))
42#undef max
43#define max(a,b) ((a) > (b) ? (a) : (b))
44
45/* Used by the ifield rtx function. */
46#define FLD(f) (fields->f)
47
48static const char * insert_normal
49 (CGEN_CPU_DESC, long, unsigned int, unsigned int, unsigned int,
50 unsigned int, unsigned int, unsigned int, CGEN_INSN_BYTES_PTR);
51static const char * insert_insn_normal
52 (CGEN_CPU_DESC, const CGEN_INSN *,
53 CGEN_FIELDS *, CGEN_INSN_BYTES_PTR, bfd_vma);
54static int extract_normal
55 (CGEN_CPU_DESC, CGEN_EXTRACT_INFO *, CGEN_INSN_INT,
56 unsigned int, unsigned int, unsigned int, unsigned int,
57 unsigned int, unsigned int, bfd_vma, long *);
58static int extract_insn_normal
59 (CGEN_CPU_DESC, const CGEN_INSN *, CGEN_EXTRACT_INFO *,
60 CGEN_INSN_INT, CGEN_FIELDS *, bfd_vma);
61#if CGEN_INT_INSN_P
62static void put_insn_int_value
63 (CGEN_CPU_DESC, CGEN_INSN_BYTES_PTR, int, int, CGEN_INSN_INT);
64#endif
65#if ! CGEN_INT_INSN_P
66static CGEN_INLINE void insert_1
67 (CGEN_CPU_DESC, unsigned long, int, int, int, unsigned char *);
68static CGEN_INLINE int fill_cache
69 (CGEN_CPU_DESC, CGEN_EXTRACT_INFO *, int, int, bfd_vma);
70static CGEN_INLINE long extract_1
71 (CGEN_CPU_DESC, CGEN_EXTRACT_INFO *, int, int, int, unsigned char *, bfd_vma);
72#endif
73\f
74/* Operand insertion. */
75
76#if ! CGEN_INT_INSN_P
77
78/* Subroutine of insert_normal. */
79
80static CGEN_INLINE void
81insert_1 (CGEN_CPU_DESC cd,
82 unsigned long value,
83 int start,
84 int length,
85 int word_length,
86 unsigned char *bufp)
87{
88 unsigned long x,mask;
89 int shift;
90
91 x = cgen_get_insn_value (cd, bufp, word_length);
92
93 /* Written this way to avoid undefined behaviour. */
94 mask = (((1L << (length - 1)) - 1) << 1) | 1;
95 if (CGEN_INSN_LSB0_P)
96 shift = (start + 1) - length;
97 else
98 shift = (word_length - (start + length));
99 x = (x & ~(mask << shift)) | ((value & mask) << shift);
100
101 cgen_put_insn_value (cd, bufp, word_length, (bfd_vma) x);
102}
103
104#endif /* ! CGEN_INT_INSN_P */
105
106/* Default insertion routine.
107
108 ATTRS is a mask of the boolean attributes.
109 WORD_OFFSET is the offset in bits from the start of the insn of the value.
110 WORD_LENGTH is the length of the word in bits in which the value resides.
111 START is the starting bit number in the word, architecture origin.
112 LENGTH is the length of VALUE in bits.
113 TOTAL_LENGTH is the total length of the insn in bits.
114
115 The result is an error message or NULL if success. */
116
117/* ??? This duplicates functionality with bfd's howto table and
118 bfd_install_relocation. */
119/* ??? This doesn't handle bfd_vma's. Create another function when
120 necessary. */
121
122static const char *
123insert_normal (CGEN_CPU_DESC cd,
124 long value,
125 unsigned int attrs,
126 unsigned int word_offset,
127 unsigned int start,
128 unsigned int length,
129 unsigned int word_length,
130 unsigned int total_length,
131 CGEN_INSN_BYTES_PTR buffer)
132{
133 static char errbuf[100];
134 /* Written this way to avoid undefined behaviour. */
135 unsigned long mask = (((1L << (length - 1)) - 1) << 1) | 1;
136
137 /* If LENGTH is zero, this operand doesn't contribute to the value. */
138 if (length == 0)
139 return NULL;
140
b7cd1872 141 if (word_length > 8 * sizeof (CGEN_INSN_INT))
d70c5fc7
NC		 142 abort ();
143
144 /* For architectures with insns smaller than the base-insn-bitsize,
145 word_length may be too big. */
146 if (cd->min_insn_bitsize < cd->base_insn_bitsize)
147 {
148 if (word_offset == 0
149 && word_length > total_length)
150 word_length = total_length;
151 }
152
153 /* Ensure VALUE will fit. */
154 if (CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGN_OPT))
155 {
156 long minval = - (1L << (length - 1));
157 unsigned long maxval = mask;
43e65147 158
d70c5fc7
NC		 159 if ((value > 0 && (unsigned long) value > maxval)
160 || value < minval)
161 {
162 /* xgettext:c-format */
163 sprintf (errbuf,
164 _("operand out of range (%ld not between %ld and %lu)"),
165 value, minval, maxval);
166 return errbuf;
167 }
168 }
169 else if (! CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGNED))
170 {
171 unsigned long maxval = mask;
ed963e2d
NC		 172 unsigned long val = (unsigned long) value;
173
174 /* For hosts with a word size > 32 check to see if value has been sign
175 extended beyond 32 bits. If so then ignore these higher sign bits
176 as the user is attempting to store a 32-bit signed value into an
177 unsigned 32-bit field which is allowed. */
178 if (sizeof (unsigned long) > 4 && ((value >> 32) == -1))
179 val &= 0xFFFFFFFF;
180
181 if (val > maxval)
d70c5fc7
NC		 182 {
183 /* xgettext:c-format */
184 sprintf (errbuf,
ed963e2d
NC		 185 _("operand out of range (0x%lx not between 0 and 0x%lx)"),
186 val, maxval);
d70c5fc7
NC		 187 return errbuf;
188 }
189 }
190 else
191 {
192 if (! cgen_signed_overflow_ok_p (cd))
193 {
194 long minval = - (1L << (length - 1));
195 long maxval = (1L << (length - 1)) - 1;
43e65147 196
d70c5fc7
NC		 197 if (value < minval || value > maxval)
198 {
199 sprintf
200 /* xgettext:c-format */
201 (errbuf, _("operand out of range (%ld not between %ld and %ld)"),
202 value, minval, maxval);
203 return errbuf;
204 }
205 }
206 }
207
208#if CGEN_INT_INSN_P
209
210 {
a143b004 211 int shift_within_word, shift_to_word, shift;
d70c5fc7 212
a143b004
AB		 213 /* How to shift the value to BIT0 of the word. */
214 shift_to_word = total_length - (word_offset + word_length);
215
216 /* How to shift the value to the field within the word. */
d70c5fc7 217 if (CGEN_INSN_LSB0_P)
a143b004 218 shift_within_word = start + 1 - length;
d70c5fc7 219 else
a143b004
AB		 220 shift_within_word = word_length - start - length;
221
222 /* The total SHIFT, then mask in the value. */
223 shift = shift_to_word + shift_within_word;
d70c5fc7
NC		 224 *buffer = (*buffer & ~(mask << shift)) | ((value & mask) << shift);
225 }
226
227#else /* ! CGEN_INT_INSN_P */
228
229 {
230 unsigned char *bufp = (unsigned char *) buffer + word_offset / 8;
231
232 insert_1 (cd, value, start, length, word_length, bufp);
233 }
234
235#endif /* ! CGEN_INT_INSN_P */
236
237 return NULL;
238}
239
240/* Default insn builder (insert handler).
241 The instruction is recorded in CGEN_INT_INSN_P byte order (meaning
242 that if CGEN_INSN_BYTES_PTR is an int * and thus, the value is
243 recorded in host byte order, otherwise BUFFER is an array of bytes
244 and the value is recorded in target byte order).
245 The result is an error message or NULL if success. */
246
247static const char *
248insert_insn_normal (CGEN_CPU_DESC cd,
249 const CGEN_INSN * insn,
250 CGEN_FIELDS * fields,
251 CGEN_INSN_BYTES_PTR buffer,
252 bfd_vma pc)
253{
254 const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
255 unsigned long value;
256 const CGEN_SYNTAX_CHAR_TYPE * syn;
257
258 CGEN_INIT_INSERT (cd);
259 value = CGEN_INSN_BASE_VALUE (insn);
260
261 /* If we're recording insns as numbers (rather than a string of bytes),
262 target byte order handling is deferred until later. */
263
264#if CGEN_INT_INSN_P
265
266 put_insn_int_value (cd, buffer, cd->base_insn_bitsize,
267 CGEN_FIELDS_BITSIZE (fields), value);
268
269#else
270
271 cgen_put_insn_value (cd, buffer, min ((unsigned) cd->base_insn_bitsize,
272 (unsigned) CGEN_FIELDS_BITSIZE (fields)),
273 value);
274
275#endif /* ! CGEN_INT_INSN_P */
276
277 /* ??? It would be better to scan the format's fields.
278 Still need to be able to insert a value based on the operand though;
279 e.g. storing a branch displacement that got resolved later.
280 Needs more thought first. */
281
282 for (syn = CGEN_SYNTAX_STRING (syntax); * syn; ++ syn)
283 {
284 const char *errmsg;
285
286 if (CGEN_SYNTAX_CHAR_P (* syn))
287 continue;
288
289 errmsg = (* cd->insert_operand) (cd, CGEN_SYNTAX_FIELD (*syn),
290 fields, buffer, pc);
291 if (errmsg)
292 return errmsg;
293 }
294
295 return NULL;
296}
297
298#if CGEN_INT_INSN_P
299/* Cover function to store an insn value into an integral insn. Must go here
300 because it needs <prefix>-desc.h for CGEN_INT_INSN_P. */
301
302static void
303put_insn_int_value (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
304 CGEN_INSN_BYTES_PTR buf,
305 int length,
306 int insn_length,
307 CGEN_INSN_INT value)
308{
309 /* For architectures with insns smaller than the base-insn-bitsize,
310 length may be too big. */
311 if (length > insn_length)
312 *buf = value;
313 else
314 {
315 int shift = insn_length - length;
316 /* Written this way to avoid undefined behaviour. */
317 CGEN_INSN_INT mask = (((1L << (length - 1)) - 1) << 1) | 1;
318
319 *buf = (*buf & ~(mask << shift)) | ((value & mask) << shift);
320 }
321}
322#endif
323\f
324/* Operand extraction. */
325
326#if ! CGEN_INT_INSN_P
327
328/* Subroutine of extract_normal.
329 Ensure sufficient bytes are cached in EX_INFO.
330 OFFSET is the offset in bytes from the start of the insn of the value.
331 BYTES is the length of the needed value.
332 Returns 1 for success, 0 for failure. */
333
334static CGEN_INLINE int
335fill_cache (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
336 CGEN_EXTRACT_INFO *ex_info,
337 int offset,
338 int bytes,
339 bfd_vma pc)
340{
341 /* It's doubtful that the middle part has already been fetched so
342 we don't optimize that case. kiss. */
343 unsigned int mask;
344 disassemble_info *info = (disassemble_info *) ex_info->dis_info;
345
346 /* First do a quick check. */
347 mask = (1 << bytes) - 1;
348 if (((ex_info->valid >> offset) & mask) == mask)
349 return 1;
350
351 /* Search for the first byte we need to read. */
352 for (mask = 1 << offset; bytes > 0; --bytes, ++offset, mask <<= 1)
353 if (! (mask & ex_info->valid))
354 break;
355
356 if (bytes)
357 {
358 int status;
359
360 pc += offset;
361 status = (*info->read_memory_func)
362 (pc, ex_info->insn_bytes + offset, bytes, info);
363
364 if (status != 0)
365 {
366 (*info->memory_error_func) (status, pc, info);
367 return 0;
368 }
369
370 ex_info->valid |= ((1 << bytes) - 1) << offset;
371 }
372
373 return 1;
374}
375
376/* Subroutine of extract_normal. */
377
378static CGEN_INLINE long
379extract_1 (CGEN_CPU_DESC cd,
380 CGEN_EXTRACT_INFO *ex_info ATTRIBUTE_UNUSED,
381 int start,
382 int length,
383 int word_length,
384 unsigned char *bufp,
385 bfd_vma pc ATTRIBUTE_UNUSED)
386{
387 unsigned long x;
388 int shift;
389
390 x = cgen_get_insn_value (cd, bufp, word_length);
391
392 if (CGEN_INSN_LSB0_P)
393 shift = (start + 1) - length;
394 else
395 shift = (word_length - (start + length));
396 return x >> shift;
397}
398
399#endif /* ! CGEN_INT_INSN_P */
400
401/* Default extraction routine.
402
403 INSN_VALUE is the first base_insn_bitsize bits of the insn in host order,
404 or sometimes less for cases like the m32r where the base insn size is 32
405 but some insns are 16 bits.
406 ATTRS is a mask of the boolean attributes. We only need `SIGNED',
407 but for generality we take a bitmask of all of them.
408 WORD_OFFSET is the offset in bits from the start of the insn of the value.
409 WORD_LENGTH is the length of the word in bits in which the value resides.
410 START is the starting bit number in the word, architecture origin.
411 LENGTH is the length of VALUE in bits.
412 TOTAL_LENGTH is the total length of the insn in bits.
413
414 Returns 1 for success, 0 for failure. */
415
416/* ??? The return code isn't properly used. wip. */
417
418/* ??? This doesn't handle bfd_vma's. Create another function when
419 necessary. */
420
421static int
422extract_normal (CGEN_CPU_DESC cd,
423#if ! CGEN_INT_INSN_P
424 CGEN_EXTRACT_INFO *ex_info,
425#else
426 CGEN_EXTRACT_INFO *ex_info ATTRIBUTE_UNUSED,
427#endif
428 CGEN_INSN_INT insn_value,
429 unsigned int attrs,
430 unsigned int word_offset,
431 unsigned int start,
432 unsigned int length,
433 unsigned int word_length,
434 unsigned int total_length,
435#if ! CGEN_INT_INSN_P
436 bfd_vma pc,
437#else
438 bfd_vma pc ATTRIBUTE_UNUSED,
439#endif
440 long *valuep)
441{
442 long value, mask;
443
444 /* If LENGTH is zero, this operand doesn't contribute to the value
445 so give it a standard value of zero. */
446 if (length == 0)
447 {
448 *valuep = 0;
449 return 1;
450 }
451
b7cd1872 452 if (word_length > 8 * sizeof (CGEN_INSN_INT))
d70c5fc7
NC		 453 abort ();
454
455 /* For architectures with insns smaller than the insn-base-bitsize,
456 word_length may be too big. */
457 if (cd->min_insn_bitsize < cd->base_insn_bitsize)
458 {
459 if (word_offset + word_length > total_length)
460 word_length = total_length - word_offset;
461 }
462
463 /* Does the value reside in INSN_VALUE, and at the right alignment? */
464
465 if (CGEN_INT_INSN_P || (word_offset == 0 && word_length == total_length))
466 {
467 if (CGEN_INSN_LSB0_P)
468 value = insn_value >> ((word_offset + start + 1) - length);
469 else
470 value = insn_value >> (total_length - ( word_offset + start + length));
471 }
472
473#if ! CGEN_INT_INSN_P
474
475 else
476 {
477 unsigned char *bufp = ex_info->insn_bytes + word_offset / 8;
478
b7cd1872 479 if (word_length > 8 * sizeof (CGEN_INSN_INT))
d70c5fc7
NC		 480 abort ();
481
482 if (fill_cache (cd, ex_info, word_offset / 8, word_length / 8, pc) == 0)
2f5dd314
AM		 483 {
484 *valuep = 0;
485 return 0;
486 }
d70c5fc7
NC		 487
488 value = extract_1 (cd, ex_info, start, length, word_length, bufp, pc);
489 }
490
491#endif /* ! CGEN_INT_INSN_P */
492
493 /* Written this way to avoid undefined behaviour. */
494 mask = (((1L << (length - 1)) - 1) << 1) | 1;
495
496 value &= mask;
497 /* sign extend? */
498 if (CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGNED)
499 && (value & (1L << (length - 1))))
500 value |= ~mask;
501
502 *valuep = value;
503
504 return 1;
505}
506
507/* Default insn extractor.
508
509 INSN_VALUE is the first base_insn_bitsize bits, translated to host order.
510 The extracted fields are stored in FIELDS.
511 EX_INFO is used to handle reading variable length insns.
512 Return the length of the insn in bits, or 0 if no match,
513 or -1 if an error occurs fetching data (memory_error_func will have
514 been called). */
515
516static int
517extract_insn_normal (CGEN_CPU_DESC cd,
518 const CGEN_INSN *insn,
519 CGEN_EXTRACT_INFO *ex_info,
520 CGEN_INSN_INT insn_value,
521 CGEN_FIELDS *fields,
522 bfd_vma pc)
523{
524 const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
525 const CGEN_SYNTAX_CHAR_TYPE *syn;
526
527 CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn);
528
529 CGEN_INIT_EXTRACT (cd);
530
531 for (syn = CGEN_SYNTAX_STRING (syntax); *syn; ++syn)
532 {
533 int length;
534
535 if (CGEN_SYNTAX_CHAR_P (*syn))
536 continue;
537
538 length = (* cd->extract_operand) (cd, CGEN_SYNTAX_FIELD (*syn),
539 ex_info, insn_value, fields, pc);
540 if (length <= 0)
541 return length;
542 }
543
544 /* We recognized and successfully extracted this insn. */
545 return CGEN_INSN_BITSIZE (insn);
546}
547\f
548/* Machine generated code added here. */
549
550const char * xc16x_cgen_insert_operand
551 (CGEN_CPU_DESC, int, CGEN_FIELDS *, CGEN_INSN_BYTES_PTR, bfd_vma);
552
553/* Main entry point for operand insertion.
554
555 This function is basically just a big switch statement. Earlier versions
556 used tables to look up the function to use, but
557 - if the table contains both assembler and disassembler functions then
558 the disassembler contains much of the assembler and vice-versa,
559 - there's a lot of inlining possibilities as things grow,
560 - using a switch statement avoids the function call overhead.
561
562 This function could be moved into `parse_insn_normal', but keeping it
563 separate makes clear the interface between `parse_insn_normal' and each of
564 the handlers. It's also needed by GAS to insert operands that couldn't be
565 resolved during parsing. */
566
567const char *
568xc16x_cgen_insert_operand (CGEN_CPU_DESC cd,
569 int opindex,
570 CGEN_FIELDS * fields,
571 CGEN_INSN_BYTES_PTR buffer,
572 bfd_vma pc ATTRIBUTE_UNUSED)
573{
574 const char * errmsg = NULL;
575 unsigned int total_length = CGEN_FIELDS_BITSIZE (fields);
576
577 switch (opindex)
578 {
579 case XC16X_OPERAND_REGNAM :
580 errmsg = insert_normal (cd, fields->f_reg8, 0, 0, 15, 8, 32, total_length, buffer);
581 break;
582 case XC16X_OPERAND_BIT01 :
583 errmsg = insert_normal (cd, fields->f_op_1bit, 0, 0, 8, 1, 32, total_length, buffer);
584 break;
585 case XC16X_OPERAND_BIT1 :
586 errmsg = insert_normal (cd, fields->f_op_bit1, 0, 0, 11, 1, 32, total_length, buffer);
587 break;
588 case XC16X_OPERAND_BIT2 :
589 errmsg = insert_normal (cd, fields->f_op_bit2, 0, 0, 11, 2, 32, total_length, buffer);
590 break;
591 case XC16X_OPERAND_BIT4 :
592 errmsg = insert_normal (cd, fields->f_op_bit4, 0, 0, 11, 4, 32, total_length, buffer);
593 break;
594 case XC16X_OPERAND_BIT8 :
595 errmsg = insert_normal (cd, fields->f_op_bit8, 0, 0, 31, 8, 32, total_length, buffer);
596 break;
597 case XC16X_OPERAND_BITONE :
598 errmsg = insert_normal (cd, fields->f_op_onebit, 0, 0, 9, 1, 32, total_length, buffer);
599 break;
600 case XC16X_OPERAND_CADDR :
601 errmsg = insert_normal (cd, fields->f_offset16, 0|(1<<CGEN_IFLD_RELOC)|(1<<CGEN_IFLD_ABS_ADDR), 0, 31, 16, 32, total_length, buffer);
602 break;
603 case XC16X_OPERAND_COND :
604 errmsg = insert_normal (cd, fields->f_condcode, 0, 0, 7, 4, 32, total_length, buffer);
605 break;
606 case XC16X_OPERAND_DATA8 :
607 errmsg = insert_normal (cd, fields->f_data8, 0, 0, 23, 8, 32, total_length, buffer);
608 break;
609 case XC16X_OPERAND_DATAHI8 :
610 errmsg = insert_normal (cd, fields->f_datahi8, 0, 0, 31, 8, 32, total_length, buffer);
611 break;
612 case XC16X_OPERAND_DOT :
613 break;
614 case XC16X_OPERAND_DR :
615 errmsg = insert_normal (cd, fields->f_r1, 0, 0, 15, 4, 32, total_length, buffer);
616 break;
617 case XC16X_OPERAND_DRB :
618 errmsg = insert_normal (cd, fields->f_r1, 0, 0, 15, 4, 32, total_length, buffer);
619 break;
620 case XC16X_OPERAND_DRI :
621 errmsg = insert_normal (cd, fields->f_r4, 0, 0, 11, 4, 32, total_length, buffer);
622 break;
623 case XC16X_OPERAND_EXTCOND :
624 errmsg = insert_normal (cd, fields->f_extccode, 0, 0, 15, 5, 32, total_length, buffer);
625 break;
626 case XC16X_OPERAND_GENREG :
627 errmsg = insert_normal (cd, fields->f_regb8, 0, 0, 15, 8, 32, total_length, buffer);
628 break;
629 case XC16X_OPERAND_HASH :
630 break;
631 case XC16X_OPERAND_ICOND :
632 errmsg = insert_normal (cd, fields->f_icondcode, 0, 0, 15, 4, 32, total_length, buffer);
633 break;
634 case XC16X_OPERAND_LBIT2 :
635 errmsg = insert_normal (cd, fields->f_op_lbit2, 0, 0, 15, 2, 32, total_length, buffer);
636 break;
637 case XC16X_OPERAND_LBIT4 :
638 errmsg = insert_normal (cd, fields->f_op_lbit4, 0, 0, 15, 4, 32, total_length, buffer);
639 break;
640 case XC16X_OPERAND_MASK8 :
641 errmsg = insert_normal (cd, fields->f_mask8, 0, 0, 23, 8, 32, total_length, buffer);
642 break;
643 case XC16X_OPERAND_MASKLO8 :
644 errmsg = insert_normal (cd, fields->f_datahi8, 0, 0, 31, 8, 32, total_length, buffer);
645 break;
646 case XC16X_OPERAND_MEMGR8 :
647 errmsg = insert_normal (cd, fields->f_memgr8, 0, 0, 31, 16, 32, total_length, buffer);
648 break;
649 case XC16X_OPERAND_MEMORY :
650 errmsg = insert_normal (cd, fields->f_memory, 0, 0, 31, 16, 32, total_length, buffer);
651 break;
652 case XC16X_OPERAND_PAG :
653 break;
654 case XC16X_OPERAND_PAGENUM :
655 errmsg = insert_normal (cd, fields->f_pagenum, 0, 0, 25, 10, 32, total_length, buffer);
656 break;
657 case XC16X_OPERAND_POF :
658 break;
659 case XC16X_OPERAND_QBIT :
660 errmsg = insert_normal (cd, fields->f_qbit, 0, 0, 7, 4, 32, total_length, buffer);
661 break;
662 case XC16X_OPERAND_QHIBIT :
663 errmsg = insert_normal (cd, fields->f_qhibit, 0, 0, 27, 4, 32, total_length, buffer);
664 break;
665 case XC16X_OPERAND_QLOBIT :
666 errmsg = insert_normal (cd, fields->f_qlobit, 0, 0, 31, 4, 32, total_length, buffer);
667 break;
668 case XC16X_OPERAND_REG8 :
669 errmsg = insert_normal (cd, fields->f_reg8, 0, 0, 15, 8, 32, total_length, buffer);
670 break;
671 case XC16X_OPERAND_REGB8 :
672 errmsg = insert_normal (cd, fields->f_regb8, 0, 0, 15, 8, 32, total_length, buffer);
673 break;
674 case XC16X_OPERAND_REGBMEM8 :
675 errmsg = insert_normal (cd, fields->f_regmem8, 0, 0, 15, 8, 32, total_length, buffer);
676 break;
677 case XC16X_OPERAND_REGHI8 :
678 errmsg = insert_normal (cd, fields->f_reghi8, 0, 0, 23, 8, 32, total_length, buffer);
679 break;
680 case XC16X_OPERAND_REGMEM8 :
681 errmsg = insert_normal (cd, fields->f_regmem8, 0, 0, 15, 8, 32, total_length, buffer);
682 break;
683 case XC16X_OPERAND_REGOFF8 :
684 errmsg = insert_normal (cd, fields->f_regoff8, 0, 0, 15, 8, 32, total_length, buffer);
685 break;
686 case XC16X_OPERAND_REL :
687 errmsg = insert_normal (cd, fields->f_rel8, 0|(1<<CGEN_IFLD_RELOC)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 15, 8, 32, total_length, buffer);
688 break;
689 case XC16X_OPERAND_RELHI :
690 errmsg = insert_normal (cd, fields->f_relhi8, 0|(1<<CGEN_IFLD_RELOC)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 23, 8, 32, total_length, buffer);
691 break;
692 case XC16X_OPERAND_SEG :
693 errmsg = insert_normal (cd, fields->f_seg8, 0, 0, 15, 8, 32, total_length, buffer);
694 break;
695 case XC16X_OPERAND_SEGHI8 :
696 errmsg = insert_normal (cd, fields->f_segnum8, 0, 0, 23, 8, 32, total_length, buffer);
697 break;
698 case XC16X_OPERAND_SEGM :
699 break;
700 case XC16X_OPERAND_SOF :
701 break;
702 case XC16X_OPERAND_SR :
703 errmsg = insert_normal (cd, fields->f_r2, 0, 0, 11, 4, 32, total_length, buffer);
704 break;
705 case XC16X_OPERAND_SR2 :
706 errmsg = insert_normal (cd, fields->f_r0, 0, 0, 9, 2, 32, total_length, buffer);
707 break;
708 case XC16X_OPERAND_SRB :
709 errmsg = insert_normal (cd, fields->f_r2, 0, 0, 11, 4, 32, total_length, buffer);
710 break;
711 case XC16X_OPERAND_SRC1 :
712 errmsg = insert_normal (cd, fields->f_r1, 0, 0, 15, 4, 32, total_length, buffer);
713 break;
714 case XC16X_OPERAND_SRC2 :
715 errmsg = insert_normal (cd, fields->f_r2, 0, 0, 11, 4, 32, total_length, buffer);
716 break;
717 case XC16X_OPERAND_SRDIV :
718 errmsg = insert_normal (cd, fields->f_reg8, 0, 0, 15, 8, 32, total_length, buffer);
719 break;
720 case XC16X_OPERAND_U4 :
721 errmsg = insert_normal (cd, fields->f_uimm4, 0, 0, 15, 4, 32, total_length, buffer);
722 break;
723 case XC16X_OPERAND_UIMM16 :
724 errmsg = insert_normal (cd, fields->f_uimm16, 0, 0, 31, 16, 32, total_length, buffer);
725 break;
726 case XC16X_OPERAND_UIMM2 :
727 errmsg = insert_normal (cd, fields->f_uimm2, 0, 0, 13, 2, 32, total_length, buffer);
728 break;
729 case XC16X_OPERAND_UIMM3 :
730 errmsg = insert_normal (cd, fields->f_uimm3, 0, 0, 10, 3, 32, total_length, buffer);
731 break;
732 case XC16X_OPERAND_UIMM4 :
733 errmsg = insert_normal (cd, fields->f_uimm4, 0, 0, 15, 4, 32, total_length, buffer);
734 break;
735 case XC16X_OPERAND_UIMM7 :
736 errmsg = insert_normal (cd, fields->f_uimm7, 0|(1<<CGEN_IFLD_RELOC)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 15, 7, 32, total_length, buffer);
737 break;
738 case XC16X_OPERAND_UIMM8 :
739 errmsg = insert_normal (cd, fields->f_uimm8, 0, 0, 23, 8, 32, total_length, buffer);
740 break;
741 case XC16X_OPERAND_UPAG16 :
742 errmsg = insert_normal (cd, fields->f_uimm16, 0, 0, 31, 16, 32, total_length, buffer);
743 break;
744 case XC16X_OPERAND_UPOF16 :
745 errmsg = insert_normal (cd, fields->f_memory, 0, 0, 31, 16, 32, total_length, buffer);
746 break;
747 case XC16X_OPERAND_USEG16 :
748 errmsg = insert_normal (cd, fields->f_offset16, 0|(1<<CGEN_IFLD_RELOC)|(1<<CGEN_IFLD_ABS_ADDR), 0, 31, 16, 32, total_length, buffer);
749 break;
750 case XC16X_OPERAND_USEG8 :
751 errmsg = insert_normal (cd, fields->f_seg8, 0, 0, 15, 8, 32, total_length, buffer);
752 break;
753 case XC16X_OPERAND_USOF16 :
754 errmsg = insert_normal (cd, fields->f_offset16, 0|(1<<CGEN_IFLD_RELOC)|(1<<CGEN_IFLD_ABS_ADDR), 0, 31, 16, 32, total_length, buffer);
755 break;
756
757 default :
758 /* xgettext:c-format */
a6743a54
AM		 759 opcodes_error_handler
760 (_("internal error: unrecognized field %d while building insn"),
761 opindex);
d70c5fc7
NC		 762 abort ();
763 }
764
765 return errmsg;
766}
767
768int xc16x_cgen_extract_operand
769 (CGEN_CPU_DESC, int, CGEN_EXTRACT_INFO *, CGEN_INSN_INT, CGEN_FIELDS *, bfd_vma);
770
771/* Main entry point for operand extraction.
772 The result is <= 0 for error, >0 for success.
773 ??? Actual values aren't well defined right now.
774
775 This function is basically just a big switch statement. Earlier versions
776 used tables to look up the function to use, but
777 - if the table contains both assembler and disassembler functions then
778 the disassembler contains much of the assembler and vice-versa,
779 - there's a lot of inlining possibilities as things grow,
780 - using a switch statement avoids the function call overhead.
781
782 This function could be moved into `print_insn_normal', but keeping it
783 separate makes clear the interface between `print_insn_normal' and each of
784 the handlers. */
785
786int
787xc16x_cgen_extract_operand (CGEN_CPU_DESC cd,
788 int opindex,
789 CGEN_EXTRACT_INFO *ex_info,
790 CGEN_INSN_INT insn_value,
791 CGEN_FIELDS * fields,
792 bfd_vma pc)
793{
794 /* Assume success (for those operands that are nops). */
795 int length = 1;
796 unsigned int total_length = CGEN_FIELDS_BITSIZE (fields);
797
798 switch (opindex)
799 {
800 case XC16X_OPERAND_REGNAM :
801 length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 8, 32, total_length, pc, & fields->f_reg8);
802 break;
803 case XC16X_OPERAND_BIT01 :
804 length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 1, 32, total_length, pc, & fields->f_op_1bit);
805 break;
806 case XC16X_OPERAND_BIT1 :
807 length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 1, 32, total_length, pc, & fields->f_op_bit1);
808 break;
809 case XC16X_OPERAND_BIT2 :
810 length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 2, 32, total_length, pc, & fields->f_op_bit2);
811 break;
812 case XC16X_OPERAND_BIT4 :
813 length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 4, 32, total_length, pc, & fields->f_op_bit4);
814 break;
815 case XC16X_OPERAND_BIT8 :
816 length = extract_normal (cd, ex_info, insn_value, 0, 0, 31, 8, 32, total_length, pc, & fields->f_op_bit8);
817 break;
818 case XC16X_OPERAND_BITONE :
819 length = extract_normal (cd, ex_info, insn_value, 0, 0, 9, 1, 32, total_length, pc, & fields->f_op_onebit);
820 break;
821 case XC16X_OPERAND_CADDR :
822 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_RELOC)|(1<<CGEN_IFLD_ABS_ADDR), 0, 31, 16, 32, total_length, pc, & fields->f_offset16);
823 break;
824 case XC16X_OPERAND_COND :
825 length = extract_normal (cd, ex_info, insn_value, 0, 0, 7, 4, 32, total_length, pc, & fields->f_condcode);
826 break;
827 case XC16X_OPERAND_DATA8 :
828 length = extract_normal (cd, ex_info, insn_value, 0, 0, 23, 8, 32, total_length, pc, & fields->f_data8);
829 break;
830 case XC16X_OPERAND_DATAHI8 :
831 length = extract_normal (cd, ex_info, insn_value, 0, 0, 31, 8, 32, total_length, pc, & fields->f_datahi8);
832 break;
833 case XC16X_OPERAND_DOT :
834 break;
835 case XC16X_OPERAND_DR :
836 length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 4, 32, total_length, pc, & fields->f_r1);
837 break;
838 case XC16X_OPERAND_DRB :
839 length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 4, 32, total_length, pc, & fields->f_r1);
840 break;
841 case XC16X_OPERAND_DRI :
842 length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 4, 32, total_length, pc, & fields->f_r4);
843 break;
844 case XC16X_OPERAND_EXTCOND :
845 length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 5, 32, total_length, pc, & fields->f_extccode);
846 break;
847 case XC16X_OPERAND_GENREG :
848 length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 8, 32, total_length, pc, & fields->f_regb8);
849 break;
850 case XC16X_OPERAND_HASH :
851 break;
852 case XC16X_OPERAND_ICOND :
853 length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 4, 32, total_length, pc, & fields->f_icondcode);
854 break;
855 case XC16X_OPERAND_LBIT2 :
856 length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 2, 32, total_length, pc, & fields->f_op_lbit2);
857 break;
858 case XC16X_OPERAND_LBIT4 :
859 length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 4, 32, total_length, pc, & fields->f_op_lbit4);
860 break;
861 case XC16X_OPERAND_MASK8 :
862 length = extract_normal (cd, ex_info, insn_value, 0, 0, 23, 8, 32, total_length, pc, & fields->f_mask8);
863 break;
864 case XC16X_OPERAND_MASKLO8 :
865 length = extract_normal (cd, ex_info, insn_value, 0, 0, 31, 8, 32, total_length, pc, & fields->f_datahi8);
866 break;
867 case XC16X_OPERAND_MEMGR8 :
868 length = extract_normal (cd, ex_info, insn_value, 0, 0, 31, 16, 32, total_length, pc, & fields->f_memgr8);
869 break;
870 case XC16X_OPERAND_MEMORY :
871 length = extract_normal (cd, ex_info, insn_value, 0, 0, 31, 16, 32, total_length, pc, & fields->f_memory);
872 break;
873 case XC16X_OPERAND_PAG :
874 break;
875 case XC16X_OPERAND_PAGENUM :
876 length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 10, 32, total_length, pc, & fields->f_pagenum);
877 break;
878 case XC16X_OPERAND_POF :
879 break;
880 case XC16X_OPERAND_QBIT :
881 length = extract_normal (cd, ex_info, insn_value, 0, 0, 7, 4, 32, total_length, pc, & fields->f_qbit);
882 break;
883 case XC16X_OPERAND_QHIBIT :
884 length = extract_normal (cd, ex_info, insn_value, 0, 0, 27, 4, 32, total_length, pc, & fields->f_qhibit);
885 break;
886 case XC16X_OPERAND_QLOBIT :
887 length = extract_normal (cd, ex_info, insn_value, 0, 0, 31, 4, 32, total_length, pc, & fields->f_qlobit);
888 break;
889 case XC16X_OPERAND_REG8 :
890 length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 8, 32, total_length, pc, & fields->f_reg8);
891 break;
892 case XC16X_OPERAND_REGB8 :
893 length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 8, 32, total_length, pc, & fields->f_regb8);
894 break;
895 case XC16X_OPERAND_REGBMEM8 :
896 length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 8, 32, total_length, pc, & fields->f_regmem8);
897 break;
898 case XC16X_OPERAND_REGHI8 :
899 length = extract_normal (cd, ex_info, insn_value, 0, 0, 23, 8, 32, total_length, pc, & fields->f_reghi8);
900 break;
901 case XC16X_OPERAND_REGMEM8 :
902 length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 8, 32, total_length, pc, & fields->f_regmem8);
903 break;
904 case XC16X_OPERAND_REGOFF8 :
905 length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 8, 32, total_length, pc, & fields->f_regoff8);
906 break;
907 case XC16X_OPERAND_REL :
908 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_RELOC)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 15, 8, 32, total_length, pc, & fields->f_rel8);
909 break;
910 case XC16X_OPERAND_RELHI :
911 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_RELOC)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 23, 8, 32, total_length, pc, & fields->f_relhi8);
912 break;
913 case XC16X_OPERAND_SEG :
914 length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 8, 32, total_length, pc, & fields->f_seg8);
915 break;
916 case XC16X_OPERAND_SEGHI8 :
917 length = extract_normal (cd, ex_info, insn_value, 0, 0, 23, 8, 32, total_length, pc, & fields->f_segnum8);
918 break;
919 case XC16X_OPERAND_SEGM :
920 break;
921 case XC16X_OPERAND_SOF :
922 break;
923 case XC16X_OPERAND_SR :
924 length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 4, 32, total_length, pc, & fields->f_r2);
925 break;
926 case XC16X_OPERAND_SR2 :
927 length = extract_normal (cd, ex_info, insn_value, 0, 0, 9, 2, 32, total_length, pc, & fields->f_r0);
928 break;
929 case XC16X_OPERAND_SRB :
930 length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 4, 32, total_length, pc, & fields->f_r2);
931 break;
932 case XC16X_OPERAND_SRC1 :
933 length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 4, 32, total_length, pc, & fields->f_r1);
934 break;
935 case XC16X_OPERAND_SRC2 :
936 length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 4, 32, total_length, pc, & fields->f_r2);
937 break;
938 case XC16X_OPERAND_SRDIV :
939 length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 8, 32, total_length, pc, & fields->f_reg8);
940 break;
941 case XC16X_OPERAND_U4 :
942 length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 4, 32, total_length, pc, & fields->f_uimm4);
943 break;
944 case XC16X_OPERAND_UIMM16 :
945 length = extract_normal (cd, ex_info, insn_value, 0, 0, 31, 16, 32, total_length, pc, & fields->f_uimm16);
946 break;
947 case XC16X_OPERAND_UIMM2 :
948 length = extract_normal (cd, ex_info, insn_value, 0, 0, 13, 2, 32, total_length, pc, & fields->f_uimm2);
949 break;
950 case XC16X_OPERAND_UIMM3 :
951 length = extract_normal (cd, ex_info, insn_value, 0, 0, 10, 3, 32, total_length, pc, & fields->f_uimm3);
952 break;
953 case XC16X_OPERAND_UIMM4 :
954 length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 4, 32, total_length, pc, & fields->f_uimm4);
955 break;
956 case XC16X_OPERAND_UIMM7 :
957 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_RELOC)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 15, 7, 32, total_length, pc, & fields->f_uimm7);
958 break;
959 case XC16X_OPERAND_UIMM8 :
960 length = extract_normal (cd, ex_info, insn_value, 0, 0, 23, 8, 32, total_length, pc, & fields->f_uimm8);
961 break;
962 case XC16X_OPERAND_UPAG16 :
963 length = extract_normal (cd, ex_info, insn_value, 0, 0, 31, 16, 32, total_length, pc, & fields->f_uimm16);
964 break;
965 case XC16X_OPERAND_UPOF16 :
966 length = extract_normal (cd, ex_info, insn_value, 0, 0, 31, 16, 32, total_length, pc, & fields->f_memory);
967 break;
968 case XC16X_OPERAND_USEG16 :
969 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_RELOC)|(1<<CGEN_IFLD_ABS_ADDR), 0, 31, 16, 32, total_length, pc, & fields->f_offset16);
970 break;
971 case XC16X_OPERAND_USEG8 :
972 length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 8, 32, total_length, pc, & fields->f_seg8);
973 break;
974 case XC16X_OPERAND_USOF16 :
975 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_RELOC)|(1<<CGEN_IFLD_ABS_ADDR), 0, 31, 16, 32, total_length, pc, & fields->f_offset16);
976 break;
977
978 default :
979 /* xgettext:c-format */
a6743a54
AM		 980 opcodes_error_handler
981 (_("internal error: unrecognized field %d while decoding insn"),
982 opindex);
d70c5fc7
NC		 983 abort ();
984 }
985
986 return length;
987}
988
43e65147 989cgen_insert_fn * const xc16x_cgen_insert_handlers[] =
d70c5fc7
NC		 990{
991 insert_insn_normal,
992};
993
43e65147 994cgen_extract_fn * const xc16x_cgen_extract_handlers[] =
d70c5fc7
NC		 995{
996 extract_insn_normal,
997};
998
999int xc16x_cgen_get_int_operand (CGEN_CPU_DESC, int, const CGEN_FIELDS *);
1000bfd_vma xc16x_cgen_get_vma_operand (CGEN_CPU_DESC, int, const CGEN_FIELDS *);
1001
1002/* Getting values from cgen_fields is handled by a collection of functions.
1003 They are distinguished by the type of the VALUE argument they return.
1004 TODO: floating point, inlining support, remove cases where result type
1005 not appropriate. */
1006
1007int
1008xc16x_cgen_get_int_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
1009 int opindex,
1010 const CGEN_FIELDS * fields)
1011{
1012 int value;
1013
1014 switch (opindex)
1015 {
1016 case XC16X_OPERAND_REGNAM :
1017 value = fields->f_reg8;
1018 break;
1019 case XC16X_OPERAND_BIT01 :
1020 value = fields->f_op_1bit;
1021 break;
1022 case XC16X_OPERAND_BIT1 :
1023 value = fields->f_op_bit1;
1024 break;
1025 case XC16X_OPERAND_BIT2 :
1026 value = fields->f_op_bit2;
1027 break;
1028 case XC16X_OPERAND_BIT4 :
1029 value = fields->f_op_bit4;
1030 break;
1031 case XC16X_OPERAND_BIT8 :
1032 value = fields->f_op_bit8;
1033 break;
1034 case XC16X_OPERAND_BITONE :
1035 value = fields->f_op_onebit;
1036 break;
1037 case XC16X_OPERAND_CADDR :
1038 value = fields->f_offset16;
1039 break;
1040 case XC16X_OPERAND_COND :
1041 value = fields->f_condcode;
1042 break;
1043 case XC16X_OPERAND_DATA8 :
1044 value = fields->f_data8;
1045 break;
1046 case XC16X_OPERAND_DATAHI8 :
1047 value = fields->f_datahi8;
1048 break;
1049 case XC16X_OPERAND_DOT :
1050 value = 0;
1051 break;
1052 case XC16X_OPERAND_DR :
1053 value = fields->f_r1;
1054 break;
1055 case XC16X_OPERAND_DRB :
1056 value = fields->f_r1;
1057 break;
1058 case XC16X_OPERAND_DRI :
1059 value = fields->f_r4;
1060 break;
1061 case XC16X_OPERAND_EXTCOND :
1062 value = fields->f_extccode;
1063 break;
1064 case XC16X_OPERAND_GENREG :
1065 value = fields->f_regb8;
1066 break;
1067 case XC16X_OPERAND_HASH :
1068 value = 0;
1069 break;
1070 case XC16X_OPERAND_ICOND :
1071 value = fields->f_icondcode;
1072 break;
1073 case XC16X_OPERAND_LBIT2 :
1074 value = fields->f_op_lbit2;
1075 break;
1076 case XC16X_OPERAND_LBIT4 :
1077 value = fields->f_op_lbit4;
1078 break;
1079 case XC16X_OPERAND_MASK8 :
1080 value = fields->f_mask8;
1081 break;
1082 case XC16X_OPERAND_MASKLO8 :
1083 value = fields->f_datahi8;
1084 break;
1085 case XC16X_OPERAND_MEMGR8 :
1086 value = fields->f_memgr8;
1087 break;
1088 case XC16X_OPERAND_MEMORY :
1089 value = fields->f_memory;
1090 break;
1091 case XC16X_OPERAND_PAG :
1092 value = 0;
1093 break;
1094 case XC16X_OPERAND_PAGENUM :
1095 value = fields->f_pagenum;
1096 break;
1097 case XC16X_OPERAND_POF :
1098 value = 0;
1099 break;
1100 case XC16X_OPERAND_QBIT :
1101 value = fields->f_qbit;
1102 break;
1103 case XC16X_OPERAND_QHIBIT :
1104 value = fields->f_qhibit;
1105 break;
1106 case XC16X_OPERAND_QLOBIT :
1107 value = fields->f_qlobit;
1108 break;
1109 case XC16X_OPERAND_REG8 :
1110 value = fields->f_reg8;
1111 break;
1112 case XC16X_OPERAND_REGB8 :
1113 value = fields->f_regb8;
1114 break;
1115 case XC16X_OPERAND_REGBMEM8 :
1116 value = fields->f_regmem8;
1117 break;
1118 case XC16X_OPERAND_REGHI8 :
1119 value = fields->f_reghi8;
1120 break;
1121 case XC16X_OPERAND_REGMEM8 :
1122 value = fields->f_regmem8;
1123 break;
1124 case XC16X_OPERAND_REGOFF8 :
1125 value = fields->f_regoff8;
1126 break;
1127 case XC16X_OPERAND_REL :
1128 value = fields->f_rel8;
1129 break;
1130 case XC16X_OPERAND_RELHI :
1131 value = fields->f_relhi8;
1132 break;
1133 case XC16X_OPERAND_SEG :
1134 value = fields->f_seg8;
1135 break;
1136 case XC16X_OPERAND_SEGHI8 :
1137 value = fields->f_segnum8;
1138 break;
1139 case XC16X_OPERAND_SEGM :
1140 value = 0;
1141 break;
1142 case XC16X_OPERAND_SOF :
1143 value = 0;
1144 break;
1145 case XC16X_OPERAND_SR :
1146 value = fields->f_r2;
1147 break;
1148 case XC16X_OPERAND_SR2 :
1149 value = fields->f_r0;
1150 break;
1151 case XC16X_OPERAND_SRB :
1152 value = fields->f_r2;
1153 break;
1154 case XC16X_OPERAND_SRC1 :
1155 value = fields->f_r1;
1156 break;
1157 case XC16X_OPERAND_SRC2 :
1158 value = fields->f_r2;
1159 break;
1160 case XC16X_OPERAND_SRDIV :
1161 value = fields->f_reg8;
1162 break;
1163 case XC16X_OPERAND_U4 :
1164 value = fields->f_uimm4;
1165 break;
1166 case XC16X_OPERAND_UIMM16 :
1167 value = fields->f_uimm16;
1168 break;
1169 case XC16X_OPERAND_UIMM2 :
1170 value = fields->f_uimm2;
1171 break;
1172 case XC16X_OPERAND_UIMM3 :
1173 value = fields->f_uimm3;
1174 break;
1175 case XC16X_OPERAND_UIMM4 :
1176 value = fields->f_uimm4;
1177 break;
1178 case XC16X_OPERAND_UIMM7 :
1179 value = fields->f_uimm7;
1180 break;
1181 case XC16X_OPERAND_UIMM8 :
1182 value = fields->f_uimm8;
1183 break;
1184 case XC16X_OPERAND_UPAG16 :
1185 value = fields->f_uimm16;
1186 break;
1187 case XC16X_OPERAND_UPOF16 :
1188 value = fields->f_memory;
1189 break;
1190 case XC16X_OPERAND_USEG16 :
1191 value = fields->f_offset16;
1192 break;
1193 case XC16X_OPERAND_USEG8 :
1194 value = fields->f_seg8;
1195 break;
1196 case XC16X_OPERAND_USOF16 :
1197 value = fields->f_offset16;
1198 break;
1199
1200 default :
1201 /* xgettext:c-format */
a6743a54
AM		 1202 opcodes_error_handler
1203 (_("internal error: unrecognized field %d while getting int operand"),
1204 opindex);
d70c5fc7
NC		 1205 abort ();
1206 }
1207
1208 return value;
1209}
1210
1211bfd_vma
1212xc16x_cgen_get_vma_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
1213 int opindex,
1214 const CGEN_FIELDS * fields)
1215{
1216 bfd_vma value;
1217
1218 switch (opindex)
1219 {
1220 case XC16X_OPERAND_REGNAM :
1221 value = fields->f_reg8;
1222 break;
1223 case XC16X_OPERAND_BIT01 :
1224 value = fields->f_op_1bit;
1225 break;
1226 case XC16X_OPERAND_BIT1 :
1227 value = fields->f_op_bit1;
1228 break;
1229 case XC16X_OPERAND_BIT2 :
1230 value = fields->f_op_bit2;
1231 break;
1232 case XC16X_OPERAND_BIT4 :
1233 value = fields->f_op_bit4;
1234 break;
1235 case XC16X_OPERAND_BIT8 :
1236 value = fields->f_op_bit8;
1237 break;
1238 case XC16X_OPERAND_BITONE :
1239 value = fields->f_op_onebit;
1240 break;
1241 case XC16X_OPERAND_CADDR :
1242 value = fields->f_offset16;
1243 break;
1244 case XC16X_OPERAND_COND :
1245 value = fields->f_condcode;
1246 break;
1247 case XC16X_OPERAND_DATA8 :
1248 value = fields->f_data8;
1249 break;
1250 case XC16X_OPERAND_DATAHI8 :
1251 value = fields->f_datahi8;
1252 break;
1253 case XC16X_OPERAND_DOT :
1254 value = 0;
1255 break;
1256 case XC16X_OPERAND_DR :
1257 value = fields->f_r1;
1258 break;
1259 case XC16X_OPERAND_DRB :
1260 value = fields->f_r1;
1261 break;
1262 case XC16X_OPERAND_DRI :
1263 value = fields->f_r4;
1264 break;
1265 case XC16X_OPERAND_EXTCOND :
1266 value = fields->f_extccode;
1267 break;
1268 case XC16X_OPERAND_GENREG :
1269 value = fields->f_regb8;
1270 break;
1271 case XC16X_OPERAND_HASH :
1272 value = 0;
1273 break;
1274 case XC16X_OPERAND_ICOND :
1275 value = fields->f_icondcode;
1276 break;
1277 case XC16X_OPERAND_LBIT2 :
1278 value = fields->f_op_lbit2;
1279 break;
1280 case XC16X_OPERAND_LBIT4 :
1281 value = fields->f_op_lbit4;
1282 break;
1283 case XC16X_OPERAND_MASK8 :
1284 value = fields->f_mask8;
1285 break;
1286 case XC16X_OPERAND_MASKLO8 :
1287 value = fields->f_datahi8;
1288 break;
1289 case XC16X_OPERAND_MEMGR8 :
1290 value = fields->f_memgr8;
1291 break;
1292 case XC16X_OPERAND_MEMORY :
1293 value = fields->f_memory;
1294 break;
1295 case XC16X_OPERAND_PAG :
1296 value = 0;
1297 break;
1298 case XC16X_OPERAND_PAGENUM :
1299 value = fields->f_pagenum;
1300 break;
1301 case XC16X_OPERAND_POF :
1302 value = 0;
1303 break;
1304 case XC16X_OPERAND_QBIT :
1305 value = fields->f_qbit;
1306 break;
1307 case XC16X_OPERAND_QHIBIT :
1308 value = fields->f_qhibit;
1309 break;
1310 case XC16X_OPERAND_QLOBIT :
1311 value = fields->f_qlobit;
1312 break;
1313 case XC16X_OPERAND_REG8 :
1314 value = fields->f_reg8;
1315 break;
1316 case XC16X_OPERAND_REGB8 :
1317 value = fields->f_regb8;
1318 break;
1319 case XC16X_OPERAND_REGBMEM8 :
1320 value = fields->f_regmem8;
1321 break;
1322 case XC16X_OPERAND_REGHI8 :
1323 value = fields->f_reghi8;
1324 break;
1325 case XC16X_OPERAND_REGMEM8 :
1326 value = fields->f_regmem8;
1327 break;
1328 case XC16X_OPERAND_REGOFF8 :
1329 value = fields->f_regoff8;
1330 break;
1331 case XC16X_OPERAND_REL :
1332 value = fields->f_rel8;
1333 break;
1334 case XC16X_OPERAND_RELHI :
1335 value = fields->f_relhi8;
1336 break;
1337 case XC16X_OPERAND_SEG :
1338 value = fields->f_seg8;
1339 break;
1340 case XC16X_OPERAND_SEGHI8 :
1341 value = fields->f_segnum8;
1342 break;
1343 case XC16X_OPERAND_SEGM :
1344 value = 0;
1345 break;
1346 case XC16X_OPERAND_SOF :
1347 value = 0;
1348 break;
1349 case XC16X_OPERAND_SR :
1350 value = fields->f_r2;
1351 break;
1352 case XC16X_OPERAND_SR2 :
1353 value = fields->f_r0;
1354 break;
1355 case XC16X_OPERAND_SRB :
1356 value = fields->f_r2;
1357 break;
1358 case XC16X_OPERAND_SRC1 :
1359 value = fields->f_r1;
1360 break;
1361 case XC16X_OPERAND_SRC2 :
1362 value = fields->f_r2;
1363 break;
1364 case XC16X_OPERAND_SRDIV :
1365 value = fields->f_reg8;
1366 break;
1367 case XC16X_OPERAND_U4 :
1368 value = fields->f_uimm4;
1369 break;
1370 case XC16X_OPERAND_UIMM16 :
1371 value = fields->f_uimm16;
1372 break;
1373 case XC16X_OPERAND_UIMM2 :
1374 value = fields->f_uimm2;
1375 break;
1376 case XC16X_OPERAND_UIMM3 :
1377 value = fields->f_uimm3;
1378 break;
1379 case XC16X_OPERAND_UIMM4 :
1380 value = fields->f_uimm4;
1381 break;
1382 case XC16X_OPERAND_UIMM7 :
1383 value = fields->f_uimm7;
1384 break;
1385 case XC16X_OPERAND_UIMM8 :
1386 value = fields->f_uimm8;
1387 break;
1388 case XC16X_OPERAND_UPAG16 :
1389 value = fields->f_uimm16;
1390 break;
1391 case XC16X_OPERAND_UPOF16 :
1392 value = fields->f_memory;
1393 break;
1394 case XC16X_OPERAND_USEG16 :
1395 value = fields->f_offset16;
1396 break;
1397 case XC16X_OPERAND_USEG8 :
1398 value = fields->f_seg8;
1399 break;
1400 case XC16X_OPERAND_USOF16 :
1401 value = fields->f_offset16;
1402 break;
1403
1404 default :
1405 /* xgettext:c-format */
a6743a54
AM		 1406 opcodes_error_handler
1407 (_("internal error: unrecognized field %d while getting vma operand"),
1408 opindex);
d70c5fc7
NC		 1409 abort ();
1410 }
1411
1412 return value;
1413}
1414
1415void xc16x_cgen_set_int_operand (CGEN_CPU_DESC, int, CGEN_FIELDS *, int);
1416void xc16x_cgen_set_vma_operand (CGEN_CPU_DESC, int, CGEN_FIELDS *, bfd_vma);
1417
1418/* Stuffing values in cgen_fields is handled by a collection of functions.
1419 They are distinguished by the type of the VALUE argument they accept.
1420 TODO: floating point, inlining support, remove cases where argument type
1421 not appropriate. */
1422
1423void
1424xc16x_cgen_set_int_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
1425 int opindex,
1426 CGEN_FIELDS * fields,
1427 int value)
1428{
1429 switch (opindex)
1430 {
1431 case XC16X_OPERAND_REGNAM :
1432 fields->f_reg8 = value;
1433 break;
1434 case XC16X_OPERAND_BIT01 :
1435 fields->f_op_1bit = value;
1436 break;
1437 case XC16X_OPERAND_BIT1 :
1438 fields->f_op_bit1 = value;
1439 break;
1440 case XC16X_OPERAND_BIT2 :
1441 fields->f_op_bit2 = value;
1442 break;
1443 case XC16X_OPERAND_BIT4 :
1444 fields->f_op_bit4 = value;
1445 break;
1446 case XC16X_OPERAND_BIT8 :
1447 fields->f_op_bit8 = value;
1448 break;
1449 case XC16X_OPERAND_BITONE :
1450 fields->f_op_onebit = value;
1451 break;
1452 case XC16X_OPERAND_CADDR :
1453 fields->f_offset16 = value;
1454 break;
1455 case XC16X_OPERAND_COND :
1456 fields->f_condcode = value;
1457 break;
1458 case XC16X_OPERAND_DATA8 :
1459 fields->f_data8 = value;
1460 break;
1461 case XC16X_OPERAND_DATAHI8 :
1462 fields->f_datahi8 = value;
1463 break;
1464 case XC16X_OPERAND_DOT :
1465 break;
1466 case XC16X_OPERAND_DR :
1467 fields->f_r1 = value;
1468 break;
1469 case XC16X_OPERAND_DRB :
1470 fields->f_r1 = value;
1471 break;
1472 case XC16X_OPERAND_DRI :
1473 fields->f_r4 = value;
1474 break;
1475 case XC16X_OPERAND_EXTCOND :
1476 fields->f_extccode = value;
1477 break;
1478 case XC16X_OPERAND_GENREG :
1479 fields->f_regb8 = value;
1480 break;
1481 case XC16X_OPERAND_HASH :
1482 break;
1483 case XC16X_OPERAND_ICOND :
1484 fields->f_icondcode = value;
1485 break;
1486 case XC16X_OPERAND_LBIT2 :
1487 fields->f_op_lbit2 = value;
1488 break;
1489 case XC16X_OPERAND_LBIT4 :
1490 fields->f_op_lbit4 = value;
1491 break;
1492 case XC16X_OPERAND_MASK8 :
1493 fields->f_mask8 = value;
1494 break;
1495 case XC16X_OPERAND_MASKLO8 :
1496 fields->f_datahi8 = value;
1497 break;
1498 case XC16X_OPERAND_MEMGR8 :
1499 fields->f_memgr8 = value;
1500 break;
1501 case XC16X_OPERAND_MEMORY :
1502 fields->f_memory = value;
1503 break;
1504 case XC16X_OPERAND_PAG :
1505 break;
1506 case XC16X_OPERAND_PAGENUM :
1507 fields->f_pagenum = value;
1508 break;
1509 case XC16X_OPERAND_POF :
1510 break;
1511 case XC16X_OPERAND_QBIT :
1512 fields->f_qbit = value;
1513 break;
1514 case XC16X_OPERAND_QHIBIT :
1515 fields->f_qhibit = value;
1516 break;
1517 case XC16X_OPERAND_QLOBIT :
1518 fields->f_qlobit = value;
1519 break;
1520 case XC16X_OPERAND_REG8 :
1521 fields->f_reg8 = value;
1522 break;
1523 case XC16X_OPERAND_REGB8 :
1524 fields->f_regb8 = value;
1525 break;
1526 case XC16X_OPERAND_REGBMEM8 :
1527 fields->f_regmem8 = value;
1528 break;
1529 case XC16X_OPERAND_REGHI8 :
1530 fields->f_reghi8 = value;
1531 break;
1532 case XC16X_OPERAND_REGMEM8 :
1533 fields->f_regmem8 = value;
1534 break;
1535 case XC16X_OPERAND_REGOFF8 :
1536 fields->f_regoff8 = value;
1537 break;
1538 case XC16X_OPERAND_REL :
1539 fields->f_rel8 = value;
1540 break;
1541 case XC16X_OPERAND_RELHI :
1542 fields->f_relhi8 = value;
1543 break;
1544 case XC16X_OPERAND_SEG :
1545 fields->f_seg8 = value;
1546 break;
1547 case XC16X_OPERAND_SEGHI8 :
1548 fields->f_segnum8 = value;
1549 break;
1550 case XC16X_OPERAND_SEGM :
1551 break;
1552 case XC16X_OPERAND_SOF :
1553 break;
1554 case XC16X_OPERAND_SR :
1555 fields->f_r2 = value;
1556 break;
1557 case XC16X_OPERAND_SR2 :
1558 fields->f_r0 = value;
1559 break;
1560 case XC16X_OPERAND_SRB :
1561 fields->f_r2 = value;
1562 break;
1563 case XC16X_OPERAND_SRC1 :
1564 fields->f_r1 = value;
1565 break;
1566 case XC16X_OPERAND_SRC2 :
1567 fields->f_r2 = value;
1568 break;
1569 case XC16X_OPERAND_SRDIV :
1570 fields->f_reg8 = value;
1571 break;
1572 case XC16X_OPERAND_U4 :
1573 fields->f_uimm4 = value;
1574 break;
1575 case XC16X_OPERAND_UIMM16 :
1576 fields->f_uimm16 = value;
1577 break;
1578 case XC16X_OPERAND_UIMM2 :
1579 fields->f_uimm2 = value;
1580 break;
1581 case XC16X_OPERAND_UIMM3 :
1582 fields->f_uimm3 = value;
1583 break;
1584 case XC16X_OPERAND_UIMM4 :
1585 fields->f_uimm4 = value;
1586 break;
1587 case XC16X_OPERAND_UIMM7 :
1588 fields->f_uimm7 = value;
1589 break;
1590 case XC16X_OPERAND_UIMM8 :
1591 fields->f_uimm8 = value;
1592 break;
1593 case XC16X_OPERAND_UPAG16 :
1594 fields->f_uimm16 = value;
1595 break;
1596 case XC16X_OPERAND_UPOF16 :
1597 fields->f_memory = value;
1598 break;
1599 case XC16X_OPERAND_USEG16 :
1600 fields->f_offset16 = value;
1601 break;
1602 case XC16X_OPERAND_USEG8 :
1603 fields->f_seg8 = value;
1604 break;
1605 case XC16X_OPERAND_USOF16 :
1606 fields->f_offset16 = value;
1607 break;
1608
1609 default :
1610 /* xgettext:c-format */
a6743a54
AM		 1611 opcodes_error_handler
1612 (_("internal error: unrecognized field %d while setting int operand"),
1613 opindex);
d70c5fc7
NC		 1614 abort ();
1615 }
1616}
1617
1618void
1619xc16x_cgen_set_vma_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
1620 int opindex,
1621 CGEN_FIELDS * fields,
1622 bfd_vma value)
1623{
1624 switch (opindex)
1625 {
1626 case XC16X_OPERAND_REGNAM :
1627 fields->f_reg8 = value;
1628 break;
1629 case XC16X_OPERAND_BIT01 :
1630 fields->f_op_1bit = value;
1631 break;
1632 case XC16X_OPERAND_BIT1 :
1633 fields->f_op_bit1 = value;
1634 break;
1635 case XC16X_OPERAND_BIT2 :
1636 fields->f_op_bit2 = value;
1637 break;
1638 case XC16X_OPERAND_BIT4 :
1639 fields->f_op_bit4 = value;
1640 break;
1641 case XC16X_OPERAND_BIT8 :
1642 fields->f_op_bit8 = value;
1643 break;
1644 case XC16X_OPERAND_BITONE :
1645 fields->f_op_onebit = value;
1646 break;
1647 case XC16X_OPERAND_CADDR :
1648 fields->f_offset16 = value;
1649 break;
1650 case XC16X_OPERAND_COND :
1651 fields->f_condcode = value;
1652 break;
1653 case XC16X_OPERAND_DATA8 :
1654 fields->f_data8 = value;
1655 break;
1656 case XC16X_OPERAND_DATAHI8 :
1657 fields->f_datahi8 = value;
1658 break;
1659 case XC16X_OPERAND_DOT :
1660 break;
1661 case XC16X_OPERAND_DR :
1662 fields->f_r1 = value;
1663 break;
1664 case XC16X_OPERAND_DRB :
1665 fields->f_r1 = value;
1666 break;
1667 case XC16X_OPERAND_DRI :
1668 fields->f_r4 = value;
1669 break;
1670 case XC16X_OPERAND_EXTCOND :
1671 fields->f_extccode = value;
1672 break;
1673 case XC16X_OPERAND_GENREG :
1674 fields->f_regb8 = value;
1675 break;
1676 case XC16X_OPERAND_HASH :
1677 break;
1678 case XC16X_OPERAND_ICOND :
1679 fields->f_icondcode = value;
1680 break;
1681 case XC16X_OPERAND_LBIT2 :
1682 fields->f_op_lbit2 = value;
1683 break;
1684 case XC16X_OPERAND_LBIT4 :
1685 fields->f_op_lbit4 = value;
1686 break;
1687 case XC16X_OPERAND_MASK8 :
1688 fields->f_mask8 = value;
1689 break;
1690 case XC16X_OPERAND_MASKLO8 :
1691 fields->f_datahi8 = value;
1692 break;
1693 case XC16X_OPERAND_MEMGR8 :
1694 fields->f_memgr8 = value;
1695 break;
1696 case XC16X_OPERAND_MEMORY :
1697 fields->f_memory = value;
1698 break;
1699 case XC16X_OPERAND_PAG :
1700 break;
1701 case XC16X_OPERAND_PAGENUM :
1702 fields->f_pagenum = value;
1703 break;
1704 case XC16X_OPERAND_POF :
1705 break;
1706 case XC16X_OPERAND_QBIT :
1707 fields->f_qbit = value;
1708 break;
1709 case XC16X_OPERAND_QHIBIT :
1710 fields->f_qhibit = value;
1711 break;
1712 case XC16X_OPERAND_QLOBIT :
1713 fields->f_qlobit = value;
1714 break;
1715 case XC16X_OPERAND_REG8 :
1716 fields->f_reg8 = value;
1717 break;
1718 case XC16X_OPERAND_REGB8 :
1719 fields->f_regb8 = value;
1720 break;
1721 case XC16X_OPERAND_REGBMEM8 :
1722 fields->f_regmem8 = value;
1723 break;
1724 case XC16X_OPERAND_REGHI8 :
1725 fields->f_reghi8 = value;
1726 break;
1727 case XC16X_OPERAND_REGMEM8 :
1728 fields->f_regmem8 = value;
1729 break;
1730 case XC16X_OPERAND_REGOFF8 :
1731 fields->f_regoff8 = value;
1732 break;
1733 case XC16X_OPERAND_REL :
1734 fields->f_rel8 = value;
1735 break;
1736 case XC16X_OPERAND_RELHI :
1737 fields->f_relhi8 = value;
1738 break;
1739 case XC16X_OPERAND_SEG :
1740 fields->f_seg8 = value;
1741 break;
1742 case XC16X_OPERAND_SEGHI8 :
1743 fields->f_segnum8 = value;
1744 break;
1745 case XC16X_OPERAND_SEGM :
1746 break;
1747 case XC16X_OPERAND_SOF :
1748 break;
1749 case XC16X_OPERAND_SR :
1750 fields->f_r2 = value;
1751 break;
1752 case XC16X_OPERAND_SR2 :
1753 fields->f_r0 = value;
1754 break;
1755 case XC16X_OPERAND_SRB :
1756 fields->f_r2 = value;
1757 break;
1758 case XC16X_OPERAND_SRC1 :
1759 fields->f_r1 = value;
1760 break;
1761 case XC16X_OPERAND_SRC2 :
1762 fields->f_r2 = value;
1763 break;
1764 case XC16X_OPERAND_SRDIV :
1765 fields->f_reg8 = value;
1766 break;
1767 case XC16X_OPERAND_U4 :
1768 fields->f_uimm4 = value;
1769 break;
1770 case XC16X_OPERAND_UIMM16 :
1771 fields->f_uimm16 = value;
1772 break;
1773 case XC16X_OPERAND_UIMM2 :
1774 fields->f_uimm2 = value;
1775 break;
1776 case XC16X_OPERAND_UIMM3 :
1777 fields->f_uimm3 = value;
1778 break;
1779 case XC16X_OPERAND_UIMM4 :
1780 fields->f_uimm4 = value;
1781 break;
1782 case XC16X_OPERAND_UIMM7 :
1783 fields->f_uimm7 = value;
1784 break;
1785 case XC16X_OPERAND_UIMM8 :
1786 fields->f_uimm8 = value;
1787 break;
1788 case XC16X_OPERAND_UPAG16 :
1789 fields->f_uimm16 = value;
1790 break;
1791 case XC16X_OPERAND_UPOF16 :
1792 fields->f_memory = value;
1793 break;
1794 case XC16X_OPERAND_USEG16 :
1795 fields->f_offset16 = value;
1796 break;
1797 case XC16X_OPERAND_USEG8 :
1798 fields->f_seg8 = value;
1799 break;
1800 case XC16X_OPERAND_USOF16 :
1801 fields->f_offset16 = value;
1802 break;
1803
1804 default :
1805 /* xgettext:c-format */
a6743a54
AM		 1806 opcodes_error_handler
1807 (_("internal error: unrecognized field %d while setting vma operand"),
1808 opindex);
d70c5fc7
NC		 1809 abort ();
1810 }
1811}
1812
1813/* Function to call before using the instruction builder tables. */
1814
1815void
1816xc16x_cgen_init_ibld_table (CGEN_CPU_DESC cd)
1817{
1818 cd->insert_handlers = & xc16x_cgen_insert_handlers[0];
1819 cd->extract_handlers = & xc16x_cgen_extract_handlers[0];
1820
1821 cd->insert_operand = xc16x_cgen_insert_operand;
1822 cd->extract_operand = xc16x_cgen_extract_operand;
1823
1824 cd->get_int_operand = xc16x_cgen_get_int_operand;
1825 cd->set_int_operand = xc16x_cgen_set_int_operand;
1826 cd->get_vma_operand = xc16x_cgen_get_vma_operand;
1827 cd->set_vma_operand = xc16x_cgen_set_vma_operand;
1828}
GDB Binutils - Deliverables
This page took 0.766104 seconds and 4 git commands to generate.