URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.18.50/] [cpu/] [mt.opc] - Blame information for rev 252

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


/* Morpho Technologies mRISC opcode support, for GNU Binutils.  -*- C -*-
   Copyright 2001, 2007, 2008 Free Software Foundation, Inc.
 
   Contributed by Red Hat Inc; developed under contract from
   Morpho Technologies.
 
   This file is part of the GNU Binutils.
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
   MA 02110-1301, USA.  */
 
 
/* Each section is delimited with start and end markers.
 
   -opc.h additions use: "-- opc.h"
   -opc.c additions use: "-- opc.c"
   -asm.c additions use: "-- asm.c"
   -dis.c additions use: "-- dis.c"
   -ibd.h additions use: "-- ibd.h"  */
 
/* -- opc.h */
 
/* Check applicability of instructions against machines.  */
#define CGEN_VALIDATE_INSN_SUPPORTED
 
/* Allows reason codes to be output when assembler errors occur.  */
#define CGEN_VERBOSE_ASSEMBLER_ERRORS
 
/* Override disassembly hashing - there are variable bits in the top
   byte of these instructions.  */
#define CGEN_DIS_HASH_SIZE 8
#define CGEN_DIS_HASH(buf, value) (((* (unsigned char *) (buf)) >> 5) % CGEN_DIS_HASH_SIZE)
 
#define CGEN_ASM_HASH_SIZE 127
#define CGEN_ASM_HASH(insn) mt_asm_hash (insn)
 
extern unsigned int mt_asm_hash (const char *);
 
extern int mt_cgen_insn_supported (CGEN_CPU_DESC, const CGEN_INSN *);
 
 
/* -- opc.c */
#include "safe-ctype.h"
 
/* Special check to ensure that instruction exists for given machine.  */
 
int
mt_cgen_insn_supported (CGEN_CPU_DESC cd, const CGEN_INSN *insn)
{
  int machs = CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_MACH);
 
  /* No mach attribute?  Assume it's supported for all machs.  */
  if (machs == 0)
    return 1;
 
  return ((machs & cd->machs) != 0);
}
 
/* A better hash function for instruction mnemonics.  */
 
unsigned int
mt_asm_hash (const char* insn)
{
  unsigned int hash;
  const char* m = insn;
 
  for (hash = 0; *m && ! ISSPACE (*m); m++)
    hash = (hash * 23) ^ (0x1F & TOLOWER (*m));
 
  /* printf ("%s %d\n", insn, (hash % CGEN_ASM_HASH_SIZE)); */
 
  return hash % CGEN_ASM_HASH_SIZE;
}
 
 
/* -- asm.c */
/* Range checking for signed numbers.  Returns 0 if acceptable
   and 1 if the value is out of bounds for a signed quantity.  */
 
static int
signed_out_of_bounds (long val)
{
  if ((val < -32768) || (val > 32767))
    return 1;
  return 0;
}
 
static const char *
parse_loopsize (CGEN_CPU_DESC cd,
                const char **strp,
                int opindex,
                void *arg)
{
  signed long * valuep = (signed long *) arg;
  const char *errmsg;
  bfd_reloc_code_real_type code = BFD_RELOC_NONE;
  enum cgen_parse_operand_result result_type;
  bfd_vma value;
 
  /* Is it a control transfer instructions?  */
  if (opindex == (CGEN_OPERAND_TYPE) MT_OPERAND_LOOPSIZE)
    {
      code = BFD_RELOC_MT_PCINSN8;
      errmsg = cgen_parse_address (cd, strp, opindex, code,
                                   & result_type, & value);
      *valuep = value;
      return errmsg;
    }
 
  abort ();
}
 
static const char *
parse_imm16 (CGEN_CPU_DESC cd,
             const char **strp,
             int opindex,
             void *arg)
{
  signed long * valuep = (signed long *) arg;
  const char *errmsg;
  enum cgen_parse_operand_result result_type;
  bfd_reloc_code_real_type code = BFD_RELOC_NONE;
  bfd_vma value;
 
  /* Is it a control transfer instructions?  */
  if (opindex == (CGEN_OPERAND_TYPE) MT_OPERAND_IMM16O)
    {
      code = BFD_RELOC_16_PCREL;
      errmsg = cgen_parse_address (cd, strp, opindex, code,
                                   & result_type, & value);
      if (errmsg == NULL)
        {
          if (signed_out_of_bounds (value))
            errmsg = _("Operand out of range. Must be between -32768 and 32767.");
        }
      *valuep = value;
      return errmsg;
    }
 
  /* If it's not a control transfer instruction, then
     we have to check for %OP relocating operators.  */
  if (opindex == (CGEN_OPERAND_TYPE) MT_OPERAND_IMM16L)
    ;
  else if (strncmp (*strp, "%hi16", 5) == 0)
    {
      *strp += 5;
      code = BFD_RELOC_HI16;
    }
  else if (strncmp (*strp, "%lo16", 5) == 0)
    {
      *strp += 5;
      code = BFD_RELOC_LO16;
    }
 
  /* If we found a %OP relocating operator, then parse it as an address.
     If not, we need to parse it as an integer, either signed or unsigned
     depending on which operand type we have.  */
  if (code != BFD_RELOC_NONE)
    {
       /* %OP relocating operator found.  */
       errmsg = cgen_parse_address (cd, strp, opindex, code,
                                   & result_type, & value);
       if (errmsg == NULL)
         {
           switch (result_type)
             {
             case (CGEN_PARSE_OPERAND_RESULT_NUMBER):
               if (code == BFD_RELOC_HI16)
                 value = (value >> 16) & 0xFFFF;
               else if (code == BFD_RELOC_LO16)
                 value = value  & 0xFFFF;
               else
                 errmsg = _("Biiiig Trouble in parse_imm16!");
               break;
 
             case (CGEN_PARSE_OPERAND_RESULT_QUEUED):
               /* No special processing for this case.  */
               break;
 
             default:
               errmsg = _("The percent-operator's operand is not a symbol");
               break;
             }
         }
       *valuep = value;
    }
  else
    {
      /* Parse hex values like 0xffff as unsigned, and sign extend
         them manually.  */
      int parse_signed = (opindex == (CGEN_OPERAND_TYPE)MT_OPERAND_IMM16);
 
      if ((*strp)[0] == '0'
          && ((*strp)[1] == 'x' || (*strp)[1] == 'X'))
        parse_signed = 0;
 
      /* No relocating operator.  Parse as an number.  */
      if (parse_signed)
        {
          /* Parse as as signed integer.  */
 
          errmsg = cgen_parse_signed_integer (cd, strp, opindex, valuep);
 
          if (errmsg == NULL)
            {
#if 0
              /* Manual range checking is needed for the signed case.  */
              if (*valuep & 0x8000)
                value = 0xffff0000 | *valuep;
              else
                value = *valuep;
 
              if (signed_out_of_bounds (value))
                errmsg = _("Operand out of range. Must be between -32768 and 32767.");
              /* Truncate to 16 bits. This is necessary
                 because cgen will have sign extended *valuep.  */
              *valuep &= 0xFFFF;
#endif
            }
        }
      else
        {
          /* MT_OPERAND_IMM16Z.  Parse as an unsigned integer.  */
          errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, (unsigned long *) valuep);
 
          if (opindex == (CGEN_OPERAND_TYPE) MT_OPERAND_IMM16
              && *valuep >= 0x8000
              && *valuep <= 0xffff)
            *valuep -= 0x10000;
        }
    }
 
  return errmsg;
}
 
 
static const char *
parse_dup (CGEN_CPU_DESC cd,
           const char **strp,
           int opindex,
           unsigned long *valuep)
{
  const char *errmsg = NULL;
 
  if (strncmp (*strp, "dup", 3) == 0 || strncmp (*strp, "DUP", 3) == 0)
    {
      *strp += 3;
      *valuep = 1;
    }
  else if (strncmp (*strp, "xx", 2) == 0 || strncmp (*strp, "XX", 2) == 0)
    {
      *strp += 2;
      *valuep = 0;
    }
  else
    errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);
 
  return errmsg;
}
 
 
static const char *
parse_ball (CGEN_CPU_DESC cd,
            const char **strp,
            int opindex,
            unsigned long *valuep)
{
  const char *errmsg = NULL;
 
  if (strncmp (*strp, "all", 3) == 0 || strncmp (*strp, "ALL", 3) == 0)
    {
      *strp += 3;
      *valuep = 1;
    }
  else if (strncmp (*strp, "one", 3) == 0 || strncmp (*strp, "ONE", 3) == 0)
    {
      *strp += 3;
      *valuep = 0;
    }
  else
    errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);
 
  return errmsg;
}
 
static const char *
parse_xmode (CGEN_CPU_DESC cd,
             const char **strp,
             int opindex,
             unsigned long *valuep)
{
  const char *errmsg = NULL;
 
  if (strncmp (*strp, "pm", 2) == 0 || strncmp (*strp, "PM", 2) == 0)
    {
      *strp += 2;
      *valuep = 1;
    }
  else if (strncmp (*strp, "xm", 2) == 0 || strncmp (*strp, "XM", 2) == 0)
    {
      *strp += 2;
      *valuep = 0;
    }
  else
    errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);
 
  return errmsg;
}
 
static const char *
parse_rc (CGEN_CPU_DESC cd,
          const char **strp,
          int opindex,
          unsigned long *valuep)
{
  const char *errmsg = NULL;
 
  if (strncmp (*strp, "r", 1) == 0 || strncmp (*strp, "R", 1) == 0)
    {
      *strp += 1;
      *valuep = 1;
    }
  else if (strncmp (*strp, "c", 1) == 0 || strncmp (*strp, "C", 1) == 0)
    {
      *strp += 1;
      *valuep = 0;
    }
  else
    errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);
 
  return errmsg;
}
 
static const char *
parse_cbrb (CGEN_CPU_DESC cd,
            const char **strp,
            int opindex,
            unsigned long *valuep)
{
  const char *errmsg = NULL;
 
  if (strncmp (*strp, "rb", 2) == 0 || strncmp (*strp, "RB", 2) == 0)
    {
      *strp += 2;
      *valuep = 1;
    }
  else if (strncmp (*strp, "cb", 2) == 0 || strncmp (*strp, "CB", 2) == 0)
    {
      *strp += 2;
      *valuep = 0;
    }
  else
    errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);
 
  return errmsg;
}
 
static const char *
parse_rbbc (CGEN_CPU_DESC cd,
            const char **strp,
            int opindex,
            unsigned long *valuep)
{
  const char *errmsg = NULL;
 
  if (strncmp (*strp, "rt", 2) == 0 || strncmp (*strp, "RT", 2) == 0)
    {
      *strp += 2;
      *valuep = 0;
    }
  else if (strncmp (*strp, "br1", 3) == 0 || strncmp (*strp, "BR1", 3) == 0)
    {
      *strp += 3;
      *valuep = 1;
    }
  else if (strncmp (*strp, "br2", 3) == 0 || strncmp (*strp, "BR2", 3) == 0)
    {
      *strp += 3;
      *valuep = 2;
    }
  else if (strncmp (*strp, "cs", 2) == 0 || strncmp (*strp, "CS", 2) == 0)
    {
      *strp += 2;
      *valuep = 3;
    }
  else
    errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);
 
  return errmsg;
}
 
static const char *
parse_type (CGEN_CPU_DESC cd,
            const char **strp,
            int opindex,
            unsigned long *valuep)
{
  const char *errmsg = NULL;
 
  if (strncmp (*strp, "odd", 3) == 0 || strncmp (*strp, "ODD", 3) == 0)
    {
      *strp += 3;
      *valuep = 0;
    }
  else if (strncmp (*strp, "even", 4) == 0 || strncmp (*strp, "EVEN", 4) == 0)
    {
      *strp += 4;
      *valuep = 1;
    }
  else if (strncmp (*strp, "oe", 2) == 0 || strncmp (*strp, "OE", 2) == 0)
    {
      *strp += 2;
      *valuep = 2;
    }
  else
    errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);
 
 if ((errmsg == NULL) && (*valuep == 3))
    errmsg = _("invalid operand.  type may have values 0,1,2 only.");
 
  return errmsg;
}
 
/* -- dis.c */
static void print_dollarhex (CGEN_CPU_DESC, PTR, long, unsigned, bfd_vma, int);
static void print_pcrel (CGEN_CPU_DESC, PTR, long, unsigned, bfd_vma, int);
 
static void
print_dollarhex (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
                 void * dis_info,
                 long value,
                 unsigned int attrs ATTRIBUTE_UNUSED,
                 bfd_vma pc ATTRIBUTE_UNUSED,
                 int length ATTRIBUTE_UNUSED)
{
  disassemble_info *info = (disassemble_info *) dis_info;
 
  info->fprintf_func (info->stream, "$%lx", value);
 
  if (0)
    print_normal (cd, dis_info, value, attrs, pc, length);
}
 
static void
print_pcrel (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
             void * dis_info,
             long value,
             unsigned int attrs ATTRIBUTE_UNUSED,
             bfd_vma pc ATTRIBUTE_UNUSED,
             int length ATTRIBUTE_UNUSED)
{
  print_address (cd, dis_info, value + pc, attrs, pc, length);
}
 
/* -- */
 
 
 
 
 

Browse

Tools

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.18.50/] [cpu/] [mt.opc] - Blame information for rev 252

Line No.	Rev	Author	Line
1	38	julius	`/* Morpho Technologies mRISC opcode support, for GNU Binutils. -- C --`
2			`Copyright 2001, 2007, 2008 Free Software Foundation, Inc.`
3
4			`Contributed by Red Hat Inc; developed under contract from`
5			`Morpho Technologies.`
6
7			`This file is part of the GNU Binutils.`
8
9			`This program is free software; you can redistribute it and/or modify`
10			`it under the terms of the GNU General Public License as published by`
11			`the Free Software Foundation; either version 3 of the License, or`
12			`(at your option) any later version.`
13
14			`This program is distributed in the hope that it will be useful,`
15			`but WITHOUT ANY WARRANTY; without even the implied warranty of`
16			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
17			`GNU General Public License for more details.`
18
19			`You should have received a copy of the GNU General Public License`
20			`along with this program; if not, write to the Free Software`
21			`Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,`
22			`MA 02110-1301, USA. */`
23
24
25			`/* Each section is delimited with start and end markers.`
26
27			`-opc.h additions use: "-- opc.h"`
28			`-opc.c additions use: "-- opc.c"`
29			`-asm.c additions use: "-- asm.c"`
30			`-dis.c additions use: "-- dis.c"`
31			`-ibd.h additions use: "-- ibd.h" */`
32
33			`/* -- opc.h */`
34
35			`/* Check applicability of instructions against machines. */`
36			`#define CGEN_VALIDATE_INSN_SUPPORTED`
37
38			`/* Allows reason codes to be output when assembler errors occur. */`
39			`#define CGEN_VERBOSE_ASSEMBLER_ERRORS`
40
41			`/* Override disassembly hashing - there are variable bits in the top`
42			`byte of these instructions. */`
43			`#define CGEN_DIS_HASH_SIZE 8`
44			`#define CGEN_DIS_HASH(buf, value) (((* (unsigned char *) (buf)) >> 5) % CGEN_DIS_HASH_SIZE)`
45
46			`#define CGEN_ASM_HASH_SIZE 127`
47			`#define CGEN_ASM_HASH(insn) mt_asm_hash (insn)`
48
49			`extern unsigned int mt_asm_hash (const char *);`
50
51			`extern int mt_cgen_insn_supported (CGEN_CPU_DESC, const CGEN_INSN *);`
52
53
54			`/* -- opc.c */`
55			`#include "safe-ctype.h"`
56
57			`/* Special check to ensure that instruction exists for given machine. */`
58
59			`int`
60			`mt_cgen_insn_supported (CGEN_CPU_DESC cd, const CGEN_INSN *insn)`
61			`{`
62			`int machs = CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_MACH);`
63
64			`/* No mach attribute? Assume it's supported for all machs. */`
65			`if (machs == 0)`
66			`return 1;`
67
68			`return ((machs & cd->machs) != 0);`
69			`}`
70
71			`/* A better hash function for instruction mnemonics. */`
72
73			`unsigned int`
74			`mt_asm_hash (const char* insn)`
75			`{`
76			`unsigned int hash;`
77			`const char* m = insn;`
78
79			`for (hash = 0; m && ! ISSPACE (m); m++)`
80			`hash = (hash * 23) ^ (0x1F & TOLOWER (*m));`
81
82			`/* printf ("%s %d\n", insn, (hash % CGEN_ASM_HASH_SIZE)); */`
83
84			`return hash % CGEN_ASM_HASH_SIZE;`
85			`}`
86
87
88			`/* -- asm.c */`
89			`/* Range checking for signed numbers. Returns 0 if acceptable`
90			`and 1 if the value is out of bounds for a signed quantity. */`
91
92			`static int`
93			`signed_out_of_bounds (long val)`
94			`{`
95			`if ((val < -32768) \|\| (val > 32767))`
96			`return 1;`
97			`return 0;`
98			`}`
99
100			`static const char *`
101			`parse_loopsize (CGEN_CPU_DESC cd,`
102			`const char **strp,`
103			`int opindex,`
104			`void *arg)`
105			`{`
106			`signed long * valuep = (signed long *) arg;`
107			`const char *errmsg;`
108			`bfd_reloc_code_real_type code = BFD_RELOC_NONE;`
109			`enum cgen_parse_operand_result result_type;`
110			`bfd_vma value;`
111
112			`/* Is it a control transfer instructions? */`
113			`if (opindex == (CGEN_OPERAND_TYPE) MT_OPERAND_LOOPSIZE)`
114			`{`
115			`code = BFD_RELOC_MT_PCINSN8;`
116			`errmsg = cgen_parse_address (cd, strp, opindex, code,`
117			`& result_type, & value);`
118			`*valuep = value;`
119			`return errmsg;`
120			`}`
121
122			`abort ();`
123			`}`
124
125			`static const char *`
126			`parse_imm16 (CGEN_CPU_DESC cd,`
127			`const char **strp,`
128			`int opindex,`
129			`void *arg)`
130			`{`
131			`signed long * valuep = (signed long *) arg;`
132			`const char *errmsg;`
133			`enum cgen_parse_operand_result result_type;`
134			`bfd_reloc_code_real_type code = BFD_RELOC_NONE;`
135			`bfd_vma value;`
136
137			`/* Is it a control transfer instructions? */`
138			`if (opindex == (CGEN_OPERAND_TYPE) MT_OPERAND_IMM16O)`
139			`{`
140			`code = BFD_RELOC_16_PCREL;`
141			`errmsg = cgen_parse_address (cd, strp, opindex, code,`
142			`& result_type, & value);`
143			`if (errmsg == NULL)`
144			`{`
145			`if (signed_out_of_bounds (value))`
146			`errmsg = _("Operand out of range. Must be between -32768 and 32767.");`
147			`}`
148			`*valuep = value;`
149			`return errmsg;`
150			`}`
151
152			`/* If it's not a control transfer instruction, then`
153			`we have to check for %OP relocating operators. */`
154			`if (opindex == (CGEN_OPERAND_TYPE) MT_OPERAND_IMM16L)`
155			`;`
156			`else if (strncmp (*strp, "%hi16", 5) == 0)`
157			`{`
158			`*strp += 5;`
159			`code = BFD_RELOC_HI16;`
160			`}`
161			`else if (strncmp (*strp, "%lo16", 5) == 0)`
162			`{`
163			`*strp += 5;`
164			`code = BFD_RELOC_LO16;`
165			`}`
166
167			`/* If we found a %OP relocating operator, then parse it as an address.`
168			`If not, we need to parse it as an integer, either signed or unsigned`
169			`depending on which operand type we have. */`
170			`if (code != BFD_RELOC_NONE)`
171			`{`
172			`/* %OP relocating operator found. */`
173			`errmsg = cgen_parse_address (cd, strp, opindex, code,`
174			`& result_type, & value);`
175			`if (errmsg == NULL)`
176			`{`
177			`switch (result_type)`
178			`{`
179			`case (CGEN_PARSE_OPERAND_RESULT_NUMBER):`
180			`if (code == BFD_RELOC_HI16)`
181			`value = (value >> 16) & 0xFFFF;`
182			`else if (code == BFD_RELOC_LO16)`
183			`value = value & 0xFFFF;`
184			`else`
185			`errmsg = _("Biiiig Trouble in parse_imm16!");`
186			`break;`
187
188			`case (CGEN_PARSE_OPERAND_RESULT_QUEUED):`
189			`/* No special processing for this case. */`
190			`break;`
191
192			`default:`
193			`errmsg = _("The percent-operator's operand is not a symbol");`
194			`break;`
195			`}`
196			`}`
197			`*valuep = value;`
198			`}`
199			`else`
200			`{`
201			`/* Parse hex values like 0xffff as unsigned, and sign extend`
202			`them manually. */`
203			`int parse_signed = (opindex == (CGEN_OPERAND_TYPE)MT_OPERAND_IMM16);`
204
205			`if ((*strp)[0] == '0'`
206			`&& ((strp)[1] == 'x' \|\| (strp)[1] == 'X'))`
207			`parse_signed = 0;`
208
209			`/* No relocating operator. Parse as an number. */`
210			`if (parse_signed)`
211			`{`
212			`/* Parse as as signed integer. */`
213
214			`errmsg = cgen_parse_signed_integer (cd, strp, opindex, valuep);`
215
216			`if (errmsg == NULL)`
217			`{`
218			`#if 0`
219			`/* Manual range checking is needed for the signed case. */`
220			`if (*valuep & 0x8000)`
221			`value = 0xffff0000 \| *valuep;`
222			`else`
223			`value = *valuep;`
224
225			`if (signed_out_of_bounds (value))`
226			`errmsg = _("Operand out of range. Must be between -32768 and 32767.");`
227			`/* Truncate to 16 bits. This is necessary`
228			`because cgen will have sign extended valuep. /`
229			`*valuep &= 0xFFFF;`
230			`#endif`
231			`}`
232			`}`
233			`else`
234			`{`
235			`/* MT_OPERAND_IMM16Z. Parse as an unsigned integer. */`
236			`errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, (unsigned long *) valuep);`
237
238			`if (opindex == (CGEN_OPERAND_TYPE) MT_OPERAND_IMM16`
239			`&& *valuep >= 0x8000`
240			`&& *valuep <= 0xffff)`
241			`*valuep -= 0x10000;`
242			`}`
243			`}`
244
245			`return errmsg;`
246			`}`
247
248
249			`static const char *`
250			`parse_dup (CGEN_CPU_DESC cd,`
251			`const char **strp,`
252			`int opindex,`
253			`unsigned long *valuep)`
254			`{`
255			`const char *errmsg = NULL;`
256
257			`if (strncmp (strp, "dup", 3) == 0 \|\| strncmp (strp, "DUP", 3) == 0)`
258			`{`
259			`*strp += 3;`
260			`*valuep = 1;`
261			`}`
262			`else if (strncmp (strp, "xx", 2) == 0 \|\| strncmp (strp, "XX", 2) == 0)`
263			`{`
264			`*strp += 2;`
265			`*valuep = 0;`
266			`}`
267			`else`
268			`errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);`
269
270			`return errmsg;`
271			`}`
272
273
274			`static const char *`
275			`parse_ball (CGEN_CPU_DESC cd,`
276			`const char **strp,`
277			`int opindex,`
278			`unsigned long *valuep)`
279			`{`
280			`const char *errmsg = NULL;`
281
282			`if (strncmp (strp, "all", 3) == 0 \|\| strncmp (strp, "ALL", 3) == 0)`
283			`{`
284			`*strp += 3;`
285			`*valuep = 1;`
286			`}`
287			`else if (strncmp (strp, "one", 3) == 0 \|\| strncmp (strp, "ONE", 3) == 0)`
288			`{`
289			`*strp += 3;`
290			`*valuep = 0;`
291			`}`
292			`else`
293			`errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);`
294
295			`return errmsg;`
296			`}`
297
298			`static const char *`
299			`parse_xmode (CGEN_CPU_DESC cd,`
300			`const char **strp,`
301			`int opindex,`
302			`unsigned long *valuep)`
303			`{`
304			`const char *errmsg = NULL;`
305
306			`if (strncmp (strp, "pm", 2) == 0 \|\| strncmp (strp, "PM", 2) == 0)`
307			`{`
308			`*strp += 2;`
309			`*valuep = 1;`
310			`}`
311			`else if (strncmp (strp, "xm", 2) == 0 \|\| strncmp (strp, "XM", 2) == 0)`
312			`{`
313			`*strp += 2;`
314			`*valuep = 0;`
315			`}`
316			`else`
317			`errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);`
318
319			`return errmsg;`
320			`}`
321
322			`static const char *`
323			`parse_rc (CGEN_CPU_DESC cd,`
324			`const char **strp,`
325			`int opindex,`
326			`unsigned long *valuep)`
327			`{`
328			`const char *errmsg = NULL;`
329
330			`if (strncmp (strp, "r", 1) == 0 \|\| strncmp (strp, "R", 1) == 0)`
331			`{`
332			`*strp += 1;`
333			`*valuep = 1;`
334			`}`
335			`else if (strncmp (strp, "c", 1) == 0 \|\| strncmp (strp, "C", 1) == 0)`
336			`{`
337			`*strp += 1;`
338			`*valuep = 0;`
339			`}`
340			`else`
341			`errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);`
342
343			`return errmsg;`
344			`}`
345
346			`static const char *`
347			`parse_cbrb (CGEN_CPU_DESC cd,`
348			`const char **strp,`
349			`int opindex,`
350			`unsigned long *valuep)`
351			`{`
352			`const char *errmsg = NULL;`
353
354			`if (strncmp (strp, "rb", 2) == 0 \|\| strncmp (strp, "RB", 2) == 0)`
355			`{`
356			`*strp += 2;`
357			`*valuep = 1;`
358			`}`
359			`else if (strncmp (strp, "cb", 2) == 0 \|\| strncmp (strp, "CB", 2) == 0)`
360			`{`
361			`*strp += 2;`
362			`*valuep = 0;`
363			`}`
364			`else`
365			`errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);`
366
367			`return errmsg;`
368			`}`
369
370			`static const char *`
371			`parse_rbbc (CGEN_CPU_DESC cd,`
372			`const char **strp,`
373			`int opindex,`
374			`unsigned long *valuep)`
375			`{`
376			`const char *errmsg = NULL;`
377
378			`if (strncmp (strp, "rt", 2) == 0 \|\| strncmp (strp, "RT", 2) == 0)`
379			`{`
380			`*strp += 2;`
381			`*valuep = 0;`
382			`}`
383			`else if (strncmp (strp, "br1", 3) == 0 \|\| strncmp (strp, "BR1", 3) == 0)`
384			`{`
385			`*strp += 3;`
386			`*valuep = 1;`
387			`}`
388			`else if (strncmp (strp, "br2", 3) == 0 \|\| strncmp (strp, "BR2", 3) == 0)`
389			`{`
390			`*strp += 3;`
391			`*valuep = 2;`
392			`}`
393			`else if (strncmp (strp, "cs", 2) == 0 \|\| strncmp (strp, "CS", 2) == 0)`
394			`{`
395			`*strp += 2;`
396			`*valuep = 3;`
397			`}`
398			`else`
399			`errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);`
400
401			`return errmsg;`
402			`}`
403
404			`static const char *`
405			`parse_type (CGEN_CPU_DESC cd,`
406			`const char **strp,`
407			`int opindex,`
408			`unsigned long *valuep)`
409			`{`
410			`const char *errmsg = NULL;`
411
412			`if (strncmp (strp, "odd", 3) == 0 \|\| strncmp (strp, "ODD", 3) == 0)`
413			`{`
414			`*strp += 3;`
415			`*valuep = 0;`
416			`}`
417			`else if (strncmp (strp, "even", 4) == 0 \|\| strncmp (strp, "EVEN", 4) == 0)`
418			`{`
419			`*strp += 4;`
420			`*valuep = 1;`
421			`}`
422			`else if (strncmp (strp, "oe", 2) == 0 \|\| strncmp (strp, "OE", 2) == 0)`
423			`{`
424			`*strp += 2;`
425			`*valuep = 2;`
426			`}`
427			`else`
428			`errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);`
429
430			`if ((errmsg == NULL) && (*valuep == 3))`
431			`errmsg = _("invalid operand. type may have values 0,1,2 only.");`
432
433			`return errmsg;`
434			`}`
435
436			`/* -- dis.c */`
437			`static void print_dollarhex (CGEN_CPU_DESC, PTR, long, unsigned, bfd_vma, int);`
438			`static void print_pcrel (CGEN_CPU_DESC, PTR, long, unsigned, bfd_vma, int);`
439
440			`static void`
441			`print_dollarhex (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,`
442			`void * dis_info,`
443			`long value,`
444			`unsigned int attrs ATTRIBUTE_UNUSED,`
445			`bfd_vma pc ATTRIBUTE_UNUSED,`
446			`int length ATTRIBUTE_UNUSED)`
447			`{`
448			`disassemble_info info = (disassemble_info ) dis_info;`
449
450			`info->fprintf_func (info->stream, "$%lx", value);`
451
452			`if (0)`
453			`print_normal (cd, dis_info, value, attrs, pc, length);`
454			`}`
455
456			`static void`
457			`print_pcrel (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,`
458			`void * dis_info,`
459			`long value,`
460			`unsigned int attrs ATTRIBUTE_UNUSED,`
461			`bfd_vma pc ATTRIBUTE_UNUSED,`
462			`int length ATTRIBUTE_UNUSED)`
463			`{`
464			`print_address (cd, dis_info, value + pc, attrs, pc, length);`
465			`}`
466
467			`/* -- */`
468
469
470
471
472