?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
NaCl changes
[nacl-binutils.git] / opcodes / mep-ibld.c
blob803e499053fe082663cbfb43822d9de01e92a213
1 /* Instruction building/extraction support for mep. -*- C -*-
2
3 THIS FILE IS MACHINE GENERATED WITH CGEN: Cpu tools GENerator.
4 - the resultant file is machine generated, cgen-ibld.in isn't
5
6 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2005, 2006, 2007
7 Free Software Foundation, Inc.
8
9 This file is part of libopcodes.
10
11 This library is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3, or (at your option)
14 any later version.
15
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.
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 "mep-desc.h"
35 #include "mep-opc.h"
36 #include "opintl.h"
37 #include "safe-ctype.h"
38
39 #undef min
40 #define min(a,b) ((a) < (b) ? (a) : (b))
41 #undef max
42 #define max(a,b) ((a) > (b) ? (a) : (b))
43
44 /* Used by the ifield rtx function. */
45 #define FLD(f) (fields->f)
46
47 static const char * insert_normal
48 (CGEN_CPU_DESC, long, unsigned int, unsigned int, unsigned int,
49 unsigned int, unsigned int, unsigned int, CGEN_INSN_BYTES_PTR);
50 static const char * insert_insn_normal
51 (CGEN_CPU_DESC, const CGEN_INSN *,
52 CGEN_FIELDS *, CGEN_INSN_BYTES_PTR, bfd_vma);
53 static int extract_normal
54 (CGEN_CPU_DESC, CGEN_EXTRACT_INFO *, CGEN_INSN_INT,
55 unsigned int, unsigned int, unsigned int, unsigned int,
56 unsigned int, unsigned int, bfd_vma, long *);
57 static int extract_insn_normal
58 (CGEN_CPU_DESC, const CGEN_INSN *, CGEN_EXTRACT_INFO *,
59 CGEN_INSN_INT, CGEN_FIELDS *, bfd_vma);
60 #if CGEN_INT_INSN_P
61 static void put_insn_int_value
62 (CGEN_CPU_DESC, CGEN_INSN_BYTES_PTR, int, int, CGEN_INSN_INT);
63 #endif
64 #if ! CGEN_INT_INSN_P
65 static CGEN_INLINE void insert_1
66 (CGEN_CPU_DESC, unsigned long, int, int, int, unsigned char *);
67 static CGEN_INLINE int fill_cache
68 (CGEN_CPU_DESC, CGEN_EXTRACT_INFO *, int, int, bfd_vma);
69 static CGEN_INLINE long extract_1
70 (CGEN_CPU_DESC, CGEN_EXTRACT_INFO *, int, int, int, unsigned char *, bfd_vma);
71 #endif
72 \f
73 /* Operand insertion. */
74
75 #if ! CGEN_INT_INSN_P
76
77 /* Subroutine of insert_normal. */
78
79 static CGEN_INLINE void
80 insert_1 (CGEN_CPU_DESC cd,
81 unsigned long value,
82 int start,
83 int length,
84 int word_length,
85 unsigned char *bufp)
86 {
87 unsigned long x,mask;
88 int shift;
89
90 x = cgen_get_insn_value (cd, bufp, word_length);
91
92 /* Written this way to avoid undefined behaviour. */
93 mask = (((1L << (length - 1)) - 1) << 1) | 1;
94 if (CGEN_INSN_LSB0_P)
95 shift = (start + 1) - length;
96 else
97 shift = (word_length - (start + length));
98 x = (x & ~(mask << shift)) | ((value & mask) << shift);
99
100 cgen_put_insn_value (cd, bufp, word_length, (bfd_vma) x);
101 }
102
103 #endif /* ! CGEN_INT_INSN_P */
104
105 /* Default insertion routine.
106
107 ATTRS is a mask of the boolean attributes.
108 WORD_OFFSET is the offset in bits from the start of the insn of the value.
109 WORD_LENGTH is the length of the word in bits in which the value resides.
110 START is the starting bit number in the word, architecture origin.
111 LENGTH is the length of VALUE in bits.
112 TOTAL_LENGTH is the total length of the insn in bits.
113
114 The result is an error message or NULL if success. */
115
116 /* ??? This duplicates functionality with bfd's howto table and
117 bfd_install_relocation. */
118 /* ??? This doesn't handle bfd_vma's. Create another function when
119 necessary. */
120
121 static const char *
122 insert_normal (CGEN_CPU_DESC cd,
123 long value,
124 unsigned int attrs,
125 unsigned int word_offset,
126 unsigned int start,
127 unsigned int length,
128 unsigned int word_length,
129 unsigned int total_length,
130 CGEN_INSN_BYTES_PTR buffer)
131 {
132 static char errbuf[100];
133 /* Written this way to avoid undefined behaviour. */
134 unsigned long mask = (((1L << (length - 1)) - 1) << 1) | 1;
135
136 /* If LENGTH is zero, this operand doesn't contribute to the value. */
137 if (length == 0)
138 return NULL;
139
140 if (word_length > 32)
141 abort ();
142
143 /* For architectures with insns smaller than the base-insn-bitsize,
144 word_length may be too big. */
145 if (cd->min_insn_bitsize < cd->base_insn_bitsize)
146 {
147 if (word_offset == 0
148 && word_length > total_length)
149 word_length = total_length;
150 }
151
152 /* Ensure VALUE will fit. */
153 if (CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGN_OPT))
154 {
155 long minval = - (1L << (length - 1));
156 unsigned long maxval = mask;
157
158 if ((value > 0 && (unsigned long) value > maxval)
159 || value < minval)
160 {
161 /* xgettext:c-format */
162 sprintf (errbuf,
163 _("operand out of range (%ld not between %ld and %lu)"),
164 value, minval, maxval);
165 return errbuf;
166 }
167 }
168 else if (! CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGNED))
169 {
170 unsigned long maxval = mask;
171 unsigned long val = (unsigned long) value;
172
173 /* For hosts with a word size > 32 check to see if value has been sign
174 extended beyond 32 bits. If so then ignore these higher sign bits
175 as the user is attempting to store a 32-bit signed value into an
176 unsigned 32-bit field which is allowed. */
177 if (sizeof (unsigned long) > 4 && ((value >> 32) == -1))
178 val &= 0xFFFFFFFF;
179
180 if (val > maxval)
181 {
182 /* xgettext:c-format */
183 sprintf (errbuf,
184 _("operand out of range (0x%lx not between 0 and 0x%lx)"),
185 val, maxval);
186 return errbuf;
187 }
188 }
189 else
190 {
191 if (! cgen_signed_overflow_ok_p (cd))
192 {
193 long minval = - (1L << (length - 1));
194 long maxval = (1L << (length - 1)) - 1;
195
196 if (value < minval || value > maxval)
197 {
198 sprintf
199 /* xgettext:c-format */
200 (errbuf, _("operand out of range (%ld not between %ld and %ld)"),
201 value, minval, maxval);
202 return errbuf;
203 }
204 }
205 }
206
207 #if CGEN_INT_INSN_P
208
209 {
210 int shift;
211
212 if (CGEN_INSN_LSB0_P)
213 shift = (word_offset + start + 1) - length;
214 else
215 shift = total_length - (word_offset + start + length);
216 *buffer = (*buffer & ~(mask << shift)) | ((value & mask) << shift);
217 }
218
219 #else /* ! CGEN_INT_INSN_P */
220
221 {
222 unsigned char *bufp = (unsigned char *) buffer + word_offset / 8;
223
224 insert_1 (cd, value, start, length, word_length, bufp);
225 }
226
227 #endif /* ! CGEN_INT_INSN_P */
228
229 return NULL;
230 }
231
232 /* Default insn builder (insert handler).
233 The instruction is recorded in CGEN_INT_INSN_P byte order (meaning
234 that if CGEN_INSN_BYTES_PTR is an int * and thus, the value is
235 recorded in host byte order, otherwise BUFFER is an array of bytes
236 and the value is recorded in target byte order).
237 The result is an error message or NULL if success. */
238
239 static const char *
240 insert_insn_normal (CGEN_CPU_DESC cd,
241 const CGEN_INSN * insn,
242 CGEN_FIELDS * fields,
243 CGEN_INSN_BYTES_PTR buffer,
244 bfd_vma pc)
245 {
246 const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
247 unsigned long value;
248 const CGEN_SYNTAX_CHAR_TYPE * syn;
249
250 CGEN_INIT_INSERT (cd);
251 value = CGEN_INSN_BASE_VALUE (insn);
252
253 /* If we're recording insns as numbers (rather than a string of bytes),
254 target byte order handling is deferred until later. */
255
256 #if CGEN_INT_INSN_P
257
258 put_insn_int_value (cd, buffer, cd->base_insn_bitsize,
259 CGEN_FIELDS_BITSIZE (fields), value);
260
261 #else
262
263 cgen_put_insn_value (cd, buffer, min ((unsigned) cd->base_insn_bitsize,
264 (unsigned) CGEN_FIELDS_BITSIZE (fields)),
265 value);
266
267 #endif /* ! CGEN_INT_INSN_P */
268
269 /* ??? It would be better to scan the format's fields.
270 Still need to be able to insert a value based on the operand though;
271 e.g. storing a branch displacement that got resolved later.
272 Needs more thought first. */
273
274 for (syn = CGEN_SYNTAX_STRING (syntax); * syn; ++ syn)
275 {
276 const char *errmsg;
277
278 if (CGEN_SYNTAX_CHAR_P (* syn))
279 continue;
280
281 errmsg = (* cd->insert_operand) (cd, CGEN_SYNTAX_FIELD (*syn),
282 fields, buffer, pc);
283 if (errmsg)
284 return errmsg;
285 }
286
287 return NULL;
288 }
289
290 #if CGEN_INT_INSN_P
291 /* Cover function to store an insn value into an integral insn. Must go here
292 because it needs <prefix>-desc.h for CGEN_INT_INSN_P. */
293
294 static void
295 put_insn_int_value (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
296 CGEN_INSN_BYTES_PTR buf,
297 int length,
298 int insn_length,
299 CGEN_INSN_INT value)
300 {
301 /* For architectures with insns smaller than the base-insn-bitsize,
302 length may be too big. */
303 if (length > insn_length)
304 *buf = value;
305 else
306 {
307 int shift = insn_length - length;
308 /* Written this way to avoid undefined behaviour. */
309 CGEN_INSN_INT mask = (((1L << (length - 1)) - 1) << 1) | 1;
310
311 *buf = (*buf & ~(mask << shift)) | ((value & mask) << shift);
312 }
313 }
314 #endif
315 \f
316 /* Operand extraction. */
317
318 #if ! CGEN_INT_INSN_P
319
320 /* Subroutine of extract_normal.
321 Ensure sufficient bytes are cached in EX_INFO.
322 OFFSET is the offset in bytes from the start of the insn of the value.
323 BYTES is the length of the needed value.
324 Returns 1 for success, 0 for failure. */
325
326 static CGEN_INLINE int
327 fill_cache (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
328 CGEN_EXTRACT_INFO *ex_info,
329 int offset,
330 int bytes,
331 bfd_vma pc)
332 {
333 /* It's doubtful that the middle part has already been fetched so
334 we don't optimize that case. kiss. */
335 unsigned int mask;
336 disassemble_info *info = (disassemble_info *) ex_info->dis_info;
337
338 /* First do a quick check. */
339 mask = (1 << bytes) - 1;
340 if (((ex_info->valid >> offset) & mask) == mask)
341 return 1;
342
343 /* Search for the first byte we need to read. */
344 for (mask = 1 << offset; bytes > 0; --bytes, ++offset, mask <<= 1)
345 if (! (mask & ex_info->valid))
346 break;
347
348 if (bytes)
349 {
350 int status;
351
352 pc += offset;
353 status = (*info->read_memory_func)
354 (pc, ex_info->insn_bytes + offset, bytes, info);
355
356 if (status != 0)
357 {
358 (*info->memory_error_func) (status, pc, info);
359 return 0;
360 }
361
362 ex_info->valid |= ((1 << bytes) - 1) << offset;
363 }
364
365 return 1;
366 }
367
368 /* Subroutine of extract_normal. */
369
370 static CGEN_INLINE long
371 extract_1 (CGEN_CPU_DESC cd,
372 CGEN_EXTRACT_INFO *ex_info ATTRIBUTE_UNUSED,
373 int start,
374 int length,
375 int word_length,
376 unsigned char *bufp,
377 bfd_vma pc ATTRIBUTE_UNUSED)
378 {
379 unsigned long x;
380 int shift;
381
382 x = cgen_get_insn_value (cd, bufp, word_length);
383
384 if (CGEN_INSN_LSB0_P)
385 shift = (start + 1) - length;
386 else
387 shift = (word_length - (start + length));
388 return x >> shift;
389 }
390
391 #endif /* ! CGEN_INT_INSN_P */
392
393 /* Default extraction routine.
394
395 INSN_VALUE is the first base_insn_bitsize bits of the insn in host order,
396 or sometimes less for cases like the m32r where the base insn size is 32
397 but some insns are 16 bits.
398 ATTRS is a mask of the boolean attributes. We only need `SIGNED',
399 but for generality we take a bitmask of all of them.
400 WORD_OFFSET is the offset in bits from the start of the insn of the value.
401 WORD_LENGTH is the length of the word in bits in which the value resides.
402 START is the starting bit number in the word, architecture origin.
403 LENGTH is the length of VALUE in bits.
404 TOTAL_LENGTH is the total length of the insn in bits.
405
406 Returns 1 for success, 0 for failure. */
407
408 /* ??? The return code isn't properly used. wip. */
409
410 /* ??? This doesn't handle bfd_vma's. Create another function when
411 necessary. */
412
413 static int
414 extract_normal (CGEN_CPU_DESC cd,
415 #if ! CGEN_INT_INSN_P
416 CGEN_EXTRACT_INFO *ex_info,
417 #else
418 CGEN_EXTRACT_INFO *ex_info ATTRIBUTE_UNUSED,
419 #endif
420 CGEN_INSN_INT insn_value,
421 unsigned int attrs,
422 unsigned int word_offset,
423 unsigned int start,
424 unsigned int length,
425 unsigned int word_length,
426 unsigned int total_length,
427 #if ! CGEN_INT_INSN_P
428 bfd_vma pc,
429 #else
430 bfd_vma pc ATTRIBUTE_UNUSED,
431 #endif
432 long *valuep)
433 {
434 long value, mask;
435
436 /* If LENGTH is zero, this operand doesn't contribute to the value
437 so give it a standard value of zero. */
438 if (length == 0)
439 {
440 *valuep = 0;
441 return 1;
442 }
443
444 if (word_length > 32)
445 abort ();
446
447 /* For architectures with insns smaller than the insn-base-bitsize,
448 word_length may be too big. */
449 if (cd->min_insn_bitsize < cd->base_insn_bitsize)
450 {
451 if (word_offset + word_length > total_length)
452 word_length = total_length - word_offset;
453 }
454
455 /* Does the value reside in INSN_VALUE, and at the right alignment? */
456
457 if (CGEN_INT_INSN_P || (word_offset == 0 && word_length == total_length))
458 {
459 if (CGEN_INSN_LSB0_P)
460 value = insn_value >> ((word_offset + start + 1) - length);
461 else
462 value = insn_value >> (total_length - ( word_offset + start + length));
463 }
464
465 #if ! CGEN_INT_INSN_P
466
467 else
468 {
469 unsigned char *bufp = ex_info->insn_bytes + word_offset / 8;
470
471 if (word_length > 32)
472 abort ();
473
474 if (fill_cache (cd, ex_info, word_offset / 8, word_length / 8, pc) == 0)
475 return 0;
476
477 value = extract_1 (cd, ex_info, start, length, word_length, bufp, pc);
478 }
479
480 #endif /* ! CGEN_INT_INSN_P */
481
482 /* Written this way to avoid undefined behaviour. */
483 mask = (((1L << (length - 1)) - 1) << 1) | 1;
484
485 value &= mask;
486 /* sign extend? */
487 if (CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGNED)
488 && (value & (1L << (length - 1))))
489 value |= ~mask;
490
491 *valuep = value;
492
493 return 1;
494 }
495
496 /* Default insn extractor.
497
498 INSN_VALUE is the first base_insn_bitsize bits, translated to host order.
499 The extracted fields are stored in FIELDS.
500 EX_INFO is used to handle reading variable length insns.
501 Return the length of the insn in bits, or 0 if no match,
502 or -1 if an error occurs fetching data (memory_error_func will have
503 been called). */
504
505 static int
506 extract_insn_normal (CGEN_CPU_DESC cd,
507 const CGEN_INSN *insn,
508 CGEN_EXTRACT_INFO *ex_info,
509 CGEN_INSN_INT insn_value,
510 CGEN_FIELDS *fields,
511 bfd_vma pc)
512 {
513 const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
514 const CGEN_SYNTAX_CHAR_TYPE *syn;
515
516 CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn);
517
518 CGEN_INIT_EXTRACT (cd);
519
520 for (syn = CGEN_SYNTAX_STRING (syntax); *syn; ++syn)
521 {
522 int length;
523
524 if (CGEN_SYNTAX_CHAR_P (*syn))
525 continue;
526
527 length = (* cd->extract_operand) (cd, CGEN_SYNTAX_FIELD (*syn),
528 ex_info, insn_value, fields, pc);
529 if (length <= 0)
530 return length;
531 }
532
533 /* We recognized and successfully extracted this insn. */
534 return CGEN_INSN_BITSIZE (insn);
535 }
536 \f
537 /* Machine generated code added here. */
538
539 const char * mep_cgen_insert_operand
540 (CGEN_CPU_DESC, int, CGEN_FIELDS *, CGEN_INSN_BYTES_PTR, bfd_vma);
541
542 /* Main entry point for operand insertion.
543
544 This function is basically just a big switch statement. Earlier versions
545 used tables to look up the function to use, but
546 - if the table contains both assembler and disassembler functions then
547 the disassembler contains much of the assembler and vice-versa,
548 - there's a lot of inlining possibilities as things grow,
549 - using a switch statement avoids the function call overhead.
550
551 This function could be moved into `parse_insn_normal', but keeping it
552 separate makes clear the interface between `parse_insn_normal' and each of
553 the handlers. It's also needed by GAS to insert operands that couldn't be
554 resolved during parsing. */
555
556 const char *
557 mep_cgen_insert_operand (CGEN_CPU_DESC cd,
558 int opindex,
559 CGEN_FIELDS * fields,
560 CGEN_INSN_BYTES_PTR buffer,
561 bfd_vma pc ATTRIBUTE_UNUSED)
562 {
563 const char * errmsg = NULL;
564 unsigned int total_length = CGEN_FIELDS_BITSIZE (fields);
565
566 switch (opindex)
567 {
568 case MEP_OPERAND_ADDR24A4 :
569 {
570 {
571 FLD (f_24u8a4n_hi) = ((unsigned int) (FLD (f_24u8a4n)) >> (8));
572 FLD (f_24u8a4n_lo) = ((unsigned int) (((FLD (f_24u8a4n)) & (252))) >> (2));
573 }
574 errmsg = insert_normal (cd, fields->f_24u8a4n_hi, 0, 0, 16, 16, 32, total_length, buffer);
575 if (errmsg)
576 break;
577 errmsg = insert_normal (cd, fields->f_24u8a4n_lo, 0, 0, 8, 6, 32, total_length, buffer);
578 if (errmsg)
579 break;
580 }
581 break;
582 case MEP_OPERAND_CALLNUM :
583 {
584 {
585 FLD (f_5) = ((((unsigned int) (FLD (f_callnum)) >> (3))) & (1));
586 FLD (f_6) = ((((unsigned int) (FLD (f_callnum)) >> (2))) & (1));
587 FLD (f_7) = ((((unsigned int) (FLD (f_callnum)) >> (1))) & (1));
588 FLD (f_11) = ((FLD (f_callnum)) & (1));
589 }
590 errmsg = insert_normal (cd, fields->f_5, 0, 0, 5, 1, 32, total_length, buffer);
591 if (errmsg)
592 break;
593 errmsg = insert_normal (cd, fields->f_6, 0, 0, 6, 1, 32, total_length, buffer);
594 if (errmsg)
595 break;
596 errmsg = insert_normal (cd, fields->f_7, 0, 0, 7, 1, 32, total_length, buffer);
597 if (errmsg)
598 break;
599 errmsg = insert_normal (cd, fields->f_11, 0, 0, 11, 1, 32, total_length, buffer);
600 if (errmsg)
601 break;
602 }
603 break;
604 case MEP_OPERAND_CCCC :
605 errmsg = insert_normal (cd, fields->f_rm, 0, 0, 8, 4, 32, total_length, buffer);
606 break;
607 case MEP_OPERAND_CCRN :
608 {
609 {
610 FLD (f_ccrn_hi) = ((((unsigned int) (FLD (f_ccrn)) >> (4))) & (3));
611 FLD (f_ccrn_lo) = ((FLD (f_ccrn)) & (15));
612 }
613 errmsg = insert_normal (cd, fields->f_ccrn_hi, 0, 0, 28, 2, 32, total_length, buffer);
614 if (errmsg)
615 break;
616 errmsg = insert_normal (cd, fields->f_ccrn_lo, 0, 0, 4, 4, 32, total_length, buffer);
617 if (errmsg)
618 break;
619 }
620 break;
621 case MEP_OPERAND_CDISP8 :
622 errmsg = insert_normal (cd, fields->f_8s24, 0|(1<<CGEN_IFLD_SIGNED), 0, 24, 8, 32, total_length, buffer);
623 break;
624 case MEP_OPERAND_CDISP8A2 :
625 {
626 long value = fields->f_8s24a2;
627 value = ((int) (value) >> (1));
628 errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED), 0, 24, 7, 32, total_length, buffer);
629 }
630 break;
631 case MEP_OPERAND_CDISP8A4 :
632 {
633 long value = fields->f_8s24a4;
634 value = ((int) (value) >> (2));
635 errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED), 0, 24, 6, 32, total_length, buffer);
636 }
637 break;
638 case MEP_OPERAND_CDISP8A8 :
639 {
640 long value = fields->f_8s24a8;
641 value = ((int) (value) >> (3));
642 errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED), 0, 24, 5, 32, total_length, buffer);
643 }
644 break;
645 case MEP_OPERAND_CIMM4 :
646 errmsg = insert_normal (cd, fields->f_rn, 0, 0, 4, 4, 32, total_length, buffer);
647 break;
648 case MEP_OPERAND_CIMM5 :
649 errmsg = insert_normal (cd, fields->f_5u24, 0, 0, 24, 5, 32, total_length, buffer);
650 break;
651 case MEP_OPERAND_CODE16 :
652 errmsg = insert_normal (cd, fields->f_16u16, 0, 0, 16, 16, 32, total_length, buffer);
653 break;
654 case MEP_OPERAND_CODE24 :
655 {
656 {
657 FLD (f_24u4n_hi) = ((unsigned int) (FLD (f_24u4n)) >> (16));
658 FLD (f_24u4n_lo) = ((FLD (f_24u4n)) & (65535));
659 }
660 errmsg = insert_normal (cd, fields->f_24u4n_hi, 0, 0, 4, 8, 32, total_length, buffer);
661 if (errmsg)
662 break;
663 errmsg = insert_normal (cd, fields->f_24u4n_lo, 0, 0, 16, 16, 32, total_length, buffer);
664 if (errmsg)
665 break;
666 }
667 break;
668 case MEP_OPERAND_CP_FLAG :
669 break;
670 case MEP_OPERAND_CRN :
671 errmsg = insert_normal (cd, fields->f_crn, 0, 0, 4, 4, 32, total_length, buffer);
672 break;
673 case MEP_OPERAND_CRN64 :
674 errmsg = insert_normal (cd, fields->f_crn, 0, 0, 4, 4, 32, total_length, buffer);
675 break;
676 case MEP_OPERAND_CRNX :
677 {
678 {
679 FLD (f_crnx_lo) = ((FLD (f_crnx)) & (15));
680 FLD (f_crnx_hi) = ((unsigned int) (FLD (f_crnx)) >> (4));
681 }
682 errmsg = insert_normal (cd, fields->f_crnx_hi, 0, 0, 28, 1, 32, total_length, buffer);
683 if (errmsg)
684 break;
685 errmsg = insert_normal (cd, fields->f_crnx_lo, 0, 0, 4, 4, 32, total_length, buffer);
686 if (errmsg)
687 break;
688 }
689 break;
690 case MEP_OPERAND_CRNX64 :
691 {
692 {
693 FLD (f_crnx_lo) = ((FLD (f_crnx)) & (15));
694 FLD (f_crnx_hi) = ((unsigned int) (FLD (f_crnx)) >> (4));
695 }
696 errmsg = insert_normal (cd, fields->f_crnx_hi, 0, 0, 28, 1, 32, total_length, buffer);
697 if (errmsg)
698 break;
699 errmsg = insert_normal (cd, fields->f_crnx_lo, 0, 0, 4, 4, 32, total_length, buffer);
700 if (errmsg)
701 break;
702 }
703 break;
704 case MEP_OPERAND_CSRN :
705 {
706 {
707 FLD (f_csrn_lo) = ((FLD (f_csrn)) & (15));
708 FLD (f_csrn_hi) = ((unsigned int) (FLD (f_csrn)) >> (4));
709 }
710 errmsg = insert_normal (cd, fields->f_csrn_hi, 0, 0, 15, 1, 32, total_length, buffer);
711 if (errmsg)
712 break;
713 errmsg = insert_normal (cd, fields->f_csrn_lo, 0, 0, 8, 4, 32, total_length, buffer);
714 if (errmsg)
715 break;
716 }
717 break;
718 case MEP_OPERAND_CSRN_IDX :
719 {
720 {
721 FLD (f_csrn_lo) = ((FLD (f_csrn)) & (15));
722 FLD (f_csrn_hi) = ((unsigned int) (FLD (f_csrn)) >> (4));
723 }
724 errmsg = insert_normal (cd, fields->f_csrn_hi, 0, 0, 15, 1, 32, total_length, buffer);
725 if (errmsg)
726 break;
727 errmsg = insert_normal (cd, fields->f_csrn_lo, 0, 0, 8, 4, 32, total_length, buffer);
728 if (errmsg)
729 break;
730 }
731 break;
732 case MEP_OPERAND_DBG :
733 break;
734 case MEP_OPERAND_DEPC :
735 break;
736 case MEP_OPERAND_EPC :
737 break;
738 case MEP_OPERAND_EXC :
739 break;
740 case MEP_OPERAND_FMAX_CCRN :
741 errmsg = insert_normal (cd, fields->f_fmax_4_4, 0, 0, 4, 4, 32, total_length, buffer);
742 break;
743 case MEP_OPERAND_FMAX_FRD :
744 {
745 {
746 FLD (f_fmax_4_4) = ((FLD (f_fmax_frd)) & (15));
747 FLD (f_fmax_28_1) = ((unsigned int) (FLD (f_fmax_frd)) >> (4));
748 }
749 errmsg = insert_normal (cd, fields->f_fmax_28_1, 0, 0, 28, 1, 32, total_length, buffer);
750 if (errmsg)
751 break;
752 errmsg = insert_normal (cd, fields->f_fmax_4_4, 0, 0, 4, 4, 32, total_length, buffer);
753 if (errmsg)
754 break;
755 }
756 break;
757 case MEP_OPERAND_FMAX_FRD_INT :
758 {
759 {
760 FLD (f_fmax_4_4) = ((FLD (f_fmax_frd)) & (15));
761 FLD (f_fmax_28_1) = ((unsigned int) (FLD (f_fmax_frd)) >> (4));
762 }
763 errmsg = insert_normal (cd, fields->f_fmax_28_1, 0, 0, 28, 1, 32, total_length, buffer);
764 if (errmsg)
765 break;
766 errmsg = insert_normal (cd, fields->f_fmax_4_4, 0, 0, 4, 4, 32, total_length, buffer);
767 if (errmsg)
768 break;
769 }
770 break;
771 case MEP_OPERAND_FMAX_FRM :
772 {
773 {
774 FLD (f_fmax_24_4) = ((FLD (f_fmax_frm)) & (15));
775 FLD (f_fmax_30_1) = ((unsigned int) (FLD (f_fmax_frm)) >> (4));
776 }
777 errmsg = insert_normal (cd, fields->f_fmax_30_1, 0, 0, 30, 1, 32, total_length, buffer);
778 if (errmsg)
779 break;
780 errmsg = insert_normal (cd, fields->f_fmax_24_4, 0, 0, 24, 4, 32, total_length, buffer);
781 if (errmsg)
782 break;
783 }
784 break;
785 case MEP_OPERAND_FMAX_FRN :
786 {
787 {
788 FLD (f_fmax_20_4) = ((FLD (f_fmax_frn)) & (15));
789 FLD (f_fmax_29_1) = ((unsigned int) (FLD (f_fmax_frn)) >> (4));
790 }
791 errmsg = insert_normal (cd, fields->f_fmax_29_1, 0, 0, 29, 1, 32, total_length, buffer);
792 if (errmsg)
793 break;
794 errmsg = insert_normal (cd, fields->f_fmax_20_4, 0, 0, 20, 4, 32, total_length, buffer);
795 if (errmsg)
796 break;
797 }
798 break;
799 case MEP_OPERAND_FMAX_FRN_INT :
800 {
801 {
802 FLD (f_fmax_20_4) = ((FLD (f_fmax_frn)) & (15));
803 FLD (f_fmax_29_1) = ((unsigned int) (FLD (f_fmax_frn)) >> (4));
804 }
805 errmsg = insert_normal (cd, fields->f_fmax_29_1, 0, 0, 29, 1, 32, total_length, buffer);
806 if (errmsg)
807 break;
808 errmsg = insert_normal (cd, fields->f_fmax_20_4, 0, 0, 20, 4, 32, total_length, buffer);
809 if (errmsg)
810 break;
811 }
812 break;
813 case MEP_OPERAND_FMAX_RM :
814 errmsg = insert_normal (cd, fields->f_fmax_rm, 0, 0, 8, 4, 32, total_length, buffer);
815 break;
816 case MEP_OPERAND_HI :
817 break;
818 case MEP_OPERAND_LO :
819 break;
820 case MEP_OPERAND_LP :
821 break;
822 case MEP_OPERAND_MB0 :
823 break;
824 case MEP_OPERAND_MB1 :
825 break;
826 case MEP_OPERAND_ME0 :
827 break;
828 case MEP_OPERAND_ME1 :
829 break;
830 case MEP_OPERAND_NPC :
831 break;
832 case MEP_OPERAND_OPT :
833 break;
834 case MEP_OPERAND_PCABS24A2 :
835 {
836 {
837 FLD (f_24u5a2n_lo) = ((unsigned int) (((FLD (f_24u5a2n)) & (255))) >> (1));
838 FLD (f_24u5a2n_hi) = ((unsigned int) (FLD (f_24u5a2n)) >> (8));
839 }
840 errmsg = insert_normal (cd, fields->f_24u5a2n_hi, 0, 0, 16, 16, 32, total_length, buffer);
841 if (errmsg)
842 break;
843 errmsg = insert_normal (cd, fields->f_24u5a2n_lo, 0, 0, 5, 7, 32, total_length, buffer);
844 if (errmsg)
845 break;
846 }
847 break;
848 case MEP_OPERAND_PCREL12A2 :
849 {
850 long value = fields->f_12s4a2;
851 value = ((int) (((value) - (pc))) >> (1));
852 errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 4, 11, 32, total_length, buffer);
853 }
854 break;
855 case MEP_OPERAND_PCREL17A2 :
856 {
857 long value = fields->f_17s16a2;
858 value = ((int) (((value) - (pc))) >> (1));
859 errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 16, 16, 32, total_length, buffer);
860 }
861 break;
862 case MEP_OPERAND_PCREL24A2 :
863 {
864 {
865 FLD (f_24s5a2n) = ((FLD (f_24s5a2n)) - (pc));
866 FLD (f_24s5a2n_lo) = ((unsigned int) (((FLD (f_24s5a2n)) & (254))) >> (1));
867 FLD (f_24s5a2n_hi) = ((int) (FLD (f_24s5a2n)) >> (8));
868 }
869 errmsg = insert_normal (cd, fields->f_24s5a2n_hi, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 16, 16, 32, total_length, buffer);
870 if (errmsg)
871 break;
872 errmsg = insert_normal (cd, fields->f_24s5a2n_lo, 0|(1<<CGEN_IFLD_PCREL_ADDR), 0, 5, 7, 32, total_length, buffer);
873 if (errmsg)
874 break;
875 }
876 break;
877 case MEP_OPERAND_PCREL8A2 :
878 {
879 long value = fields->f_8s8a2;
880 value = ((int) (((value) - (pc))) >> (1));
881 errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 8, 7, 32, total_length, buffer);
882 }
883 break;
884 case MEP_OPERAND_PSW :
885 break;
886 case MEP_OPERAND_R0 :
887 break;
888 case MEP_OPERAND_R1 :
889 break;
890 case MEP_OPERAND_RL :
891 errmsg = insert_normal (cd, fields->f_rl, 0, 0, 12, 4, 32, total_length, buffer);
892 break;
893 case MEP_OPERAND_RM :
894 errmsg = insert_normal (cd, fields->f_rm, 0, 0, 8, 4, 32, total_length, buffer);
895 break;
896 case MEP_OPERAND_RMA :
897 errmsg = insert_normal (cd, fields->f_rm, 0, 0, 8, 4, 32, total_length, buffer);
898 break;
899 case MEP_OPERAND_RN :
900 errmsg = insert_normal (cd, fields->f_rn, 0, 0, 4, 4, 32, total_length, buffer);
901 break;
902 case MEP_OPERAND_RN3 :
903 errmsg = insert_normal (cd, fields->f_rn3, 0, 0, 5, 3, 32, total_length, buffer);
904 break;
905 case MEP_OPERAND_RN3C :
906 errmsg = insert_normal (cd, fields->f_rn3, 0, 0, 5, 3, 32, total_length, buffer);
907 break;
908 case MEP_OPERAND_RN3L :
909 errmsg = insert_normal (cd, fields->f_rn3, 0, 0, 5, 3, 32, total_length, buffer);
910 break;
911 case MEP_OPERAND_RN3S :
912 errmsg = insert_normal (cd, fields->f_rn3, 0, 0, 5, 3, 32, total_length, buffer);
913 break;
914 case MEP_OPERAND_RN3UC :
915 errmsg = insert_normal (cd, fields->f_rn3, 0, 0, 5, 3, 32, total_length, buffer);
916 break;
917 case MEP_OPERAND_RN3UL :
918 errmsg = insert_normal (cd, fields->f_rn3, 0, 0, 5, 3, 32, total_length, buffer);
919 break;
920 case MEP_OPERAND_RN3US :
921 errmsg = insert_normal (cd, fields->f_rn3, 0, 0, 5, 3, 32, total_length, buffer);
922 break;
923 case MEP_OPERAND_RNC :
924 errmsg = insert_normal (cd, fields->f_rn, 0, 0, 4, 4, 32, total_length, buffer);
925 break;
926 case MEP_OPERAND_RNL :
927 errmsg = insert_normal (cd, fields->f_rn, 0, 0, 4, 4, 32, total_length, buffer);
928 break;
929 case MEP_OPERAND_RNS :
930 errmsg = insert_normal (cd, fields->f_rn, 0, 0, 4, 4, 32, total_length, buffer);
931 break;
932 case MEP_OPERAND_RNUC :
933 errmsg = insert_normal (cd, fields->f_rn, 0, 0, 4, 4, 32, total_length, buffer);
934 break;
935 case MEP_OPERAND_RNUL :
936 errmsg = insert_normal (cd, fields->f_rn, 0, 0, 4, 4, 32, total_length, buffer);
937 break;
938 case MEP_OPERAND_RNUS :
939 errmsg = insert_normal (cd, fields->f_rn, 0, 0, 4, 4, 32, total_length, buffer);
940 break;
941 case MEP_OPERAND_SAR :
942 break;
943 case MEP_OPERAND_SDISP16 :
944 errmsg = insert_normal (cd, fields->f_16s16, 0|(1<<CGEN_IFLD_SIGNED), 0, 16, 16, 32, total_length, buffer);
945 break;
946 case MEP_OPERAND_SIMM16 :
947 errmsg = insert_normal (cd, fields->f_16s16, 0|(1<<CGEN_IFLD_SIGNED), 0, 16, 16, 32, total_length, buffer);
948 break;
949 case MEP_OPERAND_SIMM6 :
950 errmsg = insert_normal (cd, fields->f_6s8, 0|(1<<CGEN_IFLD_SIGNED), 0, 8, 6, 32, total_length, buffer);
951 break;
952 case MEP_OPERAND_SIMM8 :
953 errmsg = insert_normal (cd, fields->f_8s8, 0|(1<<CGEN_IFLD_SIGNED), 0, 8, 8, 32, total_length, buffer);
954 break;
955 case MEP_OPERAND_SP :
956 break;
957 case MEP_OPERAND_SPR :
958 break;
959 case MEP_OPERAND_TP :
960 break;
961 case MEP_OPERAND_TPR :
962 break;
963 case MEP_OPERAND_UDISP2 :
964 errmsg = insert_normal (cd, fields->f_2u6, 0, 0, 6, 2, 32, total_length, buffer);
965 break;
966 case MEP_OPERAND_UDISP7 :
967 errmsg = insert_normal (cd, fields->f_7u9, 0, 0, 9, 7, 32, total_length, buffer);
968 break;
969 case MEP_OPERAND_UDISP7A2 :
970 {
971 long value = fields->f_7u9a2;
972 value = ((unsigned int) (value) >> (1));
973 errmsg = insert_normal (cd, value, 0, 0, 9, 6, 32, total_length, buffer);
974 }
975 break;
976 case MEP_OPERAND_UDISP7A4 :
977 {
978 long value = fields->f_7u9a4;
979 value = ((unsigned int) (value) >> (2));
980 errmsg = insert_normal (cd, value, 0, 0, 9, 5, 32, total_length, buffer);
981 }
982 break;
983 case MEP_OPERAND_UIMM16 :
984 errmsg = insert_normal (cd, fields->f_16u16, 0, 0, 16, 16, 32, total_length, buffer);
985 break;
986 case MEP_OPERAND_UIMM2 :
987 errmsg = insert_normal (cd, fields->f_2u10, 0, 0, 10, 2, 32, total_length, buffer);
988 break;
989 case MEP_OPERAND_UIMM24 :
990 {
991 {
992 FLD (f_24u8n_hi) = ((unsigned int) (FLD (f_24u8n)) >> (8));
993 FLD (f_24u8n_lo) = ((FLD (f_24u8n)) & (255));
994 }
995 errmsg = insert_normal (cd, fields->f_24u8n_hi, 0, 0, 16, 16, 32, total_length, buffer);
996 if (errmsg)
997 break;
998 errmsg = insert_normal (cd, fields->f_24u8n_lo, 0, 0, 8, 8, 32, total_length, buffer);
999 if (errmsg)
1000 break;
1001 }
1002 break;
1003 case MEP_OPERAND_UIMM3 :
1004 errmsg = insert_normal (cd, fields->f_3u5, 0, 0, 5, 3, 32, total_length, buffer);
1005 break;
1006 case MEP_OPERAND_UIMM4 :
1007 errmsg = insert_normal (cd, fields->f_4u8, 0, 0, 8, 4, 32, total_length, buffer);
1008 break;
1009 case MEP_OPERAND_UIMM5 :
1010 errmsg = insert_normal (cd, fields->f_5u8, 0, 0, 8, 5, 32, total_length, buffer);
1011 break;
1012 case MEP_OPERAND_UIMM7A4 :
1013 {
1014 long value = fields->f_7u9a4;
1015 value = ((unsigned int) (value) >> (2));
1016 errmsg = insert_normal (cd, value, 0, 0, 9, 5, 32, total_length, buffer);
1017 }
1018 break;
1019 case MEP_OPERAND_ZERO :
1020 break;
1021
1022 default :
1023 /* xgettext:c-format */
1024 fprintf (stderr, _("Unrecognized field %d while building insn.\n"),
1025 opindex);
1026 abort ();
1027 }
1028
1029 return errmsg;
1030 }
1031
1032 int mep_cgen_extract_operand
1033 (CGEN_CPU_DESC, int, CGEN_EXTRACT_INFO *, CGEN_INSN_INT, CGEN_FIELDS *, bfd_vma);
1034
1035 /* Main entry point for operand extraction.
1036 The result is <= 0 for error, >0 for success.
1037 ??? Actual values aren't well defined right now.
1038
1039 This function is basically just a big switch statement. Earlier versions
1040 used tables to look up the function to use, but
1041 - if the table contains both assembler and disassembler functions then
1042 the disassembler contains much of the assembler and vice-versa,
1043 - there's a lot of inlining possibilities as things grow,
1044 - using a switch statement avoids the function call overhead.
1045
1046 This function could be moved into `print_insn_normal', but keeping it
1047 separate makes clear the interface between `print_insn_normal' and each of
1048 the handlers. */
1049
1050 int
1051 mep_cgen_extract_operand (CGEN_CPU_DESC cd,
1052 int opindex,
1053 CGEN_EXTRACT_INFO *ex_info,
1054 CGEN_INSN_INT insn_value,
1055 CGEN_FIELDS * fields,
1056 bfd_vma pc)
1057 {
1058 /* Assume success (for those operands that are nops). */
1059 int length = 1;
1060 unsigned int total_length = CGEN_FIELDS_BITSIZE (fields);
1061
1062 switch (opindex)
1063 {
1064 case MEP_OPERAND_ADDR24A4 :
1065 {
1066 length = extract_normal (cd, ex_info, insn_value, 0, 0, 16, 16, 32, total_length, pc, & fields->f_24u8a4n_hi);
1067 if (length <= 0) break;
1068 length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 6, 32, total_length, pc, & fields->f_24u8a4n_lo);
1069 if (length <= 0) break;
1070 FLD (f_24u8a4n) = ((((FLD (f_24u8a4n_hi)) << (8))) | (((FLD (f_24u8a4n_lo)) << (2))));
1071 }
1072 break;
1073 case MEP_OPERAND_CALLNUM :
1074 {
1075 length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 1, 32, total_length, pc, & fields->f_5);
1076 if (length <= 0) break;
1077 length = extract_normal (cd, ex_info, insn_value, 0, 0, 6, 1, 32, total_length, pc, & fields->f_6);
1078 if (length <= 0) break;
1079 length = extract_normal (cd, ex_info, insn_value, 0, 0, 7, 1, 32, total_length, pc, & fields->f_7);
1080 if (length <= 0) break;
1081 length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 1, 32, total_length, pc, & fields->f_11);
1082 if (length <= 0) break;
1083 FLD (f_callnum) = ((((FLD (f_5)) << (3))) | (((((FLD (f_6)) << (2))) | (((((FLD (f_7)) << (1))) | (FLD (f_11)))))));
1084 }
1085 break;
1086 case MEP_OPERAND_CCCC :
1087 length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 4, 32, total_length, pc, & fields->f_rm);
1088 break;
1089 case MEP_OPERAND_CCRN :
1090 {
1091 length = extract_normal (cd, ex_info, insn_value, 0, 0, 28, 2, 32, total_length, pc, & fields->f_ccrn_hi);
1092 if (length <= 0) break;
1093 length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_ccrn_lo);
1094 if (length <= 0) break;
1095 FLD (f_ccrn) = ((((FLD (f_ccrn_hi)) << (4))) | (FLD (f_ccrn_lo)));
1096 }
1097 break;
1098 case MEP_OPERAND_CDISP8 :
1099 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 24, 8, 32, total_length, pc, & fields->f_8s24);
1100 break;
1101 case MEP_OPERAND_CDISP8A2 :
1102 {
1103 long value;
1104 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 24, 7, 32, total_length, pc, & value);
1105 value = ((value) << (1));
1106 fields->f_8s24a2 = value;
1107 }
1108 break;
1109 case MEP_OPERAND_CDISP8A4 :
1110 {
1111 long value;
1112 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 24, 6, 32, total_length, pc, & value);
1113 value = ((value) << (2));
1114 fields->f_8s24a4 = value;
1115 }
1116 break;
1117 case MEP_OPERAND_CDISP8A8 :
1118 {
1119 long value;
1120 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 24, 5, 32, total_length, pc, & value);
1121 value = ((value) << (3));
1122 fields->f_8s24a8 = value;
1123 }
1124 break;
1125 case MEP_OPERAND_CIMM4 :
1126 length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_rn);
1127 break;
1128 case MEP_OPERAND_CIMM5 :
1129 length = extract_normal (cd, ex_info, insn_value, 0, 0, 24, 5, 32, total_length, pc, & fields->f_5u24);
1130 break;
1131 case MEP_OPERAND_CODE16 :
1132 length = extract_normal (cd, ex_info, insn_value, 0, 0, 16, 16, 32, total_length, pc, & fields->f_16u16);
1133 break;
1134 case MEP_OPERAND_CODE24 :
1135 {
1136 length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 8, 32, total_length, pc, & fields->f_24u4n_hi);
1137 if (length <= 0) break;
1138 length = extract_normal (cd, ex_info, insn_value, 0, 0, 16, 16, 32, total_length, pc, & fields->f_24u4n_lo);
1139 if (length <= 0) break;
1140 FLD (f_24u4n) = ((((FLD (f_24u4n_hi)) << (16))) | (FLD (f_24u4n_lo)));
1141 }
1142 break;
1143 case MEP_OPERAND_CP_FLAG :
1144 break;
1145 case MEP_OPERAND_CRN :
1146 length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_crn);
1147 break;
1148 case MEP_OPERAND_CRN64 :
1149 length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_crn);
1150 break;
1151 case MEP_OPERAND_CRNX :
1152 {
1153 length = extract_normal (cd, ex_info, insn_value, 0, 0, 28, 1, 32, total_length, pc, & fields->f_crnx_hi);
1154 if (length <= 0) break;
1155 length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_crnx_lo);
1156 if (length <= 0) break;
1157 FLD (f_crnx) = ((((FLD (f_crnx_hi)) << (4))) | (FLD (f_crnx_lo)));
1158 }
1159 break;
1160 case MEP_OPERAND_CRNX64 :
1161 {
1162 length = extract_normal (cd, ex_info, insn_value, 0, 0, 28, 1, 32, total_length, pc, & fields->f_crnx_hi);
1163 if (length <= 0) break;
1164 length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_crnx_lo);
1165 if (length <= 0) break;
1166 FLD (f_crnx) = ((((FLD (f_crnx_hi)) << (4))) | (FLD (f_crnx_lo)));
1167 }
1168 break;
1169 case MEP_OPERAND_CSRN :
1170 {
1171 length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 1, 32, total_length, pc, & fields->f_csrn_hi);
1172 if (length <= 0) break;
1173 length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 4, 32, total_length, pc, & fields->f_csrn_lo);
1174 if (length <= 0) break;
1175 FLD (f_csrn) = ((((FLD (f_csrn_hi)) << (4))) | (FLD (f_csrn_lo)));
1176 }
1177 break;
1178 case MEP_OPERAND_CSRN_IDX :
1179 {
1180 length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 1, 32, total_length, pc, & fields->f_csrn_hi);
1181 if (length <= 0) break;
1182 length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 4, 32, total_length, pc, & fields->f_csrn_lo);
1183 if (length <= 0) break;
1184 FLD (f_csrn) = ((((FLD (f_csrn_hi)) << (4))) | (FLD (f_csrn_lo)));
1185 }
1186 break;
1187 case MEP_OPERAND_DBG :
1188 break;
1189 case MEP_OPERAND_DEPC :
1190 break;
1191 case MEP_OPERAND_EPC :
1192 break;
1193 case MEP_OPERAND_EXC :
1194 break;
1195 case MEP_OPERAND_FMAX_CCRN :
1196 length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_fmax_4_4);
1197 break;
1198 case MEP_OPERAND_FMAX_FRD :
1199 {
1200 length = extract_normal (cd, ex_info, insn_value, 0, 0, 28, 1, 32, total_length, pc, & fields->f_fmax_28_1);
1201 if (length <= 0) break;
1202 length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_fmax_4_4);
1203 if (length <= 0) break;
1204 FLD (f_fmax_frd) = ((((FLD (f_fmax_28_1)) << (4))) | (FLD (f_fmax_4_4)));
1205 }
1206 break;
1207 case MEP_OPERAND_FMAX_FRD_INT :
1208 {
1209 length = extract_normal (cd, ex_info, insn_value, 0, 0, 28, 1, 32, total_length, pc, & fields->f_fmax_28_1);
1210 if (length <= 0) break;
1211 length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_fmax_4_4);
1212 if (length <= 0) break;
1213 FLD (f_fmax_frd) = ((((FLD (f_fmax_28_1)) << (4))) | (FLD (f_fmax_4_4)));
1214 }
1215 break;
1216 case MEP_OPERAND_FMAX_FRM :
1217 {
1218 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 1, 32, total_length, pc, & fields->f_fmax_30_1);
1219 if (length <= 0) break;
1220 length = extract_normal (cd, ex_info, insn_value, 0, 0, 24, 4, 32, total_length, pc, & fields->f_fmax_24_4);
1221 if (length <= 0) break;
1222 FLD (f_fmax_frm) = ((((FLD (f_fmax_30_1)) << (4))) | (FLD (f_fmax_24_4)));
1223 }
1224 break;
1225 case MEP_OPERAND_FMAX_FRN :
1226 {
1227 length = extract_normal (cd, ex_info, insn_value, 0, 0, 29, 1, 32, total_length, pc, & fields->f_fmax_29_1);
1228 if (length <= 0) break;
1229 length = extract_normal (cd, ex_info, insn_value, 0, 0, 20, 4, 32, total_length, pc, & fields->f_fmax_20_4);
1230 if (length <= 0) break;
1231 FLD (f_fmax_frn) = ((((FLD (f_fmax_29_1)) << (4))) | (FLD (f_fmax_20_4)));
1232 }
1233 break;
1234 case MEP_OPERAND_FMAX_FRN_INT :
1235 {
1236 length = extract_normal (cd, ex_info, insn_value, 0, 0, 29, 1, 32, total_length, pc, & fields->f_fmax_29_1);
1237 if (length <= 0) break;
1238 length = extract_normal (cd, ex_info, insn_value, 0, 0, 20, 4, 32, total_length, pc, & fields->f_fmax_20_4);
1239 if (length <= 0) break;
1240 FLD (f_fmax_frn) = ((((FLD (f_fmax_29_1)) << (4))) | (FLD (f_fmax_20_4)));
1241 }
1242 break;
1243 case MEP_OPERAND_FMAX_RM :
1244 length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 4, 32, total_length, pc, & fields->f_fmax_rm);
1245 break;
1246 case MEP_OPERAND_HI :
1247 break;
1248 case MEP_OPERAND_LO :
1249 break;
1250 case MEP_OPERAND_LP :
1251 break;
1252 case MEP_OPERAND_MB0 :
1253 break;
1254 case MEP_OPERAND_MB1 :
1255 break;
1256 case MEP_OPERAND_ME0 :
1257 break;
1258 case MEP_OPERAND_ME1 :
1259 break;
1260 case MEP_OPERAND_NPC :
1261 break;
1262 case MEP_OPERAND_OPT :
1263 break;
1264 case MEP_OPERAND_PCABS24A2 :
1265 {
1266 length = extract_normal (cd, ex_info, insn_value, 0, 0, 16, 16, 32, total_length, pc, & fields->f_24u5a2n_hi);
1267 if (length <= 0) break;
1268 length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 7, 32, total_length, pc, & fields->f_24u5a2n_lo);
1269 if (length <= 0) break;
1270 FLD (f_24u5a2n) = ((((FLD (f_24u5a2n_hi)) << (8))) | (((FLD (f_24u5a2n_lo)) << (1))));
1271 }
1272 break;
1273 case MEP_OPERAND_PCREL12A2 :
1274 {
1275 long value;
1276 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 4, 11, 32, total_length, pc, & value);
1277 value = ((((value) << (1))) + (pc));
1278 fields->f_12s4a2 = value;
1279 }
1280 break;
1281 case MEP_OPERAND_PCREL17A2 :
1282 {
1283 long value;
1284 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 16, 16, 32, total_length, pc, & value);
1285 value = ((((value) << (1))) + (pc));
1286 fields->f_17s16a2 = value;
1287 }
1288 break;
1289 case MEP_OPERAND_PCREL24A2 :
1290 {
1291 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 16, 16, 32, total_length, pc, & fields->f_24s5a2n_hi);
1292 if (length <= 0) break;
1293 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_PCREL_ADDR), 0, 5, 7, 32, total_length, pc, & fields->f_24s5a2n_lo);
1294 if (length <= 0) break;
1295 FLD (f_24s5a2n) = ((((((FLD (f_24s5a2n_hi)) << (8))) | (((FLD (f_24s5a2n_lo)) << (1))))) + (pc));
1296 }
1297 break;
1298 case MEP_OPERAND_PCREL8A2 :
1299 {
1300 long value;
1301 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 8, 7, 32, total_length, pc, & value);
1302 value = ((((value) << (1))) + (pc));
1303 fields->f_8s8a2 = value;
1304 }
1305 break;
1306 case MEP_OPERAND_PSW :
1307 break;
1308 case MEP_OPERAND_R0 :
1309 break;
1310 case MEP_OPERAND_R1 :
1311 break;
1312 case MEP_OPERAND_RL :
1313 length = extract_normal (cd, ex_info, insn_value, 0, 0, 12, 4, 32, total_length, pc, & fields->f_rl);
1314 break;
1315 case MEP_OPERAND_RM :
1316 length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 4, 32, total_length, pc, & fields->f_rm);
1317 break;
1318 case MEP_OPERAND_RMA :
1319 length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 4, 32, total_length, pc, & fields->f_rm);
1320 break;
1321 case MEP_OPERAND_RN :
1322 length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_rn);
1323 break;
1324 case MEP_OPERAND_RN3 :
1325 length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 3, 32, total_length, pc, & fields->f_rn3);
1326 break;
1327 case MEP_OPERAND_RN3C :
1328 length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 3, 32, total_length, pc, & fields->f_rn3);
1329 break;
1330 case MEP_OPERAND_RN3L :
1331 length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 3, 32, total_length, pc, & fields->f_rn3);
1332 break;
1333 case MEP_OPERAND_RN3S :
1334 length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 3, 32, total_length, pc, & fields->f_rn3);
1335 break;
1336 case MEP_OPERAND_RN3UC :
1337 length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 3, 32, total_length, pc, & fields->f_rn3);
1338 break;
1339 case MEP_OPERAND_RN3UL :
1340 length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 3, 32, total_length, pc, & fields->f_rn3);
1341 break;
1342 case MEP_OPERAND_RN3US :
1343 length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 3, 32, total_length, pc, & fields->f_rn3);
1344 break;
1345 case MEP_OPERAND_RNC :
1346 length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_rn);
1347 break;
1348 case MEP_OPERAND_RNL :
1349 length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_rn);
1350 break;
1351 case MEP_OPERAND_RNS :
1352 length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_rn);
1353 break;
1354 case MEP_OPERAND_RNUC :
1355 length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_rn);
1356 break;
1357 case MEP_OPERAND_RNUL :
1358 length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_rn);
1359 break;
1360 case MEP_OPERAND_RNUS :
1361 length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_rn);
1362 break;
1363 case MEP_OPERAND_SAR :
1364 break;
1365 case MEP_OPERAND_SDISP16 :
1366 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 16, 16, 32, total_length, pc, & fields->f_16s16);
1367 break;
1368 case MEP_OPERAND_SIMM16 :
1369 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 16, 16, 32, total_length, pc, & fields->f_16s16);
1370 break;
1371 case MEP_OPERAND_SIMM6 :
1372 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 8, 6, 32, total_length, pc, & fields->f_6s8);
1373 break;
1374 case MEP_OPERAND_SIMM8 :
1375 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 8, 8, 32, total_length, pc, & fields->f_8s8);
1376 break;
1377 case MEP_OPERAND_SP :
1378 break;
1379 case MEP_OPERAND_SPR :
1380 break;
1381 case MEP_OPERAND_TP :
1382 break;
1383 case MEP_OPERAND_TPR :
1384 break;
1385 case MEP_OPERAND_UDISP2 :
1386 length = extract_normal (cd, ex_info, insn_value, 0, 0, 6, 2, 32, total_length, pc, & fields->f_2u6);
1387 break;
1388 case MEP_OPERAND_UDISP7 :
1389 length = extract_normal (cd, ex_info, insn_value, 0, 0, 9, 7, 32, total_length, pc, & fields->f_7u9);
1390 break;
1391 case MEP_OPERAND_UDISP7A2 :
1392 {
1393 long value;
1394 length = extract_normal (cd, ex_info, insn_value, 0, 0, 9, 6, 32, total_length, pc, & value);
1395 value = ((value) << (1));
1396 fields->f_7u9a2 = value;
1397 }
1398 break;
1399 case MEP_OPERAND_UDISP7A4 :
1400 {
1401 long value;
1402 length = extract_normal (cd, ex_info, insn_value, 0, 0, 9, 5, 32, total_length, pc, & value);
1403 value = ((value) << (2));
1404 fields->f_7u9a4 = value;
1405 }
1406 break;
1407 case MEP_OPERAND_UIMM16 :
1408 length = extract_normal (cd, ex_info, insn_value, 0, 0, 16, 16, 32, total_length, pc, & fields->f_16u16);
1409 break;
1410 case MEP_OPERAND_UIMM2 :
1411 length = extract_normal (cd, ex_info, insn_value, 0, 0, 10, 2, 32, total_length, pc, & fields->f_2u10);
1412 break;
1413 case MEP_OPERAND_UIMM24 :
1414 {
1415 length = extract_normal (cd, ex_info, insn_value, 0, 0, 16, 16, 32, total_length, pc, & fields->f_24u8n_hi);
1416 if (length <= 0) break;
1417 length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 8, 32, total_length, pc, & fields->f_24u8n_lo);
1418 if (length <= 0) break;
1419 FLD (f_24u8n) = ((((FLD (f_24u8n_hi)) << (8))) | (FLD (f_24u8n_lo)));
1420 }
1421 break;
1422 case MEP_OPERAND_UIMM3 :
1423 length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 3, 32, total_length, pc, & fields->f_3u5);
1424 break;
1425 case MEP_OPERAND_UIMM4 :
1426 length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 4, 32, total_length, pc, & fields->f_4u8);
1427 break;
1428 case MEP_OPERAND_UIMM5 :
1429 length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 5, 32, total_length, pc, & fields->f_5u8);
1430 break;
1431 case MEP_OPERAND_UIMM7A4 :
1432 {
1433 long value;
1434 length = extract_normal (cd, ex_info, insn_value, 0, 0, 9, 5, 32, total_length, pc, & value);
1435 value = ((value) << (2));
1436 fields->f_7u9a4 = value;
1437 }
1438 break;
1439 case MEP_OPERAND_ZERO :
1440 break;
1441
1442 default :
1443 /* xgettext:c-format */
1444 fprintf (stderr, _("Unrecognized field %d while decoding insn.\n"),
1445 opindex);
1446 abort ();
1447 }
1448
1449 return length;
1450 }
1451
1452 cgen_insert_fn * const mep_cgen_insert_handlers[] =
1453 {
1454 insert_insn_normal,
1455 };
1456
1457 cgen_extract_fn * const mep_cgen_extract_handlers[] =
1458 {
1459 extract_insn_normal,
1460 };
1461
1462 int mep_cgen_get_int_operand (CGEN_CPU_DESC, int, const CGEN_FIELDS *);
1463 bfd_vma mep_cgen_get_vma_operand (CGEN_CPU_DESC, int, const CGEN_FIELDS *);
1464
1465 /* Getting values from cgen_fields is handled by a collection of functions.
1466 They are distinguished by the type of the VALUE argument they return.
1467 TODO: floating point, inlining support, remove cases where result type
1468 not appropriate. */
1469
1470 int
1471 mep_cgen_get_int_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
1472 int opindex,
1473 const CGEN_FIELDS * fields)
1474 {
1475 int value;
1476
1477 switch (opindex)
1478 {
1479 case MEP_OPERAND_ADDR24A4 :
1480 value = fields->f_24u8a4n;
1481 break;
1482 case MEP_OPERAND_CALLNUM :
1483 value = fields->f_callnum;
1484 break;
1485 case MEP_OPERAND_CCCC :
1486 value = fields->f_rm;
1487 break;
1488 case MEP_OPERAND_CCRN :
1489 value = fields->f_ccrn;
1490 break;
1491 case MEP_OPERAND_CDISP8 :
1492 value = fields->f_8s24;
1493 break;
1494 case MEP_OPERAND_CDISP8A2 :
1495 value = fields->f_8s24a2;
1496 break;
1497 case MEP_OPERAND_CDISP8A4 :
1498 value = fields->f_8s24a4;
1499 break;
1500 case MEP_OPERAND_CDISP8A8 :
1501 value = fields->f_8s24a8;
1502 break;
1503 case MEP_OPERAND_CIMM4 :
1504 value = fields->f_rn;
1505 break;
1506 case MEP_OPERAND_CIMM5 :
1507 value = fields->f_5u24;
1508 break;
1509 case MEP_OPERAND_CODE16 :
1510 value = fields->f_16u16;
1511 break;
1512 case MEP_OPERAND_CODE24 :
1513 value = fields->f_24u4n;
1514 break;
1515 case MEP_OPERAND_CP_FLAG :
1516 value = 0;
1517 break;
1518 case MEP_OPERAND_CRN :
1519 value = fields->f_crn;
1520 break;
1521 case MEP_OPERAND_CRN64 :
1522 value = fields->f_crn;
1523 break;
1524 case MEP_OPERAND_CRNX :
1525 value = fields->f_crnx;
1526 break;
1527 case MEP_OPERAND_CRNX64 :
1528 value = fields->f_crnx;
1529 break;
1530 case MEP_OPERAND_CSRN :
1531 value = fields->f_csrn;
1532 break;
1533 case MEP_OPERAND_CSRN_IDX :
1534 value = fields->f_csrn;
1535 break;
1536 case MEP_OPERAND_DBG :
1537 value = 0;
1538 break;
1539 case MEP_OPERAND_DEPC :
1540 value = 0;
1541 break;
1542 case MEP_OPERAND_EPC :
1543 value = 0;
1544 break;
1545 case MEP_OPERAND_EXC :
1546 value = 0;
1547 break;
1548 case MEP_OPERAND_FMAX_CCRN :
1549 value = fields->f_fmax_4_4;
1550 break;
1551 case MEP_OPERAND_FMAX_FRD :
1552 value = fields->f_fmax_frd;
1553 break;
1554 case MEP_OPERAND_FMAX_FRD_INT :
1555 value = fields->f_fmax_frd;
1556 break;
1557 case MEP_OPERAND_FMAX_FRM :
1558 value = fields->f_fmax_frm;
1559 break;
1560 case MEP_OPERAND_FMAX_FRN :
1561 value = fields->f_fmax_frn;
1562 break;
1563 case MEP_OPERAND_FMAX_FRN_INT :
1564 value = fields->f_fmax_frn;
1565 break;
1566 case MEP_OPERAND_FMAX_RM :
1567 value = fields->f_fmax_rm;
1568 break;
1569 case MEP_OPERAND_HI :
1570 value = 0;
1571 break;
1572 case MEP_OPERAND_LO :
1573 value = 0;
1574 break;
1575 case MEP_OPERAND_LP :
1576 value = 0;
1577 break;
1578 case MEP_OPERAND_MB0 :
1579 value = 0;
1580 break;
1581 case MEP_OPERAND_MB1 :
1582 value = 0;
1583 break;
1584 case MEP_OPERAND_ME0 :
1585 value = 0;
1586 break;
1587 case MEP_OPERAND_ME1 :
1588 value = 0;
1589 break;
1590 case MEP_OPERAND_NPC :
1591 value = 0;
1592 break;
1593 case MEP_OPERAND_OPT :
1594 value = 0;
1595 break;
1596 case MEP_OPERAND_PCABS24A2 :
1597 value = fields->f_24u5a2n;
1598 break;
1599 case MEP_OPERAND_PCREL12A2 :
1600 value = fields->f_12s4a2;
1601 break;
1602 case MEP_OPERAND_PCREL17A2 :
1603 value = fields->f_17s16a2;
1604 break;
1605 case MEP_OPERAND_PCREL24A2 :
1606 value = fields->f_24s5a2n;
1607 break;
1608 case MEP_OPERAND_PCREL8A2 :
1609 value = fields->f_8s8a2;
1610 break;
1611 case MEP_OPERAND_PSW :
1612 value = 0;
1613 break;
1614 case MEP_OPERAND_R0 :
1615 value = 0;
1616 break;
1617 case MEP_OPERAND_R1 :
1618 value = 0;
1619 break;
1620 case MEP_OPERAND_RL :
1621 value = fields->f_rl;
1622 break;
1623 case MEP_OPERAND_RM :
1624 value = fields->f_rm;
1625 break;
1626 case MEP_OPERAND_RMA :
1627 value = fields->f_rm;
1628 break;
1629 case MEP_OPERAND_RN :
1630 value = fields->f_rn;
1631 break;
1632 case MEP_OPERAND_RN3 :
1633 value = fields->f_rn3;
1634 break;
1635 case MEP_OPERAND_RN3C :
1636 value = fields->f_rn3;
1637 break;
1638 case MEP_OPERAND_RN3L :
1639 value = fields->f_rn3;
1640 break;
1641 case MEP_OPERAND_RN3S :
1642 value = fields->f_rn3;
1643 break;
1644 case MEP_OPERAND_RN3UC :
1645 value = fields->f_rn3;
1646 break;
1647 case MEP_OPERAND_RN3UL :
1648 value = fields->f_rn3;
1649 break;
1650 case MEP_OPERAND_RN3US :
1651 value = fields->f_rn3;
1652 break;
1653 case MEP_OPERAND_RNC :
1654 value = fields->f_rn;
1655 break;
1656 case MEP_OPERAND_RNL :
1657 value = fields->f_rn;
1658 break;
1659 case MEP_OPERAND_RNS :
1660 value = fields->f_rn;
1661 break;
1662 case MEP_OPERAND_RNUC :
1663 value = fields->f_rn;
1664 break;
1665 case MEP_OPERAND_RNUL :
1666 value = fields->f_rn;
1667 break;
1668 case MEP_OPERAND_RNUS :
1669 value = fields->f_rn;
1670 break;
1671 case MEP_OPERAND_SAR :
1672 value = 0;
1673 break;
1674 case MEP_OPERAND_SDISP16 :
1675 value = fields->f_16s16;
1676 break;
1677 case MEP_OPERAND_SIMM16 :
1678 value = fields->f_16s16;
1679 break;
1680 case MEP_OPERAND_SIMM6 :
1681 value = fields->f_6s8;
1682 break;
1683 case MEP_OPERAND_SIMM8 :
1684 value = fields->f_8s8;
1685 break;
1686 case MEP_OPERAND_SP :
1687 value = 0;
1688 break;
1689 case MEP_OPERAND_SPR :
1690 value = 0;
1691 break;
1692 case MEP_OPERAND_TP :
1693 value = 0;
1694 break;
1695 case MEP_OPERAND_TPR :
1696 value = 0;
1697 break;
1698 case MEP_OPERAND_UDISP2 :
1699 value = fields->f_2u6;
1700 break;
1701 case MEP_OPERAND_UDISP7 :
1702 value = fields->f_7u9;
1703 break;
1704 case MEP_OPERAND_UDISP7A2 :
1705 value = fields->f_7u9a2;
1706 break;
1707 case MEP_OPERAND_UDISP7A4 :
1708 value = fields->f_7u9a4;
1709 break;
1710 case MEP_OPERAND_UIMM16 :
1711 value = fields->f_16u16;
1712 break;
1713 case MEP_OPERAND_UIMM2 :
1714 value = fields->f_2u10;
1715 break;
1716 case MEP_OPERAND_UIMM24 :
1717 value = fields->f_24u8n;
1718 break;
1719 case MEP_OPERAND_UIMM3 :
1720 value = fields->f_3u5;
1721 break;
1722 case MEP_OPERAND_UIMM4 :
1723 value = fields->f_4u8;
1724 break;
1725 case MEP_OPERAND_UIMM5 :
1726 value = fields->f_5u8;
1727 break;
1728 case MEP_OPERAND_UIMM7A4 :
1729 value = fields->f_7u9a4;
1730 break;
1731 case MEP_OPERAND_ZERO :
1732 value = 0;
1733 break;
1734
1735 default :
1736 /* xgettext:c-format */
1737 fprintf (stderr, _("Unrecognized field %d while getting int operand.\n"),
1738 opindex);
1739 abort ();
1740 }
1741
1742 return value;
1743 }
1744
1745 bfd_vma
1746 mep_cgen_get_vma_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
1747 int opindex,
1748 const CGEN_FIELDS * fields)
1749 {
1750 bfd_vma value;
1751
1752 switch (opindex)
1753 {
1754 case MEP_OPERAND_ADDR24A4 :
1755 value = fields->f_24u8a4n;
1756 break;
1757 case MEP_OPERAND_CALLNUM :
1758 value = fields->f_callnum;
1759 break;
1760 case MEP_OPERAND_CCCC :
1761 value = fields->f_rm;
1762 break;
1763 case MEP_OPERAND_CCRN :
1764 value = fields->f_ccrn;
1765 break;
1766 case MEP_OPERAND_CDISP8 :
1767 value = fields->f_8s24;
1768 break;
1769 case MEP_OPERAND_CDISP8A2 :
1770 value = fields->f_8s24a2;
1771 break;
1772 case MEP_OPERAND_CDISP8A4 :
1773 value = fields->f_8s24a4;
1774 break;
1775 case MEP_OPERAND_CDISP8A8 :
1776 value = fields->f_8s24a8;
1777 break;
1778 case MEP_OPERAND_CIMM4 :
1779 value = fields->f_rn;
1780 break;
1781 case MEP_OPERAND_CIMM5 :
1782 value = fields->f_5u24;
1783 break;
1784 case MEP_OPERAND_CODE16 :
1785 value = fields->f_16u16;
1786 break;
1787 case MEP_OPERAND_CODE24 :
1788 value = fields->f_24u4n;
1789 break;
1790 case MEP_OPERAND_CP_FLAG :
1791 value = 0;
1792 break;
1793 case MEP_OPERAND_CRN :
1794 value = fields->f_crn;
1795 break;
1796 case MEP_OPERAND_CRN64 :
1797 value = fields->f_crn;
1798 break;
1799 case MEP_OPERAND_CRNX :
1800 value = fields->f_crnx;
1801 break;
1802 case MEP_OPERAND_CRNX64 :
1803 value = fields->f_crnx;
1804 break;
1805 case MEP_OPERAND_CSRN :
1806 value = fields->f_csrn;
1807 break;
1808 case MEP_OPERAND_CSRN_IDX :
1809 value = fields->f_csrn;
1810 break;
1811 case MEP_OPERAND_DBG :
1812 value = 0;
1813 break;
1814 case MEP_OPERAND_DEPC :
1815 value = 0;
1816 break;
1817 case MEP_OPERAND_EPC :
1818 value = 0;
1819 break;
1820 case MEP_OPERAND_EXC :
1821 value = 0;
1822 break;
1823 case MEP_OPERAND_FMAX_CCRN :
1824 value = fields->f_fmax_4_4;
1825 break;
1826 case MEP_OPERAND_FMAX_FRD :
1827 value = fields->f_fmax_frd;
1828 break;
1829 case MEP_OPERAND_FMAX_FRD_INT :
1830 value = fields->f_fmax_frd;
1831 break;
1832 case MEP_OPERAND_FMAX_FRM :
1833 value = fields->f_fmax_frm;
1834 break;
1835 case MEP_OPERAND_FMAX_FRN :
1836 value = fields->f_fmax_frn;
1837 break;
1838 case MEP_OPERAND_FMAX_FRN_INT :
1839 value = fields->f_fmax_frn;
1840 break;
1841 case MEP_OPERAND_FMAX_RM :
1842 value = fields->f_fmax_rm;
1843 break;
1844 case MEP_OPERAND_HI :
1845 value = 0;
1846 break;
1847 case MEP_OPERAND_LO :
1848 value = 0;
1849 break;
1850 case MEP_OPERAND_LP :
1851 value = 0;
1852 break;
1853 case MEP_OPERAND_MB0 :
1854 value = 0;
1855 break;
1856 case MEP_OPERAND_MB1 :
1857 value = 0;
1858 break;
1859 case MEP_OPERAND_ME0 :
1860 value = 0;
1861 break;
1862 case MEP_OPERAND_ME1 :
1863 value = 0;
1864 break;
1865 case MEP_OPERAND_NPC :
1866 value = 0;
1867 break;
1868 case MEP_OPERAND_OPT :
1869 value = 0;
1870 break;
1871 case MEP_OPERAND_PCABS24A2 :
1872 value = fields->f_24u5a2n;
1873 break;
1874 case MEP_OPERAND_PCREL12A2 :
1875 value = fields->f_12s4a2;
1876 break;
1877 case MEP_OPERAND_PCREL17A2 :
1878 value = fields->f_17s16a2;
1879 break;
1880 case MEP_OPERAND_PCREL24A2 :
1881 value = fields->f_24s5a2n;
1882 break;
1883 case MEP_OPERAND_PCREL8A2 :
1884 value = fields->f_8s8a2;
1885 break;
1886 case MEP_OPERAND_PSW :
1887 value = 0;
1888 break;
1889 case MEP_OPERAND_R0 :
1890 value = 0;
1891 break;
1892 case MEP_OPERAND_R1 :
1893 value = 0;
1894 break;
1895 case MEP_OPERAND_RL :
1896 value = fields->f_rl;
1897 break;
1898 case MEP_OPERAND_RM :
1899 value = fields->f_rm;
1900 break;
1901 case MEP_OPERAND_RMA :
1902 value = fields->f_rm;
1903 break;
1904 case MEP_OPERAND_RN :
1905 value = fields->f_rn;
1906 break;
1907 case MEP_OPERAND_RN3 :
1908 value = fields->f_rn3;
1909 break;
1910 case MEP_OPERAND_RN3C :
1911 value = fields->f_rn3;
1912 break;
1913 case MEP_OPERAND_RN3L :
1914 value = fields->f_rn3;
1915 break;
1916 case MEP_OPERAND_RN3S :
1917 value = fields->f_rn3;
1918 break;
1919 case MEP_OPERAND_RN3UC :
1920 value = fields->f_rn3;
1921 break;
1922 case MEP_OPERAND_RN3UL :
1923 value = fields->f_rn3;
1924 break;
1925 case MEP_OPERAND_RN3US :
1926 value = fields->f_rn3;
1927 break;
1928 case MEP_OPERAND_RNC :
1929 value = fields->f_rn;
1930 break;
1931 case MEP_OPERAND_RNL :
1932 value = fields->f_rn;
1933 break;
1934 case MEP_OPERAND_RNS :
1935 value = fields->f_rn;
1936 break;
1937 case MEP_OPERAND_RNUC :
1938 value = fields->f_rn;
1939 break;
1940 case MEP_OPERAND_RNUL :
1941 value = fields->f_rn;
1942 break;
1943 case MEP_OPERAND_RNUS :
1944 value = fields->f_rn;
1945 break;
1946 case MEP_OPERAND_SAR :
1947 value = 0;
1948 break;
1949 case MEP_OPERAND_SDISP16 :
1950 value = fields->f_16s16;
1951 break;
1952 case MEP_OPERAND_SIMM16 :
1953 value = fields->f_16s16;
1954 break;
1955 case MEP_OPERAND_SIMM6 :
1956 value = fields->f_6s8;
1957 break;
1958 case MEP_OPERAND_SIMM8 :
1959 value = fields->f_8s8;
1960 break;
1961 case MEP_OPERAND_SP :
1962 value = 0;
1963 break;
1964 case MEP_OPERAND_SPR :
1965 value = 0;
1966 break;
1967 case MEP_OPERAND_TP :
1968 value = 0;
1969 break;
1970 case MEP_OPERAND_TPR :
1971 value = 0;
1972 break;
1973 case MEP_OPERAND_UDISP2 :
1974 value = fields->f_2u6;
1975 break;
1976 case MEP_OPERAND_UDISP7 :
1977 value = fields->f_7u9;
1978 break;
1979 case MEP_OPERAND_UDISP7A2 :
1980 value = fields->f_7u9a2;
1981 break;
1982 case MEP_OPERAND_UDISP7A4 :
1983 value = fields->f_7u9a4;
1984 break;
1985 case MEP_OPERAND_UIMM16 :
1986 value = fields->f_16u16;
1987 break;
1988 case MEP_OPERAND_UIMM2 :
1989 value = fields->f_2u10;
1990 break;
1991 case MEP_OPERAND_UIMM24 :
1992 value = fields->f_24u8n;
1993 break;
1994 case MEP_OPERAND_UIMM3 :
1995 value = fields->f_3u5;
1996 break;
1997 case MEP_OPERAND_UIMM4 :
1998 value = fields->f_4u8;
1999 break;
2000 case MEP_OPERAND_UIMM5 :
2001 value = fields->f_5u8;
2002 break;
2003 case MEP_OPERAND_UIMM7A4 :
2004 value = fields->f_7u9a4;
2005 break;
2006 case MEP_OPERAND_ZERO :
2007 value = 0;
2008 break;
2009
2010 default :
2011 /* xgettext:c-format */
2012 fprintf (stderr, _("Unrecognized field %d while getting vma operand.\n"),
2013 opindex);
2014 abort ();
2015 }
2016
2017 return value;
2018 }
2019
2020 void mep_cgen_set_int_operand (CGEN_CPU_DESC, int, CGEN_FIELDS *, int);
2021 void mep_cgen_set_vma_operand (CGEN_CPU_DESC, int, CGEN_FIELDS *, bfd_vma);
2022
2023 /* Stuffing values in cgen_fields is handled by a collection of functions.
2024 They are distinguished by the type of the VALUE argument they accept.
2025 TODO: floating point, inlining support, remove cases where argument type
2026 not appropriate. */
2027
2028 void
2029 mep_cgen_set_int_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
2030 int opindex,
2031 CGEN_FIELDS * fields,
2032 int value)
2033 {
2034 switch (opindex)
2035 {
2036 case MEP_OPERAND_ADDR24A4 :
2037 fields->f_24u8a4n = value;
2038 break;
2039 case MEP_OPERAND_CALLNUM :
2040 fields->f_callnum = value;
2041 break;
2042 case MEP_OPERAND_CCCC :
2043 fields->f_rm = value;
2044 break;
2045 case MEP_OPERAND_CCRN :
2046 fields->f_ccrn = value;
2047 break;
2048 case MEP_OPERAND_CDISP8 :
2049 fields->f_8s24 = value;
2050 break;
2051 case MEP_OPERAND_CDISP8A2 :
2052 fields->f_8s24a2 = value;
2053 break;
2054 case MEP_OPERAND_CDISP8A4 :
2055 fields->f_8s24a4 = value;
2056 break;
2057 case MEP_OPERAND_CDISP8A8 :
2058 fields->f_8s24a8 = value;
2059 break;
2060 case MEP_OPERAND_CIMM4 :
2061 fields->f_rn = value;
2062 break;
2063 case MEP_OPERAND_CIMM5 :
2064 fields->f_5u24 = value;
2065 break;
2066 case MEP_OPERAND_CODE16 :
2067 fields->f_16u16 = value;
2068 break;
2069 case MEP_OPERAND_CODE24 :
2070 fields->f_24u4n = value;
2071 break;
2072 case MEP_OPERAND_CP_FLAG :
2073 break;
2074 case MEP_OPERAND_CRN :
2075 fields->f_crn = value;
2076 break;
2077 case MEP_OPERAND_CRN64 :
2078 fields->f_crn = value;
2079 break;
2080 case MEP_OPERAND_CRNX :
2081 fields->f_crnx = value;
2082 break;
2083 case MEP_OPERAND_CRNX64 :
2084 fields->f_crnx = value;
2085 break;
2086 case MEP_OPERAND_CSRN :
2087 fields->f_csrn = value;
2088 break;
2089 case MEP_OPERAND_CSRN_IDX :
2090 fields->f_csrn = value;
2091 break;
2092 case MEP_OPERAND_DBG :
2093 break;
2094 case MEP_OPERAND_DEPC :
2095 break;
2096 case MEP_OPERAND_EPC :
2097 break;
2098 case MEP_OPERAND_EXC :
2099 break;
2100 case MEP_OPERAND_FMAX_CCRN :
2101 fields->f_fmax_4_4 = value;
2102 break;
2103 case MEP_OPERAND_FMAX_FRD :
2104 fields->f_fmax_frd = value;
2105 break;
2106 case MEP_OPERAND_FMAX_FRD_INT :
2107 fields->f_fmax_frd = value;
2108 break;
2109 case MEP_OPERAND_FMAX_FRM :
2110 fields->f_fmax_frm = value;
2111 break;
2112 case MEP_OPERAND_FMAX_FRN :
2113 fields->f_fmax_frn = value;
2114 break;
2115 case MEP_OPERAND_FMAX_FRN_INT :
2116 fields->f_fmax_frn = value;
2117 break;
2118 case MEP_OPERAND_FMAX_RM :
2119 fields->f_fmax_rm = value;
2120 break;
2121 case MEP_OPERAND_HI :
2122 break;
2123 case MEP_OPERAND_LO :
2124 break;
2125 case MEP_OPERAND_LP :
2126 break;
2127 case MEP_OPERAND_MB0 :
2128 break;
2129 case MEP_OPERAND_MB1 :
2130 break;
2131 case MEP_OPERAND_ME0 :
2132 break;
2133 case MEP_OPERAND_ME1 :
2134 break;
2135 case MEP_OPERAND_NPC :
2136 break;
2137 case MEP_OPERAND_OPT :
2138 break;
2139 case MEP_OPERAND_PCABS24A2 :
2140 fields->f_24u5a2n = value;
2141 break;
2142 case MEP_OPERAND_PCREL12A2 :
2143 fields->f_12s4a2 = value;
2144 break;
2145 case MEP_OPERAND_PCREL17A2 :
2146 fields->f_17s16a2 = value;
2147 break;
2148 case MEP_OPERAND_PCREL24A2 :
2149 fields->f_24s5a2n = value;
2150 break;
2151 case MEP_OPERAND_PCREL8A2 :
2152 fields->f_8s8a2 = value;
2153 break;
2154 case MEP_OPERAND_PSW :
2155 break;
2156 case MEP_OPERAND_R0 :
2157 break;
2158 case MEP_OPERAND_R1 :
2159 break;
2160 case MEP_OPERAND_RL :
2161 fields->f_rl = value;
2162 break;
2163 case MEP_OPERAND_RM :
2164 fields->f_rm = value;
2165 break;
2166 case MEP_OPERAND_RMA :
2167 fields->f_rm = value;
2168 break;
2169 case MEP_OPERAND_RN :
2170 fields->f_rn = value;
2171 break;
2172 case MEP_OPERAND_RN3 :
2173 fields->f_rn3 = value;
2174 break;
2175 case MEP_OPERAND_RN3C :
2176 fields->f_rn3 = value;
2177 break;
2178 case MEP_OPERAND_RN3L :
2179 fields->f_rn3 = value;
2180 break;
2181 case MEP_OPERAND_RN3S :
2182 fields->f_rn3 = value;
2183 break;
2184 case MEP_OPERAND_RN3UC :
2185 fields->f_rn3 = value;
2186 break;
2187 case MEP_OPERAND_RN3UL :
2188 fields->f_rn3 = value;
2189 break;
2190 case MEP_OPERAND_RN3US :
2191 fields->f_rn3 = value;
2192 break;
2193 case MEP_OPERAND_RNC :
2194 fields->f_rn = value;
2195 break;
2196 case MEP_OPERAND_RNL :
2197 fields->f_rn = value;
2198 break;
2199 case MEP_OPERAND_RNS :
2200 fields->f_rn = value;
2201 break;
2202 case MEP_OPERAND_RNUC :
2203 fields->f_rn = value;
2204 break;
2205 case MEP_OPERAND_RNUL :
2206 fields->f_rn = value;
2207 break;
2208 case MEP_OPERAND_RNUS :
2209 fields->f_rn = value;
2210 break;
2211 case MEP_OPERAND_SAR :
2212 break;
2213 case MEP_OPERAND_SDISP16 :
2214 fields->f_16s16 = value;
2215 break;
2216 case MEP_OPERAND_SIMM16 :
2217 fields->f_16s16 = value;
2218 break;
2219 case MEP_OPERAND_SIMM6 :
2220 fields->f_6s8 = value;
2221 break;
2222 case MEP_OPERAND_SIMM8 :
2223 fields->f_8s8 = value;
2224 break;
2225 case MEP_OPERAND_SP :
2226 break;
2227 case MEP_OPERAND_SPR :
2228 break;
2229 case MEP_OPERAND_TP :
2230 break;
2231 case MEP_OPERAND_TPR :
2232 break;
2233 case MEP_OPERAND_UDISP2 :
2234 fields->f_2u6 = value;
2235 break;
2236 case MEP_OPERAND_UDISP7 :
2237 fields->f_7u9 = value;
2238 break;
2239 case MEP_OPERAND_UDISP7A2 :
2240 fields->f_7u9a2 = value;
2241 break;
2242 case MEP_OPERAND_UDISP7A4 :
2243 fields->f_7u9a4 = value;
2244 break;
2245 case MEP_OPERAND_UIMM16 :
2246 fields->f_16u16 = value;
2247 break;
2248 case MEP_OPERAND_UIMM2 :
2249 fields->f_2u10 = value;
2250 break;
2251 case MEP_OPERAND_UIMM24 :
2252 fields->f_24u8n = value;
2253 break;
2254 case MEP_OPERAND_UIMM3 :
2255 fields->f_3u5 = value;
2256 break;
2257 case MEP_OPERAND_UIMM4 :
2258 fields->f_4u8 = value;
2259 break;
2260 case MEP_OPERAND_UIMM5 :
2261 fields->f_5u8 = value;
2262 break;
2263 case MEP_OPERAND_UIMM7A4 :
2264 fields->f_7u9a4 = value;
2265 break;
2266 case MEP_OPERAND_ZERO :
2267 break;
2268
2269 default :
2270 /* xgettext:c-format */
2271 fprintf (stderr, _("Unrecognized field %d while setting int operand.\n"),
2272 opindex);
2273 abort ();
2274 }
2275 }
2276
2277 void
2278 mep_cgen_set_vma_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
2279 int opindex,
2280 CGEN_FIELDS * fields,
2281 bfd_vma value)
2282 {
2283 switch (opindex)
2284 {
2285 case MEP_OPERAND_ADDR24A4 :
2286 fields->f_24u8a4n = value;
2287 break;
2288 case MEP_OPERAND_CALLNUM :
2289 fields->f_callnum = value;
2290 break;
2291 case MEP_OPERAND_CCCC :
2292 fields->f_rm = value;
2293 break;
2294 case MEP_OPERAND_CCRN :
2295 fields->f_ccrn = value;
2296 break;
2297 case MEP_OPERAND_CDISP8 :
2298 fields->f_8s24 = value;
2299 break;
2300 case MEP_OPERAND_CDISP8A2 :
2301 fields->f_8s24a2 = value;
2302 break;
2303 case MEP_OPERAND_CDISP8A4 :
2304 fields->f_8s24a4 = value;
2305 break;
2306 case MEP_OPERAND_CDISP8A8 :
2307 fields->f_8s24a8 = value;
2308 break;
2309 case MEP_OPERAND_CIMM4 :
2310 fields->f_rn = value;
2311 break;
2312 case MEP_OPERAND_CIMM5 :
2313 fields->f_5u24 = value;
2314 break;
2315 case MEP_OPERAND_CODE16 :
2316 fields->f_16u16 = value;
2317 break;
2318 case MEP_OPERAND_CODE24 :
2319 fields->f_24u4n = value;
2320 break;
2321 case MEP_OPERAND_CP_FLAG :
2322 break;
2323 case MEP_OPERAND_CRN :
2324 fields->f_crn = value;
2325 break;
2326 case MEP_OPERAND_CRN64 :
2327 fields->f_crn = value;
2328 break;
2329 case MEP_OPERAND_CRNX :
2330 fields->f_crnx = value;
2331 break;
2332 case MEP_OPERAND_CRNX64 :
2333 fields->f_crnx = value;
2334 break;
2335 case MEP_OPERAND_CSRN :
2336 fields->f_csrn = value;
2337 break;
2338 case MEP_OPERAND_CSRN_IDX :
2339 fields->f_csrn = value;
2340 break;
2341 case MEP_OPERAND_DBG :
2342 break;
2343 case MEP_OPERAND_DEPC :
2344 break;
2345 case MEP_OPERAND_EPC :
2346 break;
2347 case MEP_OPERAND_EXC :
2348 break;
2349 case MEP_OPERAND_FMAX_CCRN :
2350 fields->f_fmax_4_4 = value;
2351 break;
2352 case MEP_OPERAND_FMAX_FRD :
2353 fields->f_fmax_frd = value;
2354 break;
2355 case MEP_OPERAND_FMAX_FRD_INT :
2356 fields->f_fmax_frd = value;
2357 break;
2358 case MEP_OPERAND_FMAX_FRM :
2359 fields->f_fmax_frm = value;
2360 break;
2361 case MEP_OPERAND_FMAX_FRN :
2362 fields->f_fmax_frn = value;
2363 break;
2364 case MEP_OPERAND_FMAX_FRN_INT :
2365 fields->f_fmax_frn = value;
2366 break;
2367 case MEP_OPERAND_FMAX_RM :
2368 fields->f_fmax_rm = value;
2369 break;
2370 case MEP_OPERAND_HI :
2371 break;
2372 case MEP_OPERAND_LO :
2373 break;
2374 case MEP_OPERAND_LP :
2375 break;
2376 case MEP_OPERAND_MB0 :
2377 break;
2378 case MEP_OPERAND_MB1 :
2379 break;
2380 case MEP_OPERAND_ME0 :
2381 break;
2382 case MEP_OPERAND_ME1 :
2383 break;
2384 case MEP_OPERAND_NPC :
2385 break;
2386 case MEP_OPERAND_OPT :
2387 break;
2388 case MEP_OPERAND_PCABS24A2 :
2389 fields->f_24u5a2n = value;
2390 break;
2391 case MEP_OPERAND_PCREL12A2 :
2392 fields->f_12s4a2 = value;
2393 break;
2394 case MEP_OPERAND_PCREL17A2 :
2395 fields->f_17s16a2 = value;
2396 break;
2397 case MEP_OPERAND_PCREL24A2 :
2398 fields->f_24s5a2n = value;
2399 break;
2400 case MEP_OPERAND_PCREL8A2 :
2401 fields->f_8s8a2 = value;
2402 break;
2403 case MEP_OPERAND_PSW :
2404 break;
2405 case MEP_OPERAND_R0 :
2406 break;
2407 case MEP_OPERAND_R1 :
2408 break;
2409 case MEP_OPERAND_RL :
2410 fields->f_rl = value;
2411 break;
2412 case MEP_OPERAND_RM :
2413 fields->f_rm = value;
2414 break;
2415 case MEP_OPERAND_RMA :
2416 fields->f_rm = value;
2417 break;
2418 case MEP_OPERAND_RN :
2419 fields->f_rn = value;
2420 break;
2421 case MEP_OPERAND_RN3 :
2422 fields->f_rn3 = value;
2423 break;
2424 case MEP_OPERAND_RN3C :
2425 fields->f_rn3 = value;
2426 break;
2427 case MEP_OPERAND_RN3L :
2428 fields->f_rn3 = value;
2429 break;
2430 case MEP_OPERAND_RN3S :
2431 fields->f_rn3 = value;
2432 break;
2433 case MEP_OPERAND_RN3UC :
2434 fields->f_rn3 = value;
2435 break;
2436 case MEP_OPERAND_RN3UL :
2437 fields->f_rn3 = value;
2438 break;
2439 case MEP_OPERAND_RN3US :
2440 fields->f_rn3 = value;
2441 break;
2442 case MEP_OPERAND_RNC :
2443 fields->f_rn = value;
2444 break;
2445 case MEP_OPERAND_RNL :
2446 fields->f_rn = value;
2447 break;
2448 case MEP_OPERAND_RNS :
2449 fields->f_rn = value;
2450 break;
2451 case MEP_OPERAND_RNUC :
2452 fields->f_rn = value;
2453 break;
2454 case MEP_OPERAND_RNUL :
2455 fields->f_rn = value;
2456 break;
2457 case MEP_OPERAND_RNUS :
2458 fields->f_rn = value;
2459 break;
2460 case MEP_OPERAND_SAR :
2461 break;
2462 case MEP_OPERAND_SDISP16 :
2463 fields->f_16s16 = value;
2464 break;
2465 case MEP_OPERAND_SIMM16 :
2466 fields->f_16s16 = value;
2467 break;
2468 case MEP_OPERAND_SIMM6 :
2469 fields->f_6s8 = value;
2470 break;
2471 case MEP_OPERAND_SIMM8 :
2472 fields->f_8s8 = value;
2473 break;
2474 case MEP_OPERAND_SP :
2475 break;
2476 case MEP_OPERAND_SPR :
2477 break;
2478 case MEP_OPERAND_TP :
2479 break;
2480 case MEP_OPERAND_TPR :
2481 break;
2482 case MEP_OPERAND_UDISP2 :
2483 fields->f_2u6 = value;
2484 break;
2485 case MEP_OPERAND_UDISP7 :
2486 fields->f_7u9 = value;
2487 break;
2488 case MEP_OPERAND_UDISP7A2 :
2489 fields->f_7u9a2 = value;
2490 break;
2491 case MEP_OPERAND_UDISP7A4 :
2492 fields->f_7u9a4 = value;
2493 break;
2494 case MEP_OPERAND_UIMM16 :
2495 fields->f_16u16 = value;
2496 break;
2497 case MEP_OPERAND_UIMM2 :
2498 fields->f_2u10 = value;
2499 break;
2500 case MEP_OPERAND_UIMM24 :
2501 fields->f_24u8n = value;
2502 break;
2503 case MEP_OPERAND_UIMM3 :
2504 fields->f_3u5 = value;
2505 break;
2506 case MEP_OPERAND_UIMM4 :
2507 fields->f_4u8 = value;
2508 break;
2509 case MEP_OPERAND_UIMM5 :
2510 fields->f_5u8 = value;
2511 break;
2512 case MEP_OPERAND_UIMM7A4 :
2513 fields->f_7u9a4 = value;
2514 break;
2515 case MEP_OPERAND_ZERO :
2516 break;
2517
2518 default :
2519 /* xgettext:c-format */
2520 fprintf (stderr, _("Unrecognized field %d while setting vma operand.\n"),
2521 opindex);
2522 abort ();
2523 }
2524 }
2525
2526 /* Function to call before using the instruction builder tables. */
2527
2528 void
2529 mep_cgen_init_ibld_table (CGEN_CPU_DESC cd)
2530 {
2531 cd->insert_handlers = & mep_cgen_insert_handlers[0];
2532 cd->extract_handlers = & mep_cgen_extract_handlers[0];
2533
2534 cd->insert_operand = mep_cgen_insert_operand;
2535 cd->extract_operand = mep_cgen_extract_operand;
2536
2537 cd->get_int_operand = mep_cgen_get_int_operand;
2538 cd->set_int_operand = mep_cgen_set_int_operand;
2539 cd->get_vma_operand = mep_cgen_get_vma_operand;
2540 cd->set_vma_operand = mep_cgen_set_vma_operand;
2541 }
binutils for building for Google Native Client (NaCl)