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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [binutils-2.20.1/] [cpu/] [frv.opc] - Blame information for rev 818

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 205 julius
/* Fujitsu FRV opcode support, for GNU Binutils.  -*- C -*-
2
 
3
   Copyright 2000, 2001, 2003, 2004, 2005, 2007, 2009
4
   Free Software Foundation, Inc.
5
 
6
   Contributed by Red Hat Inc; developed under contract from Fujitsu.
7
 
8
   This file is part of the GNU Binutils.
9
 
10
   This program is free software; you can redistribute it and/or modify
11
   it under the terms of the GNU General Public License as published by
12
   the Free Software Foundation; either version 3 of the License, or
13
   (at your option) any later version.
14
 
15
   This program is distributed in the hope that it will be useful,
16
   but WITHOUT ANY WARRANTY; without even the implied warranty of
17
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18
   GNU General Public License for more details.
19
 
20
   You should have received a copy of the GNU General Public License
21
   along with this program; if not, write to the Free Software
22
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
23
   MA 02110-1301, USA.  */
24
 
25
 
26
/* This file is an addendum to frv.cpu.  Heavy use of C code isn't
27
   appropriate in .cpu files, so it resides here.  This especially applies
28
   to assembly/disassembly where parsing/printing can be quite involved.
29
   Such things aren't really part of the specification of the cpu, per se,
30
   so .cpu files provide the general framework and .opc files handle the
31
   nitty-gritty details as necessary.
32
 
33
   Each section is delimited with start and end markers.
34
 
35
   -opc.h additions use: "-- opc.h"
36
   -opc.c additions use: "-- opc.c"
37
   -asm.c additions use: "-- asm.c"
38
   -dis.c additions use: "-- dis.c"
39
   -ibd.h additions use: "-- ibd.h".  */
40
 
41
/* -- opc.h */
42
 
43
#undef  CGEN_DIS_HASH_SIZE
44
#define CGEN_DIS_HASH_SIZE 128
45
#undef  CGEN_DIS_HASH
46
#define CGEN_DIS_HASH(buffer, value) (((value) >> 18) & 127)
47
 
48
/* Allows reason codes to be output when assembler errors occur.  */
49
#define CGEN_VERBOSE_ASSEMBLER_ERRORS
50
 
51
/* Vliw support.  */
52
#define FRV_VLIW_SIZE 8 /* fr550 has largest vliw size of 8.  */
53
#define PAD_VLIW_COMBO ,UNIT_NIL,UNIT_NIL,UNIT_NIL,UNIT_NIL
54
 
55
typedef CGEN_ATTR_VALUE_ENUM_TYPE VLIW_COMBO[FRV_VLIW_SIZE];
56
 
57
typedef struct
58
{
59
  int                    next_slot;
60
  int                    constraint_violation;
61
  unsigned long          mach;
62
  unsigned long          elf_flags;
63
  CGEN_ATTR_VALUE_ENUM_TYPE * unit_mapping;
64
  VLIW_COMBO *           current_vliw;
65
  CGEN_ATTR_VALUE_ENUM_TYPE   major[FRV_VLIW_SIZE];
66
  const CGEN_INSN *      insn[FRV_VLIW_SIZE];
67
} FRV_VLIW;
68
 
69
int frv_is_branch_major (CGEN_ATTR_VALUE_ENUM_TYPE, unsigned long);
70
int frv_is_float_major  (CGEN_ATTR_VALUE_ENUM_TYPE, unsigned long);
71
int frv_is_media_major  (CGEN_ATTR_VALUE_ENUM_TYPE, unsigned long);
72
int frv_is_branch_insn  (const CGEN_INSN *);
73
int frv_is_float_insn   (const CGEN_INSN *);
74
int frv_is_media_insn   (const CGEN_INSN *);
75
void frv_vliw_reset     (FRV_VLIW *, unsigned long, unsigned long);
76
int frv_vliw_add_insn   (FRV_VLIW *, const CGEN_INSN *);
77
int spr_valid           (long);
78
/* -- */
79
 
80
/* -- opc.c */
81
#include "elf/frv.h"
82
#include 
83
 
84
/* Returns TRUE if {MAJOR,MACH} is a major branch of the FRV
85
   development tree.  */
86
 
87
bfd_boolean
88
frv_is_branch_major (CGEN_ATTR_VALUE_ENUM_TYPE major, unsigned long mach)
89
{
90
  switch (mach)
91
    {
92
    case bfd_mach_fr400:
93
      if (major >= FR400_MAJOR_B_1 && major <= FR400_MAJOR_B_6)
94
        return TRUE;
95
      break;
96
    case bfd_mach_fr450:
97
      if (major >= FR450_MAJOR_B_1 && major <= FR450_MAJOR_B_6)
98
        return TRUE;
99
      break;
100
    default:
101
      if (major >= FR500_MAJOR_B_1 && major <= FR500_MAJOR_B_6)
102
        return TRUE;
103
      break;
104
    }
105
 
106
  return FALSE;
107
}
108
 
109
/* Returns TRUE if {MAJOR,MACH} supports floating point insns.  */
110
 
111
bfd_boolean
112
frv_is_float_major (CGEN_ATTR_VALUE_ENUM_TYPE major, unsigned long mach)
113
{
114
  switch (mach)
115
    {
116
    case bfd_mach_fr400:
117
    case bfd_mach_fr450:
118
      return FALSE;
119
    default:
120
      if (major >= FR500_MAJOR_F_1 && major <= FR500_MAJOR_F_8)
121
        return TRUE;
122
      break;
123
    }
124
 
125
  return FALSE;
126
}
127
 
128
/* Returns TRUE if {MAJOR,MACH} supports media insns.  */
129
 
130
bfd_boolean
131
frv_is_media_major (CGEN_ATTR_VALUE_ENUM_TYPE major, unsigned long mach)
132
{
133
  switch (mach)
134
    {
135
    case bfd_mach_fr400:
136
      if (major >= FR400_MAJOR_M_1 && major <= FR400_MAJOR_M_2)
137
        return TRUE;
138
      break;
139
    case bfd_mach_fr450:
140
      if (major >= FR450_MAJOR_M_1 && major <= FR450_MAJOR_M_6)
141
        return TRUE;
142
      break;
143
    default:
144
      if (major >= FR500_MAJOR_M_1 && major <= FR500_MAJOR_M_8)
145
        return TRUE;
146
      break;
147
    }
148
 
149
  return FALSE;
150
}
151
 
152
bfd_boolean
153
frv_is_branch_insn (const CGEN_INSN *insn)
154
{
155
  if (frv_is_branch_major (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_FR400_MAJOR),
156
                           bfd_mach_fr400))
157
    return TRUE;
158
  if (frv_is_branch_major (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_FR450_MAJOR),
159
                           bfd_mach_fr450))
160
    return TRUE;
161
  if (frv_is_branch_major (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_FR500_MAJOR),
162
                           bfd_mach_fr500))
163
    return TRUE;
164
 
165
  return FALSE;
166
}
167
 
168
bfd_boolean
169
frv_is_float_insn (const CGEN_INSN *insn)
170
{
171
  if (frv_is_float_major (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_FR400_MAJOR),
172
                          bfd_mach_fr400))
173
    return TRUE;
174
  if (frv_is_float_major (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_FR450_MAJOR),
175
                          bfd_mach_fr450))
176
    return TRUE;
177
  if (frv_is_float_major (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_FR500_MAJOR),
178
                          bfd_mach_fr500))
179
    return TRUE;
180
 
181
  return FALSE;
182
}
183
 
184
bfd_boolean
185
frv_is_media_insn (const CGEN_INSN *insn)
186
{
187
  if (frv_is_media_major (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_FR400_MAJOR),
188
                          bfd_mach_fr400))
189
    return TRUE;
190
  if (frv_is_media_major (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_FR450_MAJOR),
191
                          bfd_mach_fr450))
192
    return TRUE;
193
  if (frv_is_media_major (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_FR500_MAJOR),
194
                          bfd_mach_fr500))
195
    return TRUE;
196
 
197
  return FALSE;
198
}
199
 
200
/* This table represents the allowable packing for vliw insns for the fr400.
201
   The fr400 has only 2 vliw slots. Represent this by not allowing any insns
202
   in the extra slots.
203
   Subsets of any given row are also allowed.  */
204
static VLIW_COMBO fr400_allowed_vliw[] =
205
{
206
  /*  slot0       slot1       slot2       slot3    */
207
  {  UNIT_I0,    UNIT_I1,    UNIT_NIL,   UNIT_NIL  PAD_VLIW_COMBO },
208
  {  UNIT_I0,    UNIT_FM0,   UNIT_NIL,   UNIT_NIL  PAD_VLIW_COMBO },
209
  {  UNIT_I0,    UNIT_B0,    UNIT_NIL,   UNIT_NIL  PAD_VLIW_COMBO },
210
  {  UNIT_FM0,   UNIT_FM1,   UNIT_NIL,   UNIT_NIL  PAD_VLIW_COMBO },
211
  {  UNIT_FM0,   UNIT_B0,    UNIT_NIL,   UNIT_NIL  PAD_VLIW_COMBO },
212
  {  UNIT_B0,    UNIT_NIL,   UNIT_NIL,   UNIT_NIL  PAD_VLIW_COMBO },
213
  {  UNIT_C,     UNIT_NIL,   UNIT_NIL,   UNIT_NIL  PAD_VLIW_COMBO },
214
  {  UNIT_NIL,   UNIT_NIL,   UNIT_NIL,   UNIT_NIL  PAD_VLIW_COMBO }
215
};
216
 
217
/* This table represents the allowable packing for vliw insns for the fr500.
218
   The fr500 has only 4 vliw slots. Represent this by not allowing any insns
219
   in the extra slots.
220
   Subsets of any given row are also allowed.  */
221
static VLIW_COMBO fr500_allowed_vliw[] =
222
{
223
  /*  slot0       slot1       slot2       slot3    */
224
  {  UNIT_I0,    UNIT_FM0,   UNIT_I1,    UNIT_FM1  PAD_VLIW_COMBO },
225
  {  UNIT_I0,    UNIT_FM0,   UNIT_I1,    UNIT_B0   PAD_VLIW_COMBO },
226
  {  UNIT_I0,    UNIT_FM0,   UNIT_FM1,   UNIT_B0   PAD_VLIW_COMBO },
227
  {  UNIT_I0,    UNIT_FM0,   UNIT_B0,    UNIT_B1   PAD_VLIW_COMBO },
228
  {  UNIT_I0,    UNIT_I1,    UNIT_B0,    UNIT_B1   PAD_VLIW_COMBO },
229
  {  UNIT_I0,    UNIT_B0,    UNIT_B1,    UNIT_NIL  PAD_VLIW_COMBO },
230
  {  UNIT_FM0,   UNIT_FM1,   UNIT_B0,    UNIT_B1   PAD_VLIW_COMBO },
231
  {  UNIT_FM0,   UNIT_B0,    UNIT_B1,    UNIT_NIL  PAD_VLIW_COMBO },
232
  {  UNIT_B0,    UNIT_B1,    UNIT_NIL,   UNIT_NIL  PAD_VLIW_COMBO },
233
  {  UNIT_C,     UNIT_NIL,   UNIT_NIL,   UNIT_NIL  PAD_VLIW_COMBO },
234
  {  UNIT_NIL,   UNIT_NIL,   UNIT_NIL,   UNIT_NIL  PAD_VLIW_COMBO }
235
};
236
 
237
/* This table represents the allowable packing for vliw insns for the fr550.
238
   Subsets of any given row are also allowed.  */
239
static VLIW_COMBO fr550_allowed_vliw[] =
240
{
241
  /*  slot0       slot1       slot2       slot3       slot4       slot5       slot6       slot7   */
242
  {  UNIT_I0,    UNIT_I1,    UNIT_I2,    UNIT_I3,    UNIT_B0,    UNIT_B1 ,   UNIT_NIL,   UNIT_NIL },
243
  {  UNIT_I0,    UNIT_I1,    UNIT_I2,    UNIT_B0,    UNIT_B1 ,   UNIT_NIL,   UNIT_NIL,   UNIT_NIL },
244
  {  UNIT_I0,    UNIT_I1,    UNIT_B0,    UNIT_B1 ,   UNIT_NIL,   UNIT_NIL,   UNIT_NIL,   UNIT_NIL },
245
  {  UNIT_I0,    UNIT_B0,    UNIT_B1 ,   UNIT_NIL,   UNIT_NIL,   UNIT_NIL,   UNIT_NIL,   UNIT_NIL },
246
  {  UNIT_I0,    UNIT_FM0,   UNIT_I1,    UNIT_FM1,   UNIT_I2,    UNIT_FM2,   UNIT_I3,    UNIT_FM3 },
247
  {  UNIT_I0,    UNIT_FM0,   UNIT_I1,    UNIT_FM1,   UNIT_I2,    UNIT_FM2,   UNIT_I3,    UNIT_B0  },
248
  {  UNIT_I0,    UNIT_FM0,   UNIT_I1,    UNIT_FM1,   UNIT_I2,    UNIT_FM2,   UNIT_FM3,   UNIT_B0  },
249
  {  UNIT_I0,    UNIT_FM0,   UNIT_I1,    UNIT_FM1,   UNIT_I2,    UNIT_FM2,   UNIT_B0,    UNIT_B1  },
250
  {  UNIT_I0,    UNIT_FM0,   UNIT_I1,    UNIT_FM1,   UNIT_I2,    UNIT_I3,    UNIT_B0,    UNIT_B1  },
251
  {  UNIT_I0,    UNIT_FM0,   UNIT_I1,    UNIT_FM1,   UNIT_I2,    UNIT_B0,    UNIT_B1,    UNIT_NIL },
252
  {  UNIT_I0,    UNIT_FM0,   UNIT_I1,    UNIT_FM1,   UNIT_FM2,   UNIT_FM3,   UNIT_B0,    UNIT_B1  },
253
  {  UNIT_I0,    UNIT_FM0,   UNIT_I1,    UNIT_FM1,   UNIT_FM2,   UNIT_FM3,   UNIT_B0,    UNIT_B1  },
254
  {  UNIT_I0,    UNIT_FM0,   UNIT_I1,    UNIT_FM1,   UNIT_FM2,   UNIT_B0,    UNIT_B1,    UNIT_NIL },
255
  {  UNIT_I0,    UNIT_FM0,   UNIT_I1,    UNIT_FM1,   UNIT_B0,    UNIT_B1,    UNIT_NIL,   UNIT_NIL },
256
  {  UNIT_I0,    UNIT_FM0,   UNIT_I1,    UNIT_I2,    UNIT_I3,    UNIT_B0,    UNIT_B1,    UNIT_NIL },
257
  {  UNIT_I0,    UNIT_FM0,   UNIT_I1,    UNIT_I2,    UNIT_B0,    UNIT_B1,    UNIT_NIL,   UNIT_NIL },
258
  {  UNIT_I0,    UNIT_FM0,   UNIT_I1,    UNIT_B0,    UNIT_B1,    UNIT_NIL,   UNIT_NIL,   UNIT_NIL },
259
  {  UNIT_I0,    UNIT_FM0,   UNIT_FM1,   UNIT_FM2,   UNIT_FM3,   UNIT_B0,    UNIT_B1,    UNIT_NIL },
260
  {  UNIT_I0,    UNIT_FM0,   UNIT_FM1,   UNIT_FM2,   UNIT_B0,    UNIT_B1,    UNIT_NIL,   UNIT_NIL },
261
  {  UNIT_I0,    UNIT_FM0,   UNIT_FM1,   UNIT_B0,    UNIT_B1,    UNIT_NIL,   UNIT_NIL,   UNIT_NIL },
262
  {  UNIT_I0,    UNIT_FM0,   UNIT_B0,    UNIT_B1,    UNIT_NIL,   UNIT_NIL,   UNIT_NIL,   UNIT_NIL },
263
  {  UNIT_B0,    UNIT_B1,    UNIT_NIL,   UNIT_NIL,   UNIT_NIL,   UNIT_NIL,   UNIT_NIL,   UNIT_NIL },
264
  {  UNIT_C,     UNIT_NIL,   UNIT_NIL,   UNIT_NIL,   UNIT_NIL,   UNIT_NIL,   UNIT_NIL,   UNIT_NIL },
265
  {  UNIT_FM0,   UNIT_FM1,   UNIT_FM2,   UNIT_FM3,   UNIT_B0,    UNIT_B1,    UNIT_NIL,   UNIT_NIL },
266
  {  UNIT_FM0,   UNIT_FM1,   UNIT_FM2,   UNIT_B0,    UNIT_B1,    UNIT_NIL,   UNIT_NIL,   UNIT_NIL },
267
  {  UNIT_FM0,   UNIT_FM1,   UNIT_B0,    UNIT_B1,    UNIT_NIL,   UNIT_NIL,   UNIT_NIL,   UNIT_NIL },
268
  {  UNIT_FM0,   UNIT_B0,    UNIT_B1,    UNIT_NIL,   UNIT_NIL,   UNIT_NIL,   UNIT_NIL,   UNIT_NIL },
269
  {  UNIT_NIL,   UNIT_NIL,   UNIT_NIL,   UNIT_NIL,   UNIT_NIL,   UNIT_NIL,   UNIT_NIL,   UNIT_NIL }
270
};
271
 
272
/* Some insns are assigned specialized implementation units which map to
273
   different actual implementation units on different machines.  These
274
   tables perform that mapping.  */
275
static CGEN_ATTR_VALUE_ENUM_TYPE fr400_unit_mapping[] =
276
{
277
/* unit in insn    actual unit */
278
/* NIL      */     UNIT_NIL,
279
/* I0       */     UNIT_I0,
280
/* I1       */     UNIT_I1,
281
/* I01      */     UNIT_I01,
282
/* I2       */     UNIT_NIL, /* no I2 or I3 unit */
283
/* I3       */     UNIT_NIL,
284
/* IALL     */     UNIT_I01, /* only I0 and I1 units */
285
/* FM0      */     UNIT_FM0,
286
/* FM1      */     UNIT_FM1,
287
/* FM01     */     UNIT_FM01,
288
/* FM2      */     UNIT_NIL, /* no F2 or M2 units */
289
/* FM3      */     UNIT_NIL, /* no F3 or M3 units */
290
/* FMALL    */     UNIT_FM01,/* Only F0,F1,M0,M1 units */
291
/* FMLOW    */     UNIT_FM0, /* Only F0,M0 units */
292
/* B0       */     UNIT_B0,  /* branches only in B0 unit.  */
293
/* B1       */     UNIT_B0,
294
/* B01      */     UNIT_B0,
295
/* C        */     UNIT_C,
296
/* MULT-DIV */     UNIT_I0,  /* multiply and divide only in I0  unit.  */
297
/* IACC     */     UNIT_I01, /* iacc multiply       in I0 or I1 unit.  */
298
/* LOAD     */     UNIT_I0,  /* load                only in I0  unit.  */
299
/* STORE    */     UNIT_I0,  /* store               only in I0  unit.  */
300
/* SCAN     */     UNIT_I0,  /* scan                only in I0  unit.  */
301
/* DCPL     */     UNIT_C,   /* dcpl                only in C   unit.  */
302
/* MDUALACC */     UNIT_FM0, /* media dual acc insn only in FM0 unit.  */
303
/* MDCUTSSI */     UNIT_FM0, /* mdcutssi            only in FM0 unit.  */
304
/* MCLRACC-1*/     UNIT_FM0  /* mclracc,A==1   insn only in FM0 unit.  */
305
};
306
 
307
/* Some insns are assigned specialized implementation units which map to
308
   different actual implementation units on different machines.  These
309
   tables perform that mapping.  */
310
static CGEN_ATTR_VALUE_ENUM_TYPE fr450_unit_mapping[] =
311
{
312
/* unit in insn    actual unit */
313
/* NIL      */     UNIT_NIL,
314
/* I0       */     UNIT_I0,
315
/* I1       */     UNIT_I1,
316
/* I01      */     UNIT_I01,
317
/* I2       */     UNIT_NIL, /* no I2 or I3 unit */
318
/* I3       */     UNIT_NIL,
319
/* IALL     */     UNIT_I01, /* only I0 and I1 units */
320
/* FM0      */     UNIT_FM0,
321
/* FM1      */     UNIT_FM1,
322
/* FM01     */     UNIT_FM01,
323
/* FM2      */     UNIT_NIL, /* no F2 or M2 units */
324
/* FM3      */     UNIT_NIL, /* no F3 or M3 units */
325
/* FMALL    */     UNIT_FM01,/* Only F0,F1,M0,M1 units */
326
/* FMLOW    */     UNIT_FM0, /* Only F0,M0 units */
327
/* B0       */     UNIT_B0,  /* branches only in B0 unit.  */
328
/* B1       */     UNIT_B0,
329
/* B01      */     UNIT_B0,
330
/* C        */     UNIT_C,
331
/* MULT-DIV */     UNIT_I0,  /* multiply and divide only in I0  unit.  */
332
/* IACC     */     UNIT_I01, /* iacc multiply       in I0 or I1 unit.  */
333
/* LOAD     */     UNIT_I0,  /* load                only in I0  unit.  */
334
/* STORE    */     UNIT_I0,  /* store               only in I0  unit.  */
335
/* SCAN     */     UNIT_I0,  /* scan                only in I0  unit.  */
336
/* DCPL     */     UNIT_I0,  /* dcpl                only in I0  unit.  */
337
/* MDUALACC */     UNIT_FM0, /* media dual acc insn only in FM0 unit.  */
338
/* MDCUTSSI */     UNIT_FM01, /* mdcutssi           in FM0 or FM1.  */
339
/* MCLRACC-1*/     UNIT_FM0  /* mclracc,A==1   insn only in FM0 unit.  */
340
};
341
 
342
static CGEN_ATTR_VALUE_ENUM_TYPE fr500_unit_mapping[] =
343
{
344
/* unit in insn    actual unit */
345
/* NIL      */     UNIT_NIL,
346
/* I0       */     UNIT_I0,
347
/* I1       */     UNIT_I1,
348
/* I01      */     UNIT_I01,
349
/* I2       */     UNIT_NIL, /* no I2 or I3 unit */
350
/* I3       */     UNIT_NIL,
351
/* IALL     */     UNIT_I01, /* only I0 and I1 units */
352
/* FM0      */     UNIT_FM0,
353
/* FM1      */     UNIT_FM1,
354
/* FM01     */     UNIT_FM01,
355
/* FM2      */     UNIT_NIL, /* no F2 or M2 units */
356
/* FM3      */     UNIT_NIL, /* no F3 or M2 units */
357
/* FMALL    */     UNIT_FM01,/* Only F0,F1,M0,M1 units */
358
/* FMLOW    */     UNIT_FM0, /* Only F0,M0 units */
359
/* B0       */     UNIT_B0,
360
/* B1       */     UNIT_B1,
361
/* B01      */     UNIT_B01,
362
/* C        */     UNIT_C,
363
/* MULT-DIV */     UNIT_I01, /* multiply and divide in I0 or I1 unit.  */
364
/* IACC     */     UNIT_NIL, /* iacc multiply       not implemented */
365
/* LOAD     */     UNIT_I01, /* load                in I0 or I1 unit.  */
366
/* STORE    */     UNIT_I0,  /* store               only in I0 unit.  */
367
/* SCAN     */     UNIT_I01, /* scan                in I0 or I1 unit.  */
368
/* DCPL     */     UNIT_C,   /* dcpl                only in C unit.  */
369
/* MDUALACC */     UNIT_FM0, /* media dual acc insn only in FM0 unit.  */
370
/* MDCUTSSI */     UNIT_FM0, /* mdcutssi            only in FM0 unit.  */
371
/* MCLRACC-1*/     UNIT_FM01 /* mclracc,A==1 in FM0 or FM1 unit.  */
372
};
373
 
374
static CGEN_ATTR_VALUE_ENUM_TYPE fr550_unit_mapping[] =
375
{
376
/* unit in insn    actual unit */
377
/* NIL      */     UNIT_NIL,
378
/* I0       */     UNIT_I0,
379
/* I1       */     UNIT_I1,
380
/* I01      */     UNIT_I01,
381
/* I2       */     UNIT_I2,
382
/* I3       */     UNIT_I3,
383
/* IALL     */     UNIT_IALL,
384
/* FM0      */     UNIT_FM0,
385
/* FM1      */     UNIT_FM1,
386
/* FM01     */     UNIT_FM01,
387
/* FM2      */     UNIT_FM2,
388
/* FM3      */     UNIT_FM3,
389
/* FMALL    */     UNIT_FMALL,
390
/* FMLOW    */     UNIT_FM01, /* Only F0,F1,M0,M1 units */
391
/* B0       */     UNIT_B0,
392
/* B1       */     UNIT_B1,
393
/* B01      */     UNIT_B01,
394
/* C        */     UNIT_C,
395
/* MULT-DIV */     UNIT_I01,  /* multiply and divide in I0 or I1 unit.    */
396
/* IACC     */     UNIT_NIL,  /* iacc multiply       not implemented.     */
397
/* LOAD     */     UNIT_I01,  /* load                in I0 or I1 unit.    */
398
/* STORE    */     UNIT_I01,  /* store               in I0 or I1 unit.    */
399
/* SCAN     */     UNIT_IALL, /* scan                in any integer unit. */
400
/* DCPL     */     UNIT_I0,   /* dcpl                only in I0 unit.     */
401
/* MDUALACC */     UNIT_FMALL,/* media dual acc insn in all media units   */
402
/* MDCUTSSI */     UNIT_FM01, /* mdcutssi            in FM0 or FM1 unit.  */
403
/* MCLRACC-1*/     UNIT_FM01  /* mclracc,A==1 in FM0 or FM1 unit.         */
404
};
405
 
406
void
407
frv_vliw_reset (FRV_VLIW *vliw, unsigned long mach, unsigned long elf_flags)
408
{
409
  vliw->next_slot = 0;
410
  vliw->constraint_violation = 0;
411
  vliw->mach = mach;
412
  vliw->elf_flags = elf_flags;
413
 
414
  switch (mach)
415
    {
416
    case bfd_mach_fr400:
417
      vliw->current_vliw = fr400_allowed_vliw;
418
      vliw->unit_mapping = fr400_unit_mapping;
419
      break;
420
    case bfd_mach_fr450:
421
      vliw->current_vliw = fr400_allowed_vliw;
422
      vliw->unit_mapping = fr450_unit_mapping;
423
      break;
424
    case bfd_mach_fr550:
425
      vliw->current_vliw = fr550_allowed_vliw;
426
      vliw->unit_mapping = fr550_unit_mapping;
427
      break;
428
    default:
429
      vliw->current_vliw = fr500_allowed_vliw;
430
      vliw->unit_mapping = fr500_unit_mapping;
431
      break;
432
    }
433
}
434
 
435
/* Return TRUE if unit1 is a match for unit2.
436
   Unit1 comes from the insn's UNIT attribute. unit2 comes from one of the
437
   *_allowed_vliw tables above.  */
438
static bfd_boolean
439
match_unit (FRV_VLIW *vliw,
440
            CGEN_ATTR_VALUE_ENUM_TYPE unit1, CGEN_ATTR_VALUE_ENUM_TYPE unit2)
441
{
442
  /* Map any specialized implementation units to actual ones.  */
443
  unit1 = vliw->unit_mapping[unit1];
444
 
445
  if (unit1 == unit2)
446
    return TRUE;
447
  if (unit1 < unit2)
448
    return FALSE;
449
 
450
  switch (unit1)
451
    {
452
    case UNIT_I01:
453
    case UNIT_FM01:
454
    case UNIT_B01:
455
      /* The 01 versions of these units are within 2 enums of the 0 or 1
456
         versions.  */
457
      if (unit1 - unit2 <= 2)
458
        return TRUE;
459
      break;
460
    case UNIT_IALL:
461
    case UNIT_FMALL:
462
      /* The ALL versions of these units are within 5 enums of the 0, 1, 2 or 3
463
         versions.  */
464
      if (unit1 - unit2 <= 5)
465
        return TRUE;
466
      break;
467
    default:
468
      break;
469
    }
470
 
471
  return FALSE;
472
}
473
 
474
/* Return TRUE if the vliws match, FALSE otherwise.  */
475
 
476
static bfd_boolean
477
match_vliw (VLIW_COMBO *vliw1, VLIW_COMBO *vliw2, int vliw_size)
478
{
479
  int i;
480
 
481
  for (i = 0; i < vliw_size; ++i)
482
    if ((*vliw1)[i] != (*vliw2)[i])
483
      return FALSE;
484
 
485
  return TRUE;
486
}
487
 
488
/* Find the next vliw vliw in the table that can accomodate the new insn.
489
   If one is found then return it. Otherwise return NULL.  */
490
 
491
static VLIW_COMBO *
492
add_next_to_vliw (FRV_VLIW *vliw, CGEN_ATTR_VALUE_ENUM_TYPE unit)
493
{
494
  int           next    = vliw->next_slot;
495
  VLIW_COMBO    *current = vliw->current_vliw;
496
  VLIW_COMBO    *potential;
497
 
498
  if (next <= 0)
499
    {
500
      fprintf (stderr, "frv-opc.c line %d: bad vliw->next_slot value.\n",
501
               __LINE__);
502
      abort (); /* Should never happen.  */
503
    }
504
 
505
  /* The table is sorted by units allowed within slots, so vliws with
506
     identical starting sequences are together.  */
507
  potential = current;
508
  do
509
    {
510
      if (match_unit (vliw, unit, (*potential)[next]))
511
        return potential;
512
      ++potential;
513
    }
514
  while (match_vliw (potential, current, next));
515
 
516
  return NULL;
517
}
518
 
519
/* Look for the given major insn type in the given vliw.
520
   Returns TRUE if found, FALSE otherwise.  */
521
 
522
static bfd_boolean
523
find_major_in_vliw (FRV_VLIW *vliw, CGEN_ATTR_VALUE_ENUM_TYPE major)
524
{
525
  int i;
526
 
527
  for (i = 0; i < vliw->next_slot; ++i)
528
    if (vliw->major[i] == major)
529
      return TRUE;
530
 
531
  return FALSE;
532
}
533
 
534
/* Check for constraints between the insns in the vliw due to major insn
535
   types.  */
536
 
537
static bfd_boolean
538
fr400_check_insn_major_constraints (FRV_VLIW *vliw, CGEN_ATTR_VALUE_ENUM_TYPE major)
539
{
540
  /* In the cpu file, all media insns are represented as being allowed in
541
     both media units. This makes it easier since this is the case for fr500.
542
     Catch the invalid combinations here.  Insns of major class FR400_MAJOR_M_2
543
     cannot coexist with any other media insn in a vliw.  */
544
  switch (major)
545
    {
546
    case FR400_MAJOR_M_2:
547
      return ! find_major_in_vliw (vliw, FR400_MAJOR_M_1)
548
        &&   ! find_major_in_vliw (vliw, FR400_MAJOR_M_2);
549
    case FR400_MAJOR_M_1:
550
      return ! find_major_in_vliw (vliw, FR400_MAJOR_M_2);
551
    default:
552
      break;
553
    }
554
  return TRUE;
555
}
556
 
557
static bfd_boolean
558
fr450_check_insn_major_constraints (FRV_VLIW *vliw, CGEN_ATTR_VALUE_ENUM_TYPE major)
559
{
560
  CGEN_ATTR_VALUE_ENUM_TYPE other_major;
561
 
562
  /* Our caller guarantees there's at least one other instruction.  */
563
  other_major = CGEN_INSN_ATTR_VALUE (vliw->insn[0], CGEN_INSN_FR450_MAJOR);
564
 
565
  /* (M4, M5) and (M4, M6) are allowed.  */
566
  if (other_major == FR450_MAJOR_M_4)
567
    if (major == FR450_MAJOR_M_5 || major == FR450_MAJOR_M_6)
568
      return TRUE;
569
 
570
  /* Otherwise, instructions in even-numbered media categories cannot be
571
     executed in parallel with other media instructions.  */
572
  switch (major)
573
    {
574
    case FR450_MAJOR_M_2:
575
    case FR450_MAJOR_M_4:
576
    case FR450_MAJOR_M_6:
577
      return !(other_major >= FR450_MAJOR_M_1
578
               && other_major <= FR450_MAJOR_M_6);
579
 
580
    case FR450_MAJOR_M_1:
581
    case FR450_MAJOR_M_3:
582
    case FR450_MAJOR_M_5:
583
      return !(other_major == FR450_MAJOR_M_2
584
               || other_major == FR450_MAJOR_M_4
585
               || other_major == FR450_MAJOR_M_6);
586
 
587
    default:
588
      return TRUE;
589
    }
590
}
591
 
592
static bfd_boolean
593
find_unit_in_vliw (FRV_VLIW *vliw, CGEN_ATTR_VALUE_ENUM_TYPE unit)
594
{
595
  int i;
596
 
597
  for (i = 0; i < vliw->next_slot; ++i)
598
    if (CGEN_INSN_ATTR_VALUE (vliw->insn[i], CGEN_INSN_UNIT) == unit)
599
      return TRUE;
600
 
601
  return FALSE; /* Not found.  */
602
}
603
 
604
static bfd_boolean
605
find_major_in_slot (FRV_VLIW *vliw,
606
                    CGEN_ATTR_VALUE_ENUM_TYPE major,
607
                    CGEN_ATTR_VALUE_ENUM_TYPE slot)
608
{
609
  int i;
610
 
611
  for (i = 0; i < vliw->next_slot; ++i)
612
    if (vliw->major[i] == major && (*vliw->current_vliw)[i] == slot)
613
      return TRUE;
614
 
615
  return FALSE;
616
}
617
 
618
static bfd_boolean
619
fr550_find_media_in_vliw (FRV_VLIW *vliw)
620
{
621
  int i;
622
 
623
  for (i = 0; i < vliw->next_slot; ++i)
624
    {
625
      if (vliw->major[i] < FR550_MAJOR_M_1 || vliw->major[i] > FR550_MAJOR_M_5)
626
        continue;
627
 
628
      /* Found a media insn, however, MNOP and MCLRACC don't count.  */
629
      if (CGEN_INSN_NUM (vliw->insn[i]) == FRV_INSN_MNOP
630
          || CGEN_INSN_NUM (vliw->insn[i]) == FRV_INSN_MCLRACC_0
631
          || CGEN_INSN_NUM (vliw->insn[i]) == FRV_INSN_MCLRACC_1)
632
        continue;
633
 
634
      return TRUE; /* Found one.  */
635
    }
636
 
637
  return FALSE;
638
}
639
 
640
static bfd_boolean
641
fr550_find_float_in_vliw (FRV_VLIW *vliw)
642
{
643
  int i;
644
 
645
  for (i = 0; i < vliw->next_slot; ++i)
646
    {
647
      if (vliw->major[i] < FR550_MAJOR_F_1 || vliw->major[i] > FR550_MAJOR_F_4)
648
        continue;
649
 
650
      /* Found a floating point insn, however, FNOP doesn't count.  */
651
      if (CGEN_INSN_NUM (vliw->insn[i]) == FRV_INSN_FNOP)
652
        continue;
653
 
654
      return TRUE; /* Found one.  */
655
    }
656
 
657
  return FALSE;
658
}
659
 
660
static bfd_boolean
661
fr550_check_insn_major_constraints (FRV_VLIW *vliw,
662
                                    CGEN_ATTR_VALUE_ENUM_TYPE major,
663
                                    const CGEN_INSN *insn)
664
{
665
  CGEN_ATTR_VALUE_ENUM_TYPE unit;
666
  CGEN_ATTR_VALUE_ENUM_TYPE slot = (*vliw->current_vliw)[vliw->next_slot];
667
  switch (slot)
668
    {
669
    case UNIT_I2:
670
      /* If it's a store, then there must be another store in I1 */
671
      unit = CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_UNIT);
672
      if (unit == UNIT_STORE)
673
        return find_unit_in_vliw (vliw, UNIT_STORE);
674
      break;
675
    case UNIT_FM2:
676
    case UNIT_FM3:
677
      /* Floating point insns other than FNOP in slot f2 or f3 cannot coexist
678
         with media insns.  */
679
      if (major >= FR550_MAJOR_F_1 && major <= FR550_MAJOR_F_4
680
          && CGEN_INSN_NUM (insn) != FRV_INSN_FNOP)
681
        return ! fr550_find_media_in_vliw (vliw);
682
      /* Media insns other than MNOP in slot m2 or m3 cannot coexist with
683
         floating point insns.  */
684
      if (major >= FR550_MAJOR_M_1 && major <= FR550_MAJOR_M_5
685
          && CGEN_INSN_NUM (insn) != FRV_INSN_MNOP)
686
        return ! fr550_find_float_in_vliw (vliw);
687
      /* F-2 in slot f2 or f3 cannot coexist with F-2 or F-4 in slot f1 or f2
688
         respectively.  */
689
      if (major == FR550_MAJOR_F_2)
690
        return ! find_major_in_slot (vliw, FR550_MAJOR_F_2,
691
                                     slot - (UNIT_FM2 - UNIT_FM0))
692
          &&   ! find_major_in_slot (vliw, FR550_MAJOR_F_4,
693
                                     slot - (UNIT_FM2 - UNIT_FM0));
694
      /* M-2 or M-5 in slot m2 or m3 cannot coexist with M-2 in slot m1 or m2
695
         respectively.  */
696
      if (major == FR550_MAJOR_M_2 || major == FR550_MAJOR_M_5)
697
        return ! find_major_in_slot (vliw, FR550_MAJOR_M_2,
698
                                     slot - (UNIT_FM2 - UNIT_FM0));
699
      /* M-4 in slot m2 or m3 cannot coexist with M-4 in slot m1 or m2
700
         respectively.  */
701
      if (major == FR550_MAJOR_M_4)
702
        return ! find_major_in_slot (vliw, FR550_MAJOR_M_4,
703
                                     slot - (UNIT_FM2 - UNIT_FM0));
704
      break;
705
    default:
706
      break;
707
    }
708
  return TRUE; /* All OK.  */
709
}
710
 
711
static bfd_boolean
712
fr500_check_insn_major_constraints (FRV_VLIW *vliw, CGEN_ATTR_VALUE_ENUM_TYPE major)
713
{
714
  /* TODO: A table might be faster for some of the more complex instances
715
     here.  */
716
  switch (major)
717
    {
718
    case FR500_MAJOR_I_1:
719
    case FR500_MAJOR_I_4:
720
    case FR500_MAJOR_I_5:
721
    case FR500_MAJOR_I_6:
722
    case FR500_MAJOR_B_1:
723
    case FR500_MAJOR_B_2:
724
    case FR500_MAJOR_B_3:
725
    case FR500_MAJOR_B_4:
726
    case FR500_MAJOR_B_5:
727
    case FR500_MAJOR_B_6:
728
    case FR500_MAJOR_F_4:
729
    case FR500_MAJOR_F_8:
730
    case FR500_MAJOR_M_8:
731
      return TRUE; /* OK */
732
    case FR500_MAJOR_I_2:
733
      /* Cannot coexist with I-3 insn.  */
734
      return ! find_major_in_vliw (vliw, FR500_MAJOR_I_3);
735
    case FR500_MAJOR_I_3:
736
      /* Cannot coexist with I-2 insn.  */
737
      return ! find_major_in_vliw (vliw, FR500_MAJOR_I_2);
738
    case FR500_MAJOR_F_1:
739
    case FR500_MAJOR_F_2:
740
      /* Cannot coexist with F-5, F-6, or M-7 insn.  */
741
      return ! find_major_in_vliw (vliw, FR500_MAJOR_F_5)
742
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_F_6)
743
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_7);
744
    case FR500_MAJOR_F_3:
745
      /* Cannot coexist with F-7, or M-7 insn.  */
746
      return ! find_major_in_vliw (vliw, FR500_MAJOR_F_7)
747
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_7);
748
    case FR500_MAJOR_F_5:
749
      /* Cannot coexist with F-1, F-2, F-6, F-7, or M-7 insn.  */
750
      return ! find_major_in_vliw (vliw, FR500_MAJOR_F_1)
751
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_F_2)
752
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_F_6)
753
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_F_7)
754
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_7);
755
    case FR500_MAJOR_F_6:
756
      /* Cannot coexist with F-1, F-2, F-5, F-6, or M-7 insn.  */
757
      return ! find_major_in_vliw (vliw, FR500_MAJOR_F_1)
758
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_F_2)
759
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_F_5)
760
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_F_6)
761
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_7);
762
    case FR500_MAJOR_F_7:
763
      /* Cannot coexist with F-3, F-5, F-7, or M-7 insn.  */
764
      return ! find_major_in_vliw (vliw, FR500_MAJOR_F_3)
765
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_F_5)
766
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_F_7)
767
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_7);
768
    case FR500_MAJOR_M_1:
769
      /* Cannot coexist with M-7 insn.  */
770
      return ! find_major_in_vliw (vliw, FR500_MAJOR_M_7);
771
    case FR500_MAJOR_M_2:
772
    case FR500_MAJOR_M_3:
773
      /* Cannot coexist with M-5, M-6 or M-7 insn.  */
774
      return ! find_major_in_vliw (vliw, FR500_MAJOR_M_5)
775
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_6)
776
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_7);
777
    case FR500_MAJOR_M_4:
778
      /* Cannot coexist with M-6 insn.  */
779
      return ! find_major_in_vliw (vliw, FR500_MAJOR_M_6);
780
    case FR500_MAJOR_M_5:
781
      /* Cannot coexist with M-2, M-3, M-5, M-6  or M-7 insn.  */
782
      return ! find_major_in_vliw (vliw, FR500_MAJOR_M_2)
783
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_3)
784
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_5)
785
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_6)
786
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_7);
787
    case FR500_MAJOR_M_6:
788
      /* Cannot coexist with M-2, M-3, M-4, M-5, M-6  or M-7 insn.  */
789
      return ! find_major_in_vliw (vliw, FR500_MAJOR_M_2)
790
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_3)
791
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_4)
792
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_5)
793
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_6)
794
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_7);
795
    case FR500_MAJOR_M_7:
796
      /* Cannot coexist with M-1, M-2, M-3, M-5, M-6  or M-7 insn.  */
797
      return ! find_major_in_vliw (vliw, FR500_MAJOR_M_1)
798
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_2)
799
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_3)
800
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_5)
801
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_6)
802
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_M_7)
803
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_F_1)
804
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_F_2)
805
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_F_3)
806
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_F_5)
807
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_F_6)
808
        &&   ! find_major_in_vliw (vliw, FR500_MAJOR_F_7);
809
    default:
810
      fprintf (stderr, "frv-opc.c, line %d: bad major code, aborting.\n",
811
               __LINE__);
812
      abort ();
813
      break;
814
    }
815
  return TRUE;
816
}
817
 
818
static bfd_boolean
819
check_insn_major_constraints (FRV_VLIW *vliw,
820
                              CGEN_ATTR_VALUE_ENUM_TYPE major,
821
                              const CGEN_INSN *insn)
822
{
823
  switch (vliw->mach)
824
    {
825
    case bfd_mach_fr400:
826
      return fr400_check_insn_major_constraints (vliw, major);
827
 
828
    case bfd_mach_fr450:
829
      return fr450_check_insn_major_constraints (vliw, major);
830
 
831
    case bfd_mach_fr550:
832
      return fr550_check_insn_major_constraints (vliw, major, insn);
833
 
834
    default:
835
      return fr500_check_insn_major_constraints (vliw, major);
836
    }
837
}
838
 
839
/* Add in insn to the VLIW vliw if possible.
840
   Return 0 if successful, non-zero otherwise.  */
841
 
842
int
843
frv_vliw_add_insn (FRV_VLIW *vliw, const CGEN_INSN *insn)
844
{
845
  int index;
846
  CGEN_ATTR_VALUE_ENUM_TYPE major;
847
  CGEN_ATTR_VALUE_ENUM_TYPE unit;
848
  VLIW_COMBO *new_vliw;
849
 
850
  if (vliw->constraint_violation || CGEN_INSN_INVALID_P (insn))
851
    return 1;
852
 
853
  index = vliw->next_slot;
854
  if (index >= FRV_VLIW_SIZE)
855
    return 1;
856
 
857
  unit = CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_UNIT);
858
  if (unit == UNIT_NIL)
859
    {
860
      fprintf (stderr, "frv-opc.c line %d: bad insn unit.\n",
861
               __LINE__);
862
      abort (); /* No UNIT specified for this insn in frv.cpu.  */
863
    }
864
 
865
  switch (vliw->mach)
866
    {
867
    case bfd_mach_fr400:
868
      major = CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_FR400_MAJOR);
869
      break;
870
    case bfd_mach_fr450:
871
      major = CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_FR450_MAJOR);
872
      break;
873
    case bfd_mach_fr550:
874
      major = CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_FR550_MAJOR);
875
      break;
876
    default:
877
      major = CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_FR500_MAJOR);
878
      break;
879
    }
880
 
881
  if (index <= 0)
882
    {
883
      /* Any insn can be added to slot 0.  */
884
      while (! match_unit (vliw, unit, (*vliw->current_vliw)[0]))
885
        ++vliw->current_vliw;
886
      vliw->major[0] = major;
887
      vliw->insn[0] = insn;
888
      vliw->next_slot = 1;
889
      return 0;
890
    }
891
 
892
  /* If there are already insns in the vliw(s) check to see that
893
     this one can be added.  Do this by finding an allowable vliw
894
     combination that can accept the new insn.  */
895
  if (! (vliw->elf_flags & EF_FRV_NOPACK))
896
    {
897
      new_vliw = add_next_to_vliw (vliw, unit);
898
      if (new_vliw && check_insn_major_constraints (vliw, major, insn))
899
        {
900
          vliw->current_vliw = new_vliw;
901
          vliw->major[index] = major;
902
          vliw->insn[index] = insn;
903
          vliw->next_slot++;
904
          return 0;
905
        }
906
 
907
      /* The frv machine supports all packing conbinations.  If we fail,
908
         to add the insn, then it could not be handled as if it was the fr500.
909
         Just return as if it was handled ok.  */
910
      if (vliw->mach == bfd_mach_frv)
911
        return 0;
912
    }
913
 
914
  vliw->constraint_violation = 1;
915
  return 1;
916
}
917
 
918
bfd_boolean
919
spr_valid (long regno)
920
{
921
  if (regno < 0)     return FALSE;
922
  if (regno <= 4095) return TRUE;
923
  return FALSE;
924
}
925
/* -- */
926
 
927
/* -- asm.c */
928
inline static const char *
929
parse_symbolic_address (CGEN_CPU_DESC cd,
930
                        const char **strp,
931
                        int opindex,
932
                        int opinfo,
933
                        enum cgen_parse_operand_result *resultp,
934
                        bfd_vma *valuep)
935
{
936
  enum cgen_parse_operand_result result_type;
937
  const char *errmsg = (* cd->parse_operand_fn)
938
    (cd, CGEN_PARSE_OPERAND_SYMBOLIC, strp, opindex, opinfo,
939
     &result_type, valuep);
940
 
941
  if (errmsg == NULL
942
      && result_type != CGEN_PARSE_OPERAND_RESULT_QUEUED)
943
    return "symbolic expression required";
944
 
945
  if (resultp)
946
    *resultp = result_type;
947
 
948
  return errmsg;
949
}
950
 
951
static const char *
952
parse_ldd_annotation (CGEN_CPU_DESC cd,
953
                      const char **strp,
954
                      int opindex,
955
                      unsigned long *valuep)
956
{
957
  const char *errmsg;
958
  enum cgen_parse_operand_result result_type;
959
  bfd_vma value;
960
 
961
  if (**strp == '#' || **strp == '%')
962
    {
963
      if (strncasecmp (*strp + 1, "tlsdesc(", 8) == 0)
964
        {
965
          *strp += 9;
966
          errmsg = parse_symbolic_address (cd, strp, opindex,
967
                                           BFD_RELOC_FRV_TLSDESC_RELAX,
968
                                           &result_type, &value);
969
          if (**strp != ')')
970
            return "missing ')'";
971
          if (valuep)
972
            *valuep = value;
973
          ++*strp;
974
          if (errmsg)
975
            return errmsg;
976
        }
977
    }
978
 
979
  while (**strp == ' ' || **strp == '\t')
980
    ++*strp;
981
 
982
  if (**strp != '@')
983
    return "missing `@'";
984
 
985
  ++*strp;
986
 
987
  return NULL;
988
}
989
 
990
static const char *
991
parse_call_annotation (CGEN_CPU_DESC cd,
992
                       const char **strp,
993
                       int opindex,
994
                       unsigned long *valuep)
995
{
996
  const char *errmsg;
997
  enum cgen_parse_operand_result result_type;
998
  bfd_vma value;
999
 
1000
  if (**strp == '#' || **strp == '%')
1001
    {
1002
      if (strncasecmp (*strp + 1, "gettlsoff(", 10) == 0)
1003
        {
1004
          *strp += 11;
1005
          errmsg = parse_symbolic_address (cd, strp, opindex,
1006
                                           BFD_RELOC_FRV_GETTLSOFF_RELAX,
1007
                                           &result_type, &value);
1008
          if (**strp != ')')
1009
            return "missing ')'";
1010
          if (valuep)
1011
            *valuep = value;
1012
          ++*strp;
1013
          if (errmsg)
1014
            return errmsg;
1015
        }
1016
    }
1017
 
1018
  while (**strp == ' ' || **strp == '\t')
1019
    ++*strp;
1020
 
1021
  if (**strp != '@')
1022
    return "missing `@'";
1023
 
1024
  ++*strp;
1025
 
1026
  return NULL;
1027
}
1028
 
1029
static const char *
1030
parse_ld_annotation (CGEN_CPU_DESC cd,
1031
                     const char **strp,
1032
                     int opindex,
1033
                     unsigned long *valuep)
1034
{
1035
  const char *errmsg;
1036
  enum cgen_parse_operand_result result_type;
1037
  bfd_vma value;
1038
 
1039
  if (**strp == '#' || **strp == '%')
1040
    {
1041
      if (strncasecmp (*strp + 1, "tlsoff(", 7) == 0)
1042
        {
1043
          *strp += 8;
1044
          errmsg = parse_symbolic_address (cd, strp, opindex,
1045
                                           BFD_RELOC_FRV_TLSOFF_RELAX,
1046
                                           &result_type, &value);
1047
          if (**strp != ')')
1048
            return "missing ')'";
1049
          if (valuep)
1050
            *valuep = value;
1051
          ++*strp;
1052
          if (errmsg)
1053
            return errmsg;
1054
        }
1055
    }
1056
 
1057
  while (**strp == ' ' || **strp == '\t')
1058
    ++*strp;
1059
 
1060
  if (**strp != '@')
1061
    return "missing `@'";
1062
 
1063
  ++*strp;
1064
 
1065
  return NULL;
1066
}
1067
 
1068
static const char *
1069
parse_ulo16 (CGEN_CPU_DESC cd,
1070
             const char **strp,
1071
             int opindex,
1072
             unsigned long *valuep)
1073
{
1074
  const char *errmsg;
1075
  enum cgen_parse_operand_result result_type;
1076
  bfd_vma value;
1077
 
1078
  if (**strp == '#' || **strp == '%')
1079
    {
1080
      if (strncasecmp (*strp + 1, "lo(", 3) == 0)
1081
        {
1082
          *strp += 4;
1083
          errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_FRV_LO16,
1084
                                       & result_type, & value);
1085
          if (**strp != ')')
1086
            return "missing `)'";
1087
          ++*strp;
1088
          if (errmsg == NULL
1089
              && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
1090
            value &= 0xffff;
1091
          *valuep = value;
1092
          return errmsg;
1093
        }
1094
      if (strncasecmp (*strp + 1, "gprello(", 8) == 0)
1095
        {
1096
          *strp += 9;
1097
          errmsg = parse_symbolic_address (cd, strp, opindex,
1098
                                           BFD_RELOC_FRV_GPRELLO,
1099
                                           & result_type, & value);
1100
          if (**strp != ')')
1101
            return "missing ')'";
1102
          ++*strp;
1103
          *valuep = value;
1104
          return errmsg;
1105
        }
1106
      else if (strncasecmp (*strp + 1, "gotlo(", 6) == 0)
1107
        {
1108
          *strp += 7;
1109
          errmsg = parse_symbolic_address (cd, strp, opindex,
1110
                                           BFD_RELOC_FRV_GOTLO,
1111
                                           & result_type, & value);
1112
          if (**strp != ')')
1113
            return "missing ')'";
1114
          ++*strp;
1115
          *valuep = value;
1116
          return errmsg;
1117
        }
1118
      else if (strncasecmp (*strp + 1, "gotfuncdesclo(", 14) == 0)
1119
        {
1120
          *strp += 15;
1121
          errmsg = parse_symbolic_address (cd, strp, opindex,
1122
                                           BFD_RELOC_FRV_FUNCDESC_GOTLO,
1123
                                           & result_type, & value);
1124
          if (**strp != ')')
1125
            return "missing ')'";
1126
          ++*strp;
1127
          *valuep = value;
1128
          return errmsg;
1129
        }
1130
      else if (strncasecmp (*strp + 1, "gotofflo(", 9) == 0)
1131
        {
1132
          *strp += 10;
1133
          errmsg = parse_symbolic_address (cd, strp, opindex,
1134
                                           BFD_RELOC_FRV_GOTOFFLO,
1135
                                           & result_type, & value);
1136
          if (**strp != ')')
1137
            return "missing ')'";
1138
          ++*strp;
1139
          *valuep = value;
1140
          return errmsg;
1141
        }
1142
      else if (strncasecmp (*strp + 1, "gotofffuncdesclo(", 17) == 0)
1143
        {
1144
          *strp += 18;
1145
          errmsg = parse_symbolic_address (cd, strp, opindex,
1146
                                           BFD_RELOC_FRV_FUNCDESC_GOTOFFLO,
1147
                                           & result_type, & value);
1148
          if (**strp != ')')
1149
            return "missing ')'";
1150
          ++*strp;
1151
          *valuep = value;
1152
          return errmsg;
1153
        }
1154
      else if (strncasecmp (*strp + 1, "gottlsdesclo(", 13) == 0)
1155
        {
1156
          *strp += 14;
1157
          errmsg = parse_symbolic_address (cd, strp, opindex,
1158
                                           BFD_RELOC_FRV_GOTTLSDESCLO,
1159
                                           & result_type, & value);
1160
          if (**strp != ')')
1161
            return "missing ')'";
1162
          ++*strp;
1163
          *valuep = value;
1164
          return errmsg;
1165
        }
1166
      else if (strncasecmp (*strp + 1, "tlsmofflo(", 10) == 0)
1167
        {
1168
          *strp += 11;
1169
          errmsg = parse_symbolic_address (cd, strp, opindex,
1170
                                           BFD_RELOC_FRV_TLSMOFFLO,
1171
                                           & result_type, & value);
1172
          if (**strp != ')')
1173
            return "missing ')'";
1174
          ++*strp;
1175
          *valuep = value;
1176
          return errmsg;
1177
        }
1178
      else if (strncasecmp (*strp + 1, "gottlsofflo(", 12) == 0)
1179
        {
1180
          *strp += 13;
1181
          errmsg = parse_symbolic_address (cd, strp, opindex,
1182
                                           BFD_RELOC_FRV_GOTTLSOFFLO,
1183
                                           & result_type, & value);
1184
          if (**strp != ')')
1185
            return "missing ')'";
1186
          ++*strp;
1187
          *valuep = value;
1188
          return errmsg;
1189
        }
1190
    }
1191
  return cgen_parse_unsigned_integer (cd, strp, opindex, valuep);
1192
}
1193
 
1194
static const char *
1195
parse_uslo16 (CGEN_CPU_DESC cd,
1196
              const char **strp,
1197
              int opindex,
1198
              signed long *valuep)
1199
{
1200
  const char *errmsg;
1201
  enum cgen_parse_operand_result result_type;
1202
  bfd_vma value;
1203
 
1204
  if (**strp == '#' || **strp == '%')
1205
    {
1206
      if (strncasecmp (*strp + 1, "lo(", 3) == 0)
1207
        {
1208
          *strp += 4;
1209
          errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_FRV_LO16,
1210
                                       & result_type, & value);
1211
          if (**strp != ')')
1212
            return "missing `)'";
1213
          ++*strp;
1214
          if (errmsg == NULL
1215
              && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
1216
            value &= 0xffff;
1217
          *valuep = value;
1218
          return errmsg;
1219
        }
1220
      else if (strncasecmp (*strp + 1, "gprello(", 8) == 0)
1221
        {
1222
          *strp += 9;
1223
          errmsg = parse_symbolic_address (cd, strp, opindex,
1224
                                           BFD_RELOC_FRV_GPRELLO,
1225
                                           & result_type, & value);
1226
          if (**strp != ')')
1227
            return "missing ')'";
1228
          ++*strp;
1229
          *valuep = value;
1230
          return errmsg;
1231
        }
1232
      else if (strncasecmp (*strp + 1, "gotlo(", 6) == 0)
1233
        {
1234
          *strp += 7;
1235
          errmsg = parse_symbolic_address (cd, strp, opindex,
1236
                                           BFD_RELOC_FRV_GOTLO,
1237
                                           & result_type, & value);
1238
          if (**strp != ')')
1239
            return "missing ')'";
1240
          ++*strp;
1241
          *valuep = value;
1242
          return errmsg;
1243
        }
1244
      else if (strncasecmp (*strp + 1, "gotfuncdesclo(", 14) == 0)
1245
        {
1246
          *strp += 15;
1247
          errmsg = parse_symbolic_address (cd, strp, opindex,
1248
                                           BFD_RELOC_FRV_FUNCDESC_GOTLO,
1249
                                           & result_type, & value);
1250
          if (**strp != ')')
1251
            return "missing ')'";
1252
          ++*strp;
1253
          *valuep = value;
1254
          return errmsg;
1255
        }
1256
      else if (strncasecmp (*strp + 1, "gotofflo(", 9) == 0)
1257
        {
1258
          *strp += 10;
1259
          errmsg = parse_symbolic_address (cd, strp, opindex,
1260
                                           BFD_RELOC_FRV_GOTOFFLO,
1261
                                           & result_type, & value);
1262
          if (**strp != ')')
1263
            return "missing ')'";
1264
          ++*strp;
1265
          *valuep = value;
1266
          return errmsg;
1267
        }
1268
      else if (strncasecmp (*strp + 1, "gotofffuncdesclo(", 17) == 0)
1269
        {
1270
          *strp += 18;
1271
          errmsg = parse_symbolic_address (cd, strp, opindex,
1272
                                           BFD_RELOC_FRV_FUNCDESC_GOTOFFLO,
1273
                                           & result_type, & value);
1274
          if (**strp != ')')
1275
            return "missing ')'";
1276
          ++*strp;
1277
          *valuep = value;
1278
          return errmsg;
1279
        }
1280
      else if (strncasecmp (*strp + 1, "gottlsdesclo(", 13) == 0)
1281
        {
1282
          *strp += 14;
1283
          errmsg = parse_symbolic_address (cd, strp, opindex,
1284
                                           BFD_RELOC_FRV_GOTTLSDESCLO,
1285
                                           & result_type, & value);
1286
          if (**strp != ')')
1287
            return "missing ')'";
1288
          ++*strp;
1289
          *valuep = value;
1290
          return errmsg;
1291
        }
1292
      else if (strncasecmp (*strp + 1, "tlsmofflo(", 10) == 0)
1293
        {
1294
          *strp += 11;
1295
          errmsg = parse_symbolic_address (cd, strp, opindex,
1296
                                           BFD_RELOC_FRV_TLSMOFFLO,
1297
                                           & result_type, & value);
1298
          if (**strp != ')')
1299
            return "missing ')'";
1300
          ++*strp;
1301
          *valuep = value;
1302
          return errmsg;
1303
        }
1304
      else if (strncasecmp (*strp + 1, "gottlsofflo(", 12) == 0)
1305
        {
1306
          *strp += 13;
1307
          errmsg = parse_symbolic_address (cd, strp, opindex,
1308
                                           BFD_RELOC_FRV_GOTTLSOFFLO,
1309
                                           & result_type, & value);
1310
          if (**strp != ')')
1311
            return "missing ')'";
1312
          ++*strp;
1313
          *valuep = value;
1314
          return errmsg;
1315
        }
1316
    }
1317
  return cgen_parse_signed_integer (cd, strp, opindex, valuep);
1318
}
1319
 
1320
static const char *
1321
parse_uhi16 (CGEN_CPU_DESC cd,
1322
             const char **strp,
1323
             int opindex,
1324
             unsigned long *valuep)
1325
{
1326
  const char *errmsg;
1327
  enum cgen_parse_operand_result result_type;
1328
  bfd_vma value;
1329
 
1330
  if (**strp == '#' || **strp == '%')
1331
    {
1332
      if (strncasecmp (*strp + 1, "hi(", 3) == 0)
1333
        {
1334
          *strp += 4;
1335
          errmsg = cgen_parse_address (cd, strp, opindex, BFD_RELOC_FRV_HI16,
1336
                                       & result_type, & value);
1337
          if (**strp != ')')
1338
            return "missing `)'";
1339
          ++*strp;
1340
          if (errmsg == NULL
1341
              && result_type == CGEN_PARSE_OPERAND_RESULT_NUMBER)
1342
            {
1343
              /* If bfd_vma is wider than 32 bits, but we have a sign-
1344
                 or zero-extension, truncate it.  */
1345
              if (value >= - ((bfd_vma)1 << 31)
1346
                  || value <= ((bfd_vma)1 << 31) - (bfd_vma)1)
1347
                value &= (((bfd_vma)1 << 16) << 16) - 1;
1348
              value >>= 16;
1349
            }
1350
          *valuep = value;
1351
          return errmsg;
1352
        }
1353
      else if (strncasecmp (*strp + 1, "gprelhi(", 8) == 0)
1354
        {
1355
          *strp += 9;
1356
          errmsg = parse_symbolic_address (cd, strp, opindex,
1357
                                           BFD_RELOC_FRV_GPRELHI,
1358
                                           & result_type, & value);
1359
          if (**strp != ')')
1360
            return "missing ')'";
1361
          ++*strp;
1362
          *valuep = value;
1363
          return errmsg;
1364
        }
1365
      else if (strncasecmp (*strp + 1, "gothi(", 6) == 0)
1366
        {
1367
          *strp += 7;
1368
          errmsg = parse_symbolic_address (cd, strp, opindex,
1369
                                           BFD_RELOC_FRV_GOTHI,
1370
                                           & result_type, & value);
1371
          if (**strp != ')')
1372
            return "missing ')'";
1373
          ++*strp;
1374
          *valuep = value;
1375
          return errmsg;
1376
        }
1377
      else if (strncasecmp (*strp + 1, "gotfuncdeschi(", 14) == 0)
1378
        {
1379
          *strp += 15;
1380
          errmsg = parse_symbolic_address (cd, strp, opindex,
1381
                                           BFD_RELOC_FRV_FUNCDESC_GOTHI,
1382
                                           & result_type, & value);
1383
          if (**strp != ')')
1384
            return "missing ')'";
1385
          ++*strp;
1386
          *valuep = value;
1387
          return errmsg;
1388
        }
1389
      else if (strncasecmp (*strp + 1, "gotoffhi(", 9) == 0)
1390
        {
1391
          *strp += 10;
1392
          errmsg = parse_symbolic_address (cd, strp, opindex,
1393
                                           BFD_RELOC_FRV_GOTOFFHI,
1394
                                           & result_type, & value);
1395
          if (**strp != ')')
1396
            return "missing ')'";
1397
          ++*strp;
1398
          *valuep = value;
1399
          return errmsg;
1400
        }
1401
      else if (strncasecmp (*strp + 1, "gotofffuncdeschi(", 17) == 0)
1402
        {
1403
          *strp += 18;
1404
          errmsg = parse_symbolic_address (cd, strp, opindex,
1405
                                           BFD_RELOC_FRV_FUNCDESC_GOTOFFHI,
1406
                                           & result_type, & value);
1407
          if (**strp != ')')
1408
            return "missing ')'";
1409
          ++*strp;
1410
          *valuep = value;
1411
          return errmsg;
1412
        }
1413
      else if (strncasecmp (*strp + 1, "gottlsdeschi(", 13) == 0)
1414
        {
1415
          *strp += 14;
1416
          errmsg = parse_symbolic_address (cd, strp, opindex,
1417
                                           BFD_RELOC_FRV_GOTTLSDESCHI,
1418
                                           &result_type, &value);
1419
          if (**strp != ')')
1420
            return "missing ')'";
1421
          ++*strp;
1422
          *valuep = value;
1423
          return errmsg;
1424
        }
1425
      else if (strncasecmp (*strp + 1, "tlsmoffhi(", 10) == 0)
1426
        {
1427
          *strp += 11;
1428
          errmsg = parse_symbolic_address (cd, strp, opindex,
1429
                                           BFD_RELOC_FRV_TLSMOFFHI,
1430
                                           & result_type, & value);
1431
          if (**strp != ')')
1432
            return "missing ')'";
1433
          ++*strp;
1434
          *valuep = value;
1435
          return errmsg;
1436
        }
1437
      else if (strncasecmp (*strp + 1, "gottlsoffhi(", 12) == 0)
1438
        {
1439
          *strp += 13;
1440
          errmsg = parse_symbolic_address (cd, strp, opindex,
1441
                                           BFD_RELOC_FRV_GOTTLSOFFHI,
1442
                                           & result_type, & value);
1443
          if (**strp != ')')
1444
            return "missing ')'";
1445
          ++*strp;
1446
          *valuep = value;
1447
          return errmsg;
1448
        }
1449
    }
1450
  return cgen_parse_unsigned_integer (cd, strp, opindex, valuep);
1451
}
1452
 
1453
static long
1454
parse_register_number (const char **strp)
1455
{
1456
  int regno;
1457
 
1458
  if (**strp < '0' || **strp > '9')
1459
    return -1; /* error */
1460
 
1461
  regno = **strp - '0';
1462
  for (++*strp; **strp >= '0' && **strp <= '9'; ++*strp)
1463
    regno = regno * 10 + (**strp - '0');
1464
 
1465
  return regno;
1466
}
1467
 
1468
static const char *
1469
parse_spr (CGEN_CPU_DESC cd,
1470
           const char **strp,
1471
           CGEN_KEYWORD * table,
1472
           long *valuep)
1473
{
1474
  const char *save_strp;
1475
  long regno;
1476
 
1477
  /* Check for spr index notation.  */
1478
  if (strncasecmp (*strp, "spr[", 4) == 0)
1479
    {
1480
      *strp += 4;
1481
      regno = parse_register_number (strp);
1482
      if (**strp != ']')
1483
        return _("missing `]'");
1484
      ++*strp;
1485
      if (! spr_valid (regno))
1486
        return _("Special purpose register number is out of range");
1487
      *valuep = regno;
1488
      return NULL;
1489
    }
1490
 
1491
  save_strp = *strp;
1492
  regno = parse_register_number (strp);
1493
  if (regno != -1)
1494
    {
1495
      if (! spr_valid (regno))
1496
        return _("Special purpose register number is out of range");
1497
      *valuep = regno;
1498
      return NULL;
1499
    }
1500
 
1501
  *strp = save_strp;
1502
  return cgen_parse_keyword (cd, strp, table, valuep);
1503
}
1504
 
1505
static const char *
1506
parse_d12 (CGEN_CPU_DESC cd,
1507
           const char **strp,
1508
           int opindex,
1509
           long *valuep)
1510
{
1511
  const char *errmsg;
1512
  enum cgen_parse_operand_result result_type;
1513
  bfd_vma value;
1514
 
1515
  /* Check for small data reference.  */
1516
  if (**strp == '#' || **strp == '%')
1517
    {
1518
      if (strncasecmp (*strp + 1, "gprel12(", 8) == 0)
1519
        {
1520
          *strp += 9;
1521
          errmsg = parse_symbolic_address (cd, strp, opindex,
1522
                                           BFD_RELOC_FRV_GPREL12,
1523
                                           & result_type, & value);
1524
          if (**strp != ')')
1525
            return "missing `)'";
1526
          ++*strp;
1527
          *valuep = value;
1528
          return errmsg;
1529
        }
1530
      else if (strncasecmp (*strp + 1, "got12(", 6) == 0)
1531
        {
1532
          *strp += 7;
1533
          errmsg = parse_symbolic_address (cd, strp, opindex,
1534
                                           BFD_RELOC_FRV_GOT12,
1535
                                           & result_type, & value);
1536
          if (**strp != ')')
1537
            return "missing ')'";
1538
          ++*strp;
1539
          *valuep = value;
1540
          return errmsg;
1541
        }
1542
      else if (strncasecmp (*strp + 1, "gotfuncdesc12(", 14) == 0)
1543
        {
1544
          *strp += 15;
1545
          errmsg = parse_symbolic_address (cd, strp, opindex,
1546
                                           BFD_RELOC_FRV_FUNCDESC_GOT12,
1547
                                           & result_type, & value);
1548
          if (**strp != ')')
1549
            return "missing ')'";
1550
          ++*strp;
1551
          *valuep = value;
1552
          return errmsg;
1553
        }
1554
      else if (strncasecmp (*strp + 1, "gotoff12(", 9) == 0)
1555
        {
1556
          *strp += 10;
1557
          errmsg = parse_symbolic_address (cd, strp, opindex,
1558
                                           BFD_RELOC_FRV_GOTOFF12,
1559
                                           & result_type, & value);
1560
          if (**strp != ')')
1561
            return "missing ')'";
1562
          ++*strp;
1563
          *valuep = value;
1564
          return errmsg;
1565
        }
1566
      else if (strncasecmp (*strp + 1, "gotofffuncdesc12(", 17) == 0)
1567
        {
1568
          *strp += 18;
1569
          errmsg = parse_symbolic_address (cd, strp, opindex,
1570
                                           BFD_RELOC_FRV_FUNCDESC_GOTOFF12,
1571
                                           & result_type, & value);
1572
          if (**strp != ')')
1573
            return "missing ')'";
1574
          ++*strp;
1575
          *valuep = value;
1576
          return errmsg;
1577
        }
1578
      else if (strncasecmp (*strp + 1, "gottlsdesc12(", 13) == 0)
1579
        {
1580
          *strp += 14;
1581
          errmsg = parse_symbolic_address (cd, strp, opindex,
1582
                                           BFD_RELOC_FRV_GOTTLSDESC12,
1583
                                           & result_type, & value);
1584
          if (**strp != ')')
1585
            return "missing ')'";
1586
          ++*strp;
1587
          *valuep = value;
1588
          return errmsg;
1589
        }
1590
      else if (strncasecmp (*strp + 1, "tlsmoff12(", 10) == 0)
1591
        {
1592
          *strp += 11;
1593
          errmsg = parse_symbolic_address (cd, strp, opindex,
1594
                                           BFD_RELOC_FRV_TLSMOFF12,
1595
                                           & result_type, & value);
1596
          if (**strp != ')')
1597
            return "missing ')'";
1598
          ++*strp;
1599
          *valuep = value;
1600
          return errmsg;
1601
        }
1602
      else if (strncasecmp (*strp + 1, "gottlsoff12(", 12) == 0)
1603
        {
1604
          *strp += 13;
1605
          errmsg = parse_symbolic_address (cd, strp, opindex,
1606
                                           BFD_RELOC_FRV_GOTTLSOFF12,
1607
                                           & result_type, & value);
1608
          if (**strp != ')')
1609
            return "missing ')'";
1610
          ++*strp;
1611
          *valuep = value;
1612
          return errmsg;
1613
        }
1614
    }
1615
  return cgen_parse_signed_integer (cd, strp, opindex, valuep);
1616
}
1617
 
1618
static const char *
1619
parse_s12 (CGEN_CPU_DESC cd,
1620
           const char **strp,
1621
           int opindex,
1622
           long *valuep)
1623
{
1624
  const char *errmsg;
1625
  enum cgen_parse_operand_result result_type;
1626
  bfd_vma value;
1627
 
1628
  /* Check for small data reference.  */
1629
  if (**strp == '#' || **strp == '%')
1630
    {
1631
      if (strncasecmp (*strp + 1, "gprel12(", 8) == 0)
1632
        {
1633
          *strp += 9;
1634
          errmsg = parse_symbolic_address (cd, strp, opindex,
1635
                                           BFD_RELOC_FRV_GPREL12,
1636
                                           & result_type, & value);
1637
          if (**strp != ')')
1638
            return "missing `)'";
1639
          ++*strp;
1640
          *valuep = value;
1641
          return errmsg;
1642
        }
1643
      else if (strncasecmp (*strp + 1, "got12(", 6) == 0)
1644
        {
1645
          *strp += 7;
1646
          errmsg = parse_symbolic_address (cd, strp, opindex,
1647
                                           BFD_RELOC_FRV_GOT12,
1648
                                           & result_type, & value);
1649
          if (**strp != ')')
1650
            return "missing ')'";
1651
          ++*strp;
1652
          *valuep = value;
1653
          return errmsg;
1654
        }
1655
      else if (strncasecmp (*strp + 1, "gotfuncdesc12(", 14) == 0)
1656
        {
1657
          *strp += 15;
1658
          errmsg = parse_symbolic_address (cd, strp, opindex,
1659
                                           BFD_RELOC_FRV_FUNCDESC_GOT12,
1660
                                           & result_type, & value);
1661
          if (**strp != ')')
1662
            return "missing ')'";
1663
          ++*strp;
1664
          *valuep = value;
1665
          return errmsg;
1666
        }
1667
      else if (strncasecmp (*strp + 1, "gotoff12(", 9) == 0)
1668
        {
1669
          *strp += 10;
1670
          errmsg = parse_symbolic_address (cd, strp, opindex,
1671
                                           BFD_RELOC_FRV_GOTOFF12,
1672
                                           & result_type, & value);
1673
          if (**strp != ')')
1674
            return "missing ')'";
1675
          ++*strp;
1676
          *valuep = value;
1677
          return errmsg;
1678
        }
1679
      else if (strncasecmp (*strp + 1, "gotofffuncdesc12(", 17) == 0)
1680
        {
1681
          *strp += 18;
1682
          errmsg = parse_symbolic_address (cd, strp, opindex,
1683
                                           BFD_RELOC_FRV_FUNCDESC_GOTOFF12,
1684
                                           & result_type, & value);
1685
          if (**strp != ')')
1686
            return "missing ')'";
1687
          ++*strp;
1688
          *valuep = value;
1689
          return errmsg;
1690
        }
1691
      else if (strncasecmp (*strp + 1, "gottlsdesc12(", 13) == 0)
1692
        {
1693
          *strp += 14;
1694
          errmsg = parse_symbolic_address (cd, strp, opindex,
1695
                                           BFD_RELOC_FRV_GOTTLSDESC12,
1696
                                           & result_type, & value);
1697
          if (**strp != ')')
1698
            return "missing ')'";
1699
          ++*strp;
1700
          *valuep = value;
1701
          return errmsg;
1702
        }
1703
      else if (strncasecmp (*strp + 1, "tlsmoff12(", 10) == 0)
1704
        {
1705
          *strp += 11;
1706
          errmsg = parse_symbolic_address (cd, strp, opindex,
1707
                                           BFD_RELOC_FRV_TLSMOFF12,
1708
                                           & result_type, & value);
1709
          if (**strp != ')')
1710
            return "missing ')'";
1711
          ++*strp;
1712
          *valuep = value;
1713
          return errmsg;
1714
        }
1715
      else if (strncasecmp (*strp + 1, "gottlsoff12(", 12) == 0)
1716
        {
1717
          *strp += 13;
1718
          errmsg = parse_symbolic_address (cd, strp, opindex,
1719
                                           BFD_RELOC_FRV_GOTTLSOFF12,
1720
                                           & result_type, & value);
1721
          if (**strp != ')')
1722
            return "missing ')'";
1723
          ++*strp;
1724
          *valuep = value;
1725
          return errmsg;
1726
        }
1727
    }
1728
 
1729
  if (**strp == '#')
1730
    ++*strp;
1731
  return cgen_parse_signed_integer (cd, strp, opindex, valuep);
1732
}
1733
 
1734
static const char *
1735
parse_u12 (CGEN_CPU_DESC cd,
1736
           const char **strp,
1737
           int opindex,
1738
           long *valuep)
1739
{
1740
  const char *errmsg;
1741
  enum cgen_parse_operand_result result_type;
1742
  bfd_vma value;
1743
 
1744
  /* Check for small data reference.  */
1745
  if ((**strp == '#' || **strp == '%')
1746
      && strncasecmp (*strp + 1, "gprel12(", 8) == 0)
1747
    {
1748
      *strp += 9;
1749
      errmsg = parse_symbolic_address (cd, strp, opindex,
1750
                                       BFD_RELOC_FRV_GPRELU12,
1751
                                       & result_type, & value);
1752
      if (**strp != ')')
1753
        return "missing `)'";
1754
      ++*strp;
1755
      *valuep = value;
1756
      return errmsg;
1757
    }
1758
  else
1759
    {
1760
      if (**strp == '#')
1761
        ++*strp;
1762
      return cgen_parse_signed_integer (cd, strp, opindex, valuep);
1763
    }
1764
}
1765
 
1766
static const char *
1767
parse_A (CGEN_CPU_DESC cd,
1768
         const char **strp,
1769
         int opindex,
1770
         unsigned long *valuep,
1771
         unsigned long A)
1772
{
1773
  const char *errmsg;
1774
 
1775
  if (**strp == '#')
1776
    ++*strp;
1777
 
1778
  errmsg = cgen_parse_unsigned_integer (cd, strp, opindex, valuep);
1779
  if (errmsg)
1780
    return errmsg;
1781
 
1782
  if (*valuep != A)
1783
    return _("Value of A operand must be 0 or 1");
1784
 
1785
  return NULL;
1786
}
1787
 
1788
static const char *
1789
parse_A0 (CGEN_CPU_DESC cd,
1790
          const char **strp,
1791
          int opindex,
1792
          unsigned long *valuep)
1793
{
1794
  return parse_A (cd, strp, opindex, valuep, 0);
1795
}
1796
 
1797
static const char *
1798
parse_A1 (CGEN_CPU_DESC cd,
1799
          const char **strp,
1800
          int opindex,
1801
          unsigned long *valuep)
1802
{
1803
  return parse_A (cd, strp, opindex, valuep, 1);
1804
}
1805
 
1806
static const char *
1807
parse_even_register (CGEN_CPU_DESC  cd,
1808
                     const char **  strP,
1809
                     CGEN_KEYWORD * tableP,
1810
                     long *         valueP)
1811
{
1812
  const char * errmsg;
1813
  const char * saved_star_strP = * strP;
1814
 
1815
  errmsg = cgen_parse_keyword (cd, strP, tableP, valueP);
1816
 
1817
  if (errmsg == NULL && ((* valueP) & 1))
1818
    {
1819
      errmsg = _("register number must be even");
1820
      * strP = saved_star_strP;
1821
    }
1822
 
1823
  return errmsg;
1824
}
1825
 
1826
static const char *
1827
parse_call_label (CGEN_CPU_DESC cd,
1828
                  const char **strp,
1829
                  int opindex,
1830
                  int opinfo,
1831
                  enum cgen_parse_operand_result *resultp,
1832
                  bfd_vma *valuep)
1833
{
1834
  const char *errmsg;
1835
  bfd_vma value;
1836
 
1837
  /* Check for small data reference.  */
1838
  if (opinfo == 0 && (**strp == '#' || **strp == '%'))
1839
    {
1840
      if (strncasecmp (*strp + 1, "gettlsoff(", 10) == 0)
1841
        {
1842
          *strp += 11;
1843
          errmsg = parse_symbolic_address (cd, strp, opindex,
1844
                                           BFD_RELOC_FRV_GETTLSOFF,
1845
                                           resultp, &value);
1846
          if (**strp != ')')
1847
            return _("missing `)'");
1848
          ++*strp;
1849
          *valuep = value;
1850
          return errmsg;
1851
        }
1852
    }
1853
 
1854
  return cgen_parse_address (cd, strp, opindex, opinfo, resultp, valuep);
1855
}
1856
 
1857
/* -- */
1858
 
1859
/* -- dis.c */
1860
static void
1861
print_at (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
1862
          void * dis_info,
1863
          long reloc_ann ATTRIBUTE_UNUSED,
1864
          long value ATTRIBUTE_UNUSED,
1865
          bfd_vma pc ATTRIBUTE_UNUSED,
1866
          int length ATTRIBUTE_UNUSED)
1867
{
1868
  disassemble_info *info = (disassemble_info *) dis_info;
1869
 
1870
  (*info->fprintf_func) (info->stream, "@");
1871
}
1872
 
1873
static void
1874
print_spr (CGEN_CPU_DESC cd,
1875
           void * dis_info,
1876
           CGEN_KEYWORD *names,
1877
           long regno,
1878
           unsigned int attrs)
1879
{
1880
  /* Use the register index format for any unnamed registers.  */
1881
  if (cgen_keyword_lookup_value (names, regno) == NULL)
1882
    {
1883
      disassemble_info *info = (disassemble_info *) dis_info;
1884
      (*info->fprintf_func) (info->stream, "spr[%ld]", regno);
1885
    }
1886
  else
1887
    print_keyword (cd, dis_info, names, regno, attrs);
1888
}
1889
 
1890
static void
1891
print_hi (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
1892
          void * dis_info,
1893
          long value,
1894
          unsigned int attrs ATTRIBUTE_UNUSED,
1895
          bfd_vma pc ATTRIBUTE_UNUSED,
1896
          int length ATTRIBUTE_UNUSED)
1897
{
1898
  disassemble_info *info = (disassemble_info *) dis_info;
1899
 
1900
  (*info->fprintf_func) (info->stream, value ? "0x%lx" : "hi(0x%lx)", value);
1901
}
1902
 
1903
static void
1904
print_lo (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED,
1905
          void * dis_info,
1906
          long value,
1907
          unsigned int attrs ATTRIBUTE_UNUSED,
1908
          bfd_vma pc ATTRIBUTE_UNUSED,
1909
          int length ATTRIBUTE_UNUSED)
1910
{
1911
  disassemble_info *info = (disassemble_info *) dis_info;
1912
  if (value)
1913
    (*info->fprintf_func) (info->stream, "0x%lx", value);
1914
  else
1915
    (*info->fprintf_func) (info->stream, "lo(0x%lx)", value);
1916
}
1917
 
1918
/* -- */

powered by: WebSVN 2.1.0

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