]> Git Repo - binutils.git/blame - opcodes/xstormy16-ibld.c
projects / binutils.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
*** empty log message ***
[binutils.git] / opcodes / xstormy16-ibld.c
CommitLineData
93fbbb04
GK		 1/* Instruction building/extraction support for xstormy16. -*- C -*-
2
47b0e7ad
NC		 3 THIS FILE IS MACHINE GENERATED WITH CGEN: Cpu tools GENerator.
4 - the resultant file is machine generated, cgen-ibld.in isn't
93fbbb04 5
47b0e7ad
NC		 6 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2005
7 Free Software Foundation, Inc.
93fbbb04 8
47b0e7ad 9 This file is part of the GNU Binutils and GDB, the GNU debugger.
93fbbb04 10
47b0e7ad
NC		 11 This program 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 2, or (at your option)
14 any later version.
93fbbb04 15
47b0e7ad
NC		 16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
93fbbb04 20
47b0e7ad
NC		 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. */
93fbbb04
GK		 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 "xstormy16-desc.h"
35#include "xstormy16-opc.h"
36#include "opintl.h"
37#include "safe-ctype.h"
38
47b0e7ad 39#undef min
93fbbb04 40#define min(a,b) ((a) < (b) ? (a) : (b))
47b0e7ad 41#undef max
93fbbb04
GK		 42#define max(a,b) ((a) > (b) ? (a) : (b))
43
44/* Used by the ifield rtx function. */
45#define FLD(f) (fields->f)
46
47static const char * insert_normal
ffead7ae
MM		 48 (CGEN_CPU_DESC, long, unsigned int, unsigned int, unsigned int,
49 unsigned int, unsigned int, unsigned int, CGEN_INSN_BYTES_PTR);
93fbbb04 50static const char * insert_insn_normal
ffead7ae
MM		 51 (CGEN_CPU_DESC, const CGEN_INSN *,
52 CGEN_FIELDS *, CGEN_INSN_BYTES_PTR, bfd_vma);
93fbbb04 53static int extract_normal
ffead7ae
MM		 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 *);
93fbbb04 57static int extract_insn_normal
ffead7ae
MM		 58 (CGEN_CPU_DESC, const CGEN_INSN *, CGEN_EXTRACT_INFO *,
59 CGEN_INSN_INT, CGEN_FIELDS *, bfd_vma);
93fbbb04
GK		 60#if CGEN_INT_INSN_P
61static void put_insn_int_value
ffead7ae 62 (CGEN_CPU_DESC, CGEN_INSN_BYTES_PTR, int, int, CGEN_INSN_INT);
93fbbb04
GK		 63#endif
64#if ! CGEN_INT_INSN_P
65static CGEN_INLINE void insert_1
ffead7ae 66 (CGEN_CPU_DESC, unsigned long, int, int, int, unsigned char *);
93fbbb04 67static CGEN_INLINE int fill_cache
ffead7ae 68 (CGEN_CPU_DESC, CGEN_EXTRACT_INFO *, int, int, bfd_vma);
93fbbb04 69static CGEN_INLINE long extract_1
ffead7ae 70 (CGEN_CPU_DESC, CGEN_EXTRACT_INFO *, int, int, int, unsigned char *, bfd_vma);
93fbbb04
GK		 71#endif
72\f
73/* Operand insertion. */
74
75#if ! CGEN_INT_INSN_P
76
77/* Subroutine of insert_normal. */
78
79static CGEN_INLINE void
ffead7ae
MM		 80insert_1 (CGEN_CPU_DESC cd,
81 unsigned long value,
82 int start,
83 int length,
84 int word_length,
85 unsigned char *bufp)
93fbbb04
GK		 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
121static const char *
ffead7ae
MM		 122insert_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)
93fbbb04
GK		 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
93fbbb04
GK		 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
172 if ((unsigned long) value > maxval)
173 {
174 /* xgettext:c-format */
175 sprintf (errbuf,
176 _("operand out of range (%lu not between 0 and %lu)"),
177 value, maxval);
178 return errbuf;
179 }
180 }
181 else
182 {
183 if (! cgen_signed_overflow_ok_p (cd))
184 {
185 long minval = - (1L << (length - 1));
186 long maxval = (1L << (length - 1)) - 1;
187
188 if (value < minval || value > maxval)
189 {
190 sprintf
191 /* xgettext:c-format */
192 (errbuf, _("operand out of range (%ld not between %ld and %ld)"),
193 value, minval, maxval);
194 return errbuf;
195 }
196 }
197 }
198
199#if CGEN_INT_INSN_P
200
201 {
202 int shift;
203
204 if (CGEN_INSN_LSB0_P)
205 shift = (word_offset + start + 1) - length;
206 else
207 shift = total_length - (word_offset + start + length);
208 *buffer = (*buffer & ~(mask << shift)) | ((value & mask) << shift);
209 }
210
211#else /* ! CGEN_INT_INSN_P */
212
213 {
214 unsigned char *bufp = (unsigned char *) buffer + word_offset / 8;
215
216 insert_1 (cd, value, start, length, word_length, bufp);
217 }
218
219#endif /* ! CGEN_INT_INSN_P */
220
221 return NULL;
222}
223
224/* Default insn builder (insert handler).
225 The instruction is recorded in CGEN_INT_INSN_P byte order (meaning
226 that if CGEN_INSN_BYTES_PTR is an int * and thus, the value is
227 recorded in host byte order, otherwise BUFFER is an array of bytes
228 and the value is recorded in target byte order).
229 The result is an error message or NULL if success. */
230
231static const char *
ffead7ae
MM		 232insert_insn_normal (CGEN_CPU_DESC cd,
233 const CGEN_INSN * insn,
234 CGEN_FIELDS * fields,
235 CGEN_INSN_BYTES_PTR buffer,
236 bfd_vma pc)
93fbbb04
GK		 237{
238 const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
239 unsigned long value;
240 const CGEN_SYNTAX_CHAR_TYPE * syn;
241
242 CGEN_INIT_INSERT (cd);
243 value = CGEN_INSN_BASE_VALUE (insn);
244
245 /* If we're recording insns as numbers (rather than a string of bytes),
246 target byte order handling is deferred until later. */
247
248#if CGEN_INT_INSN_P
249
250 put_insn_int_value (cd, buffer, cd->base_insn_bitsize,
251 CGEN_FIELDS_BITSIZE (fields), value);
252
253#else
254
255 cgen_put_insn_value (cd, buffer, min ((unsigned) cd->base_insn_bitsize,
256 (unsigned) CGEN_FIELDS_BITSIZE (fields)),
257 value);
258
259#endif /* ! CGEN_INT_INSN_P */
260
261 /* ??? It would be better to scan the format's fields.
262 Still need to be able to insert a value based on the operand though;
263 e.g. storing a branch displacement that got resolved later.
264 Needs more thought first. */
265
266 for (syn = CGEN_SYNTAX_STRING (syntax); * syn; ++ syn)
267 {
268 const char *errmsg;
269
270 if (CGEN_SYNTAX_CHAR_P (* syn))
271 continue;
272
273 errmsg = (* cd->insert_operand) (cd, CGEN_SYNTAX_FIELD (*syn),
274 fields, buffer, pc);
275 if (errmsg)
276 return errmsg;
277 }
278
279 return NULL;
280}
281
282#if CGEN_INT_INSN_P
283/* Cover function to store an insn value into an integral insn. Must go here
47b0e7ad 284 because it needs <prefix>-desc.h for CGEN_INT_INSN_P. */
93fbbb04
GK		 285
286static void
ffead7ae
MM		 287put_insn_int_value (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
288 CGEN_INSN_BYTES_PTR buf,
289 int length,
290 int insn_length,
291 CGEN_INSN_INT value)
93fbbb04
GK		 292{
293 /* For architectures with insns smaller than the base-insn-bitsize,
294 length may be too big. */
295 if (length > insn_length)
296 *buf = value;
297 else
298 {
299 int shift = insn_length - length;
300 /* Written this way to avoid undefined behaviour. */
301 CGEN_INSN_INT mask = (((1L << (length - 1)) - 1) << 1) | 1;
47b0e7ad 302
93fbbb04
GK		 303 *buf = (*buf & ~(mask << shift)) | ((value & mask) << shift);
304 }
305}
306#endif
307\f
308/* Operand extraction. */
309
310#if ! CGEN_INT_INSN_P
311
312/* Subroutine of extract_normal.
313 Ensure sufficient bytes are cached in EX_INFO.
314 OFFSET is the offset in bytes from the start of the insn of the value.
315 BYTES is the length of the needed value.
316 Returns 1 for success, 0 for failure. */
317
318static CGEN_INLINE int
ffead7ae
MM		 319fill_cache (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
320 CGEN_EXTRACT_INFO *ex_info,
321 int offset,
322 int bytes,
323 bfd_vma pc)
93fbbb04
GK		 324{
325 /* It's doubtful that the middle part has already been fetched so
326 we don't optimize that case. kiss. */
327 unsigned int mask;
328 disassemble_info *info = (disassemble_info *) ex_info->dis_info;
329
330 /* First do a quick check. */
331 mask = (1 << bytes) - 1;
332 if (((ex_info->valid >> offset) & mask) == mask)
333 return 1;
334
335 /* Search for the first byte we need to read. */
336 for (mask = 1 << offset; bytes > 0; --bytes, ++offset, mask <<= 1)
337 if (! (mask & ex_info->valid))
338 break;
339
340 if (bytes)
341 {
342 int status;
343
344 pc += offset;
345 status = (*info->read_memory_func)
346 (pc, ex_info->insn_bytes + offset, bytes, info);
347
348 if (status != 0)
349 {
350 (*info->memory_error_func) (status, pc, info);
351 return 0;
352 }
353
354 ex_info->valid |= ((1 << bytes) - 1) << offset;
355 }
356
357 return 1;
358}
359
360/* Subroutine of extract_normal. */
361
362static CGEN_INLINE long
ffead7ae
MM		 363extract_1 (CGEN_CPU_DESC cd,
364 CGEN_EXTRACT_INFO *ex_info ATTRIBUTE_UNUSED,
365 int start,
366 int length,
367 int word_length,
368 unsigned char *bufp,
369 bfd_vma pc ATTRIBUTE_UNUSED)
93fbbb04
GK		 370{
371 unsigned long x;
372 int shift;
47b0e7ad 373
93fbbb04
GK		 374 x = cgen_get_insn_value (cd, bufp, word_length);
375
376 if (CGEN_INSN_LSB0_P)
377 shift = (start + 1) - length;
378 else
379 shift = (word_length - (start + length));
380 return x >> shift;
381}
382
383#endif /* ! CGEN_INT_INSN_P */
384
385/* Default extraction routine.
386
387 INSN_VALUE is the first base_insn_bitsize bits of the insn in host order,
388 or sometimes less for cases like the m32r where the base insn size is 32
389 but some insns are 16 bits.
390 ATTRS is a mask of the boolean attributes. We only need `SIGNED',
391 but for generality we take a bitmask of all of them.
392 WORD_OFFSET is the offset in bits from the start of the insn of the value.
393 WORD_LENGTH is the length of the word in bits in which the value resides.
394 START is the starting bit number in the word, architecture origin.
395 LENGTH is the length of VALUE in bits.
396 TOTAL_LENGTH is the total length of the insn in bits.
397
398 Returns 1 for success, 0 for failure. */
399
400/* ??? The return code isn't properly used. wip. */
401
402/* ??? This doesn't handle bfd_vma's. Create another function when
403 necessary. */
404
405static int
ffead7ae 406extract_normal (CGEN_CPU_DESC cd,
93fbbb04 407#if ! CGEN_INT_INSN_P
ffead7ae 408 CGEN_EXTRACT_INFO *ex_info,
93fbbb04 409#else
ffead7ae 410 CGEN_EXTRACT_INFO *ex_info ATTRIBUTE_UNUSED,
93fbbb04 411#endif
ffead7ae
MM		 412 CGEN_INSN_INT insn_value,
413 unsigned int attrs,
414 unsigned int word_offset,
415 unsigned int start,
416 unsigned int length,
417 unsigned int word_length,
418 unsigned int total_length,
93fbbb04 419#if ! CGEN_INT_INSN_P
ffead7ae 420 bfd_vma pc,
93fbbb04 421#else
ffead7ae 422 bfd_vma pc ATTRIBUTE_UNUSED,
93fbbb04 423#endif
ffead7ae 424 long *valuep)
93fbbb04
GK		 425{
426 long value, mask;
427
428 /* If LENGTH is zero, this operand doesn't contribute to the value
429 so give it a standard value of zero. */
430 if (length == 0)
431 {
432 *valuep = 0;
433 return 1;
434 }
435
93fbbb04
GK		 436 if (word_length > 32)
437 abort ();
438
439 /* For architectures with insns smaller than the insn-base-bitsize,
440 word_length may be too big. */
441 if (cd->min_insn_bitsize < cd->base_insn_bitsize)
442 {
443 if (word_offset == 0
444 && word_length > total_length)
445 word_length = total_length;
446 }
447
448 /* Does the value reside in INSN_VALUE, and at the right alignment? */
449
450 if (CGEN_INT_INSN_P || (word_offset == 0 && word_length == total_length))
451 {
452 if (CGEN_INSN_LSB0_P)
453 value = insn_value >> ((word_offset + start + 1) - length);
454 else
455 value = insn_value >> (total_length - ( word_offset + start + length));
456 }
457
458#if ! CGEN_INT_INSN_P
459
460 else
461 {
462 unsigned char *bufp = ex_info->insn_bytes + word_offset / 8;
463
464 if (word_length > 32)
465 abort ();
466
467 if (fill_cache (cd, ex_info, word_offset / 8, word_length / 8, pc) == 0)
468 return 0;
469
470 value = extract_1 (cd, ex_info, start, length, word_length, bufp, pc);
471 }
472
473#endif /* ! CGEN_INT_INSN_P */
474
475 /* Written this way to avoid undefined behaviour. */
476 mask = (((1L << (length - 1)) - 1) << 1) | 1;
477
478 value &= mask;
479 /* sign extend? */
480 if (CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGNED)
481 && (value & (1L << (length - 1))))
482 value |= ~mask;
483
484 *valuep = value;
485
486 return 1;
487}
488
489/* Default insn extractor.
490
491 INSN_VALUE is the first base_insn_bitsize bits, translated to host order.
492 The extracted fields are stored in FIELDS.
493 EX_INFO is used to handle reading variable length insns.
494 Return the length of the insn in bits, or 0 if no match,
495 or -1 if an error occurs fetching data (memory_error_func will have
496 been called). */
497
498static int
ffead7ae
MM		 499extract_insn_normal (CGEN_CPU_DESC cd,
500 const CGEN_INSN *insn,
501 CGEN_EXTRACT_INFO *ex_info,
502 CGEN_INSN_INT insn_value,
503 CGEN_FIELDS *fields,
504 bfd_vma pc)
93fbbb04
GK		 505{
506 const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
507 const CGEN_SYNTAX_CHAR_TYPE *syn;
508
509 CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn);
510
511 CGEN_INIT_EXTRACT (cd);
512
513 for (syn = CGEN_SYNTAX_STRING (syntax); *syn; ++syn)
514 {
515 int length;
516
517 if (CGEN_SYNTAX_CHAR_P (*syn))
518 continue;
519
520 length = (* cd->extract_operand) (cd, CGEN_SYNTAX_FIELD (*syn),
521 ex_info, insn_value, fields, pc);
522 if (length <= 0)
523 return length;
524 }
525
526 /* We recognized and successfully extracted this insn. */
527 return CGEN_INSN_BITSIZE (insn);
528}
529\f
47b0e7ad 530/* Machine generated code added here. */
93fbbb04
GK		 531
532const char * xstormy16_cgen_insert_operand
47b0e7ad 533 (CGEN_CPU_DESC, int, CGEN_FIELDS *, CGEN_INSN_BYTES_PTR, bfd_vma);
93fbbb04
GK		 534
535/* Main entry point for operand insertion.
536
537 This function is basically just a big switch statement. Earlier versions
538 used tables to look up the function to use, but
539 - if the table contains both assembler and disassembler functions then
540 the disassembler contains much of the assembler and vice-versa,
541 - there's a lot of inlining possibilities as things grow,
542 - using a switch statement avoids the function call overhead.
543
544 This function could be moved into `parse_insn_normal', but keeping it
545 separate makes clear the interface between `parse_insn_normal' and each of
546 the handlers. It's also needed by GAS to insert operands that couldn't be
547 resolved during parsing. */
548
549const char *
47b0e7ad
NC		 550xstormy16_cgen_insert_operand (CGEN_CPU_DESC cd,
551 int opindex,
552 CGEN_FIELDS * fields,
553 CGEN_INSN_BYTES_PTR buffer,
554 bfd_vma pc ATTRIBUTE_UNUSED)
93fbbb04
GK		 555{
556 const char * errmsg = NULL;
557 unsigned int total_length = CGEN_FIELDS_BITSIZE (fields);
558
559 switch (opindex)
560 {
561 case XSTORMY16_OPERAND_RB :
562 errmsg = insert_normal (cd, fields->f_Rb, 0, 0, 17, 3, 32, total_length, buffer);
563 break;
564 case XSTORMY16_OPERAND_RBJ :
565 errmsg = insert_normal (cd, fields->f_Rbj, 0, 0, 11, 1, 32, total_length, buffer);
566 break;
567 case XSTORMY16_OPERAND_RD :
568 errmsg = insert_normal (cd, fields->f_Rd, 0, 0, 12, 4, 32, total_length, buffer);
569 break;
570 case XSTORMY16_OPERAND_RDM :
571 errmsg = insert_normal (cd, fields->f_Rdm, 0, 0, 13, 3, 32, total_length, buffer);
572 break;
573 case XSTORMY16_OPERAND_RM :
574 errmsg = insert_normal (cd, fields->f_Rm, 0, 0, 4, 3, 32, total_length, buffer);
575 break;
576 case XSTORMY16_OPERAND_RS :
577 errmsg = insert_normal (cd, fields->f_Rs, 0, 0, 8, 4, 32, total_length, buffer);
578 break;
579 case XSTORMY16_OPERAND_ABS24 :
580 {
581{
582 FLD (f_abs24_1) = ((FLD (f_abs24)) & (255));
583 FLD (f_abs24_2) = ((unsigned int) (FLD (f_abs24)) >> (8));
584}
585 errmsg = insert_normal (cd, fields->f_abs24_1, 0, 0, 8, 8, 32, total_length, buffer);
586 if (errmsg)
587 break;
588 errmsg = insert_normal (cd, fields->f_abs24_2, 0, 0, 16, 16, 32, total_length, buffer);
589 if (errmsg)
590 break;
591 }
592 break;
593 case XSTORMY16_OPERAND_BCOND2 :
594 errmsg = insert_normal (cd, fields->f_op2, 0, 0, 4, 4, 32, total_length, buffer);
595 break;
596 case XSTORMY16_OPERAND_BCOND5 :
597 errmsg = insert_normal (cd, fields->f_op5, 0, 0, 16, 4, 32, total_length, buffer);
598 break;
599 case XSTORMY16_OPERAND_HMEM8 :
600 {
601 long value = fields->f_hmem8;
602 value = ((value) - (32512));
603 errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_ABS_ADDR), 0, 8, 8, 32, total_length, buffer);
604 }
605 break;
606 case XSTORMY16_OPERAND_IMM12 :
607 errmsg = insert_normal (cd, fields->f_imm12, 0|(1<<CGEN_IFLD_SIGNED), 0, 20, 12, 32, total_length, buffer);
608 break;
609 case XSTORMY16_OPERAND_IMM16 :
610 errmsg = insert_normal (cd, fields->f_imm16, 0|(1<<CGEN_IFLD_SIGN_OPT), 0, 16, 16, 32, total_length, buffer);
611 break;
612 case XSTORMY16_OPERAND_IMM2 :
613 errmsg = insert_normal (cd, fields->f_imm2, 0, 0, 10, 2, 32, total_length, buffer);
614 break;
615 case XSTORMY16_OPERAND_IMM3 :
616 errmsg = insert_normal (cd, fields->f_imm3, 0, 0, 4, 3, 32, total_length, buffer);
617 break;
618 case XSTORMY16_OPERAND_IMM3B :
619 errmsg = insert_normal (cd, fields->f_imm3b, 0, 0, 17, 3, 32, total_length, buffer);
620 break;
621 case XSTORMY16_OPERAND_IMM4 :
622 errmsg = insert_normal (cd, fields->f_imm4, 0, 0, 8, 4, 32, total_length, buffer);
623 break;
624 case XSTORMY16_OPERAND_IMM8 :
625 errmsg = insert_normal (cd, fields->f_imm8, 0, 0, 8, 8, 32, total_length, buffer);
626 break;
627 case XSTORMY16_OPERAND_IMM8SMALL :
628 errmsg = insert_normal (cd, fields->f_imm8, 0, 0, 8, 8, 32, total_length, buffer);
629 break;
630 case XSTORMY16_OPERAND_LMEM8 :
631 errmsg = insert_normal (cd, fields->f_lmem8, 0|(1<<CGEN_IFLD_ABS_ADDR), 0, 8, 8, 32, total_length, buffer);
632 break;
633 case XSTORMY16_OPERAND_REL12 :
634 {
635 long value = fields->f_rel12;
636 value = ((value) - (((pc) + (4))));
637 errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 20, 12, 32, total_length, buffer);
638 }
639 break;
640 case XSTORMY16_OPERAND_REL12A :
641 {
642 long value = fields->f_rel12a;
643 value = ((int) (((value) - (((pc) + (2))))) >> (1));
644 errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 4, 11, 32, total_length, buffer);
645 }
646 break;
647 case XSTORMY16_OPERAND_REL8_2 :
648 {
649 long value = fields->f_rel8_2;
650 value = ((value) - (((pc) + (2))));
651 errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 8, 8, 32, total_length, buffer);
652 }
653 break;
654 case XSTORMY16_OPERAND_REL8_4 :
655 {
656 long value = fields->f_rel8_4;
657 value = ((value) - (((pc) + (4))));
658 errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 8, 8, 32, total_length, buffer);
659 }
660 break;
661 case XSTORMY16_OPERAND_WS2 :
662 errmsg = insert_normal (cd, fields->f_op2m, 0, 0, 7, 1, 32, total_length, buffer);
663 break;
664
665 default :
666 /* xgettext:c-format */
667 fprintf (stderr, _("Unrecognized field %d while building insn.\n"),
668 opindex);
669 abort ();
670 }
671
672 return errmsg;
673}
674
675int xstormy16_cgen_extract_operand
47b0e7ad 676 (CGEN_CPU_DESC, int, CGEN_EXTRACT_INFO *, CGEN_INSN_INT, CGEN_FIELDS *, bfd_vma);
93fbbb04
GK		 677
678/* Main entry point for operand extraction.
679 The result is <= 0 for error, >0 for success.
680 ??? Actual values aren't well defined right now.
681
682 This function is basically just a big switch statement. Earlier versions
683 used tables to look up the function to use, but
684 - if the table contains both assembler and disassembler functions then
685 the disassembler contains much of the assembler and vice-versa,
686 - there's a lot of inlining possibilities as things grow,
687 - using a switch statement avoids the function call overhead.
688
689 This function could be moved into `print_insn_normal', but keeping it
690 separate makes clear the interface between `print_insn_normal' and each of
691 the handlers. */
692
693int
47b0e7ad
NC		 694xstormy16_cgen_extract_operand (CGEN_CPU_DESC cd,
695 int opindex,
696 CGEN_EXTRACT_INFO *ex_info,
697 CGEN_INSN_INT insn_value,
698 CGEN_FIELDS * fields,
699 bfd_vma pc)
93fbbb04
GK		 700{
701 /* Assume success (for those operands that are nops). */
702 int length = 1;
703 unsigned int total_length = CGEN_FIELDS_BITSIZE (fields);
704
705 switch (opindex)
706 {
707 case XSTORMY16_OPERAND_RB :
708 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 3, 32, total_length, pc, & fields->f_Rb);
709 break;
710 case XSTORMY16_OPERAND_RBJ :
711 length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 1, 32, total_length, pc, & fields->f_Rbj);
712 break;
713 case XSTORMY16_OPERAND_RD :
714 length = extract_normal (cd, ex_info, insn_value, 0, 0, 12, 4, 32, total_length, pc, & fields->f_Rd);
715 break;
716 case XSTORMY16_OPERAND_RDM :
717 length = extract_normal (cd, ex_info, insn_value, 0, 0, 13, 3, 32, total_length, pc, & fields->f_Rdm);
718 break;
719 case XSTORMY16_OPERAND_RM :
720 length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 3, 32, total_length, pc, & fields->f_Rm);
721 break;
722 case XSTORMY16_OPERAND_RS :
723 length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 4, 32, total_length, pc, & fields->f_Rs);
724 break;
725 case XSTORMY16_OPERAND_ABS24 :
726 {
727 length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 8, 32, total_length, pc, & fields->f_abs24_1);
728 if (length <= 0) break;
729 length = extract_normal (cd, ex_info, insn_value, 0, 0, 16, 16, 32, total_length, pc, & fields->f_abs24_2);
730 if (length <= 0) break;
731 FLD (f_abs24) = ((((FLD (f_abs24_2)) << (8))) | (FLD (f_abs24_1)));
732 }
733 break;
734 case XSTORMY16_OPERAND_BCOND2 :
735 length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 4, 32, total_length, pc, & fields->f_op2);
736 break;
737 case XSTORMY16_OPERAND_BCOND5 :
738 length = extract_normal (cd, ex_info, insn_value, 0, 0, 16, 4, 32, total_length, pc, & fields->f_op5);
739 break;
740 case XSTORMY16_OPERAND_HMEM8 :
741 {
742 long value;
743 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_ABS_ADDR), 0, 8, 8, 32, total_length, pc, & value);
744 value = ((value) + (32512));
745 fields->f_hmem8 = value;
746 }
747 break;
748 case XSTORMY16_OPERAND_IMM12 :
749 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 20, 12, 32, total_length, pc, & fields->f_imm12);
750 break;
751 case XSTORMY16_OPERAND_IMM16 :
752 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGN_OPT), 0, 16, 16, 32, total_length, pc, & fields->f_imm16);
753 break;
754 case XSTORMY16_OPERAND_IMM2 :
755 length = extract_normal (cd, ex_info, insn_value, 0, 0, 10, 2, 32, total_length, pc, & fields->f_imm2);
756 break;
757 case XSTORMY16_OPERAND_IMM3 :
758 length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 3, 32, total_length, pc, & fields->f_imm3);
759 break;
760 case XSTORMY16_OPERAND_IMM3B :
761 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 3, 32, total_length, pc, & fields->f_imm3b);
762 break;
763 case XSTORMY16_OPERAND_IMM4 :
764 length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 4, 32, total_length, pc, & fields->f_imm4);
765 break;
766 case XSTORMY16_OPERAND_IMM8 :
767 length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 8, 32, total_length, pc, & fields->f_imm8);
768 break;
769 case XSTORMY16_OPERAND_IMM8SMALL :
770 length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 8, 32, total_length, pc, & fields->f_imm8);
771 break;
772 case XSTORMY16_OPERAND_LMEM8 :
773 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_ABS_ADDR), 0, 8, 8, 32, total_length, pc, & fields->f_lmem8);
774 break;
775 case XSTORMY16_OPERAND_REL12 :
776 {
777 long value;
778 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 20, 12, 32, total_length, pc, & value);
779 value = ((value) + (((pc) + (4))));
780 fields->f_rel12 = value;
781 }
782 break;
783 case XSTORMY16_OPERAND_REL12A :
784 {
785 long value;
786 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);
787 value = ((((value) << (1))) + (((pc) + (2))));
788 fields->f_rel12a = value;
789 }
790 break;
791 case XSTORMY16_OPERAND_REL8_2 :
792 {
793 long value;
794 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 8, 8, 32, total_length, pc, & value);
795 value = ((value) + (((pc) + (2))));
796 fields->f_rel8_2 = value;
797 }
798 break;
799 case XSTORMY16_OPERAND_REL8_4 :
800 {
801 long value;
802 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 8, 8, 32, total_length, pc, & value);
803 value = ((value) + (((pc) + (4))));
804 fields->f_rel8_4 = value;
805 }
806 break;
807 case XSTORMY16_OPERAND_WS2 :
808 length = extract_normal (cd, ex_info, insn_value, 0, 0, 7, 1, 32, total_length, pc, & fields->f_op2m);
809 break;
810
811 default :
812 /* xgettext:c-format */
813 fprintf (stderr, _("Unrecognized field %d while decoding insn.\n"),
814 opindex);
815 abort ();
816 }
817
818 return length;
819}
820
821cgen_insert_fn * const xstormy16_cgen_insert_handlers[] =
822{
823 insert_insn_normal,
824};
825
826cgen_extract_fn * const xstormy16_cgen_extract_handlers[] =
827{
828 extract_insn_normal,
829};
830
47b0e7ad
NC		 831int xstormy16_cgen_get_int_operand (CGEN_CPU_DESC, int, const CGEN_FIELDS *);
832bfd_vma xstormy16_cgen_get_vma_operand (CGEN_CPU_DESC, int, const CGEN_FIELDS *);
93fbbb04
GK		 833
834/* Getting values from cgen_fields is handled by a collection of functions.
835 They are distinguished by the type of the VALUE argument they return.
836 TODO: floating point, inlining support, remove cases where result type
837 not appropriate. */
838
839int
47b0e7ad
NC		 840xstormy16_cgen_get_int_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
841 int opindex,
842 const CGEN_FIELDS * fields)
93fbbb04
GK		 843{
844 int value;
845
846 switch (opindex)
847 {
848 case XSTORMY16_OPERAND_RB :
849 value = fields->f_Rb;
850 break;
851 case XSTORMY16_OPERAND_RBJ :
852 value = fields->f_Rbj;
853 break;
854 case XSTORMY16_OPERAND_RD :
855 value = fields->f_Rd;
856 break;
857 case XSTORMY16_OPERAND_RDM :
858 value = fields->f_Rdm;
859 break;
860 case XSTORMY16_OPERAND_RM :
861 value = fields->f_Rm;
862 break;
863 case XSTORMY16_OPERAND_RS :
864 value = fields->f_Rs;
865 break;
866 case XSTORMY16_OPERAND_ABS24 :
867 value = fields->f_abs24;
868 break;
869 case XSTORMY16_OPERAND_BCOND2 :
870 value = fields->f_op2;
871 break;
872 case XSTORMY16_OPERAND_BCOND5 :
873 value = fields->f_op5;
874 break;
875 case XSTORMY16_OPERAND_HMEM8 :
876 value = fields->f_hmem8;
877 break;
878 case XSTORMY16_OPERAND_IMM12 :
879 value = fields->f_imm12;
880 break;
881 case XSTORMY16_OPERAND_IMM16 :
882 value = fields->f_imm16;
883 break;
884 case XSTORMY16_OPERAND_IMM2 :
885 value = fields->f_imm2;
886 break;
887 case XSTORMY16_OPERAND_IMM3 :
888 value = fields->f_imm3;
889 break;
890 case XSTORMY16_OPERAND_IMM3B :
891 value = fields->f_imm3b;
892 break;
893 case XSTORMY16_OPERAND_IMM4 :
894 value = fields->f_imm4;
895 break;
896 case XSTORMY16_OPERAND_IMM8 :
897 value = fields->f_imm8;
898 break;
899 case XSTORMY16_OPERAND_IMM8SMALL :
900 value = fields->f_imm8;
901 break;
902 case XSTORMY16_OPERAND_LMEM8 :
903 value = fields->f_lmem8;
904 break;
905 case XSTORMY16_OPERAND_REL12 :
906 value = fields->f_rel12;
907 break;
908 case XSTORMY16_OPERAND_REL12A :
909 value = fields->f_rel12a;
910 break;
911 case XSTORMY16_OPERAND_REL8_2 :
912 value = fields->f_rel8_2;
913 break;
914 case XSTORMY16_OPERAND_REL8_4 :
915 value = fields->f_rel8_4;
916 break;
917 case XSTORMY16_OPERAND_WS2 :
918 value = fields->f_op2m;
919 break;
920
921 default :
922 /* xgettext:c-format */
923 fprintf (stderr, _("Unrecognized field %d while getting int operand.\n"),
924 opindex);
925 abort ();
926 }
927
928 return value;
929}
930
931bfd_vma
47b0e7ad
NC		 932xstormy16_cgen_get_vma_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
933 int opindex,
934 const CGEN_FIELDS * fields)
93fbbb04
GK		 935{
936 bfd_vma value;
937
938 switch (opindex)
939 {
940 case XSTORMY16_OPERAND_RB :
941 value = fields->f_Rb;
942 break;
943 case XSTORMY16_OPERAND_RBJ :
944 value = fields->f_Rbj;
945 break;
946 case XSTORMY16_OPERAND_RD :
947 value = fields->f_Rd;
948 break;
949 case XSTORMY16_OPERAND_RDM :
950 value = fields->f_Rdm;
951 break;
952 case XSTORMY16_OPERAND_RM :
953 value = fields->f_Rm;
954 break;
955 case XSTORMY16_OPERAND_RS :
956 value = fields->f_Rs;
957 break;
958 case XSTORMY16_OPERAND_ABS24 :
959 value = fields->f_abs24;
960 break;
961 case XSTORMY16_OPERAND_BCOND2 :
962 value = fields->f_op2;
963 break;
964 case XSTORMY16_OPERAND_BCOND5 :
965 value = fields->f_op5;
966 break;
967 case XSTORMY16_OPERAND_HMEM8 :
968 value = fields->f_hmem8;
969 break;
970 case XSTORMY16_OPERAND_IMM12 :
971 value = fields->f_imm12;
972 break;
973 case XSTORMY16_OPERAND_IMM16 :
974 value = fields->f_imm16;
975 break;
976 case XSTORMY16_OPERAND_IMM2 :
977 value = fields->f_imm2;
978 break;
979 case XSTORMY16_OPERAND_IMM3 :
980 value = fields->f_imm3;
981 break;
982 case XSTORMY16_OPERAND_IMM3B :
983 value = fields->f_imm3b;
984 break;
985 case XSTORMY16_OPERAND_IMM4 :
986 value = fields->f_imm4;
987 break;
988 case XSTORMY16_OPERAND_IMM8 :
989 value = fields->f_imm8;
990 break;
991 case XSTORMY16_OPERAND_IMM8SMALL :
992 value = fields->f_imm8;
993 break;
994 case XSTORMY16_OPERAND_LMEM8 :
995 value = fields->f_lmem8;
996 break;
997 case XSTORMY16_OPERAND_REL12 :
998 value = fields->f_rel12;
999 break;
1000 case XSTORMY16_OPERAND_REL12A :
1001 value = fields->f_rel12a;
1002 break;
1003 case XSTORMY16_OPERAND_REL8_2 :
1004 value = fields->f_rel8_2;
1005 break;
1006 case XSTORMY16_OPERAND_REL8_4 :
1007 value = fields->f_rel8_4;
1008 break;
1009 case XSTORMY16_OPERAND_WS2 :
1010 value = fields->f_op2m;
1011 break;
1012
1013 default :
1014 /* xgettext:c-format */
1015 fprintf (stderr, _("Unrecognized field %d while getting vma operand.\n"),
1016 opindex);
1017 abort ();
1018 }
1019
1020 return value;
1021}
1022
47b0e7ad
NC		 1023void xstormy16_cgen_set_int_operand (CGEN_CPU_DESC, int, CGEN_FIELDS *, int);
1024void xstormy16_cgen_set_vma_operand (CGEN_CPU_DESC, int, CGEN_FIELDS *, bfd_vma);
93fbbb04
GK		 1025
1026/* Stuffing values in cgen_fields is handled by a collection of functions.
1027 They are distinguished by the type of the VALUE argument they accept.
1028 TODO: floating point, inlining support, remove cases where argument type
1029 not appropriate. */
1030
1031void
47b0e7ad
NC		 1032xstormy16_cgen_set_int_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
1033 int opindex,
1034 CGEN_FIELDS * fields,
1035 int value)
93fbbb04
GK		 1036{
1037 switch (opindex)
1038 {
1039 case XSTORMY16_OPERAND_RB :
1040 fields->f_Rb = value;
1041 break;
1042 case XSTORMY16_OPERAND_RBJ :
1043 fields->f_Rbj = value;
1044 break;
1045 case XSTORMY16_OPERAND_RD :
1046 fields->f_Rd = value;
1047 break;
1048 case XSTORMY16_OPERAND_RDM :
1049 fields->f_Rdm = value;
1050 break;
1051 case XSTORMY16_OPERAND_RM :
1052 fields->f_Rm = value;
1053 break;
1054 case XSTORMY16_OPERAND_RS :
1055 fields->f_Rs = value;
1056 break;
1057 case XSTORMY16_OPERAND_ABS24 :
1058 fields->f_abs24 = value;
1059 break;
1060 case XSTORMY16_OPERAND_BCOND2 :
1061 fields->f_op2 = value;
1062 break;
1063 case XSTORMY16_OPERAND_BCOND5 :
1064 fields->f_op5 = value;
1065 break;
1066 case XSTORMY16_OPERAND_HMEM8 :
1067 fields->f_hmem8 = value;
1068 break;
1069 case XSTORMY16_OPERAND_IMM12 :
1070 fields->f_imm12 = value;
1071 break;
1072 case XSTORMY16_OPERAND_IMM16 :
1073 fields->f_imm16 = value;
1074 break;
1075 case XSTORMY16_OPERAND_IMM2 :
1076 fields->f_imm2 = value;
1077 break;
1078 case XSTORMY16_OPERAND_IMM3 :
1079 fields->f_imm3 = value;
1080 break;
1081 case XSTORMY16_OPERAND_IMM3B :
1082 fields->f_imm3b = value;
1083 break;
1084 case XSTORMY16_OPERAND_IMM4 :
1085 fields->f_imm4 = value;
1086 break;
1087 case XSTORMY16_OPERAND_IMM8 :
1088 fields->f_imm8 = value;
1089 break;
1090 case XSTORMY16_OPERAND_IMM8SMALL :
1091 fields->f_imm8 = value;
1092 break;
1093 case XSTORMY16_OPERAND_LMEM8 :
1094 fields->f_lmem8 = value;
1095 break;
1096 case XSTORMY16_OPERAND_REL12 :
1097 fields->f_rel12 = value;
1098 break;
1099 case XSTORMY16_OPERAND_REL12A :
1100 fields->f_rel12a = value;
1101 break;
1102 case XSTORMY16_OPERAND_REL8_2 :
1103 fields->f_rel8_2 = value;
1104 break;
1105 case XSTORMY16_OPERAND_REL8_4 :
1106 fields->f_rel8_4 = value;
1107 break;
1108 case XSTORMY16_OPERAND_WS2 :
1109 fields->f_op2m = value;
1110 break;
1111
1112 default :
1113 /* xgettext:c-format */
1114 fprintf (stderr, _("Unrecognized field %d while setting int operand.\n"),
1115 opindex);
1116 abort ();
1117 }
1118}
1119
1120void
47b0e7ad
NC		 1121xstormy16_cgen_set_vma_operand (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
1122 int opindex,
1123 CGEN_FIELDS * fields,
1124 bfd_vma value)
93fbbb04
GK		 1125{
1126 switch (opindex)
1127 {
1128 case XSTORMY16_OPERAND_RB :
1129 fields->f_Rb = value;
1130 break;
1131 case XSTORMY16_OPERAND_RBJ :
1132 fields->f_Rbj = value;
1133 break;
1134 case XSTORMY16_OPERAND_RD :
1135 fields->f_Rd = value;
1136 break;
1137 case XSTORMY16_OPERAND_RDM :
1138 fields->f_Rdm = value;
1139 break;
1140 case XSTORMY16_OPERAND_RM :
1141 fields->f_Rm = value;
1142 break;
1143 case XSTORMY16_OPERAND_RS :
1144 fields->f_Rs = value;
1145 break;
1146 case XSTORMY16_OPERAND_ABS24 :
1147 fields->f_abs24 = value;
1148 break;
1149 case XSTORMY16_OPERAND_BCOND2 :
1150 fields->f_op2 = value;
1151 break;
1152 case XSTORMY16_OPERAND_BCOND5 :
1153 fields->f_op5 = value;
1154 break;
1155 case XSTORMY16_OPERAND_HMEM8 :
1156 fields->f_hmem8 = value;
1157 break;
1158 case XSTORMY16_OPERAND_IMM12 :
1159 fields->f_imm12 = value;
1160 break;
1161 case XSTORMY16_OPERAND_IMM16 :
1162 fields->f_imm16 = value;
1163 break;
1164 case XSTORMY16_OPERAND_IMM2 :
1165 fields->f_imm2 = value;
1166 break;
1167 case XSTORMY16_OPERAND_IMM3 :
1168 fields->f_imm3 = value;
1169 break;
1170 case XSTORMY16_OPERAND_IMM3B :
1171 fields->f_imm3b = value;
1172 break;
1173 case XSTORMY16_OPERAND_IMM4 :
1174 fields->f_imm4 = value;
1175 break;
1176 case XSTORMY16_OPERAND_IMM8 :
1177 fields->f_imm8 = value;
1178 break;
1179 case XSTORMY16_OPERAND_IMM8SMALL :
1180 fields->f_imm8 = value;
1181 break;
1182 case XSTORMY16_OPERAND_LMEM8 :
1183 fields->f_lmem8 = value;
1184 break;
1185 case XSTORMY16_OPERAND_REL12 :
1186 fields->f_rel12 = value;
1187 break;
1188 case XSTORMY16_OPERAND_REL12A :
1189 fields->f_rel12a = value;
1190 break;
1191 case XSTORMY16_OPERAND_REL8_2 :
1192 fields->f_rel8_2 = value;
1193 break;
1194 case XSTORMY16_OPERAND_REL8_4 :
1195 fields->f_rel8_4 = value;
1196 break;
1197 case XSTORMY16_OPERAND_WS2 :
1198 fields->f_op2m = value;
1199 break;
1200
1201 default :
1202 /* xgettext:c-format */
1203 fprintf (stderr, _("Unrecognized field %d while setting vma operand.\n"),
1204 opindex);
1205 abort ();
1206 }
1207}
1208
1209/* Function to call before using the instruction builder tables. */
1210
1211void
47b0e7ad 1212xstormy16_cgen_init_ibld_table (CGEN_CPU_DESC cd)
93fbbb04
GK		 1213{
1214 cd->insert_handlers = & xstormy16_cgen_insert_handlers[0];
1215 cd->extract_handlers = & xstormy16_cgen_extract_handlers[0];
1216
1217 cd->insert_operand = xstormy16_cgen_insert_operand;
1218 cd->extract_operand = xstormy16_cgen_extract_operand;
1219
1220 cd->get_int_operand = xstormy16_cgen_get_int_operand;
1221 cd->set_int_operand = xstormy16_cgen_set_int_operand;
1222 cd->get_vma_operand = xstormy16_cgen_get_vma_operand;
1223 cd->set_vma_operand = xstormy16_cgen_set_vma_operand;
1224}
Empty description
This page took 0.608787 seconds and 4 git commands to generate.