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

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [opcodes/] [openrisc-desc.c] - Blame information for rev 53

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

Line No. Rev Author Line
1 18 khays 
/* CPU data for openrisc.
2 
 
3 
THIS FILE IS MACHINE GENERATED WITH CGEN.
4 
 
5 
Copyright 1996-2010 Free Software Foundation, Inc.
6 
 
7 
This file is part of the GNU Binutils and/or GDB, the GNU debugger.
8 
 
9 
   This file 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, or (at your option)
12 
   any later version.
13 
 
14 
   It is distributed in the hope that it will be useful, but WITHOUT
15 
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
16 
   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
17 
   License for more details.
18 
 
19 
   You should have received a copy of the GNU General Public License along
20 
   with this program; if not, write to the Free Software Foundation, Inc.,
21 
   51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
22 
 
23 
*/
24 
 
25 
#include "sysdep.h"
26 
#include <stdio.h>
27 
#include <stdarg.h>
28 
#include "ansidecl.h"
29 
#include "bfd.h"
30 
#include "symcat.h"
31 
#include "openrisc-desc.h"
32 
#include "openrisc-opc.h"
33 
#include "opintl.h"
34 
#include "libiberty.h"
35 
#include "xregex.h"
36 
 
37 
/* Attributes.  */
38 
 
39 
static const CGEN_ATTR_ENTRY bool_attr[] =
40 
{
41 
  { "#f", 0 },
42 
  { "#t", 1 },
43 
  { 0, 0 }
44 
};
45 
 
46 
static const CGEN_ATTR_ENTRY MACH_attr[] ATTRIBUTE_UNUSED =
47 
{
48 
  { "base", MACH_BASE },
49 
  { "openrisc", MACH_OPENRISC },
50 
  { "or1300", MACH_OR1300 },
51 
  { "max", MACH_MAX },
52 
  { 0, 0 }
53 
};
54 
 
55 
static const CGEN_ATTR_ENTRY ISA_attr[] ATTRIBUTE_UNUSED =
56 
{
57 
  { "or32", ISA_OR32 },
58 
  { "max", ISA_MAX },
59 
  { 0, 0 }
60 
};
61 
 
62 
static const CGEN_ATTR_ENTRY HAS_CACHE_attr[] ATTRIBUTE_UNUSED =
63 
{
64 
  { "DATA_CACHE", HAS_CACHE_DATA_CACHE },
65 
  { "INSN_CACHE", HAS_CACHE_INSN_CACHE },
66 
  { 0, 0 }
67 
};
68 
 
69 
const CGEN_ATTR_TABLE openrisc_cgen_ifield_attr_table[] =
70 
{
71 
  { "MACH", & MACH_attr[0], & MACH_attr[0] },
72 
  { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
73 
  { "PCREL-ADDR", &bool_attr[0], &bool_attr[0] },
74 
  { "ABS-ADDR", &bool_attr[0], &bool_attr[0] },
75 
  { "RESERVED", &bool_attr[0], &bool_attr[0] },
76 
  { "SIGN-OPT", &bool_attr[0], &bool_attr[0] },
77 
  { "SIGNED", &bool_attr[0], &bool_attr[0] },
78 
  { 0, 0, 0 }
79 
};
80 
 
81 
const CGEN_ATTR_TABLE openrisc_cgen_hardware_attr_table[] =
82 
{
83 
  { "MACH", & MACH_attr[0], & MACH_attr[0] },
84 
  { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
85 
  { "CACHE-ADDR", &bool_attr[0], &bool_attr[0] },
86 
  { "PC", &bool_attr[0], &bool_attr[0] },
87 
  { "PROFILE", &bool_attr[0], &bool_attr[0] },
88 
  { 0, 0, 0 }
89 
};
90 
 
91 
const CGEN_ATTR_TABLE openrisc_cgen_operand_attr_table[] =
92 
{
93 
  { "MACH", & MACH_attr[0], & MACH_attr[0] },
94 
  { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
95 
  { "PCREL-ADDR", &bool_attr[0], &bool_attr[0] },
96 
  { "ABS-ADDR", &bool_attr[0], &bool_attr[0] },
97 
  { "SIGN-OPT", &bool_attr[0], &bool_attr[0] },
98 
  { "SIGNED", &bool_attr[0], &bool_attr[0] },
99 
  { "NEGATIVE", &bool_attr[0], &bool_attr[0] },
100 
  { "RELAX", &bool_attr[0], &bool_attr[0] },
101 
  { "SEM-ONLY", &bool_attr[0], &bool_attr[0] },
102 
  { 0, 0, 0 }
103 
};
104 
 
105 
const CGEN_ATTR_TABLE openrisc_cgen_insn_attr_table[] =
106 
{
107 
  { "MACH", & MACH_attr[0], & MACH_attr[0] },
108 
  { "ALIAS", &bool_attr[0], &bool_attr[0] },
109 
  { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
110 
  { "UNCOND-CTI", &bool_attr[0], &bool_attr[0] },
111 
  { "COND-CTI", &bool_attr[0], &bool_attr[0] },
112 
  { "SKIP-CTI", &bool_attr[0], &bool_attr[0] },
113 
  { "DELAY-SLOT", &bool_attr[0], &bool_attr[0] },
114 
  { "RELAXABLE", &bool_attr[0], &bool_attr[0] },
115 
  { "RELAXED", &bool_attr[0], &bool_attr[0] },
116 
  { "NO-DIS", &bool_attr[0], &bool_attr[0] },
117 
  { "PBB", &bool_attr[0], &bool_attr[0] },
118 
  { "NOT-IN-DELAY-SLOT", &bool_attr[0], &bool_attr[0] },
119 
  { 0, 0, 0 }
120 
};
121 
 
122 
/* Instruction set variants.  */
123 
 
124 
static const CGEN_ISA openrisc_cgen_isa_table[] = {
125 
  { "or32", 32, 32, 32, 32 },
126 
  { 0, 0, 0, 0, 0 }
127 
};
128 
 
129 
/* Machine variants.  */
130 
 
131 
static const CGEN_MACH openrisc_cgen_mach_table[] = {
132 
  { "openrisc", "openrisc", MACH_OPENRISC, 0 },
133 
  { "or1300", "openrisc:1300", MACH_OR1300, 0 },
134 
  { 0, 0, 0, 0 }
135 
};
136 
 
137 
static CGEN_KEYWORD_ENTRY openrisc_cgen_opval_h_gr_entries[] =
138 
{
139 
  { "r0", 0, {0, {{{0, 0}}}}, 0, 0 },
140 
  { "r1", 1, {0, {{{0, 0}}}}, 0, 0 },
141 
  { "r2", 2, {0, {{{0, 0}}}}, 0, 0 },
142 
  { "r3", 3, {0, {{{0, 0}}}}, 0, 0 },
143 
  { "r4", 4, {0, {{{0, 0}}}}, 0, 0 },
144 
  { "r5", 5, {0, {{{0, 0}}}}, 0, 0 },
145 
  { "r6", 6, {0, {{{0, 0}}}}, 0, 0 },
146 
  { "r7", 7, {0, {{{0, 0}}}}, 0, 0 },
147 
  { "r8", 8, {0, {{{0, 0}}}}, 0, 0 },
148 
  { "r9", 9, {0, {{{0, 0}}}}, 0, 0 },
149 
  { "r10", 10, {0, {{{0, 0}}}}, 0, 0 },
150 
  { "r11", 11, {0, {{{0, 0}}}}, 0, 0 },
151 
  { "r12", 12, {0, {{{0, 0}}}}, 0, 0 },
152 
  { "r13", 13, {0, {{{0, 0}}}}, 0, 0 },
153 
  { "r14", 14, {0, {{{0, 0}}}}, 0, 0 },
154 
  { "r15", 15, {0, {{{0, 0}}}}, 0, 0 },
155 
  { "r16", 16, {0, {{{0, 0}}}}, 0, 0 },
156 
  { "r17", 17, {0, {{{0, 0}}}}, 0, 0 },
157 
  { "r18", 18, {0, {{{0, 0}}}}, 0, 0 },
158 
  { "r19", 19, {0, {{{0, 0}}}}, 0, 0 },
159 
  { "r20", 20, {0, {{{0, 0}}}}, 0, 0 },
160 
  { "r21", 21, {0, {{{0, 0}}}}, 0, 0 },
161 
  { "r22", 22, {0, {{{0, 0}}}}, 0, 0 },
162 
  { "r23", 23, {0, {{{0, 0}}}}, 0, 0 },
163 
  { "r24", 24, {0, {{{0, 0}}}}, 0, 0 },
164 
  { "r25", 25, {0, {{{0, 0}}}}, 0, 0 },
165 
  { "r26", 26, {0, {{{0, 0}}}}, 0, 0 },
166 
  { "r27", 27, {0, {{{0, 0}}}}, 0, 0 },
167 
  { "r28", 28, {0, {{{0, 0}}}}, 0, 0 },
168 
  { "r29", 29, {0, {{{0, 0}}}}, 0, 0 },
169 
  { "r30", 30, {0, {{{0, 0}}}}, 0, 0 },
170 
  { "r31", 31, {0, {{{0, 0}}}}, 0, 0 },
171 
  { "lr", 11, {0, {{{0, 0}}}}, 0, 0 },
172 
  { "sp", 1, {0, {{{0, 0}}}}, 0, 0 },
173 
  { "fp", 2, {0, {{{0, 0}}}}, 0, 0 }
174 
};
175 
 
176 
CGEN_KEYWORD openrisc_cgen_opval_h_gr =
177 
{
178 
  & openrisc_cgen_opval_h_gr_entries[0],
179 
  35,
180 
  0, 0, 0, 0, ""
181 
};
182 
 
183 
 
184 
/* The hardware table.  */
185 
 
186 
#define A(a) (1 << CGEN_HW_##a)
187 
 
188 
const CGEN_HW_ENTRY openrisc_cgen_hw_table[] =
189 
{
190 
  { "h-memory", HW_H_MEMORY, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
191 
  { "h-sint", HW_H_SINT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
192 
  { "h-uint", HW_H_UINT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
193 
  { "h-addr", HW_H_ADDR, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
194 
  { "h-iaddr", HW_H_IADDR, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
195 
  { "h-pc", HW_H_PC, CGEN_ASM_NONE, 0, { 0|A(PROFILE)|A(PC), { { { (1<<MACH_BASE), 0 } } } } },
196 
  { "h-gr", HW_H_GR, CGEN_ASM_KEYWORD, (PTR) & openrisc_cgen_opval_h_gr, { 0|A(PROFILE), { { { (1<<MACH_BASE), 0 } } } } },
197 
  { "h-sr", HW_H_SR, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
198 
  { "h-hi16", HW_H_HI16, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
199 
  { "h-lo16", HW_H_LO16, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
200 
  { "h-cbit", HW_H_CBIT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
201 
  { "h-delay-insn", HW_H_DELAY_INSN, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
202 
  { 0, 0, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } }
203 
};
204 
 
205 
#undef A
206 
 
207 
 
208 
/* The instruction field table.  */
209 
 
210 
#define A(a) (1 << CGEN_IFLD_##a)
211 
 
212 
const CGEN_IFLD openrisc_cgen_ifld_table[] =
213 
{
214 
  { OPENRISC_F_NIL, "f-nil", 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
215 
  { OPENRISC_F_ANYOF, "f-anyof", 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
216 
  { OPENRISC_F_CLASS, "f-class", 0, 32, 31, 2, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
217 
  { OPENRISC_F_SUB, "f-sub", 0, 32, 29, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
218 
  { OPENRISC_F_R1, "f-r1", 0, 32, 25, 5, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
219 
  { OPENRISC_F_R2, "f-r2", 0, 32, 20, 5, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
220 
  { OPENRISC_F_R3, "f-r3", 0, 32, 15, 5, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
221 
  { OPENRISC_F_SIMM16, "f-simm16", 0, 32, 15, 16, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
222 
  { OPENRISC_F_UIMM16, "f-uimm16", 0, 32, 15, 16, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
223 
  { OPENRISC_F_UIMM5, "f-uimm5", 0, 32, 4, 5, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
224 
  { OPENRISC_F_HI16, "f-hi16", 0, 32, 15, 16, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
225 
  { OPENRISC_F_LO16, "f-lo16", 0, 32, 15, 16, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
226 
  { OPENRISC_F_OP1, "f-op1", 0, 32, 31, 2, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
227 
  { OPENRISC_F_OP2, "f-op2", 0, 32, 29, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
228 
  { OPENRISC_F_OP3, "f-op3", 0, 32, 25, 2, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
229 
  { OPENRISC_F_OP4, "f-op4", 0, 32, 23, 3, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
230 
  { OPENRISC_F_OP5, "f-op5", 0, 32, 25, 5, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
231 
  { OPENRISC_F_OP6, "f-op6", 0, 32, 7, 3, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
232 
  { OPENRISC_F_OP7, "f-op7", 0, 32, 3, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
233 
  { OPENRISC_F_I16_1, "f-i16-1", 0, 32, 10, 11, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
234 
  { OPENRISC_F_I16_2, "f-i16-2", 0, 32, 25, 5, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
235 
  { OPENRISC_F_DISP26, "f-disp26", 0, 32, 25, 26, { 0|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
236 
  { OPENRISC_F_ABS26, "f-abs26", 0, 32, 25, 26, { 0|A(ABS_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
237 
  { OPENRISC_F_I16NC, "f-i16nc", 0, 0, 0, 0,{ 0|A(SIGN_OPT)|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } }  },
238 
  { OPENRISC_F_F_15_8, "f-f-15-8", 0, 32, 15, 8, { 0|A(RESERVED), { { { (1<<MACH_BASE), 0 } } } }  },
239 
  { OPENRISC_F_F_10_3, "f-f-10-3", 0, 32, 10, 3, { 0|A(RESERVED), { { { (1<<MACH_BASE), 0 } } } }  },
240 
  { OPENRISC_F_F_4_1, "f-f-4-1", 0, 32, 4, 1, { 0|A(RESERVED), { { { (1<<MACH_BASE), 0 } } } }  },
241 
  { OPENRISC_F_F_7_3, "f-f-7-3", 0, 32, 7, 3, { 0|A(RESERVED), { { { (1<<MACH_BASE), 0 } } } }  },
242 
  { OPENRISC_F_F_10_7, "f-f-10-7", 0, 32, 10, 7, { 0|A(RESERVED), { { { (1<<MACH_BASE), 0 } } } }  },
243 
  { OPENRISC_F_F_10_11, "f-f-10-11", 0, 32, 10, 11, { 0|A(RESERVED), { { { (1<<MACH_BASE), 0 } } } }  },
244 
  { 0, 0, 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } }
245 
};
246 
 
247 
#undef A
248 
 
249 
 
250 
 
251 
/* multi ifield declarations */
252 
 
253 
const CGEN_MAYBE_MULTI_IFLD OPENRISC_F_I16NC_MULTI_IFIELD [];
254 
 
255 
 
256 
/* multi ifield definitions */
257 
 
258 
const CGEN_MAYBE_MULTI_IFLD OPENRISC_F_I16NC_MULTI_IFIELD [] =
259 
{
260 
    { 0, { (const PTR) &openrisc_cgen_ifld_table[OPENRISC_F_I16_1] } },
261 
    { 0, { (const PTR) &openrisc_cgen_ifld_table[OPENRISC_F_I16_2] } },
262 
    { 0, { (const PTR) 0 } }
263 
};
264 
 
265 
/* The operand table.  */
266 
 
267 
#define A(a) (1 << CGEN_OPERAND_##a)
268 
#define OPERAND(op) OPENRISC_OPERAND_##op
269 
 
270 
const CGEN_OPERAND openrisc_cgen_operand_table[] =
271 
{
272 
/* pc: program counter */
273 
  { "pc", OPENRISC_OPERAND_PC, HW_H_PC, 0, 0,
274 
    { 0, { (const PTR) &openrisc_cgen_ifld_table[OPENRISC_F_NIL] } },
275 
    { 0|A(SEM_ONLY), { { { (1<<MACH_BASE), 0 } } } }  },
276 
/* sr: special register */
277 
  { "sr", OPENRISC_OPERAND_SR, HW_H_SR, 0, 0,
278 
    { 0, { (const PTR) 0 } },
279 
    { 0|A(SEM_ONLY), { { { (1<<MACH_BASE), 0 } } } }  },
280 
/* cbit: condition bit */
281 
  { "cbit", OPENRISC_OPERAND_CBIT, HW_H_CBIT, 0, 0,
282 
    { 0, { (const PTR) 0 } },
283 
    { 0|A(SEM_ONLY), { { { (1<<MACH_BASE), 0 } } } }  },
284 
/* simm-16: 16 bit signed immediate */
285 
  { "simm-16", OPENRISC_OPERAND_SIMM_16, HW_H_SINT, 15, 16,
286 
    { 0, { (const PTR) &openrisc_cgen_ifld_table[OPENRISC_F_SIMM16] } },
287 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
288 
/* uimm-16: 16 bit unsigned immediate */
289 
  { "uimm-16", OPENRISC_OPERAND_UIMM_16, HW_H_UINT, 15, 16,
290 
    { 0, { (const PTR) &openrisc_cgen_ifld_table[OPENRISC_F_UIMM16] } },
291 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
292 
/* disp-26: pc-rel 26 bit */
293 
  { "disp-26", OPENRISC_OPERAND_DISP_26, HW_H_IADDR, 25, 26,
294 
    { 0, { (const PTR) &openrisc_cgen_ifld_table[OPENRISC_F_DISP26] } },
295 
    { 0|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
296 
/* abs-26: abs 26 bit */
297 
  { "abs-26", OPENRISC_OPERAND_ABS_26, HW_H_IADDR, 25, 26,
298 
    { 0, { (const PTR) &openrisc_cgen_ifld_table[OPENRISC_F_ABS26] } },
299 
    { 0|A(ABS_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
300 
/* uimm-5: imm5 */
301 
  { "uimm-5", OPENRISC_OPERAND_UIMM_5, HW_H_UINT, 4, 5,
302 
    { 0, { (const PTR) &openrisc_cgen_ifld_table[OPENRISC_F_UIMM5] } },
303 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
304 
/* rD: destination register */
305 
  { "rD", OPENRISC_OPERAND_RD, HW_H_GR, 25, 5,
306 
    { 0, { (const PTR) &openrisc_cgen_ifld_table[OPENRISC_F_R1] } },
307 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
308 
/* rA: source register A */
309 
  { "rA", OPENRISC_OPERAND_RA, HW_H_GR, 20, 5,
310 
    { 0, { (const PTR) &openrisc_cgen_ifld_table[OPENRISC_F_R2] } },
311 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
312 
/* rB: source register B */
313 
  { "rB", OPENRISC_OPERAND_RB, HW_H_GR, 15, 5,
314 
    { 0, { (const PTR) &openrisc_cgen_ifld_table[OPENRISC_F_R3] } },
315 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
316 
/* op-f-23: f-op23 */
317 
  { "op-f-23", OPENRISC_OPERAND_OP_F_23, HW_H_UINT, 23, 3,
318 
    { 0, { (const PTR) &openrisc_cgen_ifld_table[OPENRISC_F_OP4] } },
319 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
320 
/* op-f-3: f-op3 */
321 
  { "op-f-3", OPENRISC_OPERAND_OP_F_3, HW_H_UINT, 25, 5,
322 
    { 0, { (const PTR) &openrisc_cgen_ifld_table[OPENRISC_F_OP5] } },
323 
    { 0, { { { (1<<MACH_BASE), 0 } } } }  },
324 
/* hi16: high 16 bit immediate, sign optional */
325 
  { "hi16", OPENRISC_OPERAND_HI16, HW_H_HI16, 15, 16,
326 
    { 0, { (const PTR) &openrisc_cgen_ifld_table[OPENRISC_F_SIMM16] } },
327 
    { 0|A(SIGN_OPT), { { { (1<<MACH_BASE), 0 } } } }  },
328 
/* lo16: low 16 bit immediate, sign optional */
329 
  { "lo16", OPENRISC_OPERAND_LO16, HW_H_LO16, 15, 16,
330 
    { 0, { (const PTR) &openrisc_cgen_ifld_table[OPENRISC_F_LO16] } },
331 
    { 0|A(SIGN_OPT), { { { (1<<MACH_BASE), 0 } } } }  },
332 
/* ui16nc: 16 bit immediate, sign optional */
333 
  { "ui16nc", OPENRISC_OPERAND_UI16NC, HW_H_LO16, 10, 16,
334 
    { 2, { (const PTR) &OPENRISC_F_I16NC_MULTI_IFIELD[0] } },
335 
    { 0|A(SIGN_OPT)|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } }  },
336 
/* sentinel */
337 
  { 0, 0, 0, 0, 0,
338 
    { 0, { (const PTR) 0 } },
339 
    { 0, { { { (1<<MACH_BASE), 0 } } } } }
340 
};
341 
 
342 
#undef A
343 
 
344 
 
345 
/* The instruction table.  */
346 
 
347 
#define OP(field) CGEN_SYNTAX_MAKE_FIELD (OPERAND (field))
348 
#define A(a) (1 << CGEN_INSN_##a)
349 
 
350 
static const CGEN_IBASE openrisc_cgen_insn_table[MAX_INSNS] =
351 
{
352 
  /* Special null first entry.
353 
     A `num' value of zero is thus invalid.
354 
     Also, the special `invalid' insn resides here.  */
355 
  { 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
356 
/* l.j ${abs-26} */
357 
  {
358 
    OPENRISC_INSN_L_J, "l-j", "l.j", 32,
359 
    { 0|A(NOT_IN_DELAY_SLOT)|A(UNCOND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
360 
  },
361 
/* l.jal ${abs-26} */
362 
  {
363 
    OPENRISC_INSN_L_JAL, "l-jal", "l.jal", 32,
364 
    { 0|A(NOT_IN_DELAY_SLOT)|A(UNCOND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
365 
  },
366 
/* l.jr $rA */
367 
  {
368 
    OPENRISC_INSN_L_JR, "l-jr", "l.jr", 32,
369 
    { 0|A(NOT_IN_DELAY_SLOT)|A(UNCOND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
370 
  },
371 
/* l.jalr $rA */
372 
  {
373 
    OPENRISC_INSN_L_JALR, "l-jalr", "l.jalr", 32,
374 
    { 0|A(NOT_IN_DELAY_SLOT)|A(UNCOND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
375 
  },
376 
/* l.bal ${disp-26} */
377 
  {
378 
    OPENRISC_INSN_L_BAL, "l-bal", "l.bal", 32,
379 
    { 0|A(NOT_IN_DELAY_SLOT)|A(UNCOND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
380 
  },
381 
/* l.bnf ${disp-26} */
382 
  {
383 
    OPENRISC_INSN_L_BNF, "l-bnf", "l.bnf", 32,
384 
    { 0|A(NOT_IN_DELAY_SLOT)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
385 
  },
386 
/* l.bf ${disp-26} */
387 
  {
388 
    OPENRISC_INSN_L_BF, "l-bf", "l.bf", 32,
389 
    { 0|A(NOT_IN_DELAY_SLOT)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
390 
  },
391 
/* l.brk ${uimm-16} */
392 
  {
393 
    OPENRISC_INSN_L_BRK, "l-brk", "l.brk", 32,
394 
    { 0|A(NOT_IN_DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
395 
  },
396 
/* l.rfe $rA */
397 
  {
398 
    OPENRISC_INSN_L_RFE, "l-rfe", "l.rfe", 32,
399 
    { 0|A(NOT_IN_DELAY_SLOT)|A(UNCOND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
400 
  },
401 
/* l.sys ${uimm-16} */
402 
  {
403 
    OPENRISC_INSN_L_SYS, "l-sys", "l.sys", 32,
404 
    { 0|A(NOT_IN_DELAY_SLOT)|A(UNCOND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
405 
  },
406 
/* l.nop */
407 
  {
408 
    OPENRISC_INSN_L_NOP, "l-nop", "l.nop", 32,
409 
    { 0, { { { (1<<MACH_BASE), 0 } } } }
410 
  },
411 
/* l.movhi $rD,$hi16 */
412 
  {
413 
    OPENRISC_INSN_L_MOVHI, "l-movhi", "l.movhi", 32,
414 
    { 0|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
415 
  },
416 
/* l.mfsr $rD,$rA */
417 
  {
418 
    OPENRISC_INSN_L_MFSR, "l-mfsr", "l.mfsr", 32,
419 
    { 0|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
420 
  },
421 
/* l.mtsr $rA,$rB */
422 
  {
423 
    OPENRISC_INSN_L_MTSR, "l-mtsr", "l.mtsr", 32,
424 
    { 0|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
425 
  },
426 
/* l.lw $rD,${simm-16}($rA) */
427 
  {
428 
    OPENRISC_INSN_L_LW, "l-lw", "l.lw", 32,
429 
    { 0|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
430 
  },
431 
/* l.lbz $rD,${simm-16}($rA) */
432 
  {
433 
    OPENRISC_INSN_L_LBZ, "l-lbz", "l.lbz", 32,
434 
    { 0|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
435 
  },
436 
/* l.lbs $rD,${simm-16}($rA) */
437 
  {
438 
    OPENRISC_INSN_L_LBS, "l-lbs", "l.lbs", 32,
439 
    { 0|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
440 
  },
441 
/* l.lhz $rD,${simm-16}($rA) */
442 
  {
443 
    OPENRISC_INSN_L_LHZ, "l-lhz", "l.lhz", 32,
444 
    { 0|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
445 
  },
446 
/* l.lhs $rD,${simm-16}($rA) */
447 
  {
448 
    OPENRISC_INSN_L_LHS, "l-lhs", "l.lhs", 32,
449 
    { 0|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
450 
  },
451 
/* l.sw ${ui16nc}($rA),$rB */
452 
  {
453 
    OPENRISC_INSN_L_SW, "l-sw", "l.sw", 32,
454 
    { 0|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
455 
  },
456 
/* l.sb ${ui16nc}($rA),$rB */
457 
  {
458 
    OPENRISC_INSN_L_SB, "l-sb", "l.sb", 32,
459 
    { 0|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
460 
  },
461 
/* l.sh ${ui16nc}($rA),$rB */
462 
  {
463 
    OPENRISC_INSN_L_SH, "l-sh", "l.sh", 32,
464 
    { 0|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
465 
  },
466 
/* l.sll $rD,$rA,$rB */
467 
  {
468 
    OPENRISC_INSN_L_SLL, "l-sll", "l.sll", 32,
469 
    { 0, { { { (1<<MACH_BASE), 0 } } } }
470 
  },
471 
/* l.slli $rD,$rA,${uimm-5} */
472 
  {
473 
    OPENRISC_INSN_L_SLLI, "l-slli", "l.slli", 32,
474 
    { 0, { { { (1<<MACH_BASE), 0 } } } }
475 
  },
476 
/* l.srl $rD,$rA,$rB */
477 
  {
478 
    OPENRISC_INSN_L_SRL, "l-srl", "l.srl", 32,
479 
    { 0, { { { (1<<MACH_BASE), 0 } } } }
480 
  },
481 
/* l.srli $rD,$rA,${uimm-5} */
482 
  {
483 
    OPENRISC_INSN_L_SRLI, "l-srli", "l.srli", 32,
484 
    { 0, { { { (1<<MACH_BASE), 0 } } } }
485 
  },
486 
/* l.sra $rD,$rA,$rB */
487 
  {
488 
    OPENRISC_INSN_L_SRA, "l-sra", "l.sra", 32,
489 
    { 0, { { { (1<<MACH_BASE), 0 } } } }
490 
  },
491 
/* l.srai $rD,$rA,${uimm-5} */
492 
  {
493 
    OPENRISC_INSN_L_SRAI, "l-srai", "l.srai", 32,
494 
    { 0, { { { (1<<MACH_BASE), 0 } } } }
495 
  },
496 
/* l.ror $rD,$rA,$rB */
497 
  {
498 
    OPENRISC_INSN_L_ROR, "l-ror", "l.ror", 32,
499 
    { 0, { { { (1<<MACH_BASE), 0 } } } }
500 
  },
501 
/* l.rori $rD,$rA,${uimm-5} */
502 
  {
503 
    OPENRISC_INSN_L_RORI, "l-rori", "l.rori", 32,
504 
    { 0, { { { (1<<MACH_BASE), 0 } } } }
505 
  },
506 
/* l.add $rD,$rA,$rB */
507 
  {
508 
    OPENRISC_INSN_L_ADD, "l-add", "l.add", 32,
509 
    { 0, { { { (1<<MACH_BASE), 0 } } } }
510 
  },
511 
/* l.addi $rD,$rA,$lo16 */
512 
  {
513 
    OPENRISC_INSN_L_ADDI, "l-addi", "l.addi", 32,
514 
    { 0, { { { (1<<MACH_BASE), 0 } } } }
515 
  },
516 
/* l.sub $rD,$rA,$rB */
517 
  {
518 
    OPENRISC_INSN_L_SUB, "l-sub", "l.sub", 32,
519 
    { 0, { { { (1<<MACH_BASE), 0 } } } }
520 
  },
521 
/* l.subi $rD,$rA,$lo16 */
522 
  {
523 
    OPENRISC_INSN_L_SUBI, "l-subi", "l.subi", 32,
524 
    { 0, { { { (1<<MACH_BASE), 0 } } } }
525 
  },
526 
/* l.and $rD,$rA,$rB */
527 
  {
528 
    OPENRISC_INSN_L_AND, "l-and", "l.and", 32,
529 
    { 0, { { { (1<<MACH_BASE), 0 } } } }
530 
  },
531 
/* l.andi $rD,$rA,$lo16 */
532 
  {
533 
    OPENRISC_INSN_L_ANDI, "l-andi", "l.andi", 32,
534 
    { 0, { { { (1<<MACH_BASE), 0 } } } }
535 
  },
536 
/* l.or $rD,$rA,$rB */
537 
  {
538 
    OPENRISC_INSN_L_OR, "l-or", "l.or", 32,
539 
    { 0, { { { (1<<MACH_BASE), 0 } } } }
540 
  },
541 
/* l.ori $rD,$rA,$lo16 */
542 
  {
543 
    OPENRISC_INSN_L_ORI, "l-ori", "l.ori", 32,
544 
    { 0, { { { (1<<MACH_BASE), 0 } } } }
545 
  },
546 
/* l.xor $rD,$rA,$rB */
547 
  {
548 
    OPENRISC_INSN_L_XOR, "l-xor", "l.xor", 32,
549 
    { 0, { { { (1<<MACH_BASE), 0 } } } }
550 
  },
551 
/* l.xori $rD,$rA,$lo16 */
552 
  {
553 
    OPENRISC_INSN_L_XORI, "l-xori", "l.xori", 32,
554 
    { 0, { { { (1<<MACH_BASE), 0 } } } }
555 
  },
556 
/* l.mul $rD,$rA,$rB */
557 
  {
558 
    OPENRISC_INSN_L_MUL, "l-mul", "l.mul", 32,
559 
    { 0, { { { (1<<MACH_BASE), 0 } } } }
560 
  },
561 
/* l.muli $rD,$rA,$lo16 */
562 
  {
563 
    OPENRISC_INSN_L_MULI, "l-muli", "l.muli", 32,
564 
    { 0, { { { (1<<MACH_BASE), 0 } } } }
565 
  },
566 
/* l.div $rD,$rA,$rB */
567 
  {
568 
    OPENRISC_INSN_L_DIV, "l-div", "l.div", 32,
569 
    { 0|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
570 
  },
571 
/* l.divu $rD,$rA,$rB */
572 
  {
573 
    OPENRISC_INSN_L_DIVU, "l-divu", "l.divu", 32,
574 
    { 0|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
575 
  },
576 
/* l.sfgts $rA,$rB */
577 
  {
578 
    OPENRISC_INSN_L_SFGTS, "l-sfgts", "l.sfgts", 32,
579 
    { 0|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
580 
  },
581 
/* l.sfgtu $rA,$rB */
582 
  {
583 
    OPENRISC_INSN_L_SFGTU, "l-sfgtu", "l.sfgtu", 32,
584 
    { 0|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
585 
  },
586 
/* l.sfges $rA,$rB */
587 
  {
588 
    OPENRISC_INSN_L_SFGES, "l-sfges", "l.sfges", 32,
589 
    { 0|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
590 
  },
591 
/* l.sfgeu $rA,$rB */
592 
  {
593 
    OPENRISC_INSN_L_SFGEU, "l-sfgeu", "l.sfgeu", 32,
594 
    { 0|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
595 
  },
596 
/* l.sflts $rA,$rB */
597 
  {
598 
    OPENRISC_INSN_L_SFLTS, "l-sflts", "l.sflts", 32,
599 
    { 0|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
600 
  },
601 
/* l.sfltu $rA,$rB */
602 
  {
603 
    OPENRISC_INSN_L_SFLTU, "l-sfltu", "l.sfltu", 32,
604 
    { 0|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
605 
  },
606 
/* l.sfles $rA,$rB */
607 
  {
608 
    OPENRISC_INSN_L_SFLES, "l-sfles", "l.sfles", 32,
609 
    { 0|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
610 
  },
611 
/* l.sfleu $rA,$rB */
612 
  {
613 
    OPENRISC_INSN_L_SFLEU, "l-sfleu", "l.sfleu", 32,
614 
    { 0|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
615 
  },
616 
/* l.sfgtsi $rA,${simm-16} */
617 
  {
618 
    OPENRISC_INSN_L_SFGTSI, "l-sfgtsi", "l.sfgtsi", 32,
619 
    { 0|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
620 
  },
621 
/* l.sfgtui $rA,${uimm-16} */
622 
  {
623 
    OPENRISC_INSN_L_SFGTUI, "l-sfgtui", "l.sfgtui", 32,
624 
    { 0|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
625 
  },
626 
/* l.sfgesi $rA,${simm-16} */
627 
  {
628 
    OPENRISC_INSN_L_SFGESI, "l-sfgesi", "l.sfgesi", 32,
629 
    { 0|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
630 
  },
631 
/* l.sfgeui $rA,${uimm-16} */
632 
  {
633 
    OPENRISC_INSN_L_SFGEUI, "l-sfgeui", "l.sfgeui", 32,
634 
    { 0|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
635 
  },
636 
/* l.sfltsi $rA,${simm-16} */
637 
  {
638 
    OPENRISC_INSN_L_SFLTSI, "l-sfltsi", "l.sfltsi", 32,
639 
    { 0|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
640 
  },
641 
/* l.sfltui $rA,${uimm-16} */
642 
  {
643 
    OPENRISC_INSN_L_SFLTUI, "l-sfltui", "l.sfltui", 32,
644 
    { 0|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
645 
  },
646 
/* l.sflesi $rA,${simm-16} */
647 
  {
648 
    OPENRISC_INSN_L_SFLESI, "l-sflesi", "l.sflesi", 32,
649 
    { 0|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
650 
  },
651 
/* l.sfleui $rA,${uimm-16} */
652 
  {
653 
    OPENRISC_INSN_L_SFLEUI, "l-sfleui", "l.sfleui", 32,
654 
    { 0|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
655 
  },
656 
/* l.sfeq $rA,$rB */
657 
  {
658 
    OPENRISC_INSN_L_SFEQ, "l-sfeq", "l.sfeq", 32,
659 
    { 0|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
660 
  },
661 
/* l.sfeqi $rA,${simm-16} */
662 
  {
663 
    OPENRISC_INSN_L_SFEQI, "l-sfeqi", "l.sfeqi", 32,
664 
    { 0|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
665 
  },
666 
/* l.sfne $rA,$rB */
667 
  {
668 
    OPENRISC_INSN_L_SFNE, "l-sfne", "l.sfne", 32,
669 
    { 0|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
670 
  },
671 
/* l.sfnei $rA,${simm-16} */
672 
  {
673 
    OPENRISC_INSN_L_SFNEI, "l-sfnei", "l.sfnei", 32,
674 
    { 0|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
675 
  },
676 
};
677 
 
678 
#undef OP
679 
#undef A
680 
 
681 
/* Initialize anything needed to be done once, before any cpu_open call.  */
682 
 
683 
static void
684 
init_tables (void)
685 
{
686 
}
687 
 
688 
static const CGEN_MACH * lookup_mach_via_bfd_name (const CGEN_MACH *, const char *);
689 
static void build_hw_table      (CGEN_CPU_TABLE *);
690 
static void build_ifield_table  (CGEN_CPU_TABLE *);
691 
static void build_operand_table (CGEN_CPU_TABLE *);
692 
static void build_insn_table    (CGEN_CPU_TABLE *);
693 
static void openrisc_cgen_rebuild_tables (CGEN_CPU_TABLE *);
694 
 
695 
/* Subroutine of openrisc_cgen_cpu_open to look up a mach via its bfd name.  */
696 
 
697 
static const CGEN_MACH *
698 
lookup_mach_via_bfd_name (const CGEN_MACH *table, const char *name)
699 
{
700 
  while (table->name)
701 
    {
702 
      if (strcmp (name, table->bfd_name) == 0)
703 
        return table;
704 
      ++table;
705 
    }
706 
  abort ();
707 
}
708 
 
709 
/* Subroutine of openrisc_cgen_cpu_open to build the hardware table.  */
710 
 
711 
static void
712 
build_hw_table (CGEN_CPU_TABLE *cd)
713 
{
714 
  int i;
715 
  int machs = cd->machs;
716 
  const CGEN_HW_ENTRY *init = & openrisc_cgen_hw_table[0];
717 
  /* MAX_HW is only an upper bound on the number of selected entries.
718 
     However each entry is indexed by it's enum so there can be holes in
719 
     the table.  */
720 
  const CGEN_HW_ENTRY **selected =
721 
    (const CGEN_HW_ENTRY **) xmalloc (MAX_HW * sizeof (CGEN_HW_ENTRY *));
722 
 
723 
  cd->hw_table.init_entries = init;
724 
  cd->hw_table.entry_size = sizeof (CGEN_HW_ENTRY);
725 
  memset (selected, 0, MAX_HW * sizeof (CGEN_HW_ENTRY *));
726 
  /* ??? For now we just use machs to determine which ones we want.  */
727 
  for (i = 0; init[i].name != NULL; ++i)
728 
    if (CGEN_HW_ATTR_VALUE (&init[i], CGEN_HW_MACH)
729 
        & machs)
730 
      selected[init[i].type] = &init[i];
731 
  cd->hw_table.entries = selected;
732 
  cd->hw_table.num_entries = MAX_HW;
733 
}
734 
 
735 
/* Subroutine of openrisc_cgen_cpu_open to build the hardware table.  */
736 
 
737 
static void
738 
build_ifield_table (CGEN_CPU_TABLE *cd)
739 
{
740 
  cd->ifld_table = & openrisc_cgen_ifld_table[0];
741 
}
742 
 
743 
/* Subroutine of openrisc_cgen_cpu_open to build the hardware table.  */
744 
 
745 
static void
746 
build_operand_table (CGEN_CPU_TABLE *cd)
747 
{
748 
  int i;
749 
  int machs = cd->machs;
750 
  const CGEN_OPERAND *init = & openrisc_cgen_operand_table[0];
751 
  /* MAX_OPERANDS is only an upper bound on the number of selected entries.
752 
     However each entry is indexed by it's enum so there can be holes in
753 
     the table.  */
754 
  const CGEN_OPERAND **selected = xmalloc (MAX_OPERANDS * sizeof (* selected));
755 
 
756 
  cd->operand_table.init_entries = init;
757 
  cd->operand_table.entry_size = sizeof (CGEN_OPERAND);
758 
  memset (selected, 0, MAX_OPERANDS * sizeof (CGEN_OPERAND *));
759 
  /* ??? For now we just use mach to determine which ones we want.  */
760 
  for (i = 0; init[i].name != NULL; ++i)
761 
    if (CGEN_OPERAND_ATTR_VALUE (&init[i], CGEN_OPERAND_MACH)
762 
        & machs)
763 
      selected[init[i].type] = &init[i];
764 
  cd->operand_table.entries = selected;
765 
  cd->operand_table.num_entries = MAX_OPERANDS;
766 
}
767 
 
768 
/* Subroutine of openrisc_cgen_cpu_open to build the hardware table.
769 
   ??? This could leave out insns not supported by the specified mach/isa,
770 
   but that would cause errors like "foo only supported by bar" to become
771 
   "unknown insn", so for now we include all insns and require the app to
772 
   do the checking later.
773 
   ??? On the other hand, parsing of such insns may require their hardware or
774 
   operand elements to be in the table [which they mightn't be].  */
775 
 
776 
static void
777 
build_insn_table (CGEN_CPU_TABLE *cd)
778 
{
779 
  int i;
780 
  const CGEN_IBASE *ib = & openrisc_cgen_insn_table[0];
781 
  CGEN_INSN *insns = xmalloc (MAX_INSNS * sizeof (CGEN_INSN));
782 
 
783 
  memset (insns, 0, MAX_INSNS * sizeof (CGEN_INSN));
784 
  for (i = 0; i < MAX_INSNS; ++i)
785 
    insns[i].base = &ib[i];
786 
  cd->insn_table.init_entries = insns;
787 
  cd->insn_table.entry_size = sizeof (CGEN_IBASE);
788 
  cd->insn_table.num_init_entries = MAX_INSNS;
789 
}
790 
 
791 
/* Subroutine of openrisc_cgen_cpu_open to rebuild the tables.  */
792 
 
793 
static void
794 
openrisc_cgen_rebuild_tables (CGEN_CPU_TABLE *cd)
795 
{
796 
  int i;
797 
  CGEN_BITSET *isas = cd->isas;
798 
  unsigned int machs = cd->machs;
799 
 
800 
  cd->int_insn_p = CGEN_INT_INSN_P;
801 
 
802 
  /* Data derived from the isa spec.  */
803 
#define UNSET (CGEN_SIZE_UNKNOWN + 1)
804 
  cd->default_insn_bitsize = UNSET;
805 
  cd->base_insn_bitsize = UNSET;
806 
  cd->min_insn_bitsize = 65535; /* Some ridiculously big number.  */
807 
  cd->max_insn_bitsize = 0;
808 
  for (i = 0; i < MAX_ISAS; ++i)
809 
    if (cgen_bitset_contains (isas, i))
810 
      {
811 
        const CGEN_ISA *isa = & openrisc_cgen_isa_table[i];
812 
 
813 
        /* Default insn sizes of all selected isas must be
814 
           equal or we set the result to 0, meaning "unknown".  */
815 
        if (cd->default_insn_bitsize == UNSET)
816 
          cd->default_insn_bitsize = isa->default_insn_bitsize;
817 
        else if (isa->default_insn_bitsize == cd->default_insn_bitsize)
818 
          ; /* This is ok.  */
819 
        else
820 
          cd->default_insn_bitsize = CGEN_SIZE_UNKNOWN;
821 
 
822 
        /* Base insn sizes of all selected isas must be equal
823 
           or we set the result to 0, meaning "unknown".  */
824 
        if (cd->base_insn_bitsize == UNSET)
825 
          cd->base_insn_bitsize = isa->base_insn_bitsize;
826 
        else if (isa->base_insn_bitsize == cd->base_insn_bitsize)
827 
          ; /* This is ok.  */
828 
        else
829 
          cd->base_insn_bitsize = CGEN_SIZE_UNKNOWN;
830 
 
831 
        /* Set min,max insn sizes.  */
832 
        if (isa->min_insn_bitsize < cd->min_insn_bitsize)
833 
          cd->min_insn_bitsize = isa->min_insn_bitsize;
834 
        if (isa->max_insn_bitsize > cd->max_insn_bitsize)
835 
          cd->max_insn_bitsize = isa->max_insn_bitsize;
836 
      }
837 
 
838 
  /* Data derived from the mach spec.  */
839 
  for (i = 0; i < MAX_MACHS; ++i)
840 
    if (((1 << i) & machs) != 0)
841 
      {
842 
        const CGEN_MACH *mach = & openrisc_cgen_mach_table[i];
843 
 
844 
        if (mach->insn_chunk_bitsize != 0)
845 
        {
846 
          if (cd->insn_chunk_bitsize != 0 && cd->insn_chunk_bitsize != mach->insn_chunk_bitsize)
847 
            {
848 
              fprintf (stderr, "openrisc_cgen_rebuild_tables: conflicting insn-chunk-bitsize values: `%d' vs. `%d'\n",
849 
                       cd->insn_chunk_bitsize, mach->insn_chunk_bitsize);
850 
              abort ();
851 
            }
852 
 
853 
          cd->insn_chunk_bitsize = mach->insn_chunk_bitsize;
854 
        }
855 
      }
856 
 
857 
  /* Determine which hw elements are used by MACH.  */
858 
  build_hw_table (cd);
859 
 
860 
  /* Build the ifield table.  */
861 
  build_ifield_table (cd);
862 
 
863 
  /* Determine which operands are used by MACH/ISA.  */
864 
  build_operand_table (cd);
865 
 
866 
  /* Build the instruction table.  */
867 
  build_insn_table (cd);
868 
}
869 
 
870 
/* Initialize a cpu table and return a descriptor.
871 
   It's much like opening a file, and must be the first function called.
872 
   The arguments are a set of (type/value) pairs, terminated with
873 
   CGEN_CPU_OPEN_END.
874 
 
875 
   Currently supported values:
876 
   CGEN_CPU_OPEN_ISAS:    bitmap of values in enum isa_attr
877 
   CGEN_CPU_OPEN_MACHS:   bitmap of values in enum mach_attr
878 
   CGEN_CPU_OPEN_BFDMACH: specify 1 mach using bfd name
879 
   CGEN_CPU_OPEN_ENDIAN:  specify endian choice
880 
   CGEN_CPU_OPEN_END:     terminates arguments
881 
 
882 
   ??? Simultaneous multiple isas might not make sense, but it's not (yet)
883 
   precluded.  */
884 
 
885 
CGEN_CPU_DESC
886 
openrisc_cgen_cpu_open (enum cgen_cpu_open_arg arg_type, ...)
887 
{
888 
  CGEN_CPU_TABLE *cd = (CGEN_CPU_TABLE *) xmalloc (sizeof (CGEN_CPU_TABLE));
889 
  static int init_p;
890 
  CGEN_BITSET *isas = 0;  /* 0 = "unspecified" */
891 
  unsigned int machs = 0; /* 0 = "unspecified" */
892 
  enum cgen_endian endian = CGEN_ENDIAN_UNKNOWN;
893 
  va_list ap;
894 
 
895 
  if (! init_p)
896 
    {
897 
      init_tables ();
898 
      init_p = 1;
899 
    }
900 
 
901 
  memset (cd, 0, sizeof (*cd));
902 
 
903 
  va_start (ap, arg_type);
904 
  while (arg_type != CGEN_CPU_OPEN_END)
905 
    {
906 
      switch (arg_type)
907 
        {
908 
        case CGEN_CPU_OPEN_ISAS :
909 
          isas = va_arg (ap, CGEN_BITSET *);
910 
          break;
911 
        case CGEN_CPU_OPEN_MACHS :
912 
          machs = va_arg (ap, unsigned int);
913 
          break;
914 
        case CGEN_CPU_OPEN_BFDMACH :
915 
          {
916 
            const char *name = va_arg (ap, const char *);
917 
            const CGEN_MACH *mach =
918 
              lookup_mach_via_bfd_name (openrisc_cgen_mach_table, name);
919 
 
920 
            machs |= 1 << mach->num;
921 
            break;
922 
          }
923 
        case CGEN_CPU_OPEN_ENDIAN :
924 
          endian = va_arg (ap, enum cgen_endian);
925 
          break;
926 
        default :
927 
          fprintf (stderr, "openrisc_cgen_cpu_open: unsupported argument `%d'\n",
928 
                   arg_type);
929 
          abort (); /* ??? return NULL? */
930 
        }
931 
      arg_type = va_arg (ap, enum cgen_cpu_open_arg);
932 
    }
933 
  va_end (ap);
934 
 
935 
  /* Mach unspecified means "all".  */
936 
  if (machs == 0)
937 
    machs = (1 << MAX_MACHS) - 1;
938 
  /* Base mach is always selected.  */
939 
  machs |= 1;
940 
  if (endian == CGEN_ENDIAN_UNKNOWN)
941 
    {
942 
      /* ??? If target has only one, could have a default.  */
943 
      fprintf (stderr, "openrisc_cgen_cpu_open: no endianness specified\n");
944 
      abort ();
945 
    }
946 
 
947 
  cd->isas = cgen_bitset_copy (isas);
948 
  cd->machs = machs;
949 
  cd->endian = endian;
950 
  /* FIXME: for the sparc case we can determine insn-endianness statically.
951 
     The worry here is where both data and insn endian can be independently
952 
     chosen, in which case this function will need another argument.
953 
     Actually, will want to allow for more arguments in the future anyway.  */
954 
  cd->insn_endian = endian;
955 
 
956 
  /* Table (re)builder.  */
957 
  cd->rebuild_tables = openrisc_cgen_rebuild_tables;
958 
  openrisc_cgen_rebuild_tables (cd);
959 
 
960 
  /* Default to not allowing signed overflow.  */
961 
  cd->signed_overflow_ok_p = 0;
962 
 
963 
  return (CGEN_CPU_DESC) cd;
964 
}
965 
 
966 
/* Cover fn to openrisc_cgen_cpu_open to handle the simple case of 1 isa, 1 mach.
967 
   MACH_NAME is the bfd name of the mach.  */
968 
 
969 
CGEN_CPU_DESC
970 
openrisc_cgen_cpu_open_1 (const char *mach_name, enum cgen_endian endian)
971 
{
972 
  return openrisc_cgen_cpu_open (CGEN_CPU_OPEN_BFDMACH, mach_name,
973 
                               CGEN_CPU_OPEN_ENDIAN, endian,
974 
                               CGEN_CPU_OPEN_END);
975 
}
976 
 
977 
/* Close a cpu table.
978 
   ??? This can live in a machine independent file, but there's currently
979 
   no place to put this file (there's no libcgen).  libopcodes is the wrong
980 
   place as some simulator ports use this but they don't use libopcodes.  */
981 
 
982 
void
983 
openrisc_cgen_cpu_close (CGEN_CPU_DESC cd)
984 
{
985 
  unsigned int i;
986 
  const CGEN_INSN *insns;
987 
 
988 
  if (cd->macro_insn_table.init_entries)
989 
    {
990 
      insns = cd->macro_insn_table.init_entries;
991 
      for (i = 0; i < cd->macro_insn_table.num_init_entries; ++i, ++insns)
992 
        if (CGEN_INSN_RX ((insns)))
993 
          regfree (CGEN_INSN_RX (insns));
994 
    }
995 
 
996 
  if (cd->insn_table.init_entries)
997 
    {
998 
      insns = cd->insn_table.init_entries;
999 
      for (i = 0; i < cd->insn_table.num_init_entries; ++i, ++insns)
1000 
        if (CGEN_INSN_RX (insns))
1001 
          regfree (CGEN_INSN_RX (insns));
1002 
    }
1003 
 
1004 
  if (cd->macro_insn_table.init_entries)
1005 
    free ((CGEN_INSN *) cd->macro_insn_table.init_entries);
1006 
 
1007 
  if (cd->insn_table.init_entries)
1008 
    free ((CGEN_INSN *) cd->insn_table.init_entries);
1009 
 
1010 
  if (cd->hw_table.entries)
1011 
    free ((CGEN_HW_ENTRY *) cd->hw_table.entries);
1012 
 
1013 
  if (cd->operand_table.entries)
1014 
    free ((CGEN_HW_ENTRY *) cd->operand_table.entries);
1015 
 
1016 
  free (cd);
1017 
}
1018 
 

powered by: WebSVN 2.1.0

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