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

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [gas/] [config/] [tc-ns32k.c] - Blame information for rev 163

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 16 khays
/* ns32k.c  -- Assemble on the National Semiconductor 32k series
2
   Copyright 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3
   2001, 2002, 2003, 2005, 2006, 2007, 2008, 2009
4
   Free Software Foundation, Inc.
5
 
6
   This file is part of GAS, the GNU Assembler.
7
 
8
   GAS is free software; you can redistribute it and/or modify
9
   it under the terms of the GNU General Public License as published by
10
   the Free Software Foundation; either version 3, or (at your option)
11
   any later version.
12
 
13
   GAS is distributed in the hope that it will be useful,
14
   but WITHOUT ANY WARRANTY; without even the implied warranty of
15
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
   GNU General Public License for more details.
17
 
18
   You should have received a copy of the GNU General Public License
19
   along with GAS; see the file COPYING.  If not, write to the Free
20
   Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
21
   02110-1301, USA.  */
22
 
23
/*#define SHOW_NUM 1*//* Uncomment for debugging.  */
24
 
25
#include "as.h"
26
#include "opcode/ns32k.h"
27
 
28
#include "obstack.h"
29
 
30
/* Macros.  */
31
#define IIF_ENTRIES 13          /* Number of entries in iif.  */
32
#define PRIVATE_SIZE 256        /* Size of my garbage memory.  */
33
#define MAX_ARGS 4
34
#define DEFAULT -1              /* addr_mode returns this value when
35
                                   plain constant or label is
36
                                   encountered.  */
37
 
38
#define IIF(ptr,a1,c1,e1,g1,i1,k1,m1,o1,q1,s1,u1)       \
39
    iif.iifP[ptr].type = a1;                            \
40
    iif.iifP[ptr].size = c1;                            \
41
    iif.iifP[ptr].object = e1;                          \
42
    iif.iifP[ptr].object_adjust = g1;                   \
43
    iif.iifP[ptr].pcrel = i1;                           \
44
    iif.iifP[ptr].pcrel_adjust = k1;                    \
45
    iif.iifP[ptr].im_disp = m1;                         \
46
    iif.iifP[ptr].relax_substate = o1;                  \
47
    iif.iifP[ptr].bit_fixP = q1;                        \
48
    iif.iifP[ptr].addr_mode = s1;                       \
49
    iif.iifP[ptr].bsr = u1;
50
 
51
#ifdef SEQUENT_COMPATABILITY
52
#define LINE_COMMENT_CHARS "|"
53
#define ABSOLUTE_PREFIX '@'
54
#define IMMEDIATE_PREFIX '#'
55
#endif
56
 
57
#ifndef LINE_COMMENT_CHARS
58
#define LINE_COMMENT_CHARS "#"
59
#endif
60
 
61
const char comment_chars[] = "#";
62
const char line_comment_chars[] = LINE_COMMENT_CHARS;
63
const char line_separator_chars[] = ";";
64
static int default_disp_size = 4; /* Displacement size for external refs.  */
65
 
66
#if !defined(ABSOLUTE_PREFIX) && !defined(IMMEDIATE_PREFIX)
67
#define ABSOLUTE_PREFIX '@'     /* One or the other MUST be defined.  */
68
#endif
69
 
70
struct addr_mode
71
{
72
  signed char mode;             /* Addressing mode of operand (0-31).  */
73
  signed char scaled_mode;      /* Mode combined with scaled mode.  */
74
  char scaled_reg;              /* Register used in scaled+1 (1-8).  */
75
  char float_flag;              /* Set if R0..R7 was F0..F7 ie a
76
                                   floating-point-register.  */
77
  char am_size;                 /* Estimated max size of general addr-mode
78
                                   parts.  */
79
  char im_disp;                 /* If im_disp==1 we have a displacement.  */
80
  char pcrel;                   /* 1 if pcrel, this is really redundant info.  */
81
  char disp_suffix[2];          /* Length of displacement(s), 0=undefined.  */
82
  char *disp[2];                /* Pointer(s) at displacement(s)
83
                                   or immediates(s)     (ascii).  */
84
  char index_byte;              /* Index byte.  */
85
};
86
typedef struct addr_mode addr_modeS;
87
 
88
char *freeptr, *freeptr_static; /* Points at some number of free bytes.  */
89
struct hash_control *inst_hash_handle;
90
 
91
struct ns32k_opcode *desc;      /* Pointer at description of instruction.  */
92
addr_modeS addr_modeP;
93
const char EXP_CHARS[] = "eE";
94
const char FLT_CHARS[] = "fd";  /* We don't want to support lowercase,
95
                                   do we?  */
96
 
97
/* UPPERCASE denotes live names when an instruction is built, IIF is
98
   used as an intermediate form to store the actual parts of the
99
   instruction. A ns32k machine instruction can be divided into a
100
   couple of sub PARTs. When an instruction is assembled the
101
   appropriate PART get an assignment. When an IIF has been completed
102
   it is converted to a FRAGment as specified in AS.H.  */
103
 
104
/* Internal structs.  */
105
struct ns32k_option
106
{
107
  char *pattern;
108
  unsigned long or;
109
  unsigned long and;
110
};
111
 
112
typedef struct
113
{
114
  int type;                     /* How to interpret object.  */
115
  int size;                     /* Estimated max size of object.  */
116
  unsigned long object;         /* Binary data.  */
117
  int object_adjust;            /* Number added to object.  */
118
  int pcrel;                    /* True if object is pcrel.  */
119
  int pcrel_adjust;             /* Length in bytes from the instruction
120
                                   start to the displacement.  */
121
  int im_disp;                  /* True if the object is a displacement.  */
122
  relax_substateT relax_substate;/*Initial relaxsubstate.  */
123
  bit_fixS *bit_fixP;           /* Pointer at bit_fix struct.  */
124
  int addr_mode;                /* What addrmode do we associate with this
125
                                   iif-entry.  */
126
  char bsr;                     /* Sequent hack.  */
127
} iif_entryT;                   /* Internal Instruction Format.  */
128
 
129
struct int_ins_form
130
{
131
  int instr_size;               /* Max size of instruction in bytes.  */
132
  iif_entryT iifP[IIF_ENTRIES + 1];
133
};
134
 
135
struct int_ins_form iif;
136
expressionS exprP;
137
char *input_line_pointer;
138
 
139
/* Description of the PARTs in IIF
140
  object[n]:
141
 
142
   1    opcode
143
   2    index_byte_a
144
   3    index_byte_b
145
   4    disp_a_1
146
   5    disp_a_2
147
   6    disp_b_1
148
   7    disp_b_2
149
   8    imm_a
150
   9    imm_b
151
   10   implied1
152
   11   implied2
153
 
154
   For every entry there is a datalength in bytes. This is stored in size[n].
155
         0,     the objectlength is not explicitly given by the instruction
156
                and the operand is undefined. This is a case for relaxation.
157
                Reserve 4 bytes for the final object.
158
 
159
         1,     the entry contains one byte
160
         2,     the entry contains two bytes
161
         3,     the entry contains three bytes
162
         4,     the entry contains four bytes
163
        etc
164
 
165
   Furthermore, every entry has a data type identifier in type[n].
166
 
167
         0,     the entry is void, ignore it.
168
         1,     the entry is a binary number.
169
         2,     the entry is a pointer at an expression.
170
                Where expression may be as simple as a single '1',
171
                and as complicated as  foo-bar+12,
172
                foo and bar may be undefined but suffixed by :{b|w|d} to
173
                control the length of the object.
174
 
175
         3,     the entry is a pointer at a bignum struct
176
 
177
   The low-order-byte corresponds to low physical memory.
178
   Obviously a FRAGment must be created for each valid disp in PART whose
179
   datalength is undefined (to bad) .
180
   The case where just the expression is undefined is less severe and is
181
   handled by fix. Here the number of bytes in the objectfile is known.
182
   With this representation we simplify the assembly and separates the
183
   machine dependent/independent parts in a more clean way (said OE).  */
184
 
185
struct ns32k_option opt1[] =            /* restore, exit.  */
186
{
187
  {"r0", 0x80, 0xff},
188
  {"r1", 0x40, 0xff},
189
  {"r2", 0x20, 0xff},
190
  {"r3", 0x10, 0xff},
191
  {"r4", 0x08, 0xff},
192
  {"r5", 0x04, 0xff},
193
  {"r6", 0x02, 0xff},
194
  {"r7", 0x01, 0xff},
195
  {0, 0x00, 0xff}
196
};
197
struct ns32k_option opt2[] =            /* save, enter.  */
198
{
199
  {"r0", 0x01, 0xff},
200
  {"r1", 0x02, 0xff},
201
  {"r2", 0x04, 0xff},
202
  {"r3", 0x08, 0xff},
203
  {"r4", 0x10, 0xff},
204
  {"r5", 0x20, 0xff},
205
  {"r6", 0x40, 0xff},
206
  {"r7", 0x80, 0xff},
207
  {0, 0x00, 0xff}
208
};
209
struct ns32k_option opt3[] =            /* setcfg.  */
210
{
211
  {"c", 0x8, 0xff},
212
  {"m", 0x4, 0xff},
213
  {"f", 0x2, 0xff},
214
  {"i", 0x1, 0xff},
215
  {0, 0x0, 0xff}
216
};
217
struct ns32k_option opt4[] =            /* cinv.  */
218
{
219
  {"a", 0x4, 0xff},
220
  {"i", 0x2, 0xff},
221
  {"d", 0x1, 0xff},
222
  {0, 0x0, 0xff}
223
};
224
struct ns32k_option opt5[] =            /* String inst.  */
225
{
226
  {"b", 0x2, 0xff},
227
  {"u", 0xc, 0xff},
228
  {"w", 0x4, 0xff},
229
  {0, 0x0, 0xff}
230
};
231
struct ns32k_option opt6[] =            /* Plain reg ext,cvtp etc.  */
232
{
233
  {"r0", 0x00, 0xff},
234
  {"r1", 0x01, 0xff},
235
  {"r2", 0x02, 0xff},
236
  {"r3", 0x03, 0xff},
237
  {"r4", 0x04, 0xff},
238
  {"r5", 0x05, 0xff},
239
  {"r6", 0x06, 0xff},
240
  {"r7", 0x07, 0xff},
241
  {0, 0x00, 0xff}
242
};
243
 
244
#if !defined(NS32032) && !defined(NS32532)
245
#define NS32532
246
#endif
247
 
248
struct ns32k_option cpureg_532[] =      /* lpr spr.  */
249
{
250
  {"us", 0x0, 0xff},
251
  {"dcr", 0x1, 0xff},
252
  {"bpc", 0x2, 0xff},
253
  {"dsr", 0x3, 0xff},
254
  {"car", 0x4, 0xff},
255
  {"fp", 0x8, 0xff},
256
  {"sp", 0x9, 0xff},
257
  {"sb", 0xa, 0xff},
258
  {"usp", 0xb, 0xff},
259
  {"cfg", 0xc, 0xff},
260
  {"psr", 0xd, 0xff},
261
  {"intbase", 0xe, 0xff},
262
  {"mod", 0xf, 0xff},
263
  {0, 0x00, 0xff}
264
};
265
struct ns32k_option mmureg_532[] =      /* lmr smr.  */
266
{
267
  {"mcr", 0x9, 0xff},
268
  {"msr", 0xa, 0xff},
269
  {"tear", 0xb, 0xff},
270
  {"ptb0", 0xc, 0xff},
271
  {"ptb1", 0xd, 0xff},
272
  {"ivar0", 0xe, 0xff},
273
  {"ivar1", 0xf, 0xff},
274
  {0, 0x0, 0xff}
275
};
276
 
277
struct ns32k_option cpureg_032[] =      /* lpr spr.  */
278
{
279
  {"upsr", 0x0, 0xff},
280
  {"fp", 0x8, 0xff},
281
  {"sp", 0x9, 0xff},
282
  {"sb", 0xa, 0xff},
283
  {"psr", 0xd, 0xff},
284
  {"intbase", 0xe, 0xff},
285
  {"mod", 0xf, 0xff},
286
  {0, 0x0, 0xff}
287
};
288
struct ns32k_option mmureg_032[] =      /* lmr smr.  */
289
{
290
  {"bpr0", 0x0, 0xff},
291
  {"bpr1", 0x1, 0xff},
292
  {"pf0", 0x4, 0xff},
293
  {"pf1", 0x5, 0xff},
294
  {"sc", 0x8, 0xff},
295
  {"msr", 0xa, 0xff},
296
  {"bcnt", 0xb, 0xff},
297
  {"ptb0", 0xc, 0xff},
298
  {"ptb1", 0xd, 0xff},
299
  {"eia", 0xf, 0xff},
300
  {0, 0x0, 0xff}
301
};
302
 
303
#if defined(NS32532)
304
struct ns32k_option *cpureg = cpureg_532;
305
struct ns32k_option *mmureg = mmureg_532;
306
#else
307
struct ns32k_option *cpureg = cpureg_032;
308
struct ns32k_option *mmureg = mmureg_032;
309
#endif
310
 
311
 
312
const pseudo_typeS md_pseudo_table[] =
313
{                                       /* So far empty.  */
314
  {0, 0, 0}
315
};
316
 
317
#define IND(x,y)        (((x)<<2)+(y))
318
 
319
/* Those are index's to relax groups in md_relax_table ie it must be
320
   multiplied by 4 to point at a group start. Viz IND(x,y) Se function
321
   relax_segment in write.c for more info.  */
322
 
323
#define BRANCH          1
324
#define PCREL           2
325
 
326
/* Those are index's to entries in a relax group.  */
327
 
328
#define BYTE            0
329
#define WORD            1
330
#define DOUBLE          2
331
#define UNDEF           3
332
/* Those limits are calculated from the displacement start in memory.
333
   The ns32k uses the beginning of the instruction as displacement
334
   base.  This type of displacements could be handled here by moving
335
   the limit window up or down. I choose to use an internal
336
   displacement base-adjust as there are other routines that must
337
   consider this. Also, as we have two various offset-adjusts in the
338
   ns32k (acb versus br/brs/jsr/bcond), two set of limits would have
339
   had to be used.  Now we dont have to think about that.  */
340
 
341
const relax_typeS md_relax_table[] =
342
{
343
  {1, 1, 0, 0},
344
  {1, 1, 0, 0},
345
  {1, 1, 0, 0},
346
  {1, 1, 0, 0},
347
 
348
  {(63), (-64), 1, IND (BRANCH, WORD)},
349
  {(8192), (-8192), 2, IND (BRANCH, DOUBLE)},
350
  {0, 0, 4, 0},
351
  {1, 1, 0, 0}
352
};
353
 
354
/* Array used to test if mode contains displacements.
355
   Value is true if mode contains displacement.  */
356
 
357
char disp_test[] =
358
{0, 0, 0, 0, 0, 0, 0, 0,
359
 1, 1, 1, 1, 1, 1, 1, 1,
360
 1, 1, 1, 0, 0, 1, 1, 0,
361
 1, 1, 1, 1, 1, 1, 1, 1};
362
 
363
/* Array used to calculate max size of displacements.  */
364
 
365
char disp_size[] =
366
{4, 1, 2, 0, 4};
367
 
368
/* Parse a general operand into an addressingmode struct
369
 
370
   In:  pointer at operand in ascii form
371
        pointer at addr_mode struct for result
372
        the level of recursion. (always 0 or 1)
373
 
374
   Out: data in addr_mode struct.  */
375
 
376
static int
377
addr_mode (char *operand,
378
           addr_modeS *addrmodeP,
379
           int recursive_level)
380
{
381
  char *str;
382
  int i;
383
  int strl;
384
  int mode;
385
  int j;
386
 
387
  mode = DEFAULT;               /* Default.  */
388
  addrmodeP->scaled_mode = 0;    /* Why not.  */
389
  addrmodeP->scaled_reg = 0;     /* If 0, not scaled index.  */
390
  addrmodeP->float_flag = 0;
391
  addrmodeP->am_size = 0;
392
  addrmodeP->im_disp = 0;
393
  addrmodeP->pcrel = 0;  /* Not set in this function.  */
394
  addrmodeP->disp_suffix[0] = 0;
395
  addrmodeP->disp_suffix[1] = 0;
396
  addrmodeP->disp[0] = NULL;
397
  addrmodeP->disp[1] = NULL;
398
  str = operand;
399
 
400
  if (str[0] == 0)
401
    return 0;
402
 
403
  strl = strlen (str);
404
 
405
  switch (str[0])
406
    {
407
      /* The following three case statements controls the mode-chars
408
         this is the place to ed if you want to change them.  */
409
#ifdef ABSOLUTE_PREFIX
410
    case ABSOLUTE_PREFIX:
411
      if (str[strl - 1] == ']')
412
        break;
413
      addrmodeP->mode = 21;     /* absolute */
414
      addrmodeP->disp[0] = str + 1;
415
      return -1;
416
#endif
417
#ifdef IMMEDIATE_PREFIX
418
    case IMMEDIATE_PREFIX:
419
      if (str[strl - 1] == ']')
420
        break;
421
      addrmodeP->mode = 20;     /* immediate */
422
      addrmodeP->disp[0] = str + 1;
423
      return -1;
424
#endif
425
    case '.':
426
      if (str[strl - 1] != ']')
427
        {
428
          switch (str[1])
429
            {
430
            case '-':
431
            case '+':
432
              if (str[2] != '\000')
433
                {
434
                  addrmodeP->mode = 27; /* pc-relative */
435
                  addrmodeP->disp[0] = str + 2;
436
                  return -1;
437
                }
438
            default:
439
              as_bad (_("Invalid syntax in PC-relative addressing mode"));
440
              return 0;
441
            }
442
        }
443
      break;
444
    case 'e':
445
      if (str[strl - 1] != ']')
446
        {
447
          if ((!strncmp (str, "ext(", 4)) && strl > 7)
448
            {                           /* external */
449
              addrmodeP->disp[0] = str + 4;
450
              i = 0;
451
              j = 2;
452
              do
453
                {                       /* disp[0]'s termination point.  */
454
                  j += 1;
455
                  if (str[j] == '(')
456
                    i++;
457
                  if (str[j] == ')')
458
                    i--;
459
                }
460
              while (j < strl && i != 0);
461
              if (i != 0 || !(str[j + 1] == '-' || str[j + 1] == '+'))
462
                {
463
                  as_bad (_("Invalid syntax in External addressing mode"));
464
                  return (0);
465
                }
466
              str[j] = '\000';          /* null terminate disp[0] */
467
              addrmodeP->disp[1] = str + j + 2;
468
              addrmodeP->mode = 22;
469
              return -1;
470
            }
471
        }
472
      break;
473
 
474
    default:
475
      ;
476
    }
477
 
478
  strl = strlen (str);
479
 
480
  switch (strl)
481
    {
482
    case 2:
483
      switch (str[0])
484
        {
485
        case 'f':
486
          addrmodeP->float_flag = 1;
487
          /* Drop through.  */
488
        case 'r':
489
          if (str[1] >= '0' && str[1] < '8')
490
            {
491
              addrmodeP->mode = str[1] - '0';
492
              return -1;
493
            }
494
          break;
495
        default:
496
          break;
497
        }
498
      /* Drop through.  */
499
 
500
    case 3:
501
      if (!strncmp (str, "tos", 3))
502
        {
503
          addrmodeP->mode = 23; /* TopOfStack */
504
          return -1;
505
        }
506
      break;
507
 
508
    default:
509
      break;
510
    }
511
 
512
  if (strl > 4)
513
    {
514
      if (str[strl - 1] == ')')
515
        {
516
          if (str[strl - 2] == ')')
517
            {
518
              if (!strncmp (&str[strl - 5], "(fp", 3))
519
                mode = 16;              /* Memory Relative.  */
520
              else if (!strncmp (&str[strl - 5], "(sp", 3))
521
                mode = 17;
522
              else if (!strncmp (&str[strl - 5], "(sb", 3))
523
                mode = 18;
524
 
525
              if (mode != DEFAULT)
526
                {
527
                  /* Memory relative.  */
528
                  addrmodeP->mode = mode;
529
                  j = strl - 5;         /* Temp for end of disp[0].  */
530
                  i = 0;
531
 
532
                  do
533
                    {
534
                      strl -= 1;
535
                      if (str[strl] == ')')
536
                        i++;
537
                      if (str[strl] == '(')
538
                        i--;
539
                    }
540
                  while (strl > -1 && i != 0);
541
 
542
                  if (i != 0)
543
                    {
544
                      as_bad (_("Invalid syntax in Memory Relative addressing mode"));
545
                      return (0);
546
                    }
547
 
548
                  addrmodeP->disp[1] = str;
549
                  addrmodeP->disp[0] = str + strl + 1;
550
                  str[j] = '\000';      /* Null terminate disp[0] .  */
551
                  str[strl] = '\000';   /* Null terminate disp[1].  */
552
 
553
                  return -1;
554
                }
555
            }
556
 
557
          switch (str[strl - 3])
558
            {
559
            case 'r':
560
            case 'R':
561
              if (str[strl - 2] >= '0'
562
                  && str[strl - 2] < '8'
563
                  && str[strl - 4] == '(')
564
                {
565
                  addrmodeP->mode = str[strl - 2] - '0' + 8;
566
                  addrmodeP->disp[0] = str;
567
                  str[strl - 4] = 0;
568
                  return -1;            /* reg rel */
569
                }
570
              /* Drop through.  */
571
 
572
            default:
573
              if (!strncmp (&str[strl - 4], "(fp", 3))
574
                mode = 24;
575
              else if (!strncmp (&str[strl - 4], "(sp", 3))
576
                mode = 25;
577
              else if (!strncmp (&str[strl - 4], "(sb", 3))
578
                mode = 26;
579
              else if (!strncmp (&str[strl - 4], "(pc", 3))
580
                mode = 27;
581
 
582
              if (mode != DEFAULT)
583
                {
584
                  addrmodeP->mode = mode;
585
                  addrmodeP->disp[0] = str;
586
                  str[strl - 4] = '\0';
587
 
588
                  return -1;            /* Memory space.  */
589
                }
590
            }
591
        }
592
 
593
      /* No trailing ')' do we have a ']' ?  */
594
      if (str[strl - 1] == ']')
595
        {
596
          switch (str[strl - 2])
597
            {
598
            case 'b':
599
              mode = 28;
600
              break;
601
            case 'w':
602
              mode = 29;
603
              break;
604
            case 'd':
605
              mode = 30;
606
              break;
607
            case 'q':
608
              mode = 31;
609
              break;
610
            default:
611
              as_bad (_("Invalid scaled-indexed mode, use (b,w,d,q)"));
612
 
613
              if (str[strl - 3] != ':' || str[strl - 6] != '['
614
                  || str[strl - 5] == 'r' || str[strl - 4] < '0'
615
                  || str[strl - 4] > '7')
616
                as_bad (_("Syntax in scaled-indexed mode, use [Rn:m] where n=[0..7] m={b,w,d,q}"));
617
            } /* Scaled index.  */
618
 
619
          if (recursive_level > 0)
620
            {
621
              as_bad (_("Scaled-indexed addressing mode combined with scaled-index"));
622
              return 0;
623
            }
624
 
625
          addrmodeP->am_size += 1;      /* scaled index byte.  */
626
          j = str[strl - 4] - '0';      /* store temporary.  */
627
          str[strl - 6] = '\000';       /* nullterminate for recursive call.  */
628
          i = addr_mode (str, addrmodeP, 1);
629
 
630
          if (!i || addrmodeP->mode == 20)
631
            {
632
              as_bad (_("Invalid or illegal addressing mode combined with scaled-index"));
633
              return 0;
634
            }
635
 
636
          addrmodeP->scaled_mode = addrmodeP->mode;     /* Store the inferior mode.  */
637
          addrmodeP->mode = mode;
638
          addrmodeP->scaled_reg = j + 1;
639
 
640
          return -1;
641
        }
642
    }
643
 
644
  addrmodeP->mode = DEFAULT;    /* Default to whatever.  */
645
  addrmodeP->disp[0] = str;
646
 
647
  return -1;
648
}
649
 
650
static void
651
evaluate_expr (expressionS *resultP, char *ptr)
652
{
653
  char *tmp_line;
654
 
655
  tmp_line = input_line_pointer;
656
  input_line_pointer = ptr;
657
  expression (resultP);
658
  input_line_pointer = tmp_line;
659
}
660
 
661
/* ptr points at string addr_modeP points at struct with result This
662
   routine calls addr_mode to determine the general addr.mode of the
663
   operand. When this is ready it parses the displacements for size
664
   specifying suffixes and determines size of immediate mode via
665
   ns32k-opcode.  Also builds index bytes if needed.  */
666
 
667
static int
668
get_addr_mode (char *ptr, addr_modeS *addrmodeP)
669
{
670
  int tmp;
671
 
672
  addr_mode (ptr, addrmodeP, 0);
673
 
674
  if (addrmodeP->mode == DEFAULT || addrmodeP->scaled_mode == -1)
675
    {
676
      /* Resolve ambiguous operands, this shouldn't be necessary if
677
         one uses standard NSC operand syntax. But the sequent
678
         compiler doesn't!!!  This finds a proper addressing mode
679
         if it is implicitly stated. See ns32k-opcode.h.  */
680
      (void) evaluate_expr (&exprP, ptr); /* This call takes time Sigh!  */
681
 
682
      if (addrmodeP->mode == DEFAULT)
683
        {
684
          if (exprP.X_add_symbol || exprP.X_op_symbol)
685
            addrmodeP->mode = desc->default_model; /* We have a label.  */
686
          else
687
            addrmodeP->mode = desc->default_modec; /* We have a constant.  */
688
        }
689
      else
690
        {
691
          if (exprP.X_add_symbol || exprP.X_op_symbol)
692
            addrmodeP->scaled_mode = desc->default_model;
693
          else
694
            addrmodeP->scaled_mode = desc->default_modec;
695
        }
696
 
697
      /* Must put this mess down in addr_mode to handle the scaled
698
         case better.  */
699
    }
700
 
701
  /* It appears as the sequent compiler wants an absolute when we have
702
     a label without @. Constants becomes immediates besides the addr
703
     case.  Think it does so with local labels too, not optimum, pcrel
704
     is better.  When I have time I will make gas check this and
705
     select pcrel when possible Actually that is trivial.  */
706
  if ((tmp = addrmodeP->scaled_reg))
707
    {                           /* Build indexbyte.  */
708
      tmp--;                    /* Remember regnumber comes incremented for
709
                                   flagpurpose.  */
710
      tmp |= addrmodeP->scaled_mode << 3;
711
      addrmodeP->index_byte = (char) tmp;
712
      addrmodeP->am_size += 1;
713
    }
714
 
715
  gas_assert (addrmodeP->mode >= 0);
716
  if (disp_test[(unsigned int) addrmodeP->mode])
717
    {
718
      char c;
719
      char suffix;
720
      char suffix_sub;
721
      int i;
722
      char *toP;
723
      char *fromP;
724
 
725
      /* There was a displacement, probe for length  specifying suffix.  */
726
      addrmodeP->pcrel = 0;
727
 
728
      gas_assert (addrmodeP->mode >= 0);
729
      if (disp_test[(unsigned int) addrmodeP->mode])
730
        {
731
          /* There is a displacement.  */
732
          if (addrmodeP->mode == 27 || addrmodeP->scaled_mode == 27)
733
            /* Do we have pcrel. mode.  */
734
            addrmodeP->pcrel = 1;
735
 
736
          addrmodeP->im_disp = 1;
737
 
738
          for (i = 0; i < 2; i++)
739
            {
740
              suffix_sub = suffix = 0;
741
 
742
              if ((toP = addrmodeP->disp[i]))
743
                {
744
                  /* Suffix of expression, the largest size rules.  */
745
                  fromP = toP;
746
 
747
                  while ((c = *fromP++))
748
                    {
749
                      *toP++ = c;
750
                      if (c == ':')
751
                        {
752
                          switch (*fromP)
753
                            {
754
                            case '\0':
755
                              as_warn (_("Premature end of suffix -- Defaulting to d"));
756
                              suffix = 4;
757
                              continue;
758
                            case 'b':
759
                              suffix_sub = 1;
760
                              break;
761
                            case 'w':
762
                              suffix_sub = 2;
763
                              break;
764
                            case 'd':
765
                              suffix_sub = 4;
766
                              break;
767
                            default:
768
                              as_warn (_("Bad suffix after ':' use {b|w|d} Defaulting to d"));
769
                              suffix = 4;
770
                            }
771
 
772
                          fromP ++;
773
                          toP --;       /* So we write over the ':' */
774
 
775
                          if (suffix < suffix_sub)
776
                            suffix = suffix_sub;
777
                        }
778
                    }
779
 
780
                  *toP = '\0'; /* Terminate properly.  */
781
                  addrmodeP->disp_suffix[i] = suffix;
782
                  addrmodeP->am_size += suffix ? suffix : 4;
783
                }
784
            }
785
        }
786
    }
787
  else
788
    {
789
      if (addrmodeP->mode == 20)
790
        {
791
          /* Look in ns32k_opcode for size.  */
792
          addrmodeP->disp_suffix[0] = addrmodeP->am_size = desc->im_size;
793
          addrmodeP->im_disp = 0;
794
        }
795
    }
796
 
797
  return addrmodeP->mode;
798
}
799
 
800
/* Read an optionlist.  */
801
 
802
static void
803
optlist (char *str,                     /* The string to extract options from.  */
804
         struct ns32k_option *optionP,  /* How to search the string.  */
805
         unsigned long *default_map)    /* Default pattern and output.  */
806
{
807
  int i, j, k, strlen1, strlen2;
808
  char *patternP, *strP;
809
 
810
  strlen1 = strlen (str);
811
 
812
  if (strlen1 < 1)
813
    as_fatal (_("Very short instr to option, ie you can't do it on a NULLstr"));
814
 
815
  for (i = 0; optionP[i].pattern != 0; i++)
816
    {
817
      strlen2 = strlen (optionP[i].pattern);
818
 
819
      for (j = 0; j < strlen1; j++)
820
        {
821
          patternP = optionP[i].pattern;
822
          strP = &str[j];
823
 
824
          for (k = 0; k < strlen2; k++)
825
            {
826
              if (*(strP++) != *(patternP++))
827
                break;
828
            }
829
 
830
          if (k == strlen2)
831
            {                   /* match */
832
              *default_map |= optionP[i].or;
833
              *default_map &= optionP[i].and;
834
            }
835
        }
836
    }
837
}
838
 
839
/* Search struct for symbols.
840
   This function is used to get the short integer form of reg names in
841
   the instructions lmr, smr, lpr, spr return true if str is found in
842
   list.  */
843
 
844
static int
845
list_search (char *str,                         /* The string to match.  */
846
             struct ns32k_option *optionP,      /* List to search.  */
847
             unsigned long *default_map)        /* Default pattern and output.  */
848
{
849
  int i;
850
 
851
  for (i = 0; optionP[i].pattern != 0; i++)
852
    {
853
      if (!strncmp (optionP[i].pattern, str, 20))
854
        {
855
          /* Use strncmp to be safe.  */
856
          *default_map |= optionP[i].or;
857
          *default_map &= optionP[i].and;
858
 
859
          return -1;
860
        }
861
    }
862
 
863
  as_bad (_("No such entry in list. (cpu/mmu register)"));
864
  return 0;
865
}
866
 
867
/* Create a bit_fixS in obstack 'notes'.
868
   This struct is used to profile the normal fix. If the bit_fixP is a
869
   valid pointer (not NULL) the bit_fix data will be used to format
870
   the fix.  */
871
 
872
static bit_fixS *
873
bit_fix_new (int size,          /* Length of bitfield.  */
874
             int offset,        /* Bit offset to bitfield.  */
875
             long min,          /* Signextended min for bitfield.  */
876
             long max,          /* Signextended max for bitfield.  */
877
             long add,          /* Add mask, used for huffman prefix.  */
878
             long base_type,    /* 0 or 1, if 1 it's exploded to opcode ptr.  */
879
             long base_adj)
880
{
881
  bit_fixS *bit_fixP;
882
 
883
  bit_fixP = obstack_alloc (&notes, sizeof (bit_fixS));
884
 
885
  bit_fixP->fx_bit_size = size;
886
  bit_fixP->fx_bit_offset = offset;
887
  bit_fixP->fx_bit_base = base_type;
888
  bit_fixP->fx_bit_base_adj = base_adj;
889
  bit_fixP->fx_bit_max = max;
890
  bit_fixP->fx_bit_min = min;
891
  bit_fixP->fx_bit_add = add;
892
 
893
  return bit_fixP;
894
}
895
 
896
/* Convert operands to iif-format and adds bitfields to the opcode.
897
   Operands are parsed in such an order that the opcode is updated from
898
   its most significant bit, that is when the operand need to alter the
899
   opcode.
900
   Be careful not to put to objects in the same iif-slot.  */
901
 
902
static void
903
encode_operand (int argc,
904
                char **argv,
905
                const char *operandsP,
906
                const char *suffixP,
907
                char im_size ATTRIBUTE_UNUSED,
908
                char opcode_bit_ptr)
909
{
910
  int i, j;
911
  char d;
912
  int pcrel, b, loop, pcrel_adjust;
913
  unsigned long tmp;
914
 
915
  for (loop = 0; loop < argc; loop++)
916
    {
917
      /* What operand are we supposed to work on.  */
918
      i = operandsP[loop << 1] - '1';
919
      if (i > 3)
920
        as_fatal (_("Internal consistency error.  check ns32k-opcode.h"));
921
 
922
      pcrel = 0;
923
      pcrel_adjust = 0;
924
      tmp = 0;
925
 
926
      switch ((d = operandsP[(loop << 1) + 1]))
927
        {
928
        case 'f':               /* Operand of sfsr turns out to be a nasty
929
                                   specialcase.  */
930
          opcode_bit_ptr -= 5;
931
        case 'Z':               /* Float not immediate.  */
932
        case 'F':               /* 32 bit float general form.  */
933
        case 'L':               /* 64 bit float.  */
934
        case 'I':               /* Integer not immediate.  */
935
        case 'B':               /* Byte  */
936
        case 'W':               /* Word  */
937
        case 'D':               /* Double-word.  */
938
        case 'A':               /* Double-word  gen-address-form ie no regs
939
                                   allowed.  */
940
          get_addr_mode (argv[i], &addr_modeP);
941
 
942
          if ((addr_modeP.mode == 20) &&
943
             (d == 'I' || d == 'Z' || d == 'A'))
944
            as_fatal (d == 'A'? _("Address of immediate operand"):
945
                        _("Invalid immediate write operand."));
946
 
947
          if (opcode_bit_ptr == desc->opcode_size)
948
            b = 4;
949
          else
950
            b = 6;
951
 
952
          for (j = b; j < (b + 2); j++)
953
            {
954
              if (addr_modeP.disp[j - b])
955
                {
956
                  IIF (j,
957
                       2,
958
                       addr_modeP.disp_suffix[j - b],
959
                       (unsigned long) addr_modeP.disp[j - b],
960
                       0,
961
                       addr_modeP.pcrel,
962
                       iif.instr_size,
963
                       addr_modeP.im_disp,
964
                       IND (BRANCH, BYTE),
965
                       NULL,
966
                       (addr_modeP.scaled_reg ? addr_modeP.scaled_mode
967
                        : addr_modeP.mode),
968
                       0);
969
                }
970
            }
971
 
972
          opcode_bit_ptr -= 5;
973
          iif.iifP[1].object |= ((long) addr_modeP.mode) << opcode_bit_ptr;
974
 
975
          if (addr_modeP.scaled_reg)
976
            {
977
              j = b / 2;
978
              IIF (j, 1, 1, (unsigned long) addr_modeP.index_byte,
979
                   0, 0, 0, 0, 0, NULL, -1, 0);
980
            }
981
          break;
982
 
983
        case 'b':               /* Multiple instruction disp.  */
984
          freeptr++;            /* OVE:this is an useful hack.  */
985
          sprintf (freeptr, "((%s-1)*%d)", argv[i], desc->im_size);
986
          argv[i] = freeptr;
987
          pcrel -= 1;           /* Make pcrel 0 in spite of what case 'p':
988
                                   wants.  */
989
          /* fall thru */
990
        case 'p':               /* Displacement - pc relative addressing.  */
991
          pcrel += 1;
992
          /* fall thru */
993
        case 'd':               /* Displacement.  */
994
          iif.instr_size += suffixP[i] ? suffixP[i] : 4;
995
          IIF (12, 2, suffixP[i], (unsigned long) argv[i], 0,
996
               pcrel, pcrel_adjust, 1, IND (BRANCH, BYTE), NULL, -1, 0);
997
          break;
998
        case 'H':               /* Sequent-hack: the linker wants a bit set
999
                                   when bsr.  */
1000
          pcrel = 1;
1001
          iif.instr_size += suffixP[i] ? suffixP[i] : 4;
1002
          IIF (12, 2, suffixP[i], (unsigned long) argv[i], 0,
1003
               pcrel, pcrel_adjust, 1, IND (BRANCH, BYTE), NULL, -1, 1);
1004
          break;
1005
        case 'q':               /* quick */
1006
          opcode_bit_ptr -= 4;
1007
          IIF (11, 2, 42, (unsigned long) argv[i], 0, 0, 0, 0, 0,
1008
               bit_fix_new (4, opcode_bit_ptr, -8, 7, 0, 1, 0), -1, 0);
1009
          break;
1010
        case 'r':               /* Register number (3 bits).  */
1011
          list_search (argv[i], opt6, &tmp);
1012
          opcode_bit_ptr -= 3;
1013
          iif.iifP[1].object |= tmp << opcode_bit_ptr;
1014
          break;
1015
        case 'O':               /* Setcfg instruction optionslist.  */
1016
          optlist (argv[i], opt3, &tmp);
1017
          opcode_bit_ptr -= 4;
1018
          iif.iifP[1].object |= tmp << 15;
1019
          break;
1020
        case 'C':               /* Cinv instruction optionslist.  */
1021
          optlist (argv[i], opt4, &tmp);
1022
          opcode_bit_ptr -= 4;
1023
          iif.iifP[1].object |= tmp << 15; /* Insert the regtype in opcode.  */
1024
          break;
1025
        case 'S':               /* String instruction options list.  */
1026
          optlist (argv[i], opt5, &tmp);
1027
          opcode_bit_ptr -= 4;
1028
          iif.iifP[1].object |= tmp << 15;
1029
          break;
1030
        case 'u':
1031
        case 'U':               /* Register list.  */
1032
          IIF (10, 1, 1, 0, 0, 0, 0, 0, 0, NULL, -1, 0);
1033
          switch (operandsP[(i << 1) + 1])
1034
            {
1035
            case 'u':           /* Restore, exit.  */
1036
              optlist (argv[i], opt1, &iif.iifP[10].object);
1037
              break;
1038
            case 'U':           /* Save, enter.  */
1039
              optlist (argv[i], opt2, &iif.iifP[10].object);
1040
              break;
1041
            }
1042
          iif.instr_size += 1;
1043
          break;
1044
        case 'M':               /* MMU register.  */
1045
          list_search (argv[i], mmureg, &tmp);
1046
          opcode_bit_ptr -= 4;
1047
          iif.iifP[1].object |= tmp << opcode_bit_ptr;
1048
          break;
1049
        case 'P':               /* CPU register.  */
1050
          list_search (argv[i], cpureg, &tmp);
1051
          opcode_bit_ptr -= 4;
1052
          iif.iifP[1].object |= tmp << opcode_bit_ptr;
1053
          break;
1054
        case 'g':               /* Inss exts.  */
1055
          iif.instr_size += 1;  /* 1 byte is allocated after the opcode.  */
1056
          IIF (10, 2, 1,
1057
               (unsigned long) argv[i], /* i always 2 here.  */
1058
               0, 0, 0, 0, 0,
1059
               bit_fix_new (3, 5, 0, 7, 0, 0, 0), /* A bit_fix is targeted to
1060
                                                     the byte.  */
1061
               -1, 0);
1062
          break;
1063
        case 'G':
1064
          IIF (11, 2, 42,
1065
               (unsigned long) argv[i], /* i always 3 here.  */
1066
               0, 0, 0, 0, 0,
1067
               bit_fix_new (5, 0, 1, 32, -1, 0, -1), -1, 0);
1068
          break;
1069
        case 'i':
1070
          iif.instr_size += 1;
1071
          b = 2 + i;            /* Put the extension byte after opcode.  */
1072
          IIF (b, 2, 1, 0, 0, 0, 0, 0, 0, 0, -1, 0);
1073
          break;
1074
        default:
1075
          as_fatal (_("Bad opcode-table-option, check in file ns32k-opcode.h"));
1076
        }
1077
    }
1078
}
1079
 
1080
/* in:  instruction line
1081
   out: internal structure of instruction
1082
   that has been prepared for direct conversion to fragment(s) and
1083
   fixes in a systematical fashion
1084
   Return-value = recursive_level.  */
1085
/* Build iif of one assembly text line.  */
1086
 
1087
static int
1088
parse (const char *line, int recursive_level)
1089
{
1090
  const char *lineptr;
1091
  char c, suffix_separator;
1092
  int i;
1093
  unsigned int argc;
1094
  int arg_type;
1095
  char sqr, sep;
1096
  char suffix[MAX_ARGS], *argv[MAX_ARGS];       /* No more than 4 operands.  */
1097
 
1098
  if (recursive_level <= 0)
1099
    {
1100
      /* Called from md_assemble.  */
1101
      for (lineptr = line; (*lineptr) != '\0' && (*lineptr) != ' '; lineptr++)
1102
        continue;
1103
 
1104
      c = *lineptr;
1105
      *(char *) lineptr = '\0';
1106
 
1107
      if (!(desc = (struct ns32k_opcode *) hash_find (inst_hash_handle, line)))
1108
        as_fatal (_("No such opcode"));
1109
 
1110
      *(char *) lineptr = c;
1111
    }
1112
  else
1113
    lineptr = line;
1114
 
1115
  argc = 0;
1116
 
1117
  if (*desc->operands)
1118
    {
1119
      if (*lineptr++ != '\0')
1120
        {
1121
          sqr = '[';
1122
          sep = ',';
1123
 
1124
          while (*lineptr != '\0')
1125
            {
1126
              if (desc->operands[argc << 1])
1127
                {
1128
                  suffix[argc] = 0;
1129
                  arg_type = desc->operands[(argc << 1) + 1];
1130
 
1131
                  switch (arg_type)
1132
                    {
1133
                    case 'd':
1134
                    case 'b':
1135
                    case 'p':
1136
                    case 'H':
1137
                      /* The operand is supposed to be a displacement.  */
1138
                      /* Hackwarning: do not forget to update the 4
1139
                         cases above when editing ns32k-opcode.h.  */
1140
                      suffix_separator = ':';
1141
                      break;
1142
                    default:
1143
                      /* If this char occurs we loose.  */
1144
                      suffix_separator = '\255';
1145
                      break;
1146
                    }
1147
 
1148
                  suffix[argc] = 0; /* 0 when no ':' is encountered.  */
1149
                  argv[argc] = freeptr;
1150
                  *freeptr = '\0';
1151
 
1152
                  while ((c = *lineptr) != '\0' && c != sep)
1153
                    {
1154
                      if (c == sqr)
1155
                        {
1156
                          if (sqr == '[')
1157
                            {
1158
                              sqr = ']';
1159
                              sep = '\0';
1160
                            }
1161
                          else
1162
                            {
1163
                              sqr = '[';
1164
                              sep = ',';
1165
                            }
1166
                        }
1167
 
1168
                      if (c == suffix_separator)
1169
                        {
1170
                          /* ':' - label/suffix separator.  */
1171
                          switch (lineptr[1])
1172
                            {
1173
                            case 'b':
1174
                              suffix[argc] = 1;
1175
                              break;
1176
                            case 'w':
1177
                              suffix[argc] = 2;
1178
                              break;
1179
                            case 'd':
1180
                              suffix[argc] = 4;
1181
                              break;
1182
                            default:
1183
                              as_warn (_("Bad suffix, defaulting to d"));
1184
                              suffix[argc] = 4;
1185
                              if (lineptr[1] == '\0' || lineptr[1] == sep)
1186
                                {
1187
                                  lineptr += 1;
1188
                                  continue;
1189
                                }
1190
                              break;
1191
                            }
1192
 
1193
                          lineptr += 2;
1194
                          continue;
1195
                        }
1196
 
1197
                      *freeptr++ = c;
1198
                      lineptr++;
1199
                    }
1200
 
1201
                  *freeptr++ = '\0';
1202
                  argc += 1;
1203
 
1204
                  if (*lineptr == '\0')
1205
                    continue;
1206
 
1207
                  lineptr += 1;
1208
                }
1209
              else
1210
                as_fatal (_("Too many operands passed to instruction"));
1211
            }
1212
        }
1213
    }
1214
 
1215
  if (argc != strlen (desc->operands) / 2)
1216
    {
1217
      if (strlen (desc->default_args))
1218
        {
1219
          /* We can apply default, don't goof.  */
1220
          if (parse (desc->default_args, 1) != 1)
1221
            /* Check error in default.  */
1222
            as_fatal (_("Wrong numbers of operands in default, check ns32k-opcodes.h"));
1223
        }
1224
      else
1225
        as_fatal (_("Wrong number of operands"));
1226
    }
1227
 
1228
  for (i = 0; i < IIF_ENTRIES; i++)
1229
    /* Mark all entries as void.  */
1230
    iif.iifP[i].type = 0;
1231
 
1232
  /* Build opcode iif-entry.  */
1233
  iif.instr_size = desc->opcode_size / 8;
1234
  IIF (1, 1, iif.instr_size, desc->opcode_seed, 0, 0, 0, 0, 0, 0, -1, 0);
1235
 
1236
  /* This call encodes operands to iif format.  */
1237
  if (argc)
1238
    encode_operand (argc, argv, &desc->operands[0],
1239
                    &suffix[0], desc->im_size, desc->opcode_size);
1240
 
1241
  return recursive_level;
1242
}
1243
 
1244
/* This functionality should really be in the bfd library.  */
1245
 
1246
static bfd_reloc_code_real_type
1247
reloc (int size, int pcrel, int type)
1248
{
1249
  int length, rel_index;
1250
  bfd_reloc_code_real_type relocs[] =
1251
  {
1252
    BFD_RELOC_NS32K_IMM_8,
1253
    BFD_RELOC_NS32K_IMM_16,
1254
    BFD_RELOC_NS32K_IMM_32,
1255
    BFD_RELOC_NS32K_IMM_8_PCREL,
1256
    BFD_RELOC_NS32K_IMM_16_PCREL,
1257
    BFD_RELOC_NS32K_IMM_32_PCREL,
1258
 
1259
    /* ns32k displacements.  */
1260
    BFD_RELOC_NS32K_DISP_8,
1261
    BFD_RELOC_NS32K_DISP_16,
1262
    BFD_RELOC_NS32K_DISP_32,
1263
    BFD_RELOC_NS32K_DISP_8_PCREL,
1264
    BFD_RELOC_NS32K_DISP_16_PCREL,
1265
    BFD_RELOC_NS32K_DISP_32_PCREL,
1266
 
1267
    /* Normal 2's complement.  */
1268
    BFD_RELOC_8,
1269
    BFD_RELOC_16,
1270
    BFD_RELOC_32,
1271
    BFD_RELOC_8_PCREL,
1272
    BFD_RELOC_16_PCREL,
1273
    BFD_RELOC_32_PCREL
1274
  };
1275
 
1276
  switch (size)
1277
    {
1278
    case 1:
1279
      length = 0;
1280
      break;
1281
    case 2:
1282
      length = 1;
1283
      break;
1284
    case 4:
1285
      length = 2;
1286
      break;
1287
    default:
1288
      length = -1;
1289
      break;
1290
    }
1291
 
1292
  rel_index = length + 3 * pcrel + 6 * type;
1293
 
1294
  if (rel_index >= 0 && (unsigned int) rel_index < sizeof (relocs) / sizeof (relocs[0]))
1295
    return relocs[rel_index];
1296
 
1297
  if (pcrel)
1298
    as_bad (_("Can not do %d byte pc-relative relocation for storage type %d"),
1299
            size, type);
1300
  else
1301
    as_bad (_("Can not do %d byte relocation for storage type %d"),
1302
            size, type);
1303
 
1304
  return BFD_RELOC_NONE;
1305
 
1306
}
1307
 
1308
static void
1309
fix_new_ns32k (fragS *frag,             /* Which frag? */
1310
               int where,               /* Where in that frag? */
1311
               int size,                /* 1, 2  or 4 usually.  */
1312
               symbolS *add_symbol,     /* X_add_symbol.  */
1313
               long offset,             /* X_add_number.  */
1314
               int pcrel,               /* True if PC-relative relocation.  */
1315
               char im_disp,            /* True if the value to write is a
1316
                                           displacement.  */
1317
               bit_fixS *bit_fixP,      /* Pointer at struct of bit_fix's, ignored if
1318
                                           NULL.  */
1319
               char bsr,                /* Sequent-linker-hack: 1 when relocobject is
1320
                                           a bsr.  */
1321
               fragS *opcode_frag,
1322
               unsigned int opcode_offset)
1323
{
1324
  fixS *fixP = fix_new (frag, where, size, add_symbol,
1325
                        offset, pcrel,
1326
                        bit_fixP ? NO_RELOC : reloc (size, pcrel, im_disp)
1327
                        );
1328
 
1329
  fix_opcode_frag (fixP) = opcode_frag;
1330
  fix_opcode_offset (fixP) = opcode_offset;
1331
  fix_im_disp (fixP) = im_disp;
1332
  fix_bsr (fixP) = bsr;
1333
  fix_bit_fixP (fixP) = bit_fixP;
1334
  /* We have a MD overflow check for displacements.  */
1335
  fixP->fx_no_overflow = (im_disp != 0);
1336
}
1337
 
1338
static void
1339
fix_new_ns32k_exp (fragS *frag,         /* Which frag? */
1340
                   int where,           /* Where in that frag? */
1341
                   int size,            /* 1, 2  or 4 usually.  */
1342
                   expressionS *exp,    /* Expression.  */
1343
                   int pcrel,           /* True if PC-relative relocation.  */
1344
                   char im_disp,        /* True if the value to write is a
1345
                                           displacement.  */
1346
                   bit_fixS *bit_fixP,  /* Pointer at struct of bit_fix's, ignored if
1347
                                           NULL.  */
1348
                   char bsr,            /* Sequent-linker-hack: 1 when relocobject is
1349
                                           a bsr.  */
1350
                   fragS *opcode_frag,
1351
                   unsigned int opcode_offset)
1352
{
1353
  fixS *fixP = fix_new_exp (frag, where, size, exp, pcrel,
1354
                            bit_fixP ? NO_RELOC : reloc (size, pcrel, im_disp)
1355
                            );
1356
 
1357
  fix_opcode_frag (fixP) = opcode_frag;
1358
  fix_opcode_offset (fixP) = opcode_offset;
1359
  fix_im_disp (fixP) = im_disp;
1360
  fix_bsr (fixP) = bsr;
1361
  fix_bit_fixP (fixP) = bit_fixP;
1362
  /* We have a MD overflow check for displacements.  */
1363
  fixP->fx_no_overflow = (im_disp != 0);
1364
}
1365
 
1366
/* Convert number to chars in correct order.  */
1367
 
1368
void
1369
md_number_to_chars (char *buf, valueT value, int nbytes)
1370
{
1371
  number_to_chars_littleendian (buf, value, nbytes);
1372
}
1373
 
1374
/* This is a variant of md_numbers_to_chars. The reason for its'
1375
   existence is the fact that ns32k uses Huffman coded
1376
   displacements. This implies that the bit order is reversed in
1377
   displacements and that they are prefixed with a size-tag.
1378
 
1379
   binary: msb -> lsb
1380
   0xxxxxxx                             byte
1381
   10xxxxxx xxxxxxxx                    word
1382
   11xxxxxx xxxxxxxx xxxxxxxx xxxxxxxx  double word
1383
 
1384
   This must be taken care of and we do it here!  */
1385
 
1386
static void
1387
md_number_to_disp (char *buf, long val, int n)
1388
{
1389
  switch (n)
1390
    {
1391
    case 1:
1392
      if (val < -64 || val > 63)
1393
        as_bad (_("value of %ld out of byte displacement range."), val);
1394
      val &= 0x7f;
1395
#ifdef SHOW_NUM
1396
      printf ("%x ", val & 0xff);
1397
#endif
1398
      *buf++ = val;
1399
      break;
1400
 
1401
    case 2:
1402
      if (val < -8192 || val > 8191)
1403
        as_bad (_("value of %ld out of word displacement range."), val);
1404
      val &= 0x3fff;
1405
      val |= 0x8000;
1406
#ifdef SHOW_NUM
1407
      printf ("%x ", val >> 8 & 0xff);
1408
#endif
1409
      *buf++ = (val >> 8);
1410
#ifdef SHOW_NUM
1411
      printf ("%x ", val & 0xff);
1412
#endif
1413
      *buf++ = val;
1414
      break;
1415
 
1416
    case 4:
1417
      if (val < -0x20000000 || val >= 0x20000000)
1418
        as_bad (_("value of %ld out of double word displacement range."), val);
1419
      val |= 0xc0000000;
1420
#ifdef SHOW_NUM
1421
      printf ("%x ", val >> 24 & 0xff);
1422
#endif
1423
      *buf++ = (val >> 24);
1424
#ifdef SHOW_NUM
1425
      printf ("%x ", val >> 16 & 0xff);
1426
#endif
1427
      *buf++ = (val >> 16);
1428
#ifdef SHOW_NUM
1429
      printf ("%x ", val >> 8 & 0xff);
1430
#endif
1431
      *buf++ = (val >> 8);
1432
#ifdef SHOW_NUM
1433
      printf ("%x ", val & 0xff);
1434
#endif
1435
      *buf++ = val;
1436
      break;
1437
 
1438
    default:
1439
      as_fatal (_("Internal logic error.  line %d, file \"%s\""),
1440
                __LINE__, __FILE__);
1441
    }
1442
}
1443
 
1444
static void
1445
md_number_to_imm (char *buf, long val, int n)
1446
{
1447
  switch (n)
1448
    {
1449
    case 1:
1450
#ifdef SHOW_NUM
1451
      printf ("%x ", val & 0xff);
1452
#endif
1453
      *buf++ = val;
1454
      break;
1455
 
1456
    case 2:
1457
#ifdef SHOW_NUM
1458
      printf ("%x ", val >> 8 & 0xff);
1459
#endif
1460
      *buf++ = (val >> 8);
1461
#ifdef SHOW_NUM
1462
      printf ("%x ", val & 0xff);
1463
#endif
1464
      *buf++ = val;
1465
      break;
1466
 
1467
    case 4:
1468
#ifdef SHOW_NUM
1469
      printf ("%x ", val >> 24 & 0xff);
1470
#endif
1471
      *buf++ = (val >> 24);
1472
#ifdef SHOW_NUM
1473
      printf ("%x ", val >> 16 & 0xff);
1474
#endif
1475
      *buf++ = (val >> 16);
1476
#ifdef SHOW_NUM
1477
      printf ("%x ", val >> 8 & 0xff);
1478
#endif
1479
      *buf++ = (val >> 8);
1480
#ifdef SHOW_NUM
1481
      printf ("%x ", val & 0xff);
1482
#endif
1483
      *buf++ = val;
1484
      break;
1485
 
1486
    default:
1487
      as_fatal (_("Internal logic error. line %d, file \"%s\""),
1488
                __LINE__, __FILE__);
1489
    }
1490
}
1491
 
1492
/* Fast bitfiddling support.  */
1493
/* Mask used to zero bitfield before oring in the true field.  */
1494
 
1495
static unsigned long l_mask[] =
1496
{
1497
  0xffffffff, 0xfffffffe, 0xfffffffc, 0xfffffff8,
1498
  0xfffffff0, 0xffffffe0, 0xffffffc0, 0xffffff80,
1499
  0xffffff00, 0xfffffe00, 0xfffffc00, 0xfffff800,
1500
  0xfffff000, 0xffffe000, 0xffffc000, 0xffff8000,
1501
  0xffff0000, 0xfffe0000, 0xfffc0000, 0xfff80000,
1502
  0xfff00000, 0xffe00000, 0xffc00000, 0xff800000,
1503
  0xff000000, 0xfe000000, 0xfc000000, 0xf8000000,
1504
  0xf0000000, 0xe0000000, 0xc0000000, 0x80000000,
1505
};
1506
static unsigned long r_mask[] =
1507
{
1508
  0x00000000, 0x00000001, 0x00000003, 0x00000007,
1509
  0x0000000f, 0x0000001f, 0x0000003f, 0x0000007f,
1510
  0x000000ff, 0x000001ff, 0x000003ff, 0x000007ff,
1511
  0x00000fff, 0x00001fff, 0x00003fff, 0x00007fff,
1512
  0x0000ffff, 0x0001ffff, 0x0003ffff, 0x0007ffff,
1513
  0x000fffff, 0x001fffff, 0x003fffff, 0x007fffff,
1514
  0x00ffffff, 0x01ffffff, 0x03ffffff, 0x07ffffff,
1515
  0x0fffffff, 0x1fffffff, 0x3fffffff, 0x7fffffff,
1516
};
1517
#define MASK_BITS 31
1518
/* Insert bitfield described by field_ptr and val at buf
1519
   This routine is written for modification of the first 4 bytes pointed
1520
   to by buf, to yield speed.
1521
   The ifdef stuff is for selection between a ns32k-dependent routine
1522
   and a general version. (My advice: use the general version!).  */
1523
 
1524
static void
1525
md_number_to_field (char *buf, long val, bit_fixS *field_ptr)
1526
{
1527
  unsigned long object;
1528
  unsigned long mask;
1529
  /* Define ENDIAN on a ns32k machine.  */
1530
#ifdef ENDIAN
1531
  unsigned long *mem_ptr;
1532
#else
1533
  char *mem_ptr;
1534
#endif
1535
 
1536
  if (field_ptr->fx_bit_min <= val && val <= field_ptr->fx_bit_max)
1537
    {
1538
#ifdef ENDIAN
1539
      if (field_ptr->fx_bit_base)
1540
        /* Override buf.  */
1541
        mem_ptr = (unsigned long *) field_ptr->fx_bit_base;
1542
      else
1543
        mem_ptr = (unsigned long *) buf;
1544
 
1545
      mem_ptr = ((unsigned long *)
1546
                 ((char *) mem_ptr + field_ptr->fx_bit_base_adj));
1547
#else
1548
      if (field_ptr->fx_bit_base)
1549
        mem_ptr = (char *) field_ptr->fx_bit_base;
1550
      else
1551
        mem_ptr = buf;
1552
 
1553
      mem_ptr += field_ptr->fx_bit_base_adj;
1554
#endif
1555
#ifdef ENDIAN
1556
      /* We have a nice ns32k machine with lowbyte at low-physical mem.  */
1557
      object = *mem_ptr;        /* get some bytes */
1558
#else /* OVE Goof! the machine is a m68k or dito.  */
1559
      /* That takes more byte fiddling.  */
1560
      object = 0;
1561
      object |= mem_ptr[3] & 0xff;
1562
      object <<= 8;
1563
      object |= mem_ptr[2] & 0xff;
1564
      object <<= 8;
1565
      object |= mem_ptr[1] & 0xff;
1566
      object <<= 8;
1567
      object |= mem_ptr[0] & 0xff;
1568
#endif
1569
      mask = 0;
1570
      mask |= (r_mask[field_ptr->fx_bit_offset]);
1571
      mask |= (l_mask[field_ptr->fx_bit_offset + field_ptr->fx_bit_size]);
1572
      object &= mask;
1573
      val += field_ptr->fx_bit_add;
1574
      object |= ((val << field_ptr->fx_bit_offset) & (mask ^ 0xffffffff));
1575
#ifdef ENDIAN
1576
      *mem_ptr = object;
1577
#else
1578
      mem_ptr[0] = (char) object;
1579
      object >>= 8;
1580
      mem_ptr[1] = (char) object;
1581
      object >>= 8;
1582
      mem_ptr[2] = (char) object;
1583
      object >>= 8;
1584
      mem_ptr[3] = (char) object;
1585
#endif
1586
    }
1587
  else
1588
    as_bad (_("Bit field out of range"));
1589
}
1590
 
1591
/* Convert iif to fragments.  From this point we start to dribble with
1592
   functions in other files than this one.(Except hash.c) So, if it's
1593
   possible to make an iif for an other CPU, you don't need to know
1594
   what frags, relax, obstacks, etc is in order to port this
1595
   assembler. You only need to know if it's possible to reduce your
1596
   cpu-instruction to iif-format (takes some work) and adopt the other
1597
   md_? parts according to given instructions Note that iif was
1598
   invented for the clean ns32k`s architecture.  */
1599
 
1600
/* GAS for the ns32k has a problem. PC relative displacements are
1601
   relative to the address of the opcode, not the address of the
1602
   operand. We used to keep track of the offset between the operand
1603
   and the opcode in pcrel_adjust for each frag and each fix. However,
1604
   we get into trouble where there are two or more pc-relative
1605
   operands and the size of the first one can't be determined. Then in
1606
   the relax phase, the size of the first operand will change and
1607
   pcrel_adjust will no longer be correct.  The current solution is
1608
   keep a pointer to the frag with the opcode in it and the offset in
1609
   that frag for each frag and each fix. Then, when needed, we can
1610
   always figure out how far it is between the opcode and the pcrel
1611
   object.  See also md_pcrel_adjust and md_fix_pcrel_adjust.  For
1612
   objects not part of an instruction, the pointer to the opcode frag
1613
   is always zero.  */
1614
 
1615
static void
1616
convert_iif (void)
1617
{
1618
  int i;
1619
  bit_fixS *j;
1620
  fragS *inst_frag;
1621
  unsigned int inst_offset;
1622
  char *inst_opcode;
1623
  char *memP;
1624
  int l;
1625
  int k;
1626
  char type;
1627
  char size = 0;
1628
 
1629
  frag_grow (iif.instr_size);   /* This is important.  */
1630
  memP = frag_more (0);
1631
  inst_opcode = memP;
1632
  inst_offset = (memP - frag_now->fr_literal);
1633
  inst_frag = frag_now;
1634
 
1635
  for (i = 0; i < IIF_ENTRIES; i++)
1636
    {
1637
      if ((type = iif.iifP[i].type))
1638
        {
1639
          /* The object exist, so handle it.  */
1640
          switch (size = iif.iifP[i].size)
1641
            {
1642
            case 42:
1643
              size = 0;
1644
              /* It's a bitfix that operates on an existing object.  */
1645
              if (iif.iifP[i].bit_fixP->fx_bit_base)
1646
                /* Expand fx_bit_base to point at opcode.  */
1647
                iif.iifP[i].bit_fixP->fx_bit_base = (long) inst_opcode;
1648
              /* Fall through.  */
1649
 
1650
            case 8:             /* bignum or doublefloat.  */
1651
            case 1:
1652
            case 2:
1653
            case 3:
1654
            case 4:
1655
              /* The final size in objectmemory is known.  */
1656
              memP = frag_more (size);
1657
              j = iif.iifP[i].bit_fixP;
1658
 
1659
              switch (type)
1660
                {
1661
                case 1: /* The object is pure binary.  */
1662
                  if (j)
1663
                    md_number_to_field (memP, exprP.X_add_number, j);
1664
 
1665
                  else if (iif.iifP[i].pcrel)
1666
                    fix_new_ns32k (frag_now,
1667
                                   (long) (memP - frag_now->fr_literal),
1668
                                   size,
1669
                                   0,
1670
                                   iif.iifP[i].object,
1671
                                   iif.iifP[i].pcrel,
1672
                                   iif.iifP[i].im_disp,
1673
                                   0,
1674
                                   iif.iifP[i].bsr,     /* Sequent hack.  */
1675
                                   inst_frag, inst_offset);
1676
                  else
1677
                    {
1678
                      /* Good, just put them bytes out.  */
1679
                      switch (iif.iifP[i].im_disp)
1680
                        {
1681
                        case 0:
1682
                          md_number_to_chars (memP, iif.iifP[i].object, size);
1683
                          break;
1684
                        case 1:
1685
                          md_number_to_disp (memP, iif.iifP[i].object, size);
1686
                          break;
1687
                        default:
1688
                          as_fatal (_("iif convert internal pcrel/binary"));
1689
                        }
1690
                    }
1691
                  break;
1692
 
1693
                case 2:
1694
                  /* The object is a pointer at an expression, so
1695
                     unpack it, note that bignums may result from the
1696
                     expression.  */
1697
                  evaluate_expr (&exprP, (char *) iif.iifP[i].object);
1698
                  if (exprP.X_op == O_big || size == 8)
1699
                    {
1700
                      if ((k = exprP.X_add_number) > 0)
1701
                        {
1702
                          /* We have a bignum ie a quad. This can only
1703
                             happens in a long suffixed instruction.  */
1704
                          if (k * 2 > size)
1705
                            as_bad (_("Bignum too big for long"));
1706
 
1707
                          if (k == 3)
1708
                            memP += 2;
1709
 
1710
                          for (l = 0; k > 0; k--, l += 2)
1711
                            md_number_to_chars (memP + l,
1712
                                                generic_bignum[l >> 1],
1713
                                                sizeof (LITTLENUM_TYPE));
1714
                        }
1715
                      else
1716
                        {
1717
                          /* flonum.  */
1718
                          LITTLENUM_TYPE words[4];
1719
 
1720
                          switch (size)
1721
                            {
1722
                            case 4:
1723
                              gen_to_words (words, 2, 8);
1724
                              md_number_to_imm (memP, (long) words[0],
1725
                                                sizeof (LITTLENUM_TYPE));
1726
                              md_number_to_imm (memP + sizeof (LITTLENUM_TYPE),
1727
                                                (long) words[1],
1728
                                                sizeof (LITTLENUM_TYPE));
1729
                              break;
1730
                            case 8:
1731
                              gen_to_words (words, 4, 11);
1732
                              md_number_to_imm (memP, (long) words[0],
1733
                                                sizeof (LITTLENUM_TYPE));
1734
                              md_number_to_imm (memP + sizeof (LITTLENUM_TYPE),
1735
                                                (long) words[1],
1736
                                                sizeof (LITTLENUM_TYPE));
1737
                              md_number_to_imm ((memP + 2
1738
                                                 * sizeof (LITTLENUM_TYPE)),
1739
                                                (long) words[2],
1740
                                                sizeof (LITTLENUM_TYPE));
1741
                              md_number_to_imm ((memP + 3
1742
                                                 * sizeof (LITTLENUM_TYPE)),
1743
                                                (long) words[3],
1744
                                                sizeof (LITTLENUM_TYPE));
1745
                              break;
1746
                            }
1747
                        }
1748
                      break;
1749
                    }
1750
                  if (exprP.X_add_symbol ||
1751
                      exprP.X_op_symbol ||
1752
                      iif.iifP[i].pcrel)
1753
                    {
1754
                      /* The expression was undefined due to an
1755
                         undefined label. Create a fix so we can fix
1756
                         the object later.  */
1757
                      exprP.X_add_number += iif.iifP[i].object_adjust;
1758
                      fix_new_ns32k_exp (frag_now,
1759
                                         (long) (memP - frag_now->fr_literal),
1760
                                         size,
1761
                                         &exprP,
1762
                                         iif.iifP[i].pcrel,
1763
                                         iif.iifP[i].im_disp,
1764
                                         j,
1765
                                         iif.iifP[i].bsr,
1766
                                         inst_frag, inst_offset);
1767
                    }
1768
                  else if (j)
1769
                    md_number_to_field (memP, exprP.X_add_number, j);
1770
                  else
1771
                    {
1772
                      /* Good, just put them bytes out.  */
1773
                      switch (iif.iifP[i].im_disp)
1774
                        {
1775
                        case 0:
1776
                          md_number_to_imm (memP, exprP.X_add_number, size);
1777
                          break;
1778
                        case 1:
1779
                          md_number_to_disp (memP, exprP.X_add_number, size);
1780
                          break;
1781
                        default:
1782
                          as_fatal (_("iif convert internal pcrel/pointer"));
1783
                        }
1784
                    }
1785
                  break;
1786
                default:
1787
                  as_fatal (_("Internal logic error in iif.iifP[n].type"));
1788
                }
1789
              break;
1790
 
1791
            case 0:
1792
              /* Too bad, the object may be undefined as far as its
1793
                 final nsize in object memory is concerned.  The size
1794
                 of the object in objectmemory is not explicitly
1795
                 given.  If the object is defined its length can be
1796
                 determined and a fix can replace the frag.  */
1797
              {
1798
                evaluate_expr (&exprP, (char *) iif.iifP[i].object);
1799
 
1800
                if ((exprP.X_add_symbol || exprP.X_op_symbol) &&
1801
                    !iif.iifP[i].pcrel)
1802
                  {
1803
                    /* Size is unknown until link time so have to default.  */
1804
                    size = default_disp_size; /* Normally 4 bytes.  */
1805
                    memP = frag_more (size);
1806
                    fix_new_ns32k_exp (frag_now,
1807
                                       (long) (memP - frag_now->fr_literal),
1808
                                       size,
1809
                                       &exprP,
1810
                                       0, /* never iif.iifP[i].pcrel, */
1811
                                       1, /* always iif.iifP[i].im_disp */
1812
                                       (bit_fixS *) 0, 0,
1813
                                       inst_frag,
1814
                                       inst_offset);
1815
                    break;              /* Exit this absolute hack.  */
1816
                  }
1817
 
1818
                if (exprP.X_add_symbol || exprP.X_op_symbol)
1819
                  {
1820
                    /* Frag it.  */
1821
                    if (exprP.X_op_symbol)
1822
                      /* We cant relax this case.  */
1823
                      as_fatal (_("Can't relax difference"));
1824
                    else
1825
                      {
1826
                        /* Size is not important.  This gets fixed by
1827
                           relax, but we assume 0 in what follows.  */
1828
                        memP = frag_more (4); /* Max size.  */
1829
                        size = 0;
1830
 
1831
                        {
1832
                          fragS *old_frag = frag_now;
1833
                          frag_variant (rs_machine_dependent,
1834
                                        4, /* Max size.  */
1835
                                        0, /* Size.  */
1836
                                        IND (BRANCH, UNDEF), /* Expecting
1837
                                                                the worst.  */
1838
                                        exprP.X_add_symbol,
1839
                                        exprP.X_add_number,
1840
                                        inst_opcode);
1841
                          frag_opcode_frag (old_frag) = inst_frag;
1842
                          frag_opcode_offset (old_frag) = inst_offset;
1843
                          frag_bsr (old_frag) = iif.iifP[i].bsr;
1844
                        }
1845
                      }
1846
                  }
1847
                else
1848
                  {
1849
                    /* This duplicates code in md_number_to_disp.  */
1850
                    if (-64 <= exprP.X_add_number && exprP.X_add_number <= 63)
1851
                      size = 1;
1852
                    else
1853
                      {
1854
                        if (-8192 <= exprP.X_add_number
1855
                            && exprP.X_add_number <= 8191)
1856
                          size = 2;
1857
                        else
1858
                          {
1859
                            if (-0x20000000 <= exprP.X_add_number
1860
                                && exprP.X_add_number<=0x1fffffff)
1861
                              size = 4;
1862
                            else
1863
                              {
1864
                                as_bad (_("Displacement too large for :d"));
1865
                                size = 4;
1866
                              }
1867
                          }
1868
                      }
1869
 
1870
                    memP = frag_more (size);
1871
                    md_number_to_disp (memP, exprP.X_add_number, size);
1872
                  }
1873
              }
1874
              break;
1875
 
1876
            default:
1877
              as_fatal (_("Internal logic error in iif.iifP[].type"));
1878
            }
1879
        }
1880
    }
1881
}
1882
 
1883
void
1884
md_assemble (char *line)
1885
{
1886
  freeptr = freeptr_static;
1887
  parse (line, 0);               /* Explode line to more fix form in iif.  */
1888
  convert_iif ();               /* Convert iif to frags, fix's etc.  */
1889
#ifdef SHOW_NUM
1890
  printf (" \t\t\t%s\n", line);
1891
#endif
1892
}
1893
 
1894
void
1895
md_begin (void)
1896
{
1897
  /* Build a hashtable of the instructions.  */
1898
  const struct ns32k_opcode *ptr;
1899 163 khays
  const char *status;
1900 16 khays
  const struct ns32k_opcode *endop;
1901
 
1902
  inst_hash_handle = hash_new ();
1903
 
1904
  endop = ns32k_opcodes + sizeof (ns32k_opcodes) / sizeof (ns32k_opcodes[0]);
1905
  for (ptr = ns32k_opcodes; ptr < endop; ptr++)
1906
    {
1907 163 khays
      if ((status = hash_insert (inst_hash_handle, ptr->name, (char *) ptr)))
1908 16 khays
        /* Fatal.  */
1909 163 khays
        as_fatal (_("Can't hash %s: %s"), ptr->name, status);
1910 16 khays
    }
1911
 
1912
  /* Some private space please!  */
1913
  freeptr_static = (char *) malloc (PRIVATE_SIZE);
1914
}
1915
 
1916
/* Turn the string pointed to by litP into a floating point constant
1917
   of type TYPE, and emit the appropriate bytes.  The number of
1918
   LITTLENUMS emitted is stored in *SIZEP.  An error message is
1919
   returned, or NULL on OK.  */
1920
 
1921
char *
1922
md_atof (int type, char *litP, int *sizeP)
1923
{
1924
  return ieee_md_atof (type, litP, sizeP, FALSE);
1925
}
1926
 
1927
int
1928
md_pcrel_adjust (fragS *fragP)
1929
{
1930
  fragS *opcode_frag;
1931
  addressT opcode_address;
1932
  unsigned int offset;
1933
 
1934
  opcode_frag = frag_opcode_frag (fragP);
1935
  if (opcode_frag == 0)
1936
    return 0;
1937
 
1938
  offset = frag_opcode_offset (fragP);
1939
  opcode_address = offset + opcode_frag->fr_address;
1940
 
1941
  return fragP->fr_address + fragP->fr_fix - opcode_address;
1942
}
1943
 
1944
static int
1945
md_fix_pcrel_adjust (fixS *fixP)
1946
{
1947
  fragS *opcode_frag;
1948
  addressT opcode_address;
1949
  unsigned int offset;
1950
 
1951
  opcode_frag = fix_opcode_frag (fixP);
1952
  if (opcode_frag == 0)
1953
    return 0;
1954
 
1955
  offset = fix_opcode_offset (fixP);
1956
  opcode_address = offset + opcode_frag->fr_address;
1957
 
1958
  return fixP->fx_where + fixP->fx_frag->fr_address - opcode_address;
1959
}
1960
 
1961
/* Apply a fixS (fixup of an instruction or data that we didn't have
1962
   enough info to complete immediately) to the data in a frag.
1963
 
1964
   On the ns32k, everything is in a different format, so we have broken
1965
   out separate functions for each kind of thing we could be fixing.
1966
   They all get called from here.  */
1967
 
1968
void
1969
md_apply_fix (fixS *fixP, valueT * valP, segT seg ATTRIBUTE_UNUSED)
1970
{
1971
  long val = * (long *) valP;
1972
  char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
1973
 
1974
  if (fix_bit_fixP (fixP))
1975
    /* Bitfields to fix, sigh.  */
1976
    md_number_to_field (buf, val, fix_bit_fixP (fixP));
1977
  else switch (fix_im_disp (fixP))
1978
    {
1979
    case 0:
1980
      /* Immediate field.  */
1981
      md_number_to_imm (buf, val, fixP->fx_size);
1982
      break;
1983
 
1984
    case 1:
1985
      /* Displacement field.  */
1986
      /* Calculate offset.  */
1987
      md_number_to_disp (buf,
1988
                         (fixP->fx_pcrel ? val + md_fix_pcrel_adjust (fixP)
1989
                          : val), fixP->fx_size);
1990
      break;
1991
 
1992
    case 2:
1993
      /* Pointer in a data object.  */
1994
      md_number_to_chars (buf, val, fixP->fx_size);
1995
      break;
1996
    }
1997
 
1998
  if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0)
1999
    fixP->fx_done = 1;
2000
}
2001
 
2002
/* Convert a relaxed displacement to ditto in final output.  */
2003
 
2004
void
2005
md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED,
2006
                 segT sec ATTRIBUTE_UNUSED,
2007
                 fragS *fragP)
2008
{
2009
  long disp;
2010
  long ext = 0;
2011
  /* Address in gas core of the place to store the displacement.  */
2012
  char *buffer_address = fragP->fr_fix + fragP->fr_literal;
2013
  /* Address in object code of the displacement.  */
2014
  int object_address;
2015
 
2016
  switch (fragP->fr_subtype)
2017
    {
2018
    case IND (BRANCH, BYTE):
2019
      ext = 1;
2020
      break;
2021
    case IND (BRANCH, WORD):
2022
      ext = 2;
2023
      break;
2024
    case IND (BRANCH, DOUBLE):
2025
      ext = 4;
2026
      break;
2027
    }
2028
 
2029
  if (ext == 0)
2030
    return;
2031
 
2032
  know (fragP->fr_symbol);
2033
 
2034
  object_address = fragP->fr_fix + fragP->fr_address;
2035
 
2036
  /* The displacement of the address, from current location.  */
2037
  disp = (S_GET_VALUE (fragP->fr_symbol) + fragP->fr_offset) - object_address;
2038
  disp += md_pcrel_adjust (fragP);
2039
 
2040
  md_number_to_disp (buffer_address, (long) disp, (int) ext);
2041
  fragP->fr_fix += ext;
2042
}
2043
 
2044
/* This function returns the estimated size a variable object will occupy,
2045
   one can say that we tries to guess the size of the objects before we
2046
   actually know it.  */
2047
 
2048
int
2049
md_estimate_size_before_relax (fragS *fragP, segT segment)
2050
{
2051
  if (fragP->fr_subtype == IND (BRANCH, UNDEF))
2052
    {
2053
      if (S_GET_SEGMENT (fragP->fr_symbol) != segment)
2054
        {
2055
          /* We don't relax symbols defined in another segment.  The
2056
             thing to do is to assume the object will occupy 4 bytes.  */
2057
          fix_new_ns32k (fragP,
2058
                         (int) (fragP->fr_fix),
2059
                         4,
2060
                         fragP->fr_symbol,
2061
                         fragP->fr_offset,
2062
                         1,
2063
                         1,
2064
                         0,
2065
                         frag_bsr(fragP), /* Sequent hack.  */
2066
                         frag_opcode_frag (fragP),
2067
                         frag_opcode_offset (fragP));
2068
          fragP->fr_fix += 4;
2069
          frag_wane (fragP);
2070
          return 4;
2071
        }
2072
 
2073
      /* Relaxable case.  Set up the initial guess for the variable
2074
         part of the frag.  */
2075
      fragP->fr_subtype = IND (BRANCH, BYTE);
2076
    }
2077
 
2078
  if (fragP->fr_subtype >= sizeof (md_relax_table) / sizeof (md_relax_table[0]))
2079
    abort ();
2080
 
2081
  /* Return the size of the variable part of the frag.  */
2082
  return md_relax_table[fragP->fr_subtype].rlx_length;
2083
}
2084
 
2085
int md_short_jump_size = 3;
2086
int md_long_jump_size = 5;
2087
 
2088
void
2089
md_create_short_jump (char *ptr,
2090
                      addressT from_addr,
2091
                      addressT to_addr,
2092
                      fragS *frag ATTRIBUTE_UNUSED,
2093
                      symbolS *to_symbol ATTRIBUTE_UNUSED)
2094
{
2095
  valueT offset;
2096
 
2097
  offset = to_addr - from_addr;
2098
  md_number_to_chars (ptr, (valueT) 0xEA, 1);
2099
  md_number_to_disp (ptr + 1, (valueT) offset, 2);
2100
}
2101
 
2102
void
2103
md_create_long_jump (char *ptr,
2104
                     addressT from_addr,
2105
                     addressT to_addr,
2106
                     fragS *frag ATTRIBUTE_UNUSED,
2107
                     symbolS *to_symbol ATTRIBUTE_UNUSED)
2108
{
2109
  valueT offset;
2110
 
2111
  offset = to_addr - from_addr;
2112
  md_number_to_chars (ptr, (valueT) 0xEA, 1);
2113
  md_number_to_disp (ptr + 1, (valueT) offset, 4);
2114
}
2115
 
2116
const char *md_shortopts = "m:";
2117
 
2118
struct option md_longopts[] =
2119
{
2120
#define OPTION_DISP_SIZE (OPTION_MD_BASE)
2121
  {"disp-size-default", required_argument , NULL, OPTION_DISP_SIZE},
2122
  {NULL, no_argument, NULL, 0}
2123
};
2124
 
2125
size_t md_longopts_size = sizeof (md_longopts);
2126
 
2127
int
2128
md_parse_option (int c, char *arg)
2129
{
2130
  switch (c)
2131
    {
2132
    case 'm':
2133
      if (!strcmp (arg, "32032"))
2134
        {
2135
          cpureg = cpureg_032;
2136
          mmureg = mmureg_032;
2137
        }
2138
      else if (!strcmp (arg, "32532"))
2139
        {
2140
          cpureg = cpureg_532;
2141
          mmureg = mmureg_532;
2142
        }
2143
      else
2144
        {
2145
          as_warn (_("invalid architecture option -m%s, ignored"), arg);
2146
          return 0;
2147
        }
2148
      break;
2149
    case OPTION_DISP_SIZE:
2150
      {
2151
        int size = atoi(arg);
2152
        switch (size)
2153
          {
2154
          case 1: case 2: case 4:
2155
            default_disp_size = size;
2156
            break;
2157
          default:
2158
            as_warn (_("invalid default displacement size \"%s\". Defaulting to %d."),
2159
                     arg, default_disp_size);
2160
          }
2161
        break;
2162
      }
2163
 
2164
    default:
2165
      return 0;
2166
    }
2167
 
2168
  return 1;
2169
}
2170
 
2171
void
2172
md_show_usage (FILE *stream)
2173
{
2174
  fprintf (stream, _("\
2175
NS32K options:\n\
2176
-m32032 | -m32532       select variant of NS32K architecture\n\
2177
--disp-size-default=<1|2|4>\n"));
2178
}
2179
 
2180
/* This is TC_CONS_FIX_NEW, called by emit_expr in read.c.  */
2181
 
2182
void
2183
cons_fix_new_ns32k (fragS *frag,        /* Which frag? */
2184
                    int where,          /* Where in that frag? */
2185
                    int size,           /* 1, 2  or 4 usually.  */
2186
                    expressionS *exp)   /* Expression.  */
2187
{
2188
  fix_new_ns32k_exp (frag, where, size, exp,
2189
                     0, 2, 0, 0, 0, 0);
2190
}
2191
 
2192
/* We have no need to default values of symbols.  */
2193
 
2194
symbolS *
2195
md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
2196
{
2197
  return 0;
2198
}
2199
 
2200
/* Round up a section size to the appropriate boundary.  */
2201
 
2202
valueT
2203
md_section_align (segT segment ATTRIBUTE_UNUSED, valueT size)
2204
{
2205
  return size;                  /* Byte alignment is fine.  */
2206
}
2207
 
2208
/* Exactly what point is a PC-relative offset relative TO?  On the
2209
   ns32k, they're relative to the start of the instruction.  */
2210
 
2211
long
2212
md_pcrel_from (fixS *fixP)
2213
{
2214
  long res;
2215
 
2216
  res = fixP->fx_where + fixP->fx_frag->fr_address;
2217
#ifdef SEQUENT_COMPATABILITY
2218
  if (frag_bsr (fixP->fx_frag))
2219
    res += 0x12                 /* FOO Kludge alert!  */
2220
#endif
2221
      return res;
2222
}
2223
 
2224
arelent *
2225
tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp)
2226
{
2227
  arelent *rel;
2228
  bfd_reloc_code_real_type code;
2229
 
2230
  code = reloc (fixp->fx_size, fixp->fx_pcrel, fix_im_disp (fixp));
2231
 
2232
  rel = xmalloc (sizeof (arelent));
2233
  rel->sym_ptr_ptr = xmalloc (sizeof (asymbol *));
2234
  *rel->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
2235
  rel->address = fixp->fx_frag->fr_address + fixp->fx_where;
2236
  if (fixp->fx_pcrel)
2237
    rel->addend = fixp->fx_addnumber;
2238
  else
2239
    rel->addend = 0;
2240
 
2241
  rel->howto = bfd_reloc_type_lookup (stdoutput, code);
2242
  if (!rel->howto)
2243
    {
2244
      const char *name;
2245
 
2246
      name = S_GET_NAME (fixp->fx_addsy);
2247
      if (name == NULL)
2248
        name = _("<unknown>");
2249
      as_fatal (_("Cannot find relocation type for symbol %s, code %d"),
2250
                name, (int) code);
2251
    }
2252
 
2253
  return rel;
2254
}

powered by: WebSVN 2.1.0

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