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

Subversion Repositories open8_urisc

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

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 16 khays
/* tc-vax.c - vax-specific -
2
   Copyright 1987, 1991, 1992, 1993, 1994, 1995, 1998, 2000, 2001, 2002,
3
   2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
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
#include "as.h"
24
 
25
#include "vax-inst.h"
26
#include "obstack.h"            /* For FRAG_APPEND_1_CHAR macro in "frags.h" */
27
#include "subsegs.h"
28
#include "safe-ctype.h"
29
 
30
#ifdef OBJ_ELF
31
#include "elf/vax.h"
32
#endif
33
 
34
/* These chars start a comment anywhere in a source file (except inside
35
   another comment */
36
const char comment_chars[] = "#";
37
 
38
/* These chars only start a comment at the beginning of a line.  */
39
/* Note that for the VAX the are the same as comment_chars above.  */
40
const char line_comment_chars[] = "#";
41
 
42
const char line_separator_chars[] = ";";
43
 
44
/* Chars that can be used to separate mant from exp in floating point nums.  */
45
const char EXP_CHARS[] = "eE";
46
 
47
/* Chars that mean this number is a floating point constant
48
   as in 0f123.456
49
   or    0H1.234E-12 (see exp chars above).  */
50
const char FLT_CHARS[] = "dDfFgGhH";
51
 
52
/* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
53
   changed in read.c .  Ideally it shouldn't have to know about it at all,
54
   but nothing is ideal around here.  */
55
 
56
/* Hold details of an operand expression.  */
57
static expressionS exp_of_operand[VIT_MAX_OPERANDS];
58
static segT seg_of_operand[VIT_MAX_OPERANDS];
59
 
60
/* A vax instruction after decoding.  */
61
static struct vit v;
62
 
63
/* Hold details of big operands.  */
64
LITTLENUM_TYPE big_operand_bits[VIT_MAX_OPERANDS][SIZE_OF_LARGE_NUMBER];
65
FLONUM_TYPE float_operand[VIT_MAX_OPERANDS];
66
/* Above is made to point into big_operand_bits by md_begin().  */
67
 
68
#ifdef OBJ_ELF
69
#define GLOBAL_OFFSET_TABLE_NAME        "_GLOBAL_OFFSET_TABLE_"
70
#define PROCEDURE_LINKAGE_TABLE_NAME    "_PROCEDURE_LINKAGE_TABLE_"
71
symbolS *GOT_symbol;            /* Pre-defined "_GLOBAL_OFFSET_TABLE_".  */
72
symbolS *PLT_symbol;            /* Pre-defined "_PROCEDURE_LINKAGE_TABLE_".  */
73
#endif
74
 
75
int flag_hash_long_names;       /* -+ */
76
int flag_one;                   /* -1 */
77
int flag_show_after_trunc;      /* -H */
78
int flag_no_hash_mixed_case;    /* -h NUM */
79
#ifdef OBJ_ELF
80
int flag_want_pic;              /* -k */
81
#endif
82
 
83
/* For VAX, relative addresses of "just the right length" are easy.
84
   The branch displacement is always the last operand, even in
85
   synthetic instructions.
86
   For VAX, we encode the relax_substateTs (in e.g. fr_substate) as:
87
 
88
                    4       3       2       1       0        bit number
89
        ---/ /--+-------+-------+-------+-------+-------+
90
                |     what state ?      |  how long ?   |
91
        ---/ /--+-------+-------+-------+-------+-------+
92
 
93
   The "how long" bits are 00=byte, 01=word, 10=long.
94
   This is a Un*x convention.
95
   Not all lengths are legit for a given value of (what state).
96
   The "how long" refers merely to the displacement length.
97
   The address usually has some constant bytes in it as well.
98
 
99
 groups for VAX address relaxing.
100
 
101
 1.     "foo" pc-relative.
102
 length of byte, word, long
103
 
104
 2a.    J<cond> where <cond> is a simple flag test.
105
 length of byte, word, long.
106
 VAX opcodes are:       (Hex)
107
 bneq/bnequ     12
108
 beql/beqlu     13
109
 bgtr           14
110
 bleq           15
111
 bgeq           18
112
 blss           19
113
 bgtru          1a
114
 blequ          1b
115
 bvc            1c
116
 bvs            1d
117
 bgequ/bcc      1e
118
 blssu/bcs      1f
119
 Always, you complement 0th bit to reverse condition.
120
 Always, 1-byte opcode, then 1-byte displacement.
121
 
122
 2b.    J<cond> where cond tests a memory bit.
123
 length of byte, word, long.
124
 Vax opcodes are:       (Hex)
125
 bbs            e0
126
 bbc            e1
127
 bbss           e2
128
 bbcs           e3
129
 bbsc           e4
130
 bbcc           e5
131
 Always, you complement 0th bit to reverse condition.
132
 Always, 1-byte opcde, longword-address, byte-address, 1-byte-displacement
133
 
134
 2c.    J<cond> where cond tests low-order memory bit
135
 length of byte,word,long.
136
 Vax opcodes are:       (Hex)
137
 blbs           e8
138
 blbc           e9
139
 Always, you complement 0th bit to reverse condition.
140
 Always, 1-byte opcode, longword-address, 1-byte displacement.
141
 
142
 3.     Jbs/Jbr.
143
 length of byte,word,long.
144
 Vax opcodes are:       (Hex)
145
 bsbb           10
146
 brb            11
147
 These are like (2) but there is no condition to reverse.
148
 Always, 1 byte opcode, then displacement/absolute.
149
 
150
 4a.    JacbX
151
 length of word, long.
152
 Vax opcodes are:       (Hex)
153
 acbw           3d
154
 acbf           4f
155
 acbd           6f
156
 abcb           9d
157
 acbl           f1
158
 acbg         4ffd
159
 acbh         6ffd
160
 Always, we cannot reverse the sense of the branch; we have a word
161
 displacement.
162
 The double-byte op-codes don't hurt: we never want to modify the
163
 opcode, so we don't care how many bytes are between the opcode and
164
 the operand.
165
 
166
 4b.    JXobXXX
167
 length of long, long, byte.
168
 Vax opcodes are:       (Hex)
169
 aoblss         f2
170
 aobleq         f3
171
 sobgeq         f4
172
 sobgtr         f5
173
 Always, we cannot reverse the sense of the branch; we have a byte
174
 displacement.
175
 
176
 The only time we need to modify the opcode is for class 2 instructions.
177
 After relax() we may complement the lowest order bit of such instruction
178
 to reverse sense of branch.
179
 
180
 For class 2 instructions, we store context of "where is the opcode literal".
181
 We can change an opcode's lowest order bit without breaking anything else.
182
 
183
 We sometimes store context in the operand literal. This way we can figure out
184
 after relax() what the original addressing mode was.  */
185
 
186
/* These displacements are relative to the start address of the
187
   displacement.  The first letter is Byte, Word.  2nd letter is
188
   Forward, Backward.  */
189
#define BF (1+ 127)
190
#define BB (1+-128)
191
#define WF (2+ 32767)
192
#define WB (2+-32768)
193
/* Dont need LF, LB because they always reach. [They are coded as 0.]  */
194
 
195
#define C(a,b) ENCODE_RELAX(a,b)
196
/* This macro has no side-effects.  */
197
#define ENCODE_RELAX(what,length) (((what) << 2) + (length))
198
#define RELAX_STATE(s) ((s) >> 2)
199
#define RELAX_LENGTH(s) ((s) & 3)
200
 
201
const relax_typeS md_relax_table[] =
202
{
203
  {1, 1, 0, 0},                   /* error sentinel   0,0 */
204
  {1, 1, 0, 0},                   /* unused           0,1 */
205
  {1, 1, 0, 0},                   /* unused           0,2 */
206
  {1, 1, 0, 0},                   /* unused           0,3 */
207
 
208
  {BF + 1, BB + 1, 2, C (1, 1)},/* B^"foo"          1,0 */
209
  {WF + 1, WB + 1, 3, C (1, 2)},/* W^"foo"          1,1 */
210
  {0, 0, 5, 0},                    /* L^"foo"          1,2 */
211
  {1, 1, 0, 0},                   /* unused           1,3 */
212
 
213
  {BF, BB, 1, C (2, 1)},        /* b<cond> B^"foo"  2,0 */
214
  {WF + 2, WB + 2, 4, C (2, 2)},/* br.+? brw X      2,1 */
215
  {0, 0, 7, 0},                    /* br.+? jmp X      2,2 */
216
  {1, 1, 0, 0},                   /* unused           2,3 */
217
 
218
  {BF, BB, 1, C (3, 1)},        /* brb B^foo        3,0 */
219
  {WF, WB, 2, C (3, 2)},        /* brw W^foo        3,1 */
220
  {0, 0, 5, 0},                    /* Jmp L^foo        3,2 */
221
  {1, 1, 0, 0},                   /* unused           3,3 */
222
 
223
  {1, 1, 0, 0},                   /* unused           4,0 */
224
  {WF, WB, 2, C (4, 2)},        /* acb_ ^Wfoo       4,1 */
225
  {0, 0, 10, 0},           /* acb_,br,jmp L^foo4,2 */
226
  {1, 1, 0, 0},                   /* unused           4,3 */
227
 
228
  {BF, BB, 1, C (5, 1)},        /* Xob___,,foo      5,0 */
229
  {WF + 4, WB + 4, 6, C (5, 2)},/* Xob.+2,brb.+3,brw5,1 */
230
  {0, 0, 9, 0},                    /* Xob.+2,brb.+6,jmp5,2 */
231
  {1, 1, 0, 0},                   /* unused           5,3 */
232
};
233
 
234
#undef C
235
#undef BF
236
#undef BB
237
#undef WF
238
#undef WB
239
 
240
void float_cons (int);
241
int flonum_gen2vax (char, FLONUM_TYPE *, LITTLENUM_TYPE *);
242
 
243
const pseudo_typeS md_pseudo_table[] =
244
{
245
  {"dfloat", float_cons, 'd'},
246
  {"ffloat", float_cons, 'f'},
247
  {"gfloat", float_cons, 'g'},
248
  {"hfloat", float_cons, 'h'},
249
  {"d_floating", float_cons, 'd'},
250
  {"f_floating", float_cons, 'f'},
251
  {"g_floating", float_cons, 'g'},
252
  {"h_floating", float_cons, 'h'},
253
  {NULL, NULL, 0},
254
};
255
 
256
#define STATE_PC_RELATIVE               (1)
257
#define STATE_CONDITIONAL_BRANCH        (2)
258
#define STATE_ALWAYS_BRANCH             (3)     /* includes BSB...  */
259
#define STATE_COMPLEX_BRANCH            (4)
260
#define STATE_COMPLEX_HOP               (5)
261
 
262
#define STATE_BYTE                      (0)
263
#define STATE_WORD                      (1)
264
#define STATE_LONG                      (2)
265
#define STATE_UNDF                      (3)     /* Symbol undefined in pass1.  */
266
 
267
#define min(a, b)       ((a) < (b) ? (a) : (b))
268
 
269
void
270
md_number_to_chars (char con[], valueT value, int nbytes)
271
{
272
  number_to_chars_littleendian (con, value, nbytes);
273
}
274
 
275
/* Fix up some data or instructions after we find out the value of a symbol
276
   that they reference.  */
277
 
278
void                            /* Knows about order of bytes in address.  */
279
md_apply_fix (fixS *fixP, valueT *valueP, segT seg ATTRIBUTE_UNUSED)
280
{
281
  valueT value = * valueP;
282
 
283
  if (((fixP->fx_addsy == NULL && fixP->fx_subsy == NULL)
284
       && fixP->fx_r_type != BFD_RELOC_32_PLT_PCREL
285
       && fixP->fx_r_type != BFD_RELOC_32_GOT_PCREL)
286
      || fixP->fx_r_type == NO_RELOC)
287
    number_to_chars_littleendian (fixP->fx_where + fixP->fx_frag->fr_literal,
288
                                  value, fixP->fx_size);
289
 
290
  if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0)
291
    fixP->fx_done = 1;
292
}
293
 
294
/* Convert a number from VAX byte order (little endian)
295
   into host byte order.
296
   con          is the buffer to convert,
297
   nbytes       is the length of the given buffer.  */
298
static long
299
md_chars_to_number (unsigned char con[], int nbytes)
300
{
301
  long retval;
302
 
303
  for (retval = 0, con += nbytes - 1; nbytes--; con--)
304
    {
305
      retval <<= BITS_PER_CHAR;
306
      retval |= *con;
307
    }
308
  return retval;
309
}
310
 
311
/* Copy a bignum from in to out.
312
   If the output is shorter than the input, copy lower-order
313
   littlenums.  Return 0 or the number of significant littlenums
314
   dropped.  Assumes littlenum arrays are densely packed: no unused
315
   chars between the littlenums. Uses memcpy() to move littlenums, and
316
   wants to know length (in chars) of the input bignum.  */
317
 
318
static int
319
bignum_copy (LITTLENUM_TYPE *in,
320
             int in_length,     /* in sizeof(littlenum)s */
321
             LITTLENUM_TYPE *out,
322
             int out_length     /* in sizeof(littlenum)s */)
323
{
324
  int significant_littlenums_dropped;
325
 
326
  if (out_length < in_length)
327
    {
328
      LITTLENUM_TYPE *p;        /* -> most significant (non-zero) input
329
                                      littlenum.  */
330
 
331
      memcpy ((void *) out, (void *) in,
332
              (unsigned int) out_length << LITTLENUM_SHIFT);
333
      for (p = in + in_length - 1; p >= in; --p)
334
        {
335
          if (*p)
336
            break;
337
        }
338
      significant_littlenums_dropped = p - in - in_length + 1;
339
 
340
      if (significant_littlenums_dropped < 0)
341
        significant_littlenums_dropped = 0;
342
    }
343
  else
344
    {
345
      memcpy ((char *) out, (char *) in,
346
              (unsigned int) in_length << LITTLENUM_SHIFT);
347
 
348
      if (out_length > in_length)
349
        memset ((char *) (out + in_length), '\0',
350
                (unsigned int) (out_length - in_length) << LITTLENUM_SHIFT);
351
 
352
      significant_littlenums_dropped = 0;
353
    }
354
 
355
  return significant_littlenums_dropped;
356
}
357
 
358
/* md_estimate_size_before_relax(), called just before relax().
359
   Any symbol that is now undefined will not become defined.
360
   Return the correct fr_subtype in the frag and the growth beyond
361
   fr_fix.  */
362
int
363
md_estimate_size_before_relax (fragS *fragP, segT segment)
364
{
365
  if (RELAX_LENGTH (fragP->fr_subtype) == STATE_UNDF)
366
    {
367
      if (S_GET_SEGMENT (fragP->fr_symbol) != segment
368
#ifdef OBJ_ELF
369
          || S_IS_WEAK (fragP->fr_symbol)
370
          || S_IS_EXTERNAL (fragP->fr_symbol)
371
#endif
372
          )
373
        {
374
          /* Non-relaxable cases.  */
375
          int reloc_type = NO_RELOC;
376
          char *p;
377
          int old_fr_fix;
378
 
379
          old_fr_fix = fragP->fr_fix;
380
          p = fragP->fr_literal + old_fr_fix;
381
#ifdef OBJ_ELF
382
          /* If this is to an undefined symbol, then if it's an indirect
383
             reference indicate that is can mutated into a GLOB_DAT or
384
             JUMP_SLOT by the loader.  We restrict ourselves to no offset
385
             due to a limitation in the NetBSD linker.  */
386
 
387
          if (GOT_symbol == NULL)
388
            GOT_symbol = symbol_find (GLOBAL_OFFSET_TABLE_NAME);
389
          if (PLT_symbol == NULL)
390
            PLT_symbol = symbol_find (PROCEDURE_LINKAGE_TABLE_NAME);
391
          if ((GOT_symbol == NULL || fragP->fr_symbol != GOT_symbol)
392
              && (PLT_symbol == NULL || fragP->fr_symbol != PLT_symbol)
393
              && fragP->fr_symbol != NULL
394
              && flag_want_pic
395
              && (!S_IS_DEFINED (fragP->fr_symbol)
396
                  || S_IS_WEAK (fragP->fr_symbol)
397
                  || S_IS_EXTERNAL (fragP->fr_symbol)))
398
            {
399
              /* Indirect references cannot go through the GOT or PLT,
400
                 let's hope they'll become local in the final link.  */
401
              if ((ELF_ST_VISIBILITY (S_GET_OTHER (fragP->fr_symbol))
402
                   != STV_DEFAULT)
403
                  || (p[0] & 0x10))
404
                reloc_type = BFD_RELOC_32_PCREL;
405
              else if (((unsigned char *) fragP->fr_opcode)[0] == VAX_CALLS
406
                       || ((unsigned char *) fragP->fr_opcode)[0] == VAX_CALLG
407
                       || ((unsigned char *) fragP->fr_opcode)[0] == VAX_JSB
408
                       || ((unsigned char *) fragP->fr_opcode)[0] == VAX_JMP
409
                       || S_IS_FUNCTION (fragP->fr_symbol))
410
                reloc_type = BFD_RELOC_32_PLT_PCREL;
411
              else
412
                reloc_type = BFD_RELOC_32_GOT_PCREL;
413
            }
414
#endif
415
          switch (RELAX_STATE (fragP->fr_subtype))
416
            {
417
            case STATE_PC_RELATIVE:
418
              p[0] |= VAX_PC_RELATIVE_MODE;      /* Preserve @ bit.  */
419
              fragP->fr_fix += 1 + 4;
420
              fix_new (fragP, old_fr_fix + 1, 4, fragP->fr_symbol,
421
                       fragP->fr_offset, 1, reloc_type);
422
              break;
423
 
424
            case STATE_CONDITIONAL_BRANCH:
425
              *fragP->fr_opcode ^= 1;           /* Reverse sense of branch.  */
426
              p[0] = 6;
427
              p[1] = VAX_JMP;
428
              p[2] = VAX_PC_RELATIVE_MODE;      /* ...(PC) */
429
              fragP->fr_fix += 1 + 1 + 1 + 4;
430
              fix_new (fragP, old_fr_fix + 3, 4, fragP->fr_symbol,
431
                       fragP->fr_offset, 1, NO_RELOC);
432
              break;
433
 
434
            case STATE_COMPLEX_BRANCH:
435
              p[0] = 2;
436
              p[1] = 0;
437
              p[2] = VAX_BRB;
438
              p[3] = 6;
439
              p[4] = VAX_JMP;
440
              p[5] = VAX_PC_RELATIVE_MODE;      /* ...(pc) */
441
              fragP->fr_fix += 2 + 2 + 1 + 1 + 4;
442
              fix_new (fragP, old_fr_fix + 6, 4, fragP->fr_symbol,
443
                       fragP->fr_offset, 1, NO_RELOC);
444
              break;
445
 
446
            case STATE_COMPLEX_HOP:
447
              p[0] = 2;
448
              p[1] = VAX_BRB;
449
              p[2] = 6;
450
              p[3] = VAX_JMP;
451
              p[4] = VAX_PC_RELATIVE_MODE;      /* ...(pc) */
452
              fragP->fr_fix += 1 + 2 + 1 + 1 + 4;
453
              fix_new (fragP, old_fr_fix + 5, 4, fragP->fr_symbol,
454
                       fragP->fr_offset, 1, NO_RELOC);
455
              break;
456
 
457
            case STATE_ALWAYS_BRANCH:
458
              *fragP->fr_opcode += VAX_WIDEN_LONG;
459
              p[0] = VAX_PC_RELATIVE_MODE;       /* ...(PC) */
460
              fragP->fr_fix += 1 + 4;
461
              fix_new (fragP, old_fr_fix + 1, 4, fragP->fr_symbol,
462
                       fragP->fr_offset, 1, NO_RELOC);
463
              break;
464
 
465
            default:
466
              abort ();
467
            }
468
          frag_wane (fragP);
469
 
470
          /* Return the growth in the fixed part of the frag.  */
471
          return fragP->fr_fix - old_fr_fix;
472
        }
473
 
474
      /* Relaxable cases.  Set up the initial guess for the variable
475
         part of the frag.  */
476
      switch (RELAX_STATE (fragP->fr_subtype))
477
        {
478
        case STATE_PC_RELATIVE:
479
          fragP->fr_subtype = ENCODE_RELAX (STATE_PC_RELATIVE, STATE_BYTE);
480
          break;
481
        case STATE_CONDITIONAL_BRANCH:
482
          fragP->fr_subtype = ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_BYTE);
483
          break;
484
        case STATE_COMPLEX_BRANCH:
485
          fragP->fr_subtype = ENCODE_RELAX (STATE_COMPLEX_BRANCH, STATE_WORD);
486
          break;
487
        case STATE_COMPLEX_HOP:
488
          fragP->fr_subtype = ENCODE_RELAX (STATE_COMPLEX_HOP, STATE_BYTE);
489
          break;
490
        case STATE_ALWAYS_BRANCH:
491
          fragP->fr_subtype = ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_BYTE);
492
          break;
493
        }
494
    }
495
 
496
  if (fragP->fr_subtype >= sizeof (md_relax_table) / sizeof (md_relax_table[0]))
497
    abort ();
498
 
499
  /* Return the size of the variable part of the frag.  */
500
  return md_relax_table[fragP->fr_subtype].rlx_length;
501
}
502
 
503
/* Called after relax() is finished.
504
   In:  Address of frag.
505
        fr_type == rs_machine_dependent.
506
        fr_subtype is what the address relaxed to.
507
 
508
   Out: Any fixSs and constants are set up.
509
        Caller will turn frag into a ".space 0".  */
510
void
511
md_convert_frag (bfd *headers ATTRIBUTE_UNUSED,
512
                 segT seg ATTRIBUTE_UNUSED,
513
                 fragS *fragP)
514
{
515
  char *addressP;               /* -> _var to change.  */
516
  char *opcodeP;                /* -> opcode char(s) to change.  */
517
  short int extension = 0;       /* Size of relaxed address.  */
518
  /* Added to fr_fix: incl. ALL var chars.  */
519
  symbolS *symbolP;
520
  long where;
521
 
522
  know (fragP->fr_type == rs_machine_dependent);
523
  where = fragP->fr_fix;
524
  addressP = fragP->fr_literal + where;
525
  opcodeP = fragP->fr_opcode;
526
  symbolP = fragP->fr_symbol;
527
  know (symbolP);
528
 
529
  switch (fragP->fr_subtype)
530
    {
531
    case ENCODE_RELAX (STATE_PC_RELATIVE, STATE_BYTE):
532
      know (*addressP == 0 || *addressP == 0x10);        /* '@' bit.  */
533
      addressP[0] |= 0xAF;       /* Byte displacement. */
534
      fix_new (fragP, fragP->fr_fix + 1, 1, fragP->fr_symbol,
535
               fragP->fr_offset, 1, NO_RELOC);
536
      extension = 2;
537
      break;
538
 
539
    case ENCODE_RELAX (STATE_PC_RELATIVE, STATE_WORD):
540
      know (*addressP == 0 || *addressP == 0x10);        /* '@' bit.  */
541
      addressP[0] |= 0xCF;       /* Word displacement. */
542
      fix_new (fragP, fragP->fr_fix + 1, 2, fragP->fr_symbol,
543
               fragP->fr_offset, 1, NO_RELOC);
544
      extension = 3;
545
      break;
546
 
547
    case ENCODE_RELAX (STATE_PC_RELATIVE, STATE_LONG):
548
      know (*addressP == 0 || *addressP == 0x10);        /* '@' bit.  */
549
      addressP[0] |= 0xEF;       /* Long word displacement. */
550
      fix_new (fragP, fragP->fr_fix + 1, 4, fragP->fr_symbol,
551
               fragP->fr_offset, 1, NO_RELOC);
552
      extension = 5;
553
      break;
554
 
555
    case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_BYTE):
556
      fix_new (fragP, fragP->fr_fix, 1, fragP->fr_symbol,
557
               fragP->fr_offset, 1, NO_RELOC);
558
      extension = 1;
559
      break;
560
 
561
    case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_WORD):
562
      opcodeP[0] ^= 1;           /* Reverse sense of test.  */
563
      addressP[0] = 3;
564
      addressP[1] = VAX_BRW;
565
      fix_new (fragP, fragP->fr_fix + 2, 2, fragP->fr_symbol,
566
               fragP->fr_offset, 1, NO_RELOC);
567
      extension = 4;
568
      break;
569
 
570
    case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_LONG):
571
      opcodeP[0] ^= 1;           /* Reverse sense of test.  */
572
      addressP[0] = 6;
573
      addressP[1] = VAX_JMP;
574
      addressP[2] = VAX_PC_RELATIVE_MODE;
575
      fix_new (fragP, fragP->fr_fix + 3, 4, fragP->fr_symbol,
576
               fragP->fr_offset, 1, NO_RELOC);
577
      extension = 7;
578
      break;
579
 
580
    case ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_BYTE):
581
      fix_new (fragP, fragP->fr_fix, 1, fragP->fr_symbol,
582
               fragP->fr_offset, 1, NO_RELOC);
583
      extension = 1;
584
      break;
585
 
586
    case ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_WORD):
587
      opcodeP[0] += VAX_WIDEN_WORD;      /* brb -> brw, bsbb -> bsbw */
588
      fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol, fragP->fr_offset,
589
               1, NO_RELOC);
590
      extension = 2;
591
      break;
592
 
593
    case ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_LONG):
594
      opcodeP[0] += VAX_WIDEN_LONG;      /* brb -> jmp, bsbb -> jsb */
595
      addressP[0] = VAX_PC_RELATIVE_MODE;
596
      fix_new (fragP, fragP->fr_fix + 1, 4, fragP->fr_symbol,
597
               fragP->fr_offset, 1, NO_RELOC);
598
      extension = 5;
599
      break;
600
 
601
    case ENCODE_RELAX (STATE_COMPLEX_BRANCH, STATE_WORD):
602
      fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol,
603
               fragP->fr_offset, 1, NO_RELOC);
604
      extension = 2;
605
      break;
606
 
607
    case ENCODE_RELAX (STATE_COMPLEX_BRANCH, STATE_LONG):
608
      addressP[0] = 2;
609
      addressP[1] = 0;
610
      addressP[2] = VAX_BRB;
611
      addressP[3] = 6;
612
      addressP[4] = VAX_JMP;
613
      addressP[5] = VAX_PC_RELATIVE_MODE;
614
      fix_new (fragP, fragP->fr_fix + 6, 4, fragP->fr_symbol,
615
               fragP->fr_offset, 1, NO_RELOC);
616
      extension = 10;
617
      break;
618
 
619
    case ENCODE_RELAX (STATE_COMPLEX_HOP, STATE_BYTE):
620
      fix_new (fragP, fragP->fr_fix, 1, fragP->fr_symbol,
621
               fragP->fr_offset, 1, NO_RELOC);
622
      extension = 1;
623
      break;
624
 
625
    case ENCODE_RELAX (STATE_COMPLEX_HOP, STATE_WORD):
626
      addressP[0] = 2;
627
      addressP[1] = VAX_BRB;
628
      addressP[2] = 3;
629
      addressP[3] = VAX_BRW;
630
      fix_new (fragP, fragP->fr_fix + 4, 2, fragP->fr_symbol,
631
               fragP->fr_offset, 1, NO_RELOC);
632
      extension = 6;
633
      break;
634
 
635
    case ENCODE_RELAX (STATE_COMPLEX_HOP, STATE_LONG):
636
      addressP[0] = 2;
637
      addressP[1] = VAX_BRB;
638
      addressP[2] = 6;
639
      addressP[3] = VAX_JMP;
640
      addressP[4] = VAX_PC_RELATIVE_MODE;
641
      fix_new (fragP, fragP->fr_fix + 5, 4, fragP->fr_symbol,
642
               fragP->fr_offset, 1, NO_RELOC);
643
      extension = 9;
644
      break;
645
 
646
    default:
647
      BAD_CASE (fragP->fr_subtype);
648
      break;
649
    }
650
  fragP->fr_fix += extension;
651
}
652
 
653
/* Translate internal format of relocation info into target format.
654
 
655
   On vax: first 4 bytes are normal unsigned long, next three bytes
656
   are symbolnum, least sig. byte first.  Last byte is broken up with
657
   the upper nibble as nuthin, bit 3 as extern, bits 2 & 1 as length, and
658
   bit 0 as pcrel.  */
659
#ifdef comment
660
void
661
md_ri_to_chars (char *the_bytes, struct reloc_info_generic ri)
662
{
663
  /* This is easy.  */
664
  md_number_to_chars (the_bytes, ri.r_address, sizeof (ri.r_address));
665
  /* Now the fun stuff.  */
666
  the_bytes[6] = (ri.r_symbolnum >> 16) & 0x0ff;
667
  the_bytes[5] = (ri.r_symbolnum >> 8) & 0x0ff;
668
  the_bytes[4] = ri.r_symbolnum & 0x0ff;
669
  the_bytes[7] = (((ri.r_extern << 3) & 0x08) | ((ri.r_length << 1) & 0x06)
670
                  | ((ri.r_pcrel << 0) & 0x01)) & 0x0F;
671
}
672
 
673
#endif /* comment */
674
 
675
/*       BUGS, GRIPES,  APOLOGIA, etc.
676
 
677
   The opcode table 'votstrs' needs to be sorted on opcode frequency.
678
   That is, AFTER we hash it with hash_...(), we want most-used opcodes
679
   to come out of the hash table faster.
680
 
681
   I am sorry to inflict yet another VAX assembler on the world, but
682
   RMS says we must do everything from scratch, to prevent pin-heads
683
   restricting this software.
684
 
685
   This is a vaguely modular set of routines in C to parse VAX
686
   assembly code using DEC mnemonics. It is NOT un*x specific.
687
 
688
   The idea here is that the assembler has taken care of all:
689
     labels
690
     macros
691
     listing
692
     pseudo-ops
693
     line continuation
694
     comments
695
     condensing any whitespace down to exactly one space
696
   and all we have to do is parse 1 line into a vax instruction
697
   partially formed. We will accept a line, and deliver:
698
     an error message (hopefully empty)
699
     a skeleton VAX instruction (tree structure)
700
     textual pointers to all the operand expressions
701
     a warning message that notes a silly operand (hopefully empty)
702
 
703
                E D I T   H I S T O R Y
704
 
705
   17may86 Dean Elsner. Bug if line ends immediately after opcode.
706
   30apr86 Dean Elsner. New vip_op() uses arg block so change call.
707
    6jan86 Dean Elsner. Crock vip_begin() to call vip_op_defaults().
708
    2jan86 Dean Elsner. Invent synthetic opcodes.
709
        Widen vax_opcodeT to 32 bits. Use a bit for VIT_OPCODE_SYNTHETIC,
710
        which means this is not a real opcode, it is like a macro; it will
711
        be relax()ed into 1 or more instructions.
712
        Use another bit for VIT_OPCODE_SPECIAL if the op-code is not optimised
713
        like a regular branch instruction. Option added to vip_begin():
714
        exclude synthetic opcodes. Invent synthetic_votstrs[].
715
   31dec85 Dean Elsner. Invent vit_opcode_nbytes.
716
        Also make vit_opcode into a char[]. We now have n-byte vax opcodes,
717
        so caller's don't have to know the difference between a 1-byte & a
718
        2-byte op-code. Still need vax_opcodeT concept, so we know how
719
        big an object must be to hold an op.code.
720
   30dec85 Dean Elsner. Widen typedef vax_opcodeT in "vax-inst.h"
721
        because vax opcodes may be 16 bits. Our crufty C compiler was
722
        happily initialising 8-bit vot_codes with 16-bit numbers!
723
        (Wouldn't the 'phone company like to compress data so easily!)
724
   29dec85 Dean Elsner. New static table vax_operand_width_size[].
725
        Invented so we know hw many bytes a "I^#42" needs in its immediate
726
        operand. Revised struct vop in "vax-inst.h": explicitly include
727
        byte length of each operand, and it's letter-code datum type.
728
   17nov85 Dean Elsner. Name Change.
729
        Due to ar(1) truncating names, we learned the hard way that
730
        "vax-inst-parse.c" -> "vax-inst-parse." dropping the "o" off
731
        the archived object name. SO... we shortened the name of this
732
        source file, and changed the makefile.  */
733
 
734
/* Handle of the OPCODE hash table.  */
735
static struct hash_control *op_hash;
736
 
737
/* In:  1 character, from "bdfghloqpw" being the data-type of an operand
738
        of a vax instruction.
739
 
740
   Out: the length of an operand of that type, in bytes.
741
        Special branch operands types "-?!" have length 0.  */
742
 
743
static const short int vax_operand_width_size[256] =
744
{
745
  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
746
  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
747
  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
748
  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
749
  0, 0, 1, 0, 8, 0, 4, 8, 16, 0, 0, 0, 4, 0, 0,16,       /* ..b.d.fgh...l..o  */
750
  0, 8, 0, 0, 0, 0, 0, 2,  0, 0, 0, 0, 0, 0, 0, 0,    /* .q.....w........  */
751
  0, 0, 1, 0, 8, 0, 4, 8, 16, 0, 0, 0, 4, 0, 0,16,       /* ..b.d.fgh...l..o  */
752
  0, 8, 0, 0, 0, 0, 0, 2,  0, 0, 0, 0, 0, 0, 0, 0,    /* .q.....w........  */
753
  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
754
  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
755
  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
756
  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
757
  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
758
  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
759
  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
760
  0, 0, 0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0, 0, 0,
761
};
762
 
763
/* This perversion encodes all the vax opcodes as a bunch of strings.
764
   RMS says we should build our hash-table at run-time. Hmm.
765
   Please would someone arrange these in decreasing frequency of opcode?
766
   Because of the way hash_...() works, the most frequently used opcode
767
   should be textually first and so on.
768
 
769
   Input for this table was 'vax.opcodes', awk(1)ed by 'vax.opcodes.c.awk' .
770
   So change 'vax.opcodes', then re-generate this table.  */
771
 
772
#include "opcode/vax.h"
773
 
774
/* This is a table of optional op-codes. All of them represent
775
   'synthetic' instructions that seem popular.
776
 
777
   Here we make some pseudo op-codes. Every code has a bit set to say
778
   it is synthetic. This lets you catch them if you want to
779
   ban these opcodes. They are mnemonics for "elastic" instructions
780
   that are supposed to assemble into the fewest bytes needed to do a
781
   branch, or to do a conditional branch, or whatever.
782
 
783
   The opcode is in the usual place [low-order n*8 bits]. This means
784
   that if you mask off the bucky bits, the usual rules apply about
785
   how long the opcode is.
786
 
787
   All VAX branch displacements come at the end of the instruction.
788
   For simple branches (1-byte opcode + 1-byte displacement) the last
789
   operand is coded 'b?' where the "data type" '?' is a clue that we
790
   may reverse the sense of the branch (complement lowest order bit)
791
   and branch around a jump. This is by far the most common case.
792
   That is why the VIT_OPCODE_SYNTHETIC bit is set: it says this is
793
   a 0-byte op-code followed by 2 or more bytes of operand address.
794
 
795
   If the op-code has VIT_OPCODE_SPECIAL set, then we have a more unusual
796
   case.
797
 
798
   For JBSB & JBR the treatment is the similar, except (1) we have a 'bw'
799
   option before (2) we can directly JSB/JMP because there is no condition.
800
   These operands have 'b-' as their access/data type.
801
 
802
   That leaves a bunch of random opcodes: JACBx, JxOBxxx. In these
803
   cases, we do the same idea. JACBxxx are all marked with a 'b!'
804
   JAOBxxx & JSOBxxx are marked with a 'b:'.  */
805
#if (VIT_OPCODE_SYNTHETIC != 0x80000000)
806
#error "You have just broken the encoding below, which assumes the sign bit means 'I am an imaginary instruction'."
807
#endif
808
 
809
#if (VIT_OPCODE_SPECIAL != 0x40000000)
810
#error "You have just broken the encoding below, which assumes the 0x40 M bit means 'I am not to be "optimised" the way normal branches are'."
811
#endif
812
 
813
static const struct vot
814
  synthetic_votstrs[] =
815
{
816
  {"jbsb",      {"b-", 0xC0000010}},            /* BSD 4.2 */
817
/* jsb used already */
818
  {"jbr",       {"b-", 0xC0000011}},            /* BSD 4.2 */
819
  {"jr",        {"b-", 0xC0000011}},            /* consistent */
820
  {"jneq",      {"b?", 0x80000012}},
821
  {"jnequ",     {"b?", 0x80000012}},
822
  {"jeql",      {"b?", 0x80000013}},
823
  {"jeqlu",     {"b?", 0x80000013}},
824
  {"jgtr",      {"b?", 0x80000014}},
825
  {"jleq",      {"b?", 0x80000015}},
826
/* un-used opcodes here */
827
  {"jgeq",      {"b?", 0x80000018}},
828
  {"jlss",      {"b?", 0x80000019}},
829
  {"jgtru",     {"b?", 0x8000001a}},
830
  {"jlequ",     {"b?", 0x8000001b}},
831
  {"jvc",       {"b?", 0x8000001c}},
832
  {"jvs",       {"b?", 0x8000001d}},
833
  {"jgequ",     {"b?", 0x8000001e}},
834
  {"jcc",       {"b?", 0x8000001e}},
835
  {"jlssu",     {"b?", 0x8000001f}},
836
  {"jcs",       {"b?", 0x8000001f}},
837
 
838
  {"jacbw",     {"rwrwmwb!", 0xC000003d}},
839
  {"jacbf",     {"rfrfmfb!", 0xC000004f}},
840
  {"jacbd",     {"rdrdmdb!", 0xC000006f}},
841
  {"jacbb",     {"rbrbmbb!", 0xC000009d}},
842
  {"jacbl",     {"rlrlmlb!", 0xC00000f1}},
843
  {"jacbg",     {"rgrgmgb!", 0xC0004ffd}},
844
  {"jacbh",     {"rhrhmhb!", 0xC0006ffd}},
845
 
846
  {"jbs",       {"rlvbb?", 0x800000e0}},
847
  {"jbc",       {"rlvbb?", 0x800000e1}},
848
  {"jbss",      {"rlvbb?", 0x800000e2}},
849
  {"jbcs",      {"rlvbb?", 0x800000e3}},
850
  {"jbsc",      {"rlvbb?", 0x800000e4}},
851
  {"jbcc",      {"rlvbb?", 0x800000e5}},
852
  {"jbssi",     {"rlvbb?", 0x800000e6}},
853
  {"jbcci",     {"rlvbb?", 0x800000e7}},
854
  {"jlbs",      {"rlb?", 0x800000e8}},
855
  {"jlbc",      {"rlb?", 0x800000e9}},
856
 
857
  {"jaoblss",   {"rlmlb:", 0xC00000f2}},
858
  {"jaobleq",   {"rlmlb:", 0xC00000f3}},
859
  {"jsobgeq",   {"mlb:", 0xC00000f4}},
860
  {"jsobgtr",   {"mlb:", 0xC00000f5}},
861
 
862
/* CASEx has no branch addresses in our conception of it.  */
863
/* You should use ".word ..." statements after the "case ...".  */
864
 
865
  {"",          {"", 0}} /* Empty is end sentinel.  */
866
};
867
 
868
/* Because this module is useful for both VMS and UN*X style assemblers
869
   and because of the variety of UN*X assemblers we must recognise
870
   the different conventions for assembler operand notation. For example
871
   VMS says "#42" for immediate mode, while most UN*X say "$42".
872
   We permit arbitrary sets of (single) characters to represent the
873
   3 concepts that DEC writes '#', '@', '^'.  */
874
 
875
/* Character tests.  */
876
#define VIP_IMMEDIATE 01        /* Character is like DEC # */
877
#define VIP_INDIRECT  02        /* Char is like DEC @ */
878
#define VIP_DISPLEN   04        /* Char is like DEC ^ */
879
 
880
#define IMMEDIATEP(c)   (vip_metacharacters [(c) & 0xff] & VIP_IMMEDIATE)
881
#define INDIRECTP(c)    (vip_metacharacters [(c) & 0xff] & VIP_INDIRECT)
882
#define DISPLENP(c)     (vip_metacharacters [(c) & 0xff] & VIP_DISPLEN)
883
 
884
/* We assume 8 bits per byte. Use vip_op_defaults() to set these up BEFORE we
885
   are ever called.  */
886
 
887
#if defined(CONST_TABLE)
888
#define _ 0,
889
#define I VIP_IMMEDIATE,
890
#define S VIP_INDIRECT,
891
#define D VIP_DISPLEN,
892
static const char
893
vip_metacharacters[256] =
894
{
895
  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _       /* ^@ ^A ^B ^C ^D ^E ^F ^G ^H ^I ^J ^K ^L ^M ^N ^O*/
896
  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _       /* ^P ^Q ^R ^S ^T ^U ^V ^W ^X ^Y ^Z ^[ ^\ ^] ^^ ^_ */
897
  _ _ _ _ I _ _ _ _ _ S _ _ _ _ _       /* sp !  "  #  $  %  & '  (  )  *  +  ,  -  .  / */
898
  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _       /*0  1  2  3  4  5  6  7  8  9  :  ;  <  =  >  ?*/
899
  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _       /*@  A  B  C  D  E  F  G  H  I  J  K  L  M  N  O*/
900
  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _       /*P  Q  R  S  T  U  V  W  X  Y  Z  [  \  ]  ^  _*/
901
  D _ _ _ _ _ _ _ _ _ _ _ _ _ _ _       /*`  a  b  c  d  e  f  g  h  i  j  k  l  m  n  o*/
902
  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _       /*p  q  r  s  t  u  v  w  x  y  z  {  |  }  ~  ^?*/
903
 
904
  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
905
  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
906
  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
907
  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
908
  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
909
  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
910
  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
911
  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
912
};
913
#undef _
914
#undef I
915
#undef S
916
#undef D
917
 
918
#else
919
 
920
static char vip_metacharacters[256];
921
 
922
static void
923
vip_op_1 (int bit, const char *syms)
924
{
925
  unsigned char t;
926
 
927
  while ((t = *syms++) != 0)
928
    vip_metacharacters[t] |= bit;
929
}
930
 
931
/* Can be called any time.  More arguments may appear in future.  */
932
static void
933
vip_op_defaults (const char *immediate, const char *indirect, const char *displen)
934
{
935
  vip_op_1 (VIP_IMMEDIATE, immediate);
936
  vip_op_1 (VIP_INDIRECT, indirect);
937
  vip_op_1 (VIP_DISPLEN, displen);
938
}
939
 
940
#endif
941
 
942
/* Call me once before you decode any lines.
943
   I decode votstrs into a hash table at op_hash (which I create).
944
   I return an error text or null.
945
   If you want, I will include the 'synthetic' jXXX instructions in the
946
   instruction table.
947
   You must nominate metacharacters for eg DEC's "#", "@", "^".  */
948
 
949
static const char *
950
vip_begin (int synthetic_too,           /* 1 means include jXXX op-codes.  */
951
           const char *immediate,
952
           const char *indirect,
953
           const char *displen)
954
{
955
  const struct vot *vP;         /* scan votstrs */
956
  const char *retval = 0;        /* error text */
957
 
958
  op_hash = hash_new ();
959
 
960
  for (vP = votstrs; *vP->vot_name && !retval; vP++)
961
    retval = hash_insert (op_hash, vP->vot_name, (void *) &vP->vot_detail);
962
 
963
  if (synthetic_too)
964
    for (vP = synthetic_votstrs; *vP->vot_name && !retval; vP++)
965
      retval = hash_insert (op_hash, vP->vot_name, (void *) &vP->vot_detail);
966
 
967
#ifndef CONST_TABLE
968
  vip_op_defaults (immediate, indirect, displen);
969
#endif
970
 
971
  return retval;
972
}
973
 
974
/* Take 3 char.s, the last of which may be `\0` (non-existent)
975
   and return the VAX register number that they represent.
976
 
977
   Return -1 if they don't form a register name. Good names return
978
   a number from 0:15 inclusive.
979
 
980
   Case is not important in a name.
981
 
982
   Register names understood are:
983
 
984
        R0
985
        R1
986
        R2
987
        R3
988
        R4
989
        R5
990
        R6
991
        R7
992
        R8
993
        R9
994
        R10
995
        R11
996
        R12     AP
997
        R13     FP
998
        R14     SP
999
        R15     PC  */
1000
 
1001
#define AP 12
1002
#define FP 13
1003
#define SP 14
1004
#define PC 15
1005
 
1006
/* Returns the register number of something like '%r15' or 'ap', supplied
1007
   in four single chars. Returns -1 if the register isn't recognized,
1008
   0..15 otherwise.  */
1009
static int
1010
vax_reg_parse (char c1, char c2, char c3, char c4)
1011
{
1012
  int retval = -1;
1013
 
1014
#ifdef OBJ_ELF
1015
  if (c1 != '%')        /* Register prefixes are mandatory for ELF.  */
1016
    return retval;
1017
  c1 = c2;
1018
  c2 = c3;
1019
  c3 = c4;
1020
#endif
1021
#ifdef OBJ_VMS
1022
  if (c4 != 0)           /* Register prefixes are not allowed under VMS.  */
1023
    return retval;
1024
#endif
1025
#ifdef OBJ_AOUT
1026
  if (c1 == '%')        /* Register prefixes are optional under a.out.  */
1027
    {
1028
      c1 = c2;
1029
      c2 = c3;
1030
      c3 = c4;
1031
    }
1032
  else if (c3 && c4)    /* Can't be 4 characters long.  */
1033
    return retval;
1034
#endif
1035
 
1036
  c1 = TOLOWER (c1);
1037
  c2 = TOLOWER (c2);
1038
  if (ISDIGIT (c2) && c1 == 'r')
1039
    {
1040
      retval = c2 - '0';
1041
      if (ISDIGIT (c3))
1042
        {
1043
          retval = retval * 10 + c3 - '0';
1044
          retval = (retval > 15) ? -1 : retval;
1045
          /* clamp the register value to 1 hex digit */
1046
        }
1047
      else if (c3)
1048
        retval = -1;            /* c3 must be '\0' or a digit.  */
1049
    }
1050
  else if (c3)                  /* There are no three letter regs.  */
1051
    retval = -1;
1052
  else if (c2 == 'p')
1053
    {
1054
      switch (c1)
1055
        {
1056
        case 's':
1057
          retval = SP;
1058
          break;
1059
        case 'f':
1060
          retval = FP;
1061
          break;
1062
        case 'a':
1063
          retval = AP;
1064
          break;
1065
        default:
1066
          retval = -1;
1067
        }
1068
    }
1069
  else if (c1 == 'p' && c2 == 'c')
1070
    retval = PC;
1071
  else
1072
    retval = -1;
1073
  return retval;
1074
}
1075
 
1076
/* Parse a vax operand in DEC assembler notation.
1077
   For speed, expect a string of whitespace to be reduced to a single ' '.
1078
   This is the case for GNU AS, and is easy for other DEC-compatible
1079
   assemblers.
1080
 
1081
   Knowledge about DEC VAX assembler operand notation lives here.
1082
   This doesn't even know what a register name is, except it believes
1083
   all register names are 2 or 3 characters, and lets vax_reg_parse() say
1084
   what number each name represents.
1085
   It does, however, know that PC, SP etc are special registers so it can
1086
   detect addressing modes that are silly for those registers.
1087
 
1088
   Where possible, it delivers 1 fatal or 1 warning message if the operand
1089
   is suspect. Exactly what we test for is still evolving.
1090
 
1091
   ---
1092
        Arg block.
1093
 
1094
   There were a number of 'mismatched argument type' bugs to vip_op.
1095
   The most general solution is to typedef each (of many) arguments.
1096
   We used instead a typedef'd argument block. This is less modular
1097
   than using separate return pointers for each result, but runs faster
1098
   on most engines, and seems to keep programmers happy. It will have
1099
   to be done properly if we ever want to use vip_op as a general-purpose
1100
   module (it was designed to be).
1101
 
1102
        G^
1103
 
1104
   Doesn't support DEC "G^" format operands. These always take 5 bytes
1105
   to express, and code as modes 8F or 9F. Reason: "G^" deprives you of
1106
   optimising to (say) a "B^" if you are lucky in the way you link.
1107
   When someone builds a linker smart enough to convert "G^" to "B^", "W^"
1108
   whenever possible, then we should implement it.
1109
   If there is some other use for "G^", feel free to code it in!
1110
 
1111
        speed
1112
 
1113
   If I nested if()s more, I could avoid testing (*err) which would save
1114
   time, space and page faults. I didn't nest all those if()s for clarity
1115
   and because I think the mode testing can be re-arranged 1st to test the
1116
   commoner constructs 1st. Does anybody have statistics on this?
1117
 
1118
        error messages
1119
 
1120
   In future, we should be able to 'compose' error messages in a scratch area
1121
   and give the user MUCH more informative error messages. Although this takes
1122
   a little more code at run-time, it will make this module much more self-
1123
   documenting. As an example of what sucks now: most error messages have
1124
   hardwired into them the DEC VAX metacharacters "#^@" which are nothing like
1125
   the Un*x characters "$`*", that most users will expect from this AS.
1126
 
1127
   ----
1128
 
1129
   The input is a string, ending with '\0'.
1130
 
1131
   We also require a 'hint' of what kind of operand is expected: so
1132
   we can remind caller not to write into literals for instance.
1133
 
1134
   The output is a skeletal instruction.
1135
 
1136
   The algorithm has two parts.
1137
   1. extract the syntactic features (parse off all the @^#-()+[] mode crud);
1138
   2. express the @^#-()+[] as some parameters suited to further analysis.
1139
 
1140
   2nd step is where we detect the googles of possible invalid combinations
1141
   a human (or compiler) might write. Note that if we do a half-way
1142
   decent assembler, we don't know how long to make (eg) displacement
1143
   fields when we first meet them (because they may not have defined values).
1144
   So we must wait until we know how many bits are needed for each address,
1145
   then we can know both length and opcodes of instructions.
1146
   For reason(s) above, we will pass to our caller a 'broken' instruction
1147
   of these major components, from which our caller can generate instructions:
1148
    -  displacement length      I^ S^ L^ B^ W^ unspecified
1149
    -  mode                     (many)
1150
    -  register                 R0-R15 or absent
1151
    -  index register           R0-R15 or absent
1152
    -  expression text          what we don't parse
1153
    -  error text(s)            why we couldn't understand the operand
1154
 
1155
   ----
1156
 
1157
   To decode output of this, test errtxt. If errtxt[0] == '\0', then
1158
   we had no errors that prevented parsing. Also, if we ever report
1159
   an internal bug, errtxt[0] is set non-zero. So one test tells you
1160
   if the other outputs are to be taken seriously.
1161
 
1162
   ----
1163
 
1164
   Dec defines the semantics of address modes (and values)
1165
   by a two-letter code, explained here.
1166
 
1167
     letter 1:   access type
1168
 
1169
       a         address calculation - no data access, registers forbidden
1170
       b         branch displacement
1171
       m         read - let go of bus - write back    "modify"
1172
       r         read
1173
       v         bit field address: like 'a' but registers are OK
1174
       w         write
1175
       space     no operator (eg ".long foo") [our convention]
1176
 
1177
     letter 2:   data type (i.e. width, alignment)
1178
 
1179
       b         byte
1180
       d         double precision floating point (D format)
1181
       f         single precision floating point (F format)
1182
       g         G format floating
1183
       h         H format floating
1184
       l         longword
1185
       o         octaword
1186
       q         quadword
1187
       w         word
1188
       ?         simple synthetic branch operand
1189
       -         unconditional synthetic JSB/JSR operand
1190
       !         complex synthetic branch operand
1191
 
1192
   The '-?!' letter 2's are not for external consumption. They are used
1193
   for various assemblers. Generally, all unknown widths are assumed 0.
1194
   We don't limit your choice of width character.
1195
 
1196
   DEC operands are hard work to parse. For example, '@' as the first
1197
   character means indirect (deferred) mode but elsewhere it is a shift
1198
   operator.
1199
   The long-winded explanation of how this is supposed to work is
1200
   cancelled. Read a DEC vax manual.
1201
   We try hard not to parse anything that MIGHT be part of the expression
1202
   buried in that syntax. For example if we see @...(Rn) we don't check
1203
   for '-' before the '(' because mode @-(Rn) does not exist.
1204
 
1205
   After parsing we have:
1206
 
1207
   at                     1 if leading '@' (or Un*x '*')
1208
   len                    takes one value from " bilsw". eg B^ -> 'b'.
1209
   hash                   1 if leading '#' (or Un*x '$')
1210
   expr_begin, expr_end   the expression we did not parse
1211
                          even though we don't interpret it, we make use
1212
                          of its presence or absence.
1213
   sign                   -1: -(Rn)    0: absent    +1: (Rn)+
1214
   paren                  1 if () are around register
1215
   reg                    major register number 0:15    -1 means absent
1216
   ndx                    index register number 0:15    -1 means absent
1217
 
1218
   Again, I dare not explain it: just trace ALL the code!
1219
 
1220
   Summary of vip_op outputs.
1221
 
1222
  mode  reg     len     ndx
1223
  (Rn) => @Rn
1224
  {@}Rn                 5+@     n       ' '     optional
1225
  branch operand                0        -1      ' '     -1
1226
  S^#foo                        0        -1      's'     -1
1227
  -(Rn)                 7       n       ' '     optional
1228
  {@}(Rn)+              8+@     n       ' '     optional
1229
  {@}#foo, no S^                8+@     PC      " i"    optional
1230
  {@}{q^}{(Rn)}         10+@+q  option  " bwl"  optional  */
1231
 
1232
/* Dissect user-input 'optext' (which is something like "@B^foo@bar(AP)[FP]:")
1233
   using the vop in vopP. vopP's vop_access and vop_width. We fill _ndx, _reg,
1234
   _mode, _short, _warn, _error, _expr_begin, _expr_end and _nbytes.  */
1235
 
1236
static void
1237
vip_op (char *optext, struct vop *vopP)
1238
{
1239
  /* Track operand text forward.  */
1240
  char *p;
1241
  /* Track operand text backward.  */
1242
  char *q;
1243
  /* 1 if leading '@' ('*') seen.  */
1244
  int at;
1245
  /* one of " bilsw" */
1246
  char len;
1247
  /* 1 if leading '#' ('$') seen.  */
1248
  int hash;
1249
  /* -1, 0 or +1.  */
1250
  int sign = 0;
1251
  /* 1 if () surround register.  */
1252
  int paren = 0;
1253
  /* Register number, -1:absent.  */
1254
  int reg = 0;
1255
  /* Index register number -1:absent.  */
1256
  int ndx = 0;
1257
  /* Report illegal operand, ""==OK.  */
1258
  /* " " is a FAKE error: means we won.  */
1259
  /* ANY err that begins with ' ' is a fake.  */
1260
  /* " " is converted to "" before return.  */
1261
  const char *err;
1262
  /* Warn about weird modes pf address.  */
1263
  const char *wrn;
1264
  /* Preserve q in case we backup.  */
1265
  char *oldq = NULL;
1266
  /* Build up 4-bit operand mode here.  */
1267
  /* Note: index mode is in ndx, this is.  */
1268
  /* The major mode of operand address.  */
1269
  int mode = 0;
1270
  /* Notice how we move wrong-arg-type bugs INSIDE this module: if we
1271
     get the types wrong below, we lose at compile time rather than at
1272
     lint or run time.  */
1273
  char access_mode;             /* vop_access.  */
1274
 
1275
  access_mode = vopP->vop_access;
1276
  /* None of our code bugs (yet), no user text errors, no warnings
1277
     even.  */
1278
  err = wrn = 0;
1279
 
1280
  p = optext;
1281
 
1282
  if (*p == ' ')                /* Expect all whitespace reduced to ' '.  */
1283
    p++;                        /* skip over whitespace */
1284
 
1285
  if ((at = INDIRECTP (*p)) != 0)
1286
    {                           /* 1 if *p=='@'(or '*' for Un*x) */
1287
      p++;                      /* at is determined */
1288
      if (*p == ' ')            /* Expect all whitespace reduced to ' '.  */
1289
        p++;                    /* skip over whitespace */
1290
    }
1291
 
1292
  /* This code is subtle. It tries to detect all legal (letter)'^'
1293
     but it doesn't waste time explicitly testing for premature '\0' because
1294
     this case is rejected as a mismatch against either (letter) or '^'.  */
1295
  {
1296
    char c;
1297
 
1298
    c = *p;
1299
    c = TOLOWER (c);
1300
    if (DISPLENP (p[1]) && strchr ("bilws", len = c))
1301
      p += 2;                   /* Skip (letter) '^'.  */
1302
    else                        /* No (letter) '^' seen.  */
1303
      len = ' ';                /* Len is determined.  */
1304
  }
1305
 
1306
  if (*p == ' ')                /* Expect all whitespace reduced to ' '.  */
1307
    p++;
1308
 
1309
  if ((hash = IMMEDIATEP (*p)) != 0)     /* 1 if *p=='#' ('$' for Un*x) */
1310
    p++;                        /* Hash is determined.  */
1311
 
1312
  /* p points to what may be the beginning of an expression.
1313
     We have peeled off the front all that is peelable.
1314
     We know at, len, hash.
1315
 
1316
     Lets point q at the end of the text and parse that (backwards).  */
1317
 
1318
  for (q = p; *q; q++)
1319
    ;
1320
  q--;                          /* Now q points at last char of text.  */
1321
 
1322
  if (*q == ' ' && q >= p)      /* Expect all whitespace reduced to ' '.  */
1323
    q--;
1324
 
1325
  /* Reverse over whitespace, but don't.  */
1326
  /* Run back over *p.  */
1327
 
1328
  /* As a matter of policy here, we look for [Rn], although both Rn and S^#
1329
     forbid [Rn]. This is because it is easy, and because only a sick
1330
     cyborg would have [...] trailing an expression in a VAX-like assembler.
1331
     A meticulous parser would first check for Rn followed by '(' or '['
1332
     and not parse a trailing ']' if it found another. We just ban expressions
1333
     ending in ']'.  */
1334
  if (*q == ']')
1335
    {
1336
      while (q >= p && *q != '[')
1337
        q--;
1338
      /* Either q<p or we got matching '['.  */
1339
      if (q < p)
1340
        err = _("no '[' to match ']'");
1341
      else
1342
        {
1343
          /* Confusers like "[]" will eventually lose with a bad register
1344
           * name error. So again we don't need to check for early '\0'.  */
1345
          if (q[3] == ']')
1346
            ndx = vax_reg_parse (q[1], q[2], 0, 0);
1347
          else if (q[4] == ']')
1348
            ndx = vax_reg_parse (q[1], q[2], q[3], 0);
1349
          else if (q[5] == ']')
1350
            ndx = vax_reg_parse (q[1], q[2], q[3], q[4]);
1351
          else
1352
            ndx = -1;
1353
          /* Since we saw a ']' we will demand a register name in the [].
1354
           * If luser hasn't given us one: be rude.  */
1355
          if (ndx < 0)
1356
            err = _("bad register in []");
1357
          else if (ndx == PC)
1358
            err = _("[PC] index banned");
1359
          else
1360
            /* Point q just before "[...]".  */
1361
            q--;
1362
        }
1363
    }
1364
  else
1365
    /* No ']', so no iNDeX register.  */
1366
    ndx = -1;
1367
 
1368
  /* If err = "..." then we lost: run away.
1369
     Otherwise ndx == -1 if there was no "[...]".
1370
     Otherwise, ndx is index register number, and q points before "[...]".  */
1371
 
1372
  if (*q == ' ' && q >= p)      /* Expect all whitespace reduced to ' '.  */
1373
    q--;
1374
  /* Reverse over whitespace, but don't.  */
1375
  /* Run back over *p.  */
1376
  if (!err || !*err)
1377
    {
1378
      /* no ()+ or -() seen yet */
1379
      sign = 0;
1380
 
1381
      if (q > p + 3 && *q == '+' && q[-1] == ')')
1382
        {
1383
          sign = 1;             /* we saw a ")+" */
1384
          q--;                  /* q points to ')' */
1385
        }
1386
 
1387
      if (*q == ')' && q > p + 2)
1388
        {
1389
          paren = 1;            /* assume we have "(...)" */
1390
          while (q >= p && *q != '(')
1391
            q--;
1392
          /* either q<p or we got matching '(' */
1393
          if (q < p)
1394
            err = _("no '(' to match ')'");
1395
          else
1396
            {
1397
              /* Confusers like "()" will eventually lose with a bad register
1398
                 name error. So again we don't need to check for early '\0'.  */
1399
              if (q[3] == ')')
1400
                reg = vax_reg_parse (q[1], q[2], 0, 0);
1401
              else if (q[4] == ')')
1402
                reg = vax_reg_parse (q[1], q[2], q[3], 0);
1403
              else if (q[5] == ')')
1404
                reg = vax_reg_parse (q[1], q[2], q[3], q[4]);
1405
              else
1406
                reg = -1;
1407
              /* Since we saw a ')' we will demand a register name in the ')'.
1408
                 This is nasty: why can't our hypothetical assembler permit
1409
                 parenthesised expressions? BECAUSE I AM LAZY! That is why.
1410
                 Abuse luser if we didn't spy a register name.  */
1411
              if (reg < 0)
1412
                {
1413
                  /* JF allow parenthesized expressions.  I hope this works.  */
1414
                  paren = 0;
1415
                  while (*q != ')')
1416
                    q++;
1417
                  /* err = "unknown register in ()"; */
1418
                }
1419
              else
1420
                q--;            /* point just before '(' of "(...)" */
1421
              /* If err == "..." then we lost. Run away.
1422
                 Otherwise if reg >= 0 then we saw (Rn).  */
1423
            }
1424
          /* If err == "..." then we lost.
1425
             Otherwise paren==1 and reg = register in "()".  */
1426
        }
1427
      else
1428
        paren = 0;
1429
      /* If err == "..." then we lost.
1430
         Otherwise, q points just before "(Rn)", if any.
1431
         If there was a "(...)" then paren==1, and reg is the register.  */
1432
 
1433
      /* We should only seek '-' of "-(...)" if:
1434
           we saw "(...)"                    paren == 1
1435
           we have no errors so far          ! *err
1436
           we did not see '+' of "(...)+"    sign < 1
1437
         We don't check len. We want a specific error message later if
1438
         user tries "x^...-(Rn)". This is a feature not a bug.  */
1439
      if (!err || !*err)
1440
        {
1441
          if (paren && sign < 1)/* !sign is adequate test */
1442
            {
1443
              if (*q == '-')
1444
                {
1445
                  sign = -1;
1446
                  q--;
1447
                }
1448
            }
1449
          /* We have back-tracked over most
1450
             of the crud at the end of an operand.
1451
             Unless err, we know: sign, paren. If paren, we know reg.
1452
             The last case is of an expression "Rn".
1453
             This is worth hunting for if !err, !paren.
1454
             We wouldn't be here if err.
1455
             We remember to save q, in case we didn't want "Rn" anyway.  */
1456
          if (!paren)
1457
            {
1458
              if (*q == ' ' && q >= p)  /* Expect all whitespace reduced to ' '.  */
1459
                q--;
1460
              /* Reverse over whitespace, but don't.  */
1461
              /* Run back over *p.  */
1462
              /* Room for Rn or Rnn (include prefix) exactly?  */
1463
              if (q > p && q < p + 4)
1464
                reg = vax_reg_parse (p[0], p[1],
1465
                  q < p + 2 ? 0 : p[2],
1466
                  q < p + 3 ? 0 : p[3]);
1467
              else
1468
                reg = -1;       /* Always comes here if no register at all.  */
1469
              /* Here with a definitive reg value.  */
1470
              if (reg >= 0)
1471
                {
1472
                  oldq = q;
1473
                  q = p - 1;
1474
                }
1475
            }
1476
        }
1477
    }
1478
  /* have reg. -1:absent; else 0:15.  */
1479
 
1480
  /* We have:  err, at, len, hash, ndx, sign, paren, reg.
1481
     Also, any remaining expression is from *p through *q inclusive.
1482
     Should there be no expression, q==p-1. So expression length = q-p+1.
1483
     This completes the first part: parsing the operand text.  */
1484
 
1485
  /* We now want to boil the data down, checking consistency on the way.
1486
     We want:  len, mode, reg, ndx, err, p, q, wrn, bug.
1487
     We will deliver a 4-bit reg, and a 4-bit mode.  */
1488
 
1489
  /* Case of branch operand. Different. No L^B^W^I^S^ allowed for instance.
1490
 
1491
     in:  at    ?
1492
          len   ?
1493
          hash  ?
1494
          p:q   ?
1495
          sign  ?
1496
          paren ?
1497
          reg   ?
1498
          ndx   ?
1499
 
1500
     out: mode  0
1501
          reg   -1
1502
          len   ' '
1503
          p:q   whatever was input
1504
          ndx   -1
1505
          err   " "              or error message, and other outputs trashed.  */
1506
  /* Branch operands have restricted forms.  */
1507
  if ((!err || !*err) && access_mode == 'b')
1508
    {
1509
      if (at || hash || sign || paren || ndx >= 0 || reg >= 0 || len != ' ')
1510
        err = _("invalid branch operand");
1511
      else
1512
        err = " ";
1513
    }
1514
 
1515
  /* Since nobody seems to use it: comment this 'feature'(?) out for now.  */
1516
#ifdef NEVER
1517
  /* Case of stand-alone operand. e.g. ".long foo"
1518
 
1519
     in:  at    ?
1520
          len   ?
1521
          hash  ?
1522
          p:q   ?
1523
          sign  ?
1524
          paren ?
1525
          reg   ?
1526
          ndx   ?
1527
 
1528
     out: mode  0
1529
          reg   -1
1530
          len   ' '
1531
          p:q   whatever was input
1532
          ndx   -1
1533
          err   " "              or error message, and other outputs trashed.  */
1534
  if ((!err || !*err) && access_mode == ' ')
1535
    {
1536
      if (at)
1537
        err = _("address prohibits @");
1538
      else if (hash)
1539
        err = _("address prohibits #");
1540
      else if (sign)
1541
        {
1542
          if (sign < 0)
1543
            err = _("address prohibits -()");
1544
          else
1545
            err = _("address prohibits ()+");
1546
        }
1547
      else if (paren)
1548
        err = _("address prohibits ()");
1549
      else if (ndx >= 0)
1550
        err = _("address prohibits []");
1551
      else if (reg >= 0)
1552
        err = _("address prohibits register");
1553
      else if (len != ' ')
1554
        err = _("address prohibits displacement length specifier");
1555
      else
1556
        {
1557
          err = " ";    /* succeed */
1558
          mode = 0;
1559
        }
1560
    }
1561
#endif
1562
 
1563
  /* Case of S^#.
1564
 
1565
     in:  at       0
1566
          len      's'               definition
1567
          hash     1              demand
1568
          p:q                        demand not empty
1569
          sign     0                 by paren==0
1570
          paren    0             by "()" scan logic because "S^" seen
1571
          reg      -1                or nn by mistake
1572
          ndx      -1
1573
 
1574
     out: mode     0
1575
          reg      -1
1576
          len      's'
1577
          exp
1578
          ndx      -1  */
1579
  if ((!err || !*err) && len == 's')
1580
    {
1581
      if (!hash || paren || at || ndx >= 0)
1582
        err = _("invalid operand of S^#");
1583
      else
1584
        {
1585
          if (reg >= 0)
1586
            {
1587
              /* Darn! we saw S^#Rnn ! put the Rnn back in
1588
                 expression. KLUDGE! Use oldq so we don't
1589
                 need to know exact length of reg name.  */
1590
              q = oldq;
1591
              reg = 0;
1592
            }
1593
          /* We have all the expression we will ever get.  */
1594
          if (p > q)
1595
            err = _("S^# needs expression");
1596
          else if (access_mode == 'r')
1597
            {
1598
              err = " ";        /* WIN! */
1599
              mode = 0;
1600
            }
1601
          else
1602
            err = _("S^# may only read-access");
1603
        }
1604
    }
1605
 
1606
  /* Case of -(Rn), which is weird case.
1607
 
1608
     in:  at       0
1609
          len      '
1610
          hash     0
1611
          p:q      q<p
1612
          sign     -1                by definition
1613
          paren    1              by definition
1614
          reg      present           by definition
1615
          ndx      optional
1616
 
1617
     out: mode     7
1618
          reg      present
1619
          len      ' '
1620
          exp      ""                enforce empty expression
1621
          ndx      optional          warn if same as reg.  */
1622
  if ((!err || !*err) && sign < 0)
1623
    {
1624
      if (len != ' ' || hash || at || p <= q)
1625
        err = _("invalid operand of -()");
1626
      else
1627
        {
1628
          err = " ";            /* win */
1629
          mode = 7;
1630
          if (reg == PC)
1631
            wrn = _("-(PC) unpredictable");
1632
          else if (reg == ndx)
1633
            wrn = _("[]index same as -()register: unpredictable");
1634
        }
1635
    }
1636
 
1637
  /* We convert "(Rn)" to "@Rn" for our convenience.
1638
     (I hope this is convenient: has someone got a better way to parse this?)
1639
     A side-effect of this is that "@Rn" is a valid operand.  */
1640
  if (paren && !sign && !hash && !at && len == ' ' && p > q)
1641
    {
1642
      at = 1;
1643
      paren = 0;
1644
    }
1645
 
1646
  /* Case of (Rn)+, which is slightly different.
1647
 
1648
     in:  at
1649
          len      ' '
1650
          hash     0
1651
          p:q      q<p
1652
          sign     +1                by definition
1653
          paren    1              by definition
1654
          reg      present           by definition
1655
          ndx      optional
1656
 
1657
     out: mode     8+@
1658
          reg      present
1659
          len      ' '
1660
          exp      ""                enforce empty expression
1661
          ndx      optional          warn if same as reg.  */
1662
  if ((!err || !*err) && sign > 0)
1663
    {
1664
      if (len != ' ' || hash || p <= q)
1665
        err = _("invalid operand of ()+");
1666
      else
1667
        {
1668
          err = " ";            /* win */
1669
          mode = 8 + (at ? 1 : 0);
1670
          if (reg == PC)
1671
            wrn = _("(PC)+ unpredictable");
1672
          else if (reg == ndx)
1673
            wrn = _("[]index same as ()+register: unpredictable");
1674
        }
1675
    }
1676
 
1677
  /* Case of #, without S^.
1678
 
1679
     in:  at
1680
          len      ' ' or 'i'
1681
          hash     1              by definition
1682
          p:q
1683
          sign     0
1684
          paren    0
1685
          reg      absent
1686
          ndx      optional
1687
 
1688
     out: mode     8+@
1689
          reg      PC
1690
          len      ' ' or 'i'
1691
          exp
1692
          ndx      optional.  */
1693
  if ((!err || !*err) && hash)
1694
    {
1695
      if (len != 'i' && len != ' ')
1696
        err = _("# conflicts length");
1697
      else if (paren)
1698
        err = _("# bars register");
1699
      else
1700
        {
1701
          if (reg >= 0)
1702
            {
1703
              /* Darn! we saw #Rnn! Put the Rnn back into the expression.
1704
                 By using oldq, we don't need to know how long Rnn was.
1705
                 KLUDGE!  */
1706
              q = oldq;
1707
              reg = -1;         /* No register any more.  */
1708
            }
1709
          err = " ";            /* Win.  */
1710
 
1711
          /* JF a bugfix, I think!  */
1712
          if (at && access_mode == 'a')
1713
            vopP->vop_nbytes = 4;
1714
 
1715
          mode = (at ? 9 : 8);
1716
          reg = PC;
1717
          if ((access_mode == 'm' || access_mode == 'w') && !at)
1718
            wrn = _("writing or modifying # is unpredictable");
1719
        }
1720
    }
1721
  /* If !*err, then       sign == 0
1722
                          hash == 0 */
1723
 
1724
  /* Case of Rn. We separate this one because it has a few special
1725
     errors the remaining modes lack.
1726
 
1727
     in:  at       optional
1728
          len      ' '
1729
          hash     0             by program logic
1730
          p:q      empty
1731
          sign     0                 by program logic
1732
          paren    0             by definition
1733
          reg      present           by definition
1734
          ndx      optional
1735
 
1736
     out: mode     5+@
1737
          reg      present
1738
          len      ' '               enforce no length
1739
          exp      ""                enforce empty expression
1740
          ndx      optional          warn if same as reg.  */
1741
  if ((!err || !*err) && !paren && reg >= 0)
1742
    {
1743
      if (len != ' ')
1744
        err = _("length not needed");
1745
      else if (at)
1746
        {
1747
          err = " ";            /* win */
1748
          mode = 6;             /* @Rn */
1749
        }
1750
      else if (ndx >= 0)
1751
        err = _("can't []index a register, because it has no address");
1752
      else if (access_mode == 'a')
1753
        err = _("a register has no address");
1754
      else
1755
        {
1756
          /* Idea here is to detect from length of datum
1757
             and from register number if we will touch PC.
1758
             Warn if we do.
1759
             vop_nbytes is number of bytes in operand.
1760
             Compute highest byte affected, compare to PC0.  */
1761
          if ((vopP->vop_nbytes + reg * 4) > 60)
1762
            wrn = _("PC part of operand unpredictable");
1763
          err = " ";            /* win */
1764
          mode = 5;             /* Rn */
1765
        }
1766
    }
1767
  /* If !*err,        sign  == 0
1768
                      hash  == 0
1769
                      paren == 1  OR reg==-1  */
1770
 
1771
  /* Rest of cases fit into one bunch.
1772
 
1773
     in:  at       optional
1774
          len      ' ' or 'b' or 'w' or 'l'
1775
          hash     0             by program logic
1776
          p:q      expected          (empty is not an error)
1777
          sign     0                 by program logic
1778
          paren    optional
1779
          reg      optional
1780
          ndx      optional
1781
 
1782
     out: mode     10 + @ + len
1783
          reg      optional
1784
          len      ' ' or 'b' or 'w' or 'l'
1785
          exp                        maybe empty
1786
          ndx      optional          warn if same as reg.  */
1787
  if (!err || !*err)
1788
    {
1789
      err = " ";                /* win (always) */
1790
      mode = 10 + (at ? 1 : 0);
1791
      switch (len)
1792
        {
1793
        case 'l':
1794
          mode += 2;
1795
        case 'w':
1796
          mode += 2;
1797
        case ' ':       /* Assumed B^ until our caller changes it.  */
1798
        case 'b':
1799
          break;
1800
        }
1801
    }
1802
 
1803
  /* here with completely specified     mode
1804
                                        len
1805
                                        reg
1806
                                        expression   p,q
1807
                                        ndx.  */
1808
 
1809
  if (*err == ' ')
1810
    err = 0;                     /* " " is no longer an error.  */
1811
 
1812
  vopP->vop_mode = mode;
1813
  vopP->vop_reg = reg;
1814
  vopP->vop_short = len;
1815
  vopP->vop_expr_begin = p;
1816
  vopP->vop_expr_end = q;
1817
  vopP->vop_ndx = ndx;
1818
  vopP->vop_error = err;
1819
  vopP->vop_warn = wrn;
1820
}
1821
 
1822
/* This converts a string into a vax instruction.
1823
   The string must be a bare single instruction in dec-vax (with BSD4 frobs)
1824
   format.
1825
   It provides some error messages: at most one fatal error message (which
1826
   stops the scan) and at most one warning message for each operand.
1827
   The vax instruction is returned in exploded form, since we have no
1828
   knowledge of how you parse (or evaluate) your expressions.
1829
   We do however strip off and decode addressing modes and operation
1830
   mnemonic.
1831
 
1832
   The exploded instruction is returned to a struct vit of your choice.
1833
   #include "vax-inst.h" to know what a struct vit is.
1834
 
1835
   This function's value is a string. If it is not "" then an internal
1836
   logic error was found: read this code to assign meaning to the string.
1837
   No argument string should generate such an error string:
1838
   it means a bug in our code, not in the user's text.
1839
 
1840
   You MUST have called vip_begin() once before using this function.  */
1841
 
1842
static void
1843
vip (struct vit *vitP,          /* We build an exploded instruction here.  */
1844
     char *instring)            /* Text of a vax instruction: we modify.  */
1845
{
1846
  /* How to bit-encode this opcode.  */
1847
  struct vot_wot *vwP;
1848
  /* 1/skip whitespace.2/scan vot_how */
1849
  char *p;
1850
  char *q;
1851
  /* counts number of operands seen */
1852
  unsigned char count;
1853
  /* scan operands in struct vit */
1854
  struct vop *operandp;
1855
  /* error over all operands */
1856
  const char *alloperr;
1857
  /* Remember char, (we clobber it with '\0' temporarily).  */
1858
  char c;
1859
  /* Op-code of this instruction.  */
1860
  vax_opcodeT oc;
1861
 
1862
  if (*instring == ' ')
1863
    ++instring;
1864
 
1865
  /* MUST end in end-of-string or exactly 1 space.  */
1866
  for (p = instring; *p && *p != ' '; p++)
1867
    ;
1868
 
1869
  /* Scanned up to end of operation-code.  */
1870
  /* Operation-code is ended with whitespace.  */
1871
  if (p - instring == 0)
1872
    {
1873
      vitP->vit_error = _("No operator");
1874
      count = 0;
1875
      memset (vitP->vit_opcode, '\0', sizeof (vitP->vit_opcode));
1876
    }
1877
  else
1878
    {
1879
      c = *p;
1880
      *p = '\0';
1881
      /* Here with instring pointing to what better be an op-name, and p
1882
         pointing to character just past that.
1883
         We trust instring points to an op-name, with no whitespace.  */
1884
      vwP = (struct vot_wot *) hash_find (op_hash, instring);
1885
      /* Restore char after op-code.  */
1886
      *p = c;
1887
      if (vwP == 0)
1888
        {
1889
          vitP->vit_error = _("Unknown operator");
1890
          count = 0;
1891
          memset (vitP->vit_opcode, '\0', sizeof (vitP->vit_opcode));
1892
        }
1893
      else
1894
        {
1895
          /* We found a match! So let's pick up as many operands as the
1896
             instruction wants, and even gripe if there are too many.
1897
             We expect comma to separate each operand.
1898
             We let instring track the text, while p tracks a part of the
1899
             struct vot.  */
1900
          const char *howp;
1901
          /* The lines below know about 2-byte opcodes starting FD,FE or FF.
1902
             They also understand synthetic opcodes. Note:
1903
             we return 32 bits of opcode, including bucky bits, BUT
1904
             an opcode length is either 8 or 16 bits for vit_opcode_nbytes.  */
1905
          oc = vwP->vot_code;   /* The op-code.  */
1906
          vitP->vit_opcode_nbytes = (oc & 0xFF) >= 0xFD ? 2 : 1;
1907
          md_number_to_chars (vitP->vit_opcode, oc, 4);
1908
          count = 0;             /* No operands seen yet.  */
1909
          instring = p;         /* Point just past operation code.  */
1910
          alloperr = "";
1911
          for (howp = vwP->vot_how, operandp = vitP->vit_operand;
1912
               !(alloperr && *alloperr) && *howp;
1913
               operandp++, howp += 2)
1914
            {
1915
              /* Here to parse one operand. Leave instring pointing just
1916
                 past any one ',' that marks the end of this operand.  */
1917
              if (!howp[1])
1918
                as_fatal (_("odd number of bytes in operand description"));
1919
              else if (*instring)
1920
                {
1921
                  for (q = instring; (c = *q) && c != ','; q++)
1922
                    ;
1923
                  /* Q points to ',' or '\0' that ends argument. C is that
1924
                     character.  */
1925
                  *q = 0;
1926
                  operandp->vop_width = howp[1];
1927
                  operandp->vop_nbytes = vax_operand_width_size[(unsigned) howp[1]];
1928
                  operandp->vop_access = howp[0];
1929
                  vip_op (instring, operandp);
1930
                  *q = c;       /* Restore input text.  */
1931
                  if (operandp->vop_error)
1932
                    alloperr = _("Bad operand");
1933
                  instring = q + (c ? 1 : 0);    /* Next operand (if any).  */
1934
                  count++;      /*  Won another argument, may have an operr.  */
1935
                }
1936
              else
1937
                alloperr = _("Not enough operands");
1938
            }
1939
          if (!*alloperr)
1940
            {
1941
              if (*instring == ' ')
1942
                instring++;
1943
              if (*instring)
1944
                alloperr = _("Too many operands");
1945
            }
1946
          vitP->vit_error = alloperr;
1947
        }
1948
    }
1949
  vitP->vit_operands = count;
1950
}
1951
 
1952
#ifdef test
1953
 
1954
/* Test program for above.  */
1955
 
1956
struct vit myvit;               /* Build an exploded vax instruction here.  */
1957
char answer[100];               /* Human types a line of vax assembler here.  */
1958
char *mybug;                    /* "" or an internal logic diagnostic.  */
1959
int mycount;                    /* Number of operands.  */
1960
struct vop *myvop;              /* Scan operands from myvit.  */
1961
int mysynth;                    /* 1 means want synthetic opcodes.  */
1962
char my_immediate[200];
1963
char my_indirect[200];
1964
char my_displen[200];
1965
 
1966
int
1967
main (void)
1968
{
1969
  char *p;
1970
 
1971
  printf ("0 means no synthetic instructions.   ");
1972
  printf ("Value for vip_begin?  ");
1973
  gets (answer);
1974
  sscanf (answer, "%d", &mysynth);
1975
  printf ("Synthetic opcodes %s be included.\n", mysynth ? "will" : "will not");
1976
  printf ("enter immediate symbols eg enter #   ");
1977
  gets (my_immediate);
1978
  printf ("enter indirect symbols  eg enter @   ");
1979
  gets (my_indirect);
1980
  printf ("enter displen symbols   eg enter ^   ");
1981
  gets (my_displen);
1982
 
1983
  if (p = vip_begin (mysynth, my_immediate, my_indirect, my_displen))
1984
    error ("vip_begin=%s", p);
1985
 
1986
  printf ("An empty input line will quit you from the vax instruction parser\n");
1987
  for (;;)
1988
    {
1989
      printf ("vax instruction: ");
1990
      fflush (stdout);
1991
      gets (answer);
1992
      if (!*answer)
1993
        break;          /* Out of for each input text loop.  */
1994
 
1995
      vip (& myvit, answer);
1996
      if (*myvit.vit_error)
1997
        printf ("ERR:\"%s\"\n", myvit.vit_error);
1998
 
1999
      printf ("opcode=");
2000
      for (mycount = myvit.vit_opcode_nbytes, p = myvit.vit_opcode;
2001
           mycount;
2002
           mycount--, p++)
2003
        printf ("%02x ", *p & 0xFF);
2004
 
2005
      printf ("   operand count=%d.\n", mycount = myvit.vit_operands);
2006
      for (myvop = myvit.vit_operand; mycount; mycount--, myvop++)
2007
        {
2008
          printf ("mode=%xx reg=%xx ndx=%xx len='%c'=%c%c%d. expr=\"",
2009
                  myvop->vop_mode, myvop->vop_reg, myvop->vop_ndx,
2010
                  myvop->vop_short, myvop->vop_access, myvop->vop_width,
2011
                  myvop->vop_nbytes);
2012
          for (p = myvop->vop_expr_begin; p <= myvop->vop_expr_end; p++)
2013
            putchar (*p);
2014
 
2015
          printf ("\"\n");
2016
          if (myvop->vop_error)
2017
            printf ("  err:\"%s\"\n", myvop->vop_error);
2018
 
2019
          if (myvop->vop_warn)
2020
            printf ("  wrn:\"%s\"\n", myvop->vop_warn);
2021
        }
2022
    }
2023
  vip_end ();
2024
  exit (EXIT_SUCCESS);
2025
}
2026
 
2027
#endif
2028
 
2029
#ifdef TEST                     /* #Define to use this testbed.  */
2030
 
2031
/* Follows a test program for this function.
2032
   We declare arrays non-local in case some of our tiny-minded machines
2033
   default to small stacks. Also, helps with some debuggers.  */
2034
 
2035
char answer[100];               /* Human types into here.  */
2036
char *p;                        /*  */
2037
char *myerr;
2038
char *mywrn;
2039
char *mybug;
2040
char myaccess;
2041
char mywidth;
2042
char mymode;
2043
char myreg;
2044
char mylen;
2045
char *myleft;
2046
char *myright;
2047
char myndx;
2048
int my_operand_length;
2049
char my_immediate[200];
2050
char my_indirect[200];
2051
char my_displen[200];
2052
 
2053
int
2054
main (void)
2055
{
2056
  printf ("enter immediate symbols eg enter #   ");
2057
  gets (my_immediate);
2058
  printf ("enter indirect symbols  eg enter @   ");
2059
  gets (my_indirect);
2060
  printf ("enter displen symbols   eg enter ^   ");
2061
  gets (my_displen);
2062
  vip_op_defaults (my_immediate, my_indirect, my_displen);
2063
 
2064
  for (;;)
2065
    {
2066
      printf ("access,width (eg 'ab' or 'wh') [empty line to quit] :  ");
2067
      fflush (stdout);
2068
      gets (answer);
2069
      if (!answer[0])
2070
        exit (EXIT_SUCCESS);
2071
      myaccess = answer[0];
2072
      mywidth = answer[1];
2073
      switch (mywidth)
2074
        {
2075
        case 'b':
2076
          my_operand_length = 1;
2077
          break;
2078
        case 'd':
2079
          my_operand_length = 8;
2080
          break;
2081
        case 'f':
2082
          my_operand_length = 4;
2083
          break;
2084
        case 'g':
2085
          my_operand_length = 16;
2086
          break;
2087
        case 'h':
2088
          my_operand_length = 32;
2089
          break;
2090
        case 'l':
2091
          my_operand_length = 4;
2092
          break;
2093
        case 'o':
2094
          my_operand_length = 16;
2095
          break;
2096
        case 'q':
2097
          my_operand_length = 8;
2098
          break;
2099
        case 'w':
2100
          my_operand_length = 2;
2101
          break;
2102
        case '!':
2103
        case '?':
2104
        case '-':
2105
          my_operand_length = 0;
2106
          break;
2107
 
2108
        default:
2109
          my_operand_length = 2;
2110
          printf ("I dn't understand access width %c\n", mywidth);
2111
          break;
2112
        }
2113
      printf ("VAX assembler instruction operand: ");
2114
      fflush (stdout);
2115
      gets (answer);
2116
      mybug = vip_op (answer, myaccess, mywidth, my_operand_length,
2117
                      &mymode, &myreg, &mylen, &myleft, &myright, &myndx,
2118
                      &myerr, &mywrn);
2119
      if (*myerr)
2120
        {
2121
          printf ("error: \"%s\"\n", myerr);
2122
          if (*mybug)
2123
            printf (" bug: \"%s\"\n", mybug);
2124
        }
2125
      else
2126
        {
2127
          if (*mywrn)
2128
            printf ("warning: \"%s\"\n", mywrn);
2129
          mumble ("mode", mymode);
2130
          mumble ("register", myreg);
2131
          mumble ("index", myndx);
2132
          printf ("width:'%c'  ", mylen);
2133
          printf ("expression: \"");
2134
          while (myleft <= myright)
2135
            putchar (*myleft++);
2136
          printf ("\"\n");
2137
        }
2138
    }
2139
}
2140
 
2141
void
2142
mumble (char *text, int value)
2143
{
2144
  printf ("%s:", text);
2145
  if (value >= 0)
2146
    printf ("%xx", value);
2147
  else
2148
    printf ("ABSENT");
2149
  printf ("  ");
2150
}
2151
 
2152
#endif
2153
 
2154
int md_short_jump_size = 3;
2155
int md_long_jump_size = 6;
2156
 
2157
void
2158
md_create_short_jump (char *ptr,
2159
                      addressT from_addr,
2160
                      addressT to_addr ATTRIBUTE_UNUSED,
2161
                      fragS *frag ATTRIBUTE_UNUSED,
2162
                      symbolS *to_symbol ATTRIBUTE_UNUSED)
2163
{
2164
  valueT offset;
2165
 
2166
  /* This former calculation was off by two:
2167
      offset = to_addr - (from_addr + 1);
2168
     We need to account for the one byte instruction and also its
2169
     two byte operand.  */
2170
  offset = to_addr - (from_addr + 1 + 2);
2171
  *ptr++ = VAX_BRW;             /* Branch with word (16 bit) offset.  */
2172
  md_number_to_chars (ptr, offset, 2);
2173
}
2174
 
2175
void
2176
md_create_long_jump (char *ptr,
2177
                     addressT from_addr ATTRIBUTE_UNUSED,
2178
                     addressT to_addr,
2179
                     fragS *frag,
2180
                     symbolS *to_symbol)
2181
{
2182
  valueT offset;
2183
 
2184
  offset = to_addr - S_GET_VALUE (to_symbol);
2185
  *ptr++ = VAX_JMP;             /* Arbitrary jump.  */
2186
  *ptr++ = VAX_ABSOLUTE_MODE;
2187
  md_number_to_chars (ptr, offset, 4);
2188
  fix_new (frag, ptr - frag->fr_literal, 4, to_symbol, (long) 0, 0, NO_RELOC);
2189
}
2190
 
2191
#ifdef OBJ_VMS
2192
const char *md_shortopts = "d:STt:V+1h:Hv::";
2193
#elif defined(OBJ_ELF)
2194
const char *md_shortopts = "d:STt:VkKQ:";
2195
#else
2196
const char *md_shortopts = "d:STt:V";
2197
#endif
2198
struct option md_longopts[] =
2199
{
2200
#ifdef OBJ_ELF
2201
#define OPTION_PIC (OPTION_MD_BASE)
2202
  { "pic", no_argument, NULL, OPTION_PIC },
2203
#endif
2204
  { NULL, no_argument, NULL, 0 }
2205
};
2206
size_t md_longopts_size = sizeof (md_longopts);
2207
 
2208
int
2209
md_parse_option (int c, char *arg)
2210
{
2211
  switch (c)
2212
    {
2213
    case 'S':
2214
      as_warn (_("SYMBOL TABLE not implemented"));
2215
      break;
2216
 
2217
    case 'T':
2218
      as_warn (_("TOKEN TRACE not implemented"));
2219
      break;
2220
 
2221
    case 'd':
2222
      as_warn (_("Displacement length %s ignored!"), arg);
2223
      break;
2224
 
2225
    case 't':
2226
      as_warn (_("I don't need or use temp. file \"%s\"."), arg);
2227
      break;
2228
 
2229
    case 'V':
2230
      as_warn (_("I don't use an interpass file! -V ignored"));
2231
      break;
2232
 
2233
#ifdef OBJ_VMS
2234
    case '+':                   /* For g++.  Hash any name > 31 chars long.  */
2235
      flag_hash_long_names = 1;
2236
      break;
2237
 
2238
    case '1':                   /* For backward compatibility.  */
2239
      flag_one = 1;
2240
      break;
2241
 
2242
    case 'H':                   /* Show new symbol after hash truncation.  */
2243
      flag_show_after_trunc = 1;
2244
      break;
2245
 
2246
    case 'h':                   /* No hashing of mixed-case names.  */
2247
      {
2248
        extern char vms_name_mapping;
2249
        vms_name_mapping = atoi (arg);
2250
        flag_no_hash_mixed_case = 1;
2251
      }
2252
      break;
2253
 
2254
    case 'v':
2255
      {
2256
        extern char *compiler_version_string;
2257
 
2258
        if (!arg || !*arg || access (arg, 0) == 0)
2259
          return 0;              /* Have caller show the assembler version.  */
2260
        compiler_version_string = arg;
2261
      }
2262
      break;
2263
#endif
2264
 
2265
#ifdef OBJ_ELF
2266
    case OPTION_PIC:
2267
    case 'k':
2268
      flag_want_pic = 1;
2269
      break;                    /* -pic, Position Independent Code.  */
2270
 
2271
     /* -Qy, -Qn: SVR4 arguments controlling whether a .comment
2272
        section should be emitted or not.  FIXME: Not implemented.  */
2273
    case 'Q':
2274
      break;
2275
#endif
2276
 
2277
    default:
2278
      return 0;
2279
    }
2280
 
2281
  return 1;
2282
}
2283
 
2284
void
2285
md_show_usage (FILE *stream)
2286
{
2287
  fprintf (stream, _("\
2288
VAX options:\n\
2289
-d LENGTH               ignored\n\
2290
-J                      ignored\n\
2291
-S                      ignored\n\
2292
-t FILE                 ignored\n\
2293
-T                      ignored\n\
2294
-V                      ignored\n"));
2295
#ifdef OBJ_VMS
2296
  fprintf (stream, _("\
2297
VMS options:\n\
2298
-+                      hash encode names longer than 31 characters\n\
2299
-1                      `const' handling compatible with gcc 1.x\n\
2300
-H                      show new symbol after hash truncation\n\
2301
-h NUM                  don't hash mixed-case names, and adjust case:\n\
2302
 
2303
-v\"VERSION\"           code being assembled was produced by compiler \"VERSION\"\n"));
2304
#endif
2305
}
2306
 
2307
/* We have no need to default values of symbols.  */
2308
 
2309
symbolS *
2310
md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
2311
{
2312
  return NULL;
2313
}
2314
 
2315
/* Round up a section size to the appropriate boundary.  */
2316
valueT
2317
md_section_align (segT segment ATTRIBUTE_UNUSED, valueT size)
2318
{
2319
  /* Byte alignment is fine */
2320
  return size;
2321
}
2322
 
2323
/* Exactly what point is a PC-relative offset relative TO?
2324
   On the vax, they're relative to the address of the offset, plus
2325
   its size. */
2326
long
2327
md_pcrel_from (fixS *fixP)
2328
{
2329
  return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
2330
}
2331
 
2332
arelent *
2333
tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp)
2334
{
2335
  arelent *reloc;
2336
  bfd_reloc_code_real_type code;
2337
 
2338
  if (fixp->fx_tcbit)
2339
    abort ();
2340
 
2341
  if (fixp->fx_r_type != BFD_RELOC_NONE)
2342
    {
2343
      code = fixp->fx_r_type;
2344
 
2345
      if (fixp->fx_pcrel)
2346
        {
2347
          switch (code)
2348
            {
2349
            case BFD_RELOC_8_PCREL:
2350
            case BFD_RELOC_16_PCREL:
2351
            case BFD_RELOC_32_PCREL:
2352
#ifdef OBJ_ELF
2353
            case BFD_RELOC_8_GOT_PCREL:
2354
            case BFD_RELOC_16_GOT_PCREL:
2355
            case BFD_RELOC_32_GOT_PCREL:
2356
            case BFD_RELOC_8_PLT_PCREL:
2357
            case BFD_RELOC_16_PLT_PCREL:
2358
            case BFD_RELOC_32_PLT_PCREL:
2359
#endif
2360
              break;
2361
            default:
2362
              as_bad_where (fixp->fx_file, fixp->fx_line,
2363
                            _("Cannot make %s relocation PC relative"),
2364
                            bfd_get_reloc_code_name (code));
2365
            }
2366
        }
2367
    }
2368
  else
2369
    {
2370
#define F(SZ,PCREL)             (((SZ) << 1) + (PCREL))
2371
      switch (F (fixp->fx_size, fixp->fx_pcrel))
2372
        {
2373
#define MAP(SZ,PCREL,TYPE)      case F(SZ,PCREL): code = (TYPE); break
2374
          MAP (1, 0, BFD_RELOC_8);
2375
          MAP (2, 0, BFD_RELOC_16);
2376
          MAP (4, 0, BFD_RELOC_32);
2377
          MAP (1, 1, BFD_RELOC_8_PCREL);
2378
          MAP (2, 1, BFD_RELOC_16_PCREL);
2379
          MAP (4, 1, BFD_RELOC_32_PCREL);
2380
        default:
2381
          abort ();
2382
        }
2383
    }
2384
#undef F
2385
#undef MAP
2386
 
2387
  reloc = xmalloc (sizeof (arelent));
2388
  reloc->sym_ptr_ptr = xmalloc (sizeof (asymbol *));
2389
  *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
2390
  reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
2391
#ifndef OBJ_ELF
2392
  if (fixp->fx_pcrel)
2393
    reloc->addend = fixp->fx_addnumber;
2394
  else
2395
    reloc->addend = 0;
2396
#else
2397
  reloc->addend = fixp->fx_offset;
2398
#endif
2399
 
2400
  reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
2401
  gas_assert (reloc->howto != 0);
2402
 
2403
  return reloc;
2404
}
2405
 
2406
/* vax:md_assemble() emit frags for 1 instruction given in textual form.  */
2407
void
2408
md_assemble (char *instruction_string)
2409
{
2410
  /* Non-zero if operand expression's segment is not known yet.  */
2411
  int is_undefined;
2412
  /* Non-zero if operand expression's segment is absolute.  */
2413
  int is_absolute;
2414
  int length_code;
2415
  char *p;
2416
  /* An operand. Scans all operands.  */
2417
  struct vop *operandP;
2418
  char *save_input_line_pointer;
2419
                        /* What used to live after an expression.  */
2420
  char c_save;
2421
  /* 1: instruction_string bad for all passes.  */
2422
  int goofed;
2423
  /* Points to slot just after last operand.  */
2424
  struct vop *end_operandP;
2425
  /* Points to expression values for this operand.  */
2426
  expressionS *expP;
2427
  segT *segP;
2428
 
2429
  /* These refer to an instruction operand expression.  */
2430
  /* Target segment of the address.      */
2431
  segT to_seg;
2432
  valueT this_add_number;
2433
  /* Positive (minuend) symbol.  */
2434
  symbolS *this_add_symbol;
2435
  /* As a number.  */
2436
  long opcode_as_number;
2437
  /* Least significant byte 1st.  */
2438
  char *opcode_as_chars;
2439
  /* As an array of characters.  */
2440
  /* Least significant byte 1st */
2441
  char *opcode_low_byteP;
2442
  /* length (bytes) meant by vop_short.  */
2443
  int length;
2444
  /* 0, or 1 if '@' is in addressing mode.  */
2445
  int at;
2446
  /* From vop_nbytes: vax_operand_width (in bytes) */
2447
  int nbytes;
2448
  FLONUM_TYPE *floatP;
2449
  LITTLENUM_TYPE literal_float[8];
2450
  /* Big enough for any floating point literal.  */
2451
 
2452
  vip (&v, instruction_string);
2453
 
2454
  /* Now we try to find as many as_warn()s as we can. If we do any as_warn()s
2455
     then goofed=1. Notice that we don't make any frags yet.
2456
     Should goofed be 1, then this instruction will wedge in any pass,
2457
     and we can safely flush it, without causing interpass symbol phase
2458
     errors. That is, without changing label values in different passes.  */
2459
  if ((goofed = (*v.vit_error)) != 0)
2460
    {
2461
      as_fatal (_("Ignoring statement due to \"%s\""), v.vit_error);
2462
    }
2463
  /* We need to use expression() and friends, which require us to diddle
2464
     input_line_pointer. So we save it and restore it later.  */
2465
  save_input_line_pointer = input_line_pointer;
2466
  for (operandP = v.vit_operand,
2467
       expP = exp_of_operand,
2468
       segP = seg_of_operand,
2469
       floatP = float_operand,
2470
       end_operandP = v.vit_operand + v.vit_operands;
2471
 
2472
       operandP < end_operandP;
2473
 
2474
       operandP++, expP++, segP++, floatP++)
2475
    {
2476
      if (operandP->vop_error)
2477
        {
2478
          as_fatal (_("Aborting because statement has \"%s\""), operandP->vop_error);
2479
          goofed = 1;
2480
        }
2481
      else
2482
        {
2483
          /* Statement has no syntax goofs: let's sniff the expression.  */
2484
          int can_be_short = 0;  /* 1 if a bignum can be reduced to a short literal.  */
2485
 
2486
          input_line_pointer = operandP->vop_expr_begin;
2487
          c_save = operandP->vop_expr_end[1];
2488
          operandP->vop_expr_end[1] = '\0';
2489
          /* If to_seg == SEG_PASS1, expression() will have set need_pass_2 = 1.  */
2490
          *segP = expression (expP);
2491
          switch (expP->X_op)
2492
            {
2493
            case O_absent:
2494
              /* for BSD4.2 compatibility, missing expression is absolute 0 */
2495
              expP->X_op = O_constant;
2496
              expP->X_add_number = 0;
2497
              /* For SEG_ABSOLUTE, we shouldn't need to set X_op_symbol,
2498
                 X_add_symbol to any particular value.  But, we will program
2499
                 defensively. Since this situation occurs rarely so it costs
2500
                 us little to do, and stops Dean worrying about the origin of
2501
                 random bits in expressionS's.  */
2502
              expP->X_add_symbol = NULL;
2503
              expP->X_op_symbol = NULL;
2504
              break;
2505
 
2506
            case O_symbol:
2507
            case O_constant:
2508
              break;
2509
 
2510
            default:
2511
              /* Major bug. We can't handle the case of a
2512
                 SEG_OP expression in a VIT_OPCODE_SYNTHETIC
2513
                 variable-length instruction.
2514
                 We don't have a frag type that is smart enough to
2515
                 relax a SEG_OP, and so we just force all
2516
                 SEG_OPs to behave like SEG_PASS1s.
2517
                 Clearly, if there is a demand we can invent a new or
2518
                 modified frag type and then coding up a frag for this
2519
                 case will be easy. SEG_OP was invented for the
2520
                 .words after a CASE opcode, and was never intended for
2521
                 instruction operands.  */
2522
              need_pass_2 = 1;
2523
              as_fatal (_("Can't relocate expression"));
2524
              break;
2525
 
2526
            case O_big:
2527
              /* Preserve the bits.  */
2528
              if (expP->X_add_number > 0)
2529
                {
2530
                  bignum_copy (generic_bignum, expP->X_add_number,
2531
                               floatP->low, SIZE_OF_LARGE_NUMBER);
2532
                }
2533
              else
2534
                {
2535
                  know (expP->X_add_number < 0);
2536
                  flonum_copy (&generic_floating_point_number,
2537
                               floatP);
2538
                  if (strchr ("s i", operandP->vop_short))
2539
                    {
2540
                      /* Could possibly become S^# */
2541
                      flonum_gen2vax (-expP->X_add_number, floatP, literal_float);
2542
                      switch (-expP->X_add_number)
2543
                        {
2544
                        case 'f':
2545
                          can_be_short =
2546
                            (literal_float[0] & 0xFC0F) == 0x4000
2547
                            && literal_float[1] == 0;
2548
                          break;
2549
 
2550
                        case 'd':
2551
                          can_be_short =
2552
                            (literal_float[0] & 0xFC0F) == 0x4000
2553
                            && literal_float[1] == 0
2554
                            && literal_float[2] == 0
2555
                            && literal_float[3] == 0;
2556
                          break;
2557
 
2558
                        case 'g':
2559
                          can_be_short =
2560
                            (literal_float[0] & 0xFF81) == 0x4000
2561
                            && literal_float[1] == 0
2562
                            && literal_float[2] == 0
2563
                            && literal_float[3] == 0;
2564
                          break;
2565
 
2566
                        case 'h':
2567
                          can_be_short = ((literal_float[0] & 0xFFF8) == 0x4000
2568
                                          && (literal_float[1] & 0xE000) == 0
2569
                                          && literal_float[2] == 0
2570
                                          && literal_float[3] == 0
2571
                                          && literal_float[4] == 0
2572
                                          && literal_float[5] == 0
2573
                                          && literal_float[6] == 0
2574
                                          && literal_float[7] == 0);
2575
                          break;
2576
 
2577
                        default:
2578
                          BAD_CASE (-expP->X_add_number);
2579
                          break;
2580
                        }
2581
                    }
2582
                }
2583
 
2584
              if (operandP->vop_short == 's'
2585
                  || operandP->vop_short == 'i'
2586
                  || (operandP->vop_short == ' '
2587
                      && operandP->vop_reg == 0xF
2588
                      && (operandP->vop_mode & 0xE) == 0x8))
2589
                {
2590
                  /* Saw a '#'.  */
2591
                  if (operandP->vop_short == ' ')
2592
                    {
2593
                      /* We must chose S^ or I^.  */
2594
                      if (expP->X_add_number > 0)
2595
                        {
2596
                          /* Bignum: Short literal impossible.  */
2597
                          operandP->vop_short = 'i';
2598
                          operandP->vop_mode = 8;
2599
                          operandP->vop_reg = 0xF;      /* VAX PC.  */
2600
                        }
2601
                      else
2602
                        {
2603
                          /* Flonum: Try to do it.  */
2604
                          if (can_be_short)
2605
                            {
2606
                              operandP->vop_short = 's';
2607
                              operandP->vop_mode = 0;
2608
                              operandP->vop_ndx = -1;
2609
                              operandP->vop_reg = -1;
2610
                              expP->X_op = O_constant;
2611
                            }
2612
                          else
2613
                            {
2614
                              operandP->vop_short = 'i';
2615
                              operandP->vop_mode = 8;
2616
                              operandP->vop_reg = 0xF;  /* VAX PC */
2617
                            }
2618
                        }       /* bignum or flonum ? */
2619
                    }           /*  if #, but no S^ or I^ seen.  */
2620
                  /* No more ' ' case: either 's' or 'i'.  */
2621
                  if (operandP->vop_short == 's')
2622
                    {
2623
                      /* Wants to be a short literal.  */
2624
                      if (expP->X_add_number > 0)
2625
                        {
2626
                          as_warn (_("Bignum not permitted in short literal. Immediate mode assumed."));
2627
                          operandP->vop_short = 'i';
2628
                          operandP->vop_mode = 8;
2629
                          operandP->vop_reg = 0xF;      /* VAX PC.  */
2630
                        }
2631
                      else
2632
                        {
2633
                          if (!can_be_short)
2634
                            {
2635
                              as_warn (_("Can't do flonum short literal: immediate mode used."));
2636
                              operandP->vop_short = 'i';
2637
                              operandP->vop_mode = 8;
2638
                              operandP->vop_reg = 0xF;  /* VAX PC.  */
2639
                            }
2640
                          else
2641
                            {
2642
                              /* Encode short literal now.  */
2643
                              int temp = 0;
2644
 
2645
                              switch (-expP->X_add_number)
2646
                                {
2647
                                case 'f':
2648
                                case 'd':
2649
                                  temp = literal_float[0] >> 4;
2650
                                  break;
2651
 
2652
                                case 'g':
2653
                                  temp = literal_float[0] >> 1;
2654
                                  break;
2655
 
2656
                                case 'h':
2657
                                  temp = ((literal_float[0] << 3) & 070)
2658
                                    | ((literal_float[1] >> 13) & 07);
2659
                                  break;
2660
 
2661
                                default:
2662
                                  BAD_CASE (-expP->X_add_number);
2663
                                  break;
2664
                                }
2665
 
2666
                              floatP->low[0] = temp & 077;
2667
                              floatP->low[1] = 0;
2668
                            }
2669
                        }
2670
                    }
2671
                  else
2672
                    {
2673
                      /* I^# seen: set it up if float.  */
2674
                      if (expP->X_add_number < 0)
2675
                        {
2676
                          memcpy (floatP->low, literal_float, sizeof (literal_float));
2677
                        }
2678
                    }           /* if S^# seen.  */
2679
                }
2680
              else
2681
                {
2682
                  as_warn (_("A bignum/flonum may not be a displacement: 0x%lx used"),
2683
                           (expP->X_add_number = 0x80000000L));
2684
                  /* Chosen so luser gets the most offset bits to patch later.  */
2685
                }
2686
              expP->X_add_number = floatP->low[0]
2687
                | ((LITTLENUM_MASK & (floatP->low[1])) << LITTLENUM_NUMBER_OF_BITS);
2688
 
2689
              /* For the O_big case we have:
2690
                 If vop_short == 's' then a short floating literal is in the
2691
                        lowest 6 bits of floatP -> low [0], which is
2692
                        big_operand_bits [---] [0].
2693
                 If vop_short == 'i' then the appropriate number of elements
2694
                        of big_operand_bits [---] [...] are set up with the correct
2695
                        bits.
2696
                 Also, just in case width is byte word or long, we copy the lowest
2697
                 32 bits of the number to X_add_number.  */
2698
              break;
2699
            }
2700
          if (input_line_pointer != operandP->vop_expr_end + 1)
2701
            {
2702
              as_fatal ("Junk at end of expression \"%s\"", input_line_pointer);
2703
              goofed = 1;
2704
            }
2705
          operandP->vop_expr_end[1] = c_save;
2706
        }
2707
    }
2708
 
2709
  input_line_pointer = save_input_line_pointer;
2710
 
2711
  if (need_pass_2 || goofed)
2712
    return;
2713
 
2714
  dwarf2_emit_insn (0);
2715
  /* Emit op-code.  */
2716
  /* Remember where it is, in case we want to modify the op-code later.  */
2717
  opcode_low_byteP = frag_more (v.vit_opcode_nbytes);
2718
  memcpy (opcode_low_byteP, v.vit_opcode, v.vit_opcode_nbytes);
2719
  opcode_as_chars = v.vit_opcode;
2720
  opcode_as_number = md_chars_to_number ((unsigned char *) opcode_as_chars, 4);
2721
  for (operandP = v.vit_operand,
2722
       expP = exp_of_operand,
2723
       segP = seg_of_operand,
2724
       floatP = float_operand,
2725
       end_operandP = v.vit_operand + v.vit_operands;
2726
 
2727
       operandP < end_operandP;
2728
 
2729
       operandP++,
2730
       floatP++,
2731
       segP++,
2732
       expP++)
2733
    {
2734
      if (operandP->vop_ndx >= 0)
2735
        {
2736
          /* Indexed addressing byte.  */
2737
          /* Legality of indexed mode already checked: it is OK.  */
2738
          FRAG_APPEND_1_CHAR (0x40 + operandP->vop_ndx);
2739
        }                       /* if(vop_ndx>=0) */
2740
 
2741
      /* Here to make main operand frag(s).  */
2742
      this_add_number = expP->X_add_number;
2743
      this_add_symbol = expP->X_add_symbol;
2744
      to_seg = *segP;
2745
      is_undefined = (to_seg == undefined_section);
2746
      is_absolute = (to_seg == absolute_section);
2747
      at = operandP->vop_mode & 1;
2748
      length = (operandP->vop_short == 'b'
2749
                ? 1 : (operandP->vop_short == 'w'
2750
                       ? 2 : (operandP->vop_short == 'l'
2751
                              ? 4 : 0)));
2752
      nbytes = operandP->vop_nbytes;
2753
      if (operandP->vop_access == 'b')
2754
        {
2755
          if (to_seg == now_seg || is_undefined)
2756
            {
2757
              /* If is_undefined, then it might BECOME now_seg.  */
2758
              if (nbytes)
2759
                {
2760
                  p = frag_more (nbytes);
2761
                  fix_new (frag_now, p - frag_now->fr_literal, nbytes,
2762
                           this_add_symbol, this_add_number, 1, NO_RELOC);
2763
                }
2764
              else
2765
                {
2766
                  /* to_seg==now_seg || to_seg == SEG_UNKNOWN */
2767
                  /* nbytes==0 */
2768
                  length_code = is_undefined ? STATE_UNDF : STATE_BYTE;
2769
                  if (opcode_as_number & VIT_OPCODE_SPECIAL)
2770
                    {
2771
                      if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP)
2772
                        {
2773
                          /* br or jsb */
2774
                          frag_var (rs_machine_dependent, 5, 1,
2775
                            ENCODE_RELAX (STATE_ALWAYS_BRANCH, length_code),
2776
                                    this_add_symbol, this_add_number,
2777
                                    opcode_low_byteP);
2778
                        }
2779
                      else
2780
                        {
2781
                          if (operandP->vop_width == VAX_WIDTH_WORD_JUMP)
2782
                            {
2783
                              length_code = STATE_WORD;
2784
                              /* JF: There is no state_byte for this one! */
2785
                              frag_var (rs_machine_dependent, 10, 2,
2786
                                        ENCODE_RELAX (STATE_COMPLEX_BRANCH, length_code),
2787
                                        this_add_symbol, this_add_number,
2788
                                        opcode_low_byteP);
2789
                            }
2790
                          else
2791
                            {
2792
                              know (operandP->vop_width == VAX_WIDTH_BYTE_JUMP);
2793
                              frag_var (rs_machine_dependent, 9, 1,
2794
                              ENCODE_RELAX (STATE_COMPLEX_HOP, length_code),
2795
                                        this_add_symbol, this_add_number,
2796
                                        opcode_low_byteP);
2797
                            }
2798
                        }
2799
                    }
2800
                  else
2801
                    {
2802
                      know (operandP->vop_width == VAX_WIDTH_CONDITIONAL_JUMP);
2803
                      frag_var (rs_machine_dependent, 7, 1,
2804
                       ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, length_code),
2805
                                this_add_symbol, this_add_number,
2806
                                opcode_low_byteP);
2807
                    }
2808
                }
2809
            }
2810
          else
2811
            {
2812
              /* to_seg != now_seg && to_seg != SEG_UNKNOWN */
2813
              /* --- SEG FLOAT MAY APPEAR HERE ---  */
2814
              if (is_absolute)
2815
                {
2816
                  if (nbytes)
2817
                    {
2818
                      know (!(opcode_as_number & VIT_OPCODE_SYNTHETIC));
2819
                      p = frag_more (nbytes);
2820
                      /* Conventional relocation.  */
2821
                      fix_new (frag_now, p - frag_now->fr_literal, nbytes,
2822
                               section_symbol (absolute_section),
2823
                               this_add_number, 1, NO_RELOC);
2824
                    }
2825
                  else
2826
                    {
2827
                      know (opcode_as_number & VIT_OPCODE_SYNTHETIC);
2828
                      if (opcode_as_number & VIT_OPCODE_SPECIAL)
2829
                        {
2830
                          if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP)
2831
                            {
2832
                              /* br or jsb */
2833
                              *opcode_low_byteP = opcode_as_chars[0] + VAX_WIDEN_LONG;
2834
                              know (opcode_as_chars[1] == 0);
2835
                              p = frag_more (5);
2836
                              p[0] = VAX_ABSOLUTE_MODE;  /* @#...  */
2837
                              md_number_to_chars (p + 1, this_add_number, 4);
2838
                              /* Now (eg) JMP @#foo or JSB @#foo.  */
2839
                            }
2840
                          else
2841
                            {
2842
                              if (operandP->vop_width == VAX_WIDTH_WORD_JUMP)
2843
                                {
2844
                                  p = frag_more (10);
2845
                                  p[0] = 2;
2846
                                  p[1] = 0;
2847
                                  p[2] = VAX_BRB;
2848
                                  p[3] = 6;
2849
                                  p[4] = VAX_JMP;
2850
                                  p[5] = VAX_ABSOLUTE_MODE;     /* @#...  */
2851
                                  md_number_to_chars (p + 6, this_add_number, 4);
2852
                                  /* Now (eg)   ACBx    1f
2853
                                                BRB     2f
2854
                                        1:      JMP     @#foo
2855
                                        2:  */
2856
                                }
2857
                              else
2858
                                {
2859
                                  know (operandP->vop_width == VAX_WIDTH_BYTE_JUMP);
2860
                                  p = frag_more (9);
2861
                                  p[0] = 2;
2862
                                  p[1] = VAX_BRB;
2863
                                  p[2] = 6;
2864
                                  p[3] = VAX_JMP;
2865
                                  p[4] = VAX_ABSOLUTE_MODE;     /* @#...  */
2866
                                  md_number_to_chars (p + 5, this_add_number, 4);
2867
                                  /* Now (eg)   xOBxxx  1f
2868
                                                BRB     2f
2869
                                        1:      JMP     @#foo
2870
                                        2:  */
2871
                                }
2872
                            }
2873
                        }
2874
                      else
2875
                        {
2876
                          /* b<cond> */
2877
                          *opcode_low_byteP ^= 1;
2878
                          /* To reverse the condition in a VAX branch,
2879
                             complement the lowest order bit.  */
2880
                          p = frag_more (7);
2881
                          p[0] = 6;
2882
                          p[1] = VAX_JMP;
2883
                          p[2] = VAX_ABSOLUTE_MODE;     /* @#...  */
2884
                          md_number_to_chars (p + 3, this_add_number, 4);
2885
                          /* Now (eg)   BLEQ    1f
2886
                                        JMP     @#foo
2887
                                1:  */
2888
                        }
2889
                    }
2890
                }
2891
              else
2892
                {
2893
                  /* to_seg != now_seg && !is_undefinfed && !is_absolute */
2894
                  if (nbytes > 0)
2895
                    {
2896
                      /* Pc-relative. Conventional relocation.  */
2897
                      know (!(opcode_as_number & VIT_OPCODE_SYNTHETIC));
2898
                      p = frag_more (nbytes);
2899
                      fix_new (frag_now, p - frag_now->fr_literal, nbytes,
2900
                               section_symbol (absolute_section),
2901
                               this_add_number, 1, NO_RELOC);
2902
                    }
2903
                  else
2904
                    {
2905
                      know (opcode_as_number & VIT_OPCODE_SYNTHETIC);
2906
                      if (opcode_as_number & VIT_OPCODE_SPECIAL)
2907
                        {
2908
                          if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP)
2909
                            {
2910
                              /* br or jsb */
2911
                              know (opcode_as_chars[1] == 0);
2912
                              *opcode_low_byteP = opcode_as_chars[0] + VAX_WIDEN_LONG;
2913
                              p = frag_more (5);
2914
                              p[0] = VAX_PC_RELATIVE_MODE;
2915
                              fix_new (frag_now,
2916
                                       p + 1 - frag_now->fr_literal, 4,
2917
                                       this_add_symbol,
2918
                                       this_add_number, 1, NO_RELOC);
2919
                              /* Now eg JMP foo or JSB foo.  */
2920
                            }
2921
                          else
2922
                            {
2923
                              if (operandP->vop_width == VAX_WIDTH_WORD_JUMP)
2924
                                {
2925
                                  p = frag_more (10);
2926
                                  p[0] = 0;
2927
                                  p[1] = 2;
2928
                                  p[2] = VAX_BRB;
2929
                                  p[3] = 6;
2930
                                  p[4] = VAX_JMP;
2931
                                  p[5] = VAX_PC_RELATIVE_MODE;
2932
                                  fix_new (frag_now,
2933
                                           p + 6 - frag_now->fr_literal, 4,
2934
                                           this_add_symbol,
2935
                                           this_add_number, 1, NO_RELOC);
2936
                                  /* Now (eg)   ACBx    1f
2937
                                                BRB     2f
2938
                                        1:      JMP     foo
2939
                                        2:  */
2940
                                }
2941
                              else
2942
                                {
2943
                                  know (operandP->vop_width == VAX_WIDTH_BYTE_JUMP);
2944
                                  p = frag_more (10);
2945
                                  p[0] = 2;
2946
                                  p[1] = VAX_BRB;
2947
                                  p[2] = 6;
2948
                                  p[3] = VAX_JMP;
2949
                                  p[4] = VAX_PC_RELATIVE_MODE;
2950
                                  fix_new (frag_now,
2951
                                           p + 5 - frag_now->fr_literal,
2952
                                           4, this_add_symbol,
2953
                                           this_add_number, 1, NO_RELOC);
2954
                                  /* Now (eg)   xOBxxx  1f
2955
                                                BRB     2f
2956
                                        1:      JMP     foo
2957
                                        2:  */
2958
                                }
2959
                            }
2960
                        }
2961
                      else
2962
                        {
2963
                          know (operandP->vop_width == VAX_WIDTH_CONDITIONAL_JUMP);
2964
                          *opcode_low_byteP ^= 1;       /* Reverse branch condition.  */
2965
                          p = frag_more (7);
2966
                          p[0] = 6;
2967
                          p[1] = VAX_JMP;
2968
                          p[2] = VAX_PC_RELATIVE_MODE;
2969
                          fix_new (frag_now, p + 3 - frag_now->fr_literal,
2970
                                   4, this_add_symbol,
2971
                                   this_add_number, 1, NO_RELOC);
2972
                        }
2973
                    }
2974
                }
2975
            }
2976
        }
2977
      else
2978
        {
2979
          /* So it is ordinary operand.  */
2980
          know (operandP->vop_access != 'b');
2981
          /* ' ' target-independent: elsewhere.  */
2982
          know (operandP->vop_access != ' ');
2983
          know (operandP->vop_access == 'a'
2984
                || operandP->vop_access == 'm'
2985
                || operandP->vop_access == 'r'
2986
                || operandP->vop_access == 'v'
2987
                || operandP->vop_access == 'w');
2988
          if (operandP->vop_short == 's')
2989
            {
2990
              if (is_absolute)
2991
                {
2992
                  if (this_add_number >= 64)
2993
                    {
2994
                      as_warn (_("Short literal overflow(%ld.), immediate mode assumed."),
2995
                               (long) this_add_number);
2996
                      operandP->vop_short = 'i';
2997
                      operandP->vop_mode = 8;
2998
                      operandP->vop_reg = 0xF;
2999
                    }
3000
                }
3001
              else
3002
                {
3003
                  as_warn (_("Forced short literal to immediate mode. now_seg=%s to_seg=%s"),
3004
                           segment_name (now_seg), segment_name (to_seg));
3005
                  operandP->vop_short = 'i';
3006
                  operandP->vop_mode = 8;
3007
                  operandP->vop_reg = 0xF;
3008
                }
3009
            }
3010
          if (operandP->vop_reg >= 0 && (operandP->vop_mode < 8
3011
                  || (operandP->vop_reg != 0xF && operandP->vop_mode < 10)))
3012
            {
3013
              /* One byte operand.  */
3014
              know (operandP->vop_mode > 3);
3015
              FRAG_APPEND_1_CHAR (operandP->vop_mode << 4 | operandP->vop_reg);
3016
              /* All 1-bytes except S^# happen here.  */
3017
            }
3018
          else
3019
            {
3020
              /* {@}{q^}foo{(Rn)} or S^#foo */
3021
              if (operandP->vop_reg == -1 && operandP->vop_short != 's')
3022
                {
3023
                  /* "{@}{q^}foo" */
3024
                  if (to_seg == now_seg)
3025
                    {
3026
                      if (length == 0)
3027
                        {
3028
                          know (operandP->vop_short == ' ');
3029
                          length_code = STATE_BYTE;
3030
#ifdef OBJ_ELF
3031
                          if (S_IS_EXTERNAL (this_add_symbol)
3032
                              || S_IS_WEAK (this_add_symbol))
3033
                            length_code = STATE_UNDF;
3034
#endif
3035
                          p = frag_var (rs_machine_dependent, 10, 2,
3036
                               ENCODE_RELAX (STATE_PC_RELATIVE, length_code),
3037
                                        this_add_symbol, this_add_number,
3038
                                        opcode_low_byteP);
3039
                          know (operandP->vop_mode == 10 + at);
3040
                          *p = at << 4;
3041
                          /* At is the only context we need to carry
3042
                             to other side of relax() process.  Must
3043
                             be in the correct bit position of VAX
3044
                             operand spec. byte.  */
3045
                        }
3046
                      else
3047
                        {
3048
                          know (length);
3049
                          know (operandP->vop_short != ' ');
3050
                          p = frag_more (length + 1);
3051
                          p[0] = 0xF | ((at + "?\12\14?\16"[length]) << 4);
3052
                          fix_new (frag_now, p + 1 - frag_now->fr_literal,
3053
                                   length, this_add_symbol,
3054
                                   this_add_number, 1, NO_RELOC);
3055
                        }
3056
                    }
3057
                  else
3058
                    {
3059
                      /* to_seg != now_seg */
3060
                      if (this_add_symbol == NULL)
3061
                        {
3062
                          know (is_absolute);
3063
                          /* Do @#foo: simpler relocation than foo-.(pc) anyway.  */
3064
                          p = frag_more (5);
3065
                          p[0] = VAX_ABSOLUTE_MODE;      /* @#...  */
3066
                          md_number_to_chars (p + 1, this_add_number, 4);
3067
                          if (length && length != 4)
3068
                            as_warn (_("Length specification ignored. Address mode 9F used"));
3069
                        }
3070
                      else
3071
                        {
3072
                          /* {@}{q^}other_seg */
3073
                          know ((length == 0 && operandP->vop_short == ' ')
3074
                             || (length > 0 && operandP->vop_short != ' '));
3075
                          if (is_undefined
3076
#ifdef OBJ_ELF
3077
                              || S_IS_WEAK(this_add_symbol)
3078
                              || S_IS_EXTERNAL(this_add_symbol)
3079
#endif
3080
                              )
3081
                            {
3082
                              switch (length)
3083
                                {
3084
                                default: length_code = STATE_UNDF; break;
3085
                                case 1: length_code = STATE_BYTE; break;
3086
                                case 2: length_code = STATE_WORD; break;
3087
                                case 4: length_code = STATE_LONG; break;
3088
                                }
3089
                              /* We have a SEG_UNKNOWN symbol. It might
3090
                                 turn out to be in the same segment as
3091
                                 the instruction, permitting relaxation.  */
3092
                              p = frag_var (rs_machine_dependent, 5, 2,
3093
                               ENCODE_RELAX (STATE_PC_RELATIVE, length_code),
3094
                                            this_add_symbol, this_add_number,
3095
                                            opcode_low_byteP);
3096
                              p[0] = at << 4;
3097
                            }
3098
                          else
3099
                            {
3100
                              if (length == 0)
3101
                                {
3102
                                  know (operandP->vop_short == ' ');
3103
                                  length = 4;   /* Longest possible.  */
3104
                                }
3105
                              p = frag_more (length + 1);
3106
                              p[0] = 0xF | ((at + "?\12\14?\16"[length]) << 4);
3107
                              md_number_to_chars (p + 1, this_add_number, length);
3108
                              fix_new (frag_now,
3109
                                       p + 1 - frag_now->fr_literal,
3110
                                       length, this_add_symbol,
3111
                                       this_add_number, 1, NO_RELOC);
3112
                            }
3113
                        }
3114
                    }
3115
                }
3116
              else
3117
                {
3118
                  /* {@}{q^}foo(Rn) or S^# or I^# or # */
3119
                  if (operandP->vop_mode < 0xA)
3120
                    {
3121
                      /* # or S^# or I^# */
3122
                      if (operandP->vop_access == 'v'
3123
                          || operandP->vop_access == 'a')
3124
                        {
3125
                          if (operandP->vop_access == 'v')
3126
                            as_warn (_("Invalid operand:  immediate value used as base address."));
3127
                          else
3128
                            as_warn (_("Invalid operand:  immediate value used as address."));
3129
                          /* gcc 2.6.3 is known to generate these in at least
3130
                             one case.  */
3131
                        }
3132
                      if (length == 0
3133
                          && is_absolute && (expP->X_op != O_big)
3134
                          && operandP->vop_mode == 8    /* No '@'.  */
3135
                          && this_add_number < 64)
3136
                        {
3137
                          operandP->vop_short = 's';
3138
                        }
3139
                      if (operandP->vop_short == 's')
3140
                        {
3141
                          FRAG_APPEND_1_CHAR (this_add_number);
3142
                        }
3143
                      else
3144
                        {
3145
                          /* I^#...  */
3146
                          know (nbytes);
3147
                          p = frag_more (nbytes + 1);
3148
                          know (operandP->vop_reg == 0xF);
3149
#ifdef OBJ_ELF
3150
                          if (flag_want_pic && operandP->vop_mode == 8
3151
                                && this_add_symbol != NULL)
3152
                            {
3153
                              as_warn (_("Symbol %s used as immediate operand in PIC mode."),
3154
                                       S_GET_NAME (this_add_symbol));
3155
                            }
3156
#endif
3157
                          p[0] = (operandP->vop_mode << 4) | 0xF;
3158
                          if ((is_absolute) && (expP->X_op != O_big))
3159
                            {
3160
                              /* If nbytes > 4, then we are scrod. We
3161
                                 don't know if the high order bytes
3162
                                 are to be 0xFF or 0x00.  BSD4.2 & RMS
3163
                                 say use 0x00. OK --- but this
3164
                                 assembler needs ANOTHER rewrite to
3165
                                 cope properly with this bug.  */
3166
                              md_number_to_chars (p + 1, this_add_number,
3167
                                                  min (sizeof (valueT),
3168
                                                       (size_t) nbytes));
3169
                              if ((size_t) nbytes > sizeof (valueT))
3170
                                memset (p + 1 + sizeof (valueT),
3171
                                        '\0', nbytes - sizeof (valueT));
3172
                            }
3173
                          else
3174
                            {
3175
                              if (expP->X_op == O_big)
3176
                                {
3177
                                  /* Problem here is to get the bytes
3178
                                     in the right order.  We stored
3179
                                     our constant as LITTLENUMs, not
3180
                                     bytes.  */
3181
                                  LITTLENUM_TYPE *lP;
3182
 
3183
                                  lP = floatP->low;
3184
                                  if (nbytes & 1)
3185
                                    {
3186
                                      know (nbytes == 1);
3187
                                      p[1] = *lP;
3188
                                    }
3189
                                  else
3190
                                    {
3191
                                      for (p++; nbytes; nbytes -= 2, p += 2, lP++)
3192
                                        md_number_to_chars (p, *lP, 2);
3193
                                    }
3194
                                }
3195
                              else
3196
                                {
3197
                                  fix_new (frag_now, p + 1 - frag_now->fr_literal,
3198
                                           nbytes, this_add_symbol,
3199
                                           this_add_number, 0, NO_RELOC);
3200
                                }
3201
                            }
3202
                        }
3203
                    }
3204
                  else
3205
                    {
3206
                      /* {@}{q^}foo(Rn) */
3207
                      know ((length == 0 && operandP->vop_short == ' ')
3208
                            || (length > 0 && operandP->vop_short != ' '));
3209
                      if (length == 0)
3210
                        {
3211
                          if (is_absolute)
3212
                            {
3213
                              long test;
3214
 
3215
                              test = this_add_number;
3216
 
3217
                              if (test < 0)
3218
                                test = ~test;
3219
 
3220
                              length = test & 0xffff8000 ? 4
3221
                                : test & 0xffffff80 ? 2
3222
                                : 1;
3223
                            }
3224
                          else
3225
                            {
3226
                              length = 4;
3227
                            }
3228
                        }
3229
                      p = frag_more (1 + length);
3230
                      know (operandP->vop_reg >= 0);
3231
                      p[0] = operandP->vop_reg
3232
                        | ((at | "?\12\14?\16"[length]) << 4);
3233
                      if (is_absolute)
3234
                        {
3235
                          md_number_to_chars (p + 1, this_add_number, length);
3236
                        }
3237
                      else
3238
                        {
3239
                          fix_new (frag_now, p + 1 - frag_now->fr_literal,
3240
                                   length, this_add_symbol,
3241
                                   this_add_number, 0, NO_RELOC);
3242
                        }
3243
                    }
3244
                }
3245
            }
3246
        }
3247
    }
3248
}
3249
 
3250
void
3251
md_begin (void)
3252
{
3253
  const char *errtxt;
3254
  FLONUM_TYPE *fP;
3255
  int i;
3256
 
3257
  if ((errtxt = vip_begin (1, "$", "*", "`")) != 0)
3258
    as_fatal (_("VIP_BEGIN error:%s"), errtxt);
3259
 
3260
  for (i = 0, fP = float_operand;
3261
       fP < float_operand + VIT_MAX_OPERANDS;
3262
       i++, fP++)
3263
    {
3264
      fP->low = &big_operand_bits[i][0];
3265
      fP->high = &big_operand_bits[i][SIZE_OF_LARGE_NUMBER - 1];
3266
    }
3267
}
3268
 
3269
static char *vax_cons_special_reloc;
3270
 
3271
void
3272
vax_cons (expressionS *exp, int size)
3273
{
3274
  char *save;
3275
 
3276
  SKIP_WHITESPACE ();
3277
  vax_cons_special_reloc = NULL;
3278
  save = input_line_pointer;
3279
  if (input_line_pointer[0] == '%')
3280
    {
3281
      if (strncmp (input_line_pointer + 1, "pcrel", 5) == 0)
3282
        {
3283
          input_line_pointer += 6;
3284
          vax_cons_special_reloc = "pcrel";
3285
        }
3286
      if (vax_cons_special_reloc)
3287
        {
3288
          int bad = 0;
3289
 
3290
          switch (size)
3291
            {
3292
            case 1:
3293
              if (*input_line_pointer != '8')
3294
                bad = 1;
3295
              input_line_pointer--;
3296
              break;
3297
            case 2:
3298
              if (input_line_pointer[0] != '1' || input_line_pointer[1] != '6')
3299
                bad = 1;
3300
              break;
3301
            case 4:
3302
              if (input_line_pointer[0] != '3' || input_line_pointer[1] != '2')
3303
                bad = 1;
3304
              break;
3305
            default:
3306
              bad = 1;
3307
              break;
3308
            }
3309
 
3310
          if (bad)
3311
            {
3312
              as_bad (_("Illegal operands: Only %%r_%s%d allowed in %d-byte data fields"),
3313
                      vax_cons_special_reloc, size * 8, size);
3314
            }
3315
          else
3316
            {
3317
              input_line_pointer += 2;
3318
              if (*input_line_pointer != '(')
3319
                {
3320
                  as_bad (_("Illegal operands: %%r_%s%d requires arguments in ()"),
3321
                          vax_cons_special_reloc, size * 8);
3322
                  bad = 1;
3323
                }
3324
            }
3325
 
3326
          if (bad)
3327
            {
3328
              input_line_pointer = save;
3329
              vax_cons_special_reloc = NULL;
3330
            }
3331
          else
3332
            {
3333
              int c;
3334
              char *end = ++input_line_pointer;
3335
              int npar = 0;
3336
 
3337
              while (! is_end_of_line[(c = *end)])
3338
                {
3339
                  if (c == '(')
3340
                    npar++;
3341
                  else if (c == ')')
3342
                    {
3343
                      if (!npar)
3344
                        break;
3345
                      npar--;
3346
                    }
3347
                  end++;
3348
                }
3349
 
3350
              if (c != ')')
3351
                as_bad (_("Illegal operands: %%r_%s%d requires arguments in ()"),
3352
                        vax_cons_special_reloc, size * 8);
3353
              else
3354
                {
3355
                  *end = '\0';
3356
                  expression (exp);
3357
                  *end = c;
3358
                  if (input_line_pointer != end)
3359
                    {
3360
                      as_bad (_("Illegal operands: %%r_%s%d requires arguments in ()"),
3361
                              vax_cons_special_reloc, size * 8);
3362
                    }
3363
                  else
3364
                    {
3365
                      input_line_pointer++;
3366
                      SKIP_WHITESPACE ();
3367
                      c = *input_line_pointer;
3368
                      if (! is_end_of_line[c] && c != ',')
3369
                        as_bad (_("Illegal operands: garbage after %%r_%s%d()"),
3370
                                vax_cons_special_reloc, size * 8);
3371
                    }
3372
                }
3373
            }
3374
        }
3375
    }
3376
  if (vax_cons_special_reloc == NULL)
3377
    expression (exp);
3378
}
3379
 
3380
/* This is called by emit_expr via TC_CONS_FIX_NEW when creating a
3381
   reloc for a cons.  */
3382
 
3383
void
3384
vax_cons_fix_new (fragS *frag, int where, unsigned int nbytes, expressionS *exp)
3385
{
3386
  bfd_reloc_code_real_type r;
3387
 
3388
  r = (nbytes == 1 ? BFD_RELOC_8 :
3389
       (nbytes == 2 ? BFD_RELOC_16 : BFD_RELOC_32));
3390
 
3391
  if (vax_cons_special_reloc)
3392
    {
3393
      if (*vax_cons_special_reloc == 'p')
3394
        {
3395
          switch (nbytes)
3396
            {
3397
            case 1: r = BFD_RELOC_8_PCREL; break;
3398
            case 2: r = BFD_RELOC_16_PCREL; break;
3399
            case 4: r = BFD_RELOC_32_PCREL; break;
3400
            default: abort ();
3401
            }
3402
        }
3403
    }
3404
 
3405
  fix_new_exp (frag, where, (int) nbytes, exp, 0, r);
3406
  vax_cons_special_reloc = NULL;
3407
}
3408
 
3409
char *
3410
md_atof (int type, char * litP, int * sizeP)
3411
{
3412
  return vax_md_atof (type, litP, sizeP);
3413
}

powered by: WebSVN 2.1.0

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