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

Subversion Repositories open8_urisc

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

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 16 khays
/* tc-mmix.c -- Assembler for Don Knuth's MMIX.
2
   Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
3
   Free Software Foundation.
4
 
5
   This file is part of GAS, the GNU Assembler.
6
 
7
   GAS is free software; you can redistribute it and/or modify
8
   it under the terms of the GNU General Public License as published by
9
   the Free Software Foundation; either version 3, or (at your option)
10
   any later version.
11
 
12
   GAS is distributed in the hope that it will be useful,
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
   GNU General Public License for more details.
16
 
17
   You should have received a copy of the GNU General Public License
18
   along with GAS; see the file COPYING.  If not, write to
19
   the Free Software Foundation, 51 Franklin Street - Fifth Floor,
20
   Boston, MA 02110-1301, USA.  */
21
 
22
/* Knuth's assembler mmixal does not provide a relocatable format; mmo is
23
   to be considered a final link-format.  In the final link, we make mmo,
24
   but for relocatable files, we use ELF.
25
 
26
   One goal is to provide a superset of what mmixal does, including
27
   compatible syntax, but the main purpose is to serve GCC.  */
28
 
29
 
30
#include <limits.h>
31
#include "as.h"
32
#include "subsegs.h"
33
#include "elf/mmix.h"
34
#include "opcode/mmix.h"
35
#include "safe-ctype.h"
36
#include "dwarf2dbg.h"
37
#include "obstack.h"
38
 
39
/* Something to describe what we need to do with a fixup before output,
40
   for example assert something of what it became or make a relocation.  */
41
 
42
enum mmix_fixup_action
43
 {
44
   mmix_fixup_byte,
45
   mmix_fixup_register,
46
   mmix_fixup_register_or_adjust_for_byte
47
 };
48
 
49
static int get_spec_regno (char *);
50
static int get_operands (int, char *, expressionS *);
51
static int get_putget_operands (struct mmix_opcode *, char *, expressionS *);
52
static void s_prefix (int);
53
static void s_greg (int);
54
static void s_loc (int);
55
static void s_bspec (int);
56
static void s_espec (int);
57
static void mmix_s_local (int);
58
static void mmix_greg_internal (char *);
59
static void mmix_set_geta_branch_offset (char *, offsetT);
60
static void mmix_set_jmp_offset (char *, offsetT);
61
static void mmix_fill_nops (char *, int);
62
static int cmp_greg_symbol_fixes (const void *, const void *);
63
static int cmp_greg_val_greg_symbol_fixes (const void *, const void *);
64
static void mmix_handle_rest_of_empty_line (void);
65
static void mmix_discard_rest_of_line (void);
66
static void mmix_byte (void);
67
static void mmix_cons (int);
68
 
69
/* Continue the tradition of symbols.c; use control characters to enforce
70
   magic.  These are used when replacing e.g. 8F and 8B so we can handle
71
   such labels correctly with the common parser hooks.  */
72
#define MAGIC_FB_BACKWARD_CHAR '\003'
73
#define MAGIC_FB_FORWARD_CHAR '\004'
74
 
75
/* Copy the location of a frag to a fix.  */
76
#define COPY_FR_WHERE_TO_FX(FRAG, FIX)          \
77
 do                                             \
78
   {                                            \
79
     (FIX)->fx_file = (FRAG)->fr_file;          \
80
     (FIX)->fx_line = (FRAG)->fr_line;          \
81
   }                                            \
82
 while (0)
83
 
84
const char *md_shortopts = "x";
85
static int current_fb_label = -1;
86
static char *pending_label = NULL;
87
 
88
static bfd_vma lowest_text_loc = (bfd_vma) -1;
89
static int text_has_contents = 0;
90
 
91
/* The alignment of the previous instruction, and a boolean for whether we
92
   want to avoid aligning the next WYDE, TETRA, OCTA or insn.  */
93
static int last_alignment = 0;
94
static int want_unaligned = 0;
95
 
96
static bfd_vma lowest_data_loc = (bfd_vma) -1;
97
static int data_has_contents = 0;
98
 
99
/* The fragS of the instruction being assembled.  Only valid from within
100
   md_assemble.  */
101
fragS *mmix_opcode_frag = NULL;
102
 
103
/* Raw GREGs as appearing in input.  These may be fewer than the number
104
   after relaxing.  */
105
static int n_of_raw_gregs = 0;
106
static struct
107
 {
108
   char *label;
109
   expressionS exp;
110
 } mmix_raw_gregs[MAX_GREGS];
111
 
112
/* Fixups for all unique GREG registers.  We store the fixups here in
113
   md_convert_frag, then we use the array to convert
114
   BFD_RELOC_MMIX_BASE_PLUS_OFFSET fixups in tc_gen_reloc.  The index is
115
   just a running number and is not supposed to be correlated to a
116
   register number.  */
117
static fixS *mmix_gregs[MAX_GREGS];
118
static int n_of_cooked_gregs = 0;
119
 
120
/* Pointing to the register section we use for output.  */
121
static asection *real_reg_section;
122
 
123
/* For each symbol; unknown or section symbol, we keep a list of GREG
124
   definitions sorted on increasing offset.  It seems no use keeping count
125
   to allocate less room than the maximum number of gregs when we've found
126
   one for a section or symbol.  */
127
struct mmix_symbol_gregs
128
 {
129
   int n_gregs;
130
   struct mmix_symbol_greg_fixes
131
   {
132
     fixS *fix;
133
 
134
     /* A signed type, since we may have GREGs pointing slightly before the
135
        contents of a section.  */
136
     offsetT offs;
137
   } greg_fixes[MAX_GREGS];
138
 };
139
 
140
/* Should read insert a colon on something that starts in column 0 on
141
   this line?  */
142
static int label_without_colon_this_line = 1;
143
 
144
/* Should we automatically expand instructions into multiple insns in
145
   order to generate working code?  */
146
static int expand_op = 1;
147
 
148
/* Should we warn when expanding operands?  FIXME: test-cases for when -x
149
   is absent.  */
150
static int warn_on_expansion = 1;
151
 
152
/* Should we merge non-zero GREG register definitions?  */
153
static int merge_gregs = 1;
154
 
155
/* Should we pass on undefined BFD_RELOC_MMIX_BASE_PLUS_OFFSET relocs
156
   (missing suitable GREG definitions) to the linker?  */
157
static int allocate_undefined_gregs_in_linker = 0;
158
 
159
/* Should we emit built-in symbols?  */
160
static int predefined_syms = 1;
161
 
162
/* Should we allow anything but the listed special register name
163
   (e.g. equated symbols)?  */
164
static int equated_spec_regs = 1;
165
 
166
/* Do we require standard GNU syntax?  */
167
int mmix_gnu_syntax = 0;
168
 
169
/* Do we globalize all symbols?  */
170
int mmix_globalize_symbols = 0;
171
 
172
/* When expanding insns, do we want to expand PUSHJ as a call to a stub
173
   (or else as a series of insns)?  */
174
int pushj_stubs = 1;
175
 
176
/* Do we know that the next semicolon is at the end of the operands field
177
   (in mmixal mode; constant 1 in GNU mode)?  */
178
int mmix_next_semicolon_is_eoln = 1;
179
 
180
/* Do we have a BSPEC in progress?  */
181
static int doing_bspec = 0;
182
static char *bspec_file;
183
static unsigned int bspec_line;
184
 
185
struct option md_longopts[] =
186
 {
187
#define OPTION_RELAX  (OPTION_MD_BASE)
188
#define OPTION_NOEXPAND  (OPTION_RELAX + 1)
189
#define OPTION_NOMERGEGREG  (OPTION_NOEXPAND + 1)
190
#define OPTION_NOSYMS  (OPTION_NOMERGEGREG + 1)
191
#define OPTION_GNU_SYNTAX  (OPTION_NOSYMS + 1)
192
#define OPTION_GLOBALIZE_SYMBOLS  (OPTION_GNU_SYNTAX + 1)
193
#define OPTION_FIXED_SPEC_REGS  (OPTION_GLOBALIZE_SYMBOLS + 1)
194
#define OPTION_LINKER_ALLOCATED_GREGS  (OPTION_FIXED_SPEC_REGS + 1)
195
#define OPTION_NOPUSHJSTUBS  (OPTION_LINKER_ALLOCATED_GREGS + 1)
196
   {"linkrelax", no_argument, NULL, OPTION_RELAX},
197
   {"no-expand", no_argument, NULL, OPTION_NOEXPAND},
198
   {"no-merge-gregs", no_argument, NULL, OPTION_NOMERGEGREG},
199
   {"no-predefined-syms", no_argument, NULL, OPTION_NOSYMS},
200
   {"gnu-syntax", no_argument, NULL, OPTION_GNU_SYNTAX},
201
   {"globalize-symbols", no_argument, NULL, OPTION_GLOBALIZE_SYMBOLS},
202
   {"fixed-special-register-names", no_argument, NULL,
203
    OPTION_FIXED_SPEC_REGS},
204
   {"linker-allocated-gregs", no_argument, NULL,
205
    OPTION_LINKER_ALLOCATED_GREGS},
206
   {"no-pushj-stubs", no_argument, NULL, OPTION_NOPUSHJSTUBS},
207
   {"no-stubs", no_argument, NULL, OPTION_NOPUSHJSTUBS},
208
   {NULL, no_argument, NULL, 0}
209
 };
210
 
211
size_t md_longopts_size = sizeof (md_longopts);
212
 
213
static struct hash_control *mmix_opcode_hash;
214
 
215
/* We use these when implementing the PREFIX pseudo.  */
216
char *mmix_current_prefix;
217
struct obstack mmix_sym_obstack;
218
 
219
 
220
/* For MMIX, we encode the relax_substateT:s (in e.g. fr_substate) as one
221
   bit length, and the relax-type shifted on top of that.  There seems to
222
   be no point in making the relaxation more fine-grained; the linker does
223
   that better and we might interfere by changing non-optimal relaxations
224
   into other insns that cannot be relaxed as easily.
225
 
226
   Groups for MMIX relaxing:
227
 
228
   1. GETA
229
      extra length: zero or three insns.
230
 
231
   2. Bcc
232
      extra length: zero or five insns.
233
 
234
   3. PUSHJ
235
      extra length: zero or four insns.
236
      Special handling to deal with transition to PUSHJSTUB.
237
 
238
   4. JMP
239
      extra length: zero or four insns.
240
 
241
   5. GREG
242
      special handling, allocates a named global register unless another
243
      is within reach for all uses.
244
 
245
   6. PUSHJSTUB
246
      special handling (mostly) for external references; assumes the
247
      linker will generate a stub if target is no longer than 256k from
248
      the end of the section plus max size of previous stubs.  Zero or
249
      four insns.  */
250
 
251
#define STATE_GETA      (1)
252
#define STATE_BCC       (2)
253
#define STATE_PUSHJ     (3)
254
#define STATE_JMP       (4)
255
#define STATE_GREG      (5)
256
#define STATE_PUSHJSTUB (6)
257
 
258
/* No fine-grainedness here.  */
259
#define STATE_LENGTH_MASK           (1)
260
 
261
#define STATE_ZERO                  (0)
262
#define STATE_MAX                   (1)
263
 
264
/* More descriptive name for convenience.  */
265
/* FIXME: We should start on something different, not MAX.  */
266
#define STATE_UNDF                  STATE_MAX
267
 
268
/* FIXME: For GREG, we must have other definitions; UNDF == MAX isn't
269
   appropriate; we need it the other way round.  This value together with
270
   fragP->tc_frag_data shows what state the frag is in: tc_frag_data
271
   non-NULL means 0, NULL means 8 bytes.  */
272
#define STATE_GREG_UNDF ENCODE_RELAX (STATE_GREG, STATE_ZERO)
273
#define STATE_GREG_DEF ENCODE_RELAX (STATE_GREG, STATE_MAX)
274
 
275
/* These displacements are relative to the address following the opcode
276
   word of the instruction.  The catch-all states have zero for "reach"
277
   and "next" entries.  */
278
 
279
#define GETA_0F (65536 * 4 - 8)
280
#define GETA_0B (-65536 * 4 - 4)
281
 
282
#define GETA_MAX_LEN 4 * 4
283
#define GETA_3F 0
284
#define GETA_3B 0
285
 
286
#define BCC_0F GETA_0F
287
#define BCC_0B GETA_0B
288
 
289
#define BCC_MAX_LEN 6 * 4
290
#define BCC_5F GETA_3F
291
#define BCC_5B GETA_3B
292
 
293
#define PUSHJ_0F GETA_0F
294
#define PUSHJ_0B GETA_0B
295
 
296
#define PUSHJ_MAX_LEN 5 * 4
297
#define PUSHJ_4F GETA_3F
298
#define PUSHJ_4B GETA_3B
299
 
300
/* We'll very rarely have sections longer than LONG_MAX, but we'll make a
301
   feeble attempt at getting 64-bit values.  */
302
#define PUSHJSTUB_MAX ((offsetT) (((addressT) -1) >> 1))
303
#define PUSHJSTUB_MIN (-PUSHJSTUB_MAX - 1)
304
 
305
#define JMP_0F (65536 * 256 * 4 - 8)
306
#define JMP_0B (-65536 * 256 * 4 - 4)
307
 
308
#define JMP_MAX_LEN 5 * 4
309
#define JMP_4F 0
310
#define JMP_4B 0
311
 
312
#define RELAX_ENCODE_SHIFT 1
313
#define ENCODE_RELAX(what, length) (((what) << RELAX_ENCODE_SHIFT) + (length))
314
 
315
const relax_typeS mmix_relax_table[] =
316
 {
317
   /* Error sentinel (0, 0).  */
318
   {1,          1,              0,       0},
319
 
320
   /* Unused (0, 1).  */
321
   {1,          1,              0,       0},
322
 
323
   /* GETA (1, 0).  */
324
   {GETA_0F,    GETA_0B,        0,       ENCODE_RELAX (STATE_GETA, STATE_MAX)},
325
 
326
   /* GETA (1, 1).  */
327
   {GETA_3F,    GETA_3B,
328
                GETA_MAX_LEN - 4,       0},
329
 
330
   /* BCC (2, 0).  */
331
   {BCC_0F,     BCC_0B,         0,       ENCODE_RELAX (STATE_BCC, STATE_MAX)},
332
 
333
   /* BCC (2, 1).  */
334
   {BCC_5F,     BCC_5B,
335
                BCC_MAX_LEN - 4,        0},
336
 
337
   /* PUSHJ (3, 0).  Next state is actually PUSHJSTUB (6, 0).  */
338
   {PUSHJ_0F,   PUSHJ_0B,       0,       ENCODE_RELAX (STATE_PUSHJSTUB, STATE_ZERO)},
339
 
340
   /* PUSHJ (3, 1).  */
341
   {PUSHJ_4F,   PUSHJ_4B,
342
                PUSHJ_MAX_LEN - 4,      0},
343
 
344
   /* JMP (4, 0).  */
345
   {JMP_0F,     JMP_0B,         0,       ENCODE_RELAX (STATE_JMP, STATE_MAX)},
346
 
347
   /* JMP (4, 1).  */
348
   {JMP_4F,     JMP_4B,
349
                JMP_MAX_LEN - 4,        0},
350
 
351
   /* GREG (5, 0), (5, 1), though the table entry isn't used.  */
352
   {0, 0, 0, 0}, {0, 0, 0, 0},
353
 
354
   /* PUSHJSTUB (6, 0).  PUSHJ (3, 0) uses the range, so we set it to infinite.  */
355
   {PUSHJSTUB_MAX, PUSHJSTUB_MIN,
356
                0,                       ENCODE_RELAX (STATE_PUSHJ, STATE_MAX)},
357
   /* PUSHJSTUB (6, 1) isn't used.  */
358
   {0, 0, PUSHJ_MAX_LEN,          0}
359
};
360
 
361
const pseudo_typeS md_pseudo_table[] =
362
 {
363
   /* Support " .greg sym,expr" syntax.  */
364
   {"greg", s_greg, 0},
365
 
366
   /* Support " .bspec expr" syntax.  */
367
   {"bspec", s_bspec, 1},
368
 
369
   /* Support " .espec" syntax.  */
370
   {"espec", s_espec, 1},
371
 
372
   /* Support " .local $45" syntax.  */
373
   {"local", mmix_s_local, 1},
374
 
375
   {NULL, 0, 0}
376
 };
377
 
378
const char mmix_comment_chars[] = "%!";
379
 
380
/* A ':' is a valid symbol character in mmixal.  It's the prefix
381
   delimiter, but other than that, it works like a symbol character,
382
   except that we strip one off at the beginning of symbols.  An '@' is a
383
   symbol by itself (for the current location); space around it must not
384
   be stripped.  */
385
const char mmix_symbol_chars[] = ":@";
386
 
387
const char line_comment_chars[] = "*#";
388
 
389
const char line_separator_chars[] = ";";
390
 
391
const char mmix_exp_chars[] = "eE";
392
 
393
const char mmix_flt_chars[] = "rf";
394
 
395
 
396
/* Fill in the offset-related part of GETA or Bcc.  */
397
 
398
static void
399
mmix_set_geta_branch_offset (char *opcodep, offsetT value)
400
{
401
  if (value < 0)
402
    {
403
      value += 65536 * 4;
404
      opcodep[0] |= 1;
405
    }
406
 
407
  value /= 4;
408
  md_number_to_chars (opcodep + 2, value, 2);
409
}
410
 
411
/* Fill in the offset-related part of JMP.  */
412
 
413
static void
414
mmix_set_jmp_offset (char *opcodep, offsetT value)
415
{
416
  if (value < 0)
417
    {
418
      value += 65536 * 256 * 4;
419
      opcodep[0] |= 1;
420
    }
421
 
422
  value /= 4;
423
  md_number_to_chars (opcodep + 1, value, 3);
424
}
425
 
426
/* Fill in NOP:s for the expanded part of GETA/JMP/Bcc/PUSHJ.  */
427
 
428
static void
429
mmix_fill_nops (char *opcodep, int n)
430
{
431
  int i;
432
 
433
  for (i = 0; i < n; i++)
434
    md_number_to_chars (opcodep + i * 4, SWYM_INSN_BYTE << 24, 4);
435
}
436
 
437
/* See macro md_parse_name in tc-mmix.h.  */
438
 
439
int
440
mmix_current_location (void (*fn) (expressionS *), expressionS *exp)
441
{
442
  (*fn) (exp);
443
 
444
  return 1;
445
}
446
 
447
/* Get up to three operands, filling them into the exp array.
448
   General idea and code stolen from the tic80 port.  */
449
 
450
static int
451
get_operands (int max_operands, char *s, expressionS *exp)
452
{
453
  char *p = s;
454
  int numexp = 0;
455
  int nextchar = ',';
456
 
457
  while (nextchar == ',')
458
    {
459
      /* Skip leading whitespace */
460
      while (*p == ' ' || *p == '\t')
461
        p++;
462
 
463
      /* Check to see if we have any operands left to parse */
464
      if (*p == 0 || *p == '\n' || *p == '\r')
465
        {
466
          break;
467
        }
468
      else if (numexp == max_operands)
469
        {
470
          /* This seems more sane than saying "too many operands".  We'll
471
             get here only if the trailing trash starts with a comma.  */
472
          as_bad (_("invalid operands"));
473
          mmix_discard_rest_of_line ();
474
          return 0;
475
        }
476
 
477
      /* Begin operand parsing at the current scan point.  */
478
 
479
      input_line_pointer = p;
480
      expression (&exp[numexp]);
481
 
482
      if (exp[numexp].X_op == O_illegal)
483
        {
484
          as_bad (_("invalid operands"));
485
        }
486
      else if (exp[numexp].X_op == O_absent)
487
        {
488
          as_bad (_("missing operand"));
489
        }
490
 
491
      numexp++;
492
      p = input_line_pointer;
493
 
494
      /* Skip leading whitespace */
495
      while (*p == ' ' || *p == '\t')
496
        p++;
497
      nextchar = *p++;
498
    }
499
 
500
  /* If we allow "naked" comments, ignore the rest of the line.  */
501
  if (nextchar != ',')
502
    {
503
      mmix_handle_rest_of_empty_line ();
504
      input_line_pointer--;
505
    }
506
 
507
  /* Mark the end of the valid operands with an illegal expression.  */
508
  exp[numexp].X_op = O_illegal;
509
 
510
  return (numexp);
511
}
512
 
513
/* Get the value of a special register, or -1 if the name does not match
514
   one.  NAME is a null-terminated string.  */
515
 
516
static int
517
get_spec_regno (char *name)
518
{
519
  int i;
520
 
521
  if (name == NULL)
522
    return -1;
523
 
524
  if (*name == ':')
525
    name++;
526
 
527
  /* Well, it's a short array and we'll most often just match the first
528
     entry, rJ.  */
529
  for (i = 0; mmix_spec_regs[i].name != NULL; i++)
530
    if (strcmp (name, mmix_spec_regs[i].name) == 0)
531
      return mmix_spec_regs[i].number;
532
 
533
  return -1;
534
}
535
 
536
/* For GET and PUT, parse the register names "manually", so we don't use
537
   user labels.  */
538
static int
539
get_putget_operands (struct mmix_opcode *insn, char *operands,
540
                     expressionS *exp)
541
{
542
  expressionS *expp_reg;
543
  expressionS *expp_sreg;
544
  char *sregp = NULL;
545
  char *sregend = operands;
546
  char *p = operands;
547
  char c = *sregend;
548
  int regno;
549
 
550
  /* Skip leading whitespace */
551
  while (*p == ' ' || *p == '\t')
552
    p++;
553
 
554
  input_line_pointer = p;
555
 
556
  /* Initialize both possible operands to error state, in case we never
557
     get further.  */
558
  exp[0].X_op = O_illegal;
559
  exp[1].X_op = O_illegal;
560
 
561
  if (insn->operands == mmix_operands_get)
562
    {
563
      expp_reg = &exp[0];
564
      expp_sreg = &exp[1];
565
 
566
      expression (expp_reg);
567
 
568
      p = input_line_pointer;
569
 
570
      /* Skip whitespace */
571
      while (*p == ' ' || *p == '\t')
572
        p++;
573
 
574
      if (*p == ',')
575
        {
576
          p++;
577
 
578
          /* Skip whitespace */
579
          while (*p == ' ' || *p == '\t')
580
            p++;
581
          sregp = p;
582
          input_line_pointer = sregp;
583
          c = get_symbol_end ();
584
          sregend = input_line_pointer;
585
        }
586
    }
587
  else
588
    {
589
      expp_sreg = &exp[0];
590
      expp_reg = &exp[1];
591
 
592
      sregp = p;
593
      c = get_symbol_end ();
594
      sregend = p = input_line_pointer;
595
      *p = c;
596
 
597
      /* Skip whitespace */
598
      while (*p == ' ' || *p == '\t')
599
        p++;
600
 
601
      if (*p == ',')
602
        {
603
          p++;
604
 
605
          /* Skip whitespace */
606
          while (*p == ' ' || *p == '\t')
607
            p++;
608
 
609
          input_line_pointer = p;
610
          expression (expp_reg);
611
        }
612
      *sregend = 0;
613
    }
614
 
615
  regno = get_spec_regno (sregp);
616
  *sregend = c;
617
 
618
  /* Let the caller issue errors; we've made sure the operands are
619
     invalid.  */
620
  if (expp_reg->X_op != O_illegal
621
      && expp_reg->X_op != O_absent
622
      && regno != -1)
623
    {
624
      expp_sreg->X_op = O_register;
625
      expp_sreg->X_add_number = regno + 256;
626
    }
627
 
628
  return 2;
629
}
630
 
631
/* Handle MMIX-specific option.  */
632
 
633
int
634
md_parse_option (int c, char *arg ATTRIBUTE_UNUSED)
635
{
636
  switch (c)
637
    {
638
    case 'x':
639
      warn_on_expansion = 0;
640
      allocate_undefined_gregs_in_linker = 1;
641
      break;
642
 
643
    case OPTION_RELAX:
644
      linkrelax = 1;
645
      break;
646
 
647
    case OPTION_NOEXPAND:
648
      expand_op = 0;
649
      break;
650
 
651
    case OPTION_NOMERGEGREG:
652
      merge_gregs = 0;
653
      break;
654
 
655
    case OPTION_NOSYMS:
656
      predefined_syms = 0;
657
      equated_spec_regs = 0;
658
      break;
659
 
660
    case OPTION_GNU_SYNTAX:
661
      mmix_gnu_syntax = 1;
662
      label_without_colon_this_line = 0;
663
      break;
664
 
665
    case OPTION_GLOBALIZE_SYMBOLS:
666
      mmix_globalize_symbols = 1;
667
      break;
668
 
669
    case OPTION_FIXED_SPEC_REGS:
670
      equated_spec_regs = 0;
671
      break;
672
 
673
    case OPTION_LINKER_ALLOCATED_GREGS:
674
      allocate_undefined_gregs_in_linker = 1;
675
      break;
676
 
677
    case OPTION_NOPUSHJSTUBS:
678
      pushj_stubs = 0;
679
      break;
680
 
681
    default:
682
      return 0;
683
    }
684
 
685
  return 1;
686
}
687
 
688
/* Display MMIX-specific help text.  */
689
 
690
void
691
md_show_usage (FILE * stream)
692
{
693
  fprintf (stream, _(" MMIX-specific command line options:\n"));
694
  fprintf (stream, _("\
695
  -fixed-special-register-names\n\
696
                          Allow only the original special register names.\n"));
697
  fprintf (stream, _("\
698
  -globalize-symbols      Make all symbols global.\n"));
699
  fprintf (stream, _("\
700
  -gnu-syntax             Turn off mmixal syntax compatibility.\n"));
701
  fprintf (stream, _("\
702
  -relax                  Create linker relaxable code.\n"));
703
  fprintf (stream, _("\
704
  -no-predefined-syms     Do not provide mmixal built-in constants.\n\
705
                          Implies -fixed-special-register-names.\n"));
706
  fprintf (stream, _("\
707
  -no-expand              Do not expand GETA, branches, PUSHJ or JUMP\n\
708
                          into multiple instructions.\n"));
709
  fprintf (stream, _("\
710
  -no-merge-gregs         Do not merge GREG definitions with nearby values.\n"));
711
  fprintf (stream, _("\
712
  -linker-allocated-gregs If there's no suitable GREG definition for the\
713
                          operands of an instruction, let the linker resolve.\n"));
714
  fprintf (stream, _("\
715
  -x                      Do not warn when an operand to GETA, a branch,\n\
716
                          PUSHJ or JUMP is not known to be within range.\n\
717
                          The linker will catch any errors.  Implies\n\
718
                          -linker-allocated-gregs."));
719
}
720
 
721
/* Step to end of line, but don't step over the end of the line.  */
722
 
723
static void
724
mmix_discard_rest_of_line (void)
725
{
726
  while (*input_line_pointer
727
         && (! is_end_of_line[(unsigned char) *input_line_pointer]
728
             || TC_EOL_IN_INSN (input_line_pointer)))
729
    input_line_pointer++;
730
}
731
 
732
/* Act as demand_empty_rest_of_line if we're in strict GNU syntax mode,
733
   otherwise just ignore the rest of the line (and skip the end-of-line
734
   delimiter).  */
735
 
736
static void
737
mmix_handle_rest_of_empty_line (void)
738
{
739
  if (mmix_gnu_syntax)
740
    demand_empty_rest_of_line ();
741
  else
742
    {
743
      mmix_discard_rest_of_line ();
744
      input_line_pointer++;
745
    }
746
}
747
 
748
/* Initialize GAS MMIX specifics.  */
749
 
750
void
751
mmix_md_begin (void)
752
{
753
  int i;
754
  const struct mmix_opcode *opcode;
755
 
756
  /* We assume nobody will use this, so don't allocate any room.  */
757
  obstack_begin (&mmix_sym_obstack, 0);
758
 
759
  /* This will break the day the "lex" thingy changes.  For now, it's the
760
     only way to make ':' part of a name, and a name beginner.  */
761
  lex_type[':'] = (LEX_NAME | LEX_BEGIN_NAME);
762
 
763
  mmix_opcode_hash = hash_new ();
764
 
765
  real_reg_section
766
    = bfd_make_section_old_way (stdoutput, MMIX_REG_SECTION_NAME);
767
 
768
  for (opcode = mmix_opcodes; opcode->name; opcode++)
769
    hash_insert (mmix_opcode_hash, opcode->name, (char *) opcode);
770
 
771
  /* We always insert the ordinary registers 0..255 as registers.  */
772
  for (i = 0; i < 256; i++)
773
    {
774
      char buf[5];
775
 
776
      /* Alternatively, we could diddle with '$' and the following number,
777
         but keeping the registers as symbols helps keep parsing simple.  */
778
      sprintf (buf, "$%d", i);
779
      symbol_table_insert (symbol_new (buf, reg_section, i,
780
                                       &zero_address_frag));
781
    }
782
 
783
  /* Insert mmixal built-in names if allowed.  */
784
  if (predefined_syms)
785
    {
786
      for (i = 0; mmix_spec_regs[i].name != NULL; i++)
787
        symbol_table_insert (symbol_new (mmix_spec_regs[i].name,
788
                                         reg_section,
789
                                         mmix_spec_regs[i].number + 256,
790
                                         &zero_address_frag));
791
 
792
      /* FIXME: Perhaps these should be recognized as specials; as field
793
         names for those instructions.  */
794
      symbol_table_insert (symbol_new ("ROUND_CURRENT", reg_section, 512,
795
                                       &zero_address_frag));
796
      symbol_table_insert (symbol_new ("ROUND_OFF", reg_section, 512 + 1,
797
                                       &zero_address_frag));
798
      symbol_table_insert (symbol_new ("ROUND_UP", reg_section, 512 + 2,
799
                                       &zero_address_frag));
800
      symbol_table_insert (symbol_new ("ROUND_DOWN", reg_section, 512 + 3,
801
                                       &zero_address_frag));
802
      symbol_table_insert (symbol_new ("ROUND_NEAR", reg_section, 512 + 4,
803
                                       &zero_address_frag));
804
    }
805
}
806
 
807
/* Assemble one insn in STR.  */
808
 
809
void
810
md_assemble (char *str)
811
{
812
  char *operands = str;
813
  char modified_char = 0;
814
  struct mmix_opcode *instruction;
815
  fragS *opc_fragP = NULL;
816
  int max_operands = 3;
817
 
818
  /* Note that the struct frag member fr_literal in frags.h is char[], so
819
     I have to make this a plain char *.  */
820
  /* unsigned */ char *opcodep = NULL;
821
 
822
  expressionS exp[4];
823
  int n_operands = 0;
824
 
825
  /* Move to end of opcode.  */
826
  for (operands = str;
827
       is_part_of_name (*operands);
828
       ++operands)
829
    ;
830
 
831
  if (ISSPACE (*operands))
832
    {
833
      modified_char = *operands;
834
      *operands++ = '\0';
835
    }
836
 
837
  instruction = (struct mmix_opcode *) hash_find (mmix_opcode_hash, str);
838
  if (instruction == NULL)
839
    {
840
      as_bad (_("unknown opcode: `%s'"), str);
841
 
842
      /* Avoid "unhandled label" errors.  */
843
      pending_label = NULL;
844
      return;
845
    }
846
 
847
  /* Put back the character after the opcode.  */
848
  if (modified_char != 0)
849
    operands[-1] = modified_char;
850
 
851
  input_line_pointer = operands;
852
 
853
  /* Is this a mmixal pseudodirective?  */
854
  if (instruction->type == mmix_type_pseudo)
855
    {
856
      /* For mmixal compatibility, a label for an instruction (and
857
         emitting pseudo) refers to the _aligned_ address.  We emit the
858
         label here for the pseudos that don't handle it themselves.  When
859
         having an fb-label, emit it here, and increment the counter after
860
         the pseudo.  */
861
      switch (instruction->operands)
862
        {
863
        case mmix_operands_loc:
864
        case mmix_operands_byte:
865
        case mmix_operands_prefix:
866
        case mmix_operands_local:
867
        case mmix_operands_bspec:
868
        case mmix_operands_espec:
869
          if (current_fb_label >= 0)
870
            colon (fb_label_name (current_fb_label, 1));
871
          else if (pending_label != NULL)
872
            {
873
              colon (pending_label);
874
              pending_label = NULL;
875
            }
876
          break;
877
 
878
        default:
879
          break;
880
        }
881
 
882
      /* Some of the pseudos emit contents, others don't.  Set a
883
         contents-emitted flag when we emit something into .text   */
884
      switch (instruction->operands)
885
        {
886
        case mmix_operands_loc:
887
          /* LOC */
888
          s_loc (0);
889
          break;
890
 
891
        case mmix_operands_byte:
892
          /* BYTE */
893
          mmix_byte ();
894
          break;
895
 
896
        case mmix_operands_wyde:
897
          /* WYDE */
898
          mmix_cons (2);
899
          break;
900
 
901
        case mmix_operands_tetra:
902
          /* TETRA */
903
          mmix_cons (4);
904
          break;
905
 
906
        case mmix_operands_octa:
907
          /* OCTA */
908
          mmix_cons (8);
909
          break;
910
 
911
        case mmix_operands_prefix:
912
          /* PREFIX */
913
          s_prefix (0);
914
          break;
915
 
916
        case mmix_operands_local:
917
          /* LOCAL */
918
          mmix_s_local (0);
919
          break;
920
 
921
        case mmix_operands_bspec:
922
          /* BSPEC */
923
          s_bspec (0);
924
          break;
925
 
926
        case mmix_operands_espec:
927
          /* ESPEC */
928
          s_espec (0);
929
          break;
930
 
931
        default:
932
          BAD_CASE (instruction->operands);
933
        }
934
 
935
      /* These are all working like the pseudo functions in read.c:s_...,
936
         in that they step over the end-of-line marker at the end of the
937
         line.  We don't want that here.  */
938
      input_line_pointer--;
939
 
940
      /* Step up the fb-label counter if there was a definition on this
941
         line.  */
942
      if (current_fb_label >= 0)
943
        {
944
          fb_label_instance_inc (current_fb_label);
945
          current_fb_label = -1;
946
        }
947
 
948
      /* Reset any don't-align-next-datum request, unless this was a LOC
949
         directive.  */
950
      if (instruction->operands != mmix_operands_loc)
951
        want_unaligned = 0;
952
 
953
      return;
954
    }
955
 
956
  /* Not a pseudo; we *will* emit contents.  */
957
  if (now_seg == data_section)
958
    {
959
      if (lowest_data_loc != (bfd_vma) -1 && (lowest_data_loc & 3) != 0)
960
        {
961
          if (data_has_contents)
962
            as_bad (_("specified location wasn't TETRA-aligned"));
963
          else if (want_unaligned)
964
            as_bad (_("unaligned data at an absolute location is not supported"));
965
 
966
          lowest_data_loc &= ~(bfd_vma) 3;
967
          lowest_data_loc += 4;
968
        }
969
 
970
      data_has_contents = 1;
971
    }
972
  else if (now_seg == text_section)
973
    {
974
      if (lowest_text_loc != (bfd_vma) -1 && (lowest_text_loc & 3) != 0)
975
        {
976
          if (text_has_contents)
977
            as_bad (_("specified location wasn't TETRA-aligned"));
978
          else if (want_unaligned)
979
            as_bad (_("unaligned data at an absolute location is not supported"));
980
 
981
          lowest_text_loc &= ~(bfd_vma) 3;
982
          lowest_text_loc += 4;
983
        }
984
 
985
      text_has_contents = 1;
986
    }
987
 
988
  /* After a sequence of BYTEs or WYDEs, we need to get to instruction
989
     alignment.  For other pseudos, a ".p2align 2" is supposed to be
990
     inserted by the user.  */
991
  if (last_alignment < 2 && ! want_unaligned)
992
    {
993
      frag_align (2, 0, 0);
994
      record_alignment (now_seg, 2);
995
      last_alignment = 2;
996
    }
997
  else
998
    /* Reset any don't-align-next-datum request.  */
999
    want_unaligned = 0;
1000
 
1001
  /* For mmixal compatibility, a label for an instruction (and emitting
1002
     pseudo) refers to the _aligned_ address.  So we have to emit the
1003
     label here.  */
1004
  if (pending_label != NULL)
1005
    {
1006
      colon (pending_label);
1007
      pending_label = NULL;
1008
    }
1009
 
1010
  /* We assume that mmix_opcodes keeps having unique mnemonics for each
1011
     opcode, so we don't have to iterate over more than one opcode; if the
1012
     syntax does not match, then there's a syntax error.  */
1013
 
1014
  /* Operands have little or no context and are all comma-separated; it is
1015
     easier to parse each expression first.   */
1016
  switch (instruction->operands)
1017
    {
1018
    case mmix_operands_reg_yz:
1019
    case mmix_operands_pop:
1020
    case mmix_operands_regaddr:
1021
    case mmix_operands_pushj:
1022
    case mmix_operands_get:
1023
    case mmix_operands_put:
1024
    case mmix_operands_set:
1025
    case mmix_operands_save:
1026
    case mmix_operands_unsave:
1027
      max_operands = 2;
1028
      break;
1029
 
1030
    case mmix_operands_sync:
1031
    case mmix_operands_jmp:
1032
    case mmix_operands_resume:
1033
      max_operands = 1;
1034
      break;
1035
 
1036
      /* The original 3 is fine for the rest.  */
1037
    default:
1038
      break;
1039
    }
1040
 
1041
  /* If this is GET or PUT, and we don't do allow those names to be
1042
     equated, we need to parse the names ourselves, so we don't pick up a
1043
     user label instead of the special register.  */
1044
  if (! equated_spec_regs
1045
      && (instruction->operands == mmix_operands_get
1046
          || instruction->operands == mmix_operands_put))
1047
    n_operands = get_putget_operands (instruction, operands, exp);
1048
  else
1049
    n_operands = get_operands (max_operands, operands, exp);
1050
 
1051
  /* If there's a fb-label on the current line, set that label.  This must
1052
     be done *after* evaluating expressions of operands, since neither a
1053
     "1B" nor a "1F" refers to "1H" on the same line.  */
1054
  if (current_fb_label >= 0)
1055
    {
1056
      fb_label_instance_inc (current_fb_label);
1057
      colon (fb_label_name (current_fb_label, 0));
1058
      current_fb_label = -1;
1059
    }
1060
 
1061
  /* We also assume that the length of the instruction is at least 4, the
1062
     size of an unexpanded instruction.  We need a self-contained frag
1063
     since we want the relocation to point to the instruction, not the
1064
     variant part.  */
1065
 
1066
  opcodep = frag_more (4);
1067
  mmix_opcode_frag = opc_fragP = frag_now;
1068
  frag_now->fr_opcode = opcodep;
1069
 
1070
  /* Mark start of insn for DWARF2 debug features.  */
1071
  if (OUTPUT_FLAVOR == bfd_target_elf_flavour)
1072
    dwarf2_emit_insn (4);
1073
 
1074
  md_number_to_chars (opcodep, instruction->match, 4);
1075
 
1076
  switch (instruction->operands)
1077
    {
1078
    case mmix_operands_jmp:
1079
      if (n_operands == 0 && ! mmix_gnu_syntax)
1080
        /* Zeros are in place - nothing needs to be done when we have no
1081
           operands.  */
1082
        break;
1083
 
1084
      /* Add a frag for a JMP relaxation; we need room for max four
1085
         extra instructions.  We don't do any work around here to check if
1086
         we can determine the offset right away.  */
1087
      if (n_operands != 1 || exp[0].X_op == O_register)
1088
        {
1089
          as_bad (_("invalid operand to opcode %s: `%s'"),
1090
                  instruction->name, operands);
1091
          return;
1092
        }
1093
 
1094
      if (expand_op)
1095
        frag_var (rs_machine_dependent, 4 * 4, 0,
1096
                  ENCODE_RELAX (STATE_JMP, STATE_UNDF),
1097
                  exp[0].X_add_symbol,
1098
                  exp[0].X_add_number,
1099
                  opcodep);
1100
      else
1101
        fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal, 4,
1102
                     exp + 0, 1, BFD_RELOC_MMIX_ADDR27);
1103
      break;
1104
 
1105
    case mmix_operands_pushj:
1106
      /* We take care of PUSHJ in full here.  */
1107
      if (n_operands != 2
1108
          || ((exp[0].X_op == O_constant || exp[0].X_op == O_register)
1109
              && (exp[0].X_add_number > 255 || exp[0].X_add_number < 0)))
1110
        {
1111
          as_bad (_("invalid operands to opcode %s: `%s'"),
1112
                  instruction->name, operands);
1113
          return;
1114
        }
1115
 
1116
      if (exp[0].X_op == O_register || exp[0].X_op == O_constant)
1117
        opcodep[1] = exp[0].X_add_number;
1118
      else
1119
        fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 1,
1120
                     1, exp + 0, 0, BFD_RELOC_MMIX_REG_OR_BYTE);
1121
 
1122
      if (expand_op)
1123
        frag_var (rs_machine_dependent, PUSHJ_MAX_LEN - 4, 0,
1124
                  ENCODE_RELAX (STATE_PUSHJ, STATE_UNDF),
1125
                  exp[1].X_add_symbol,
1126
                  exp[1].X_add_number,
1127
                  opcodep);
1128
      else
1129
        fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal, 4,
1130
                     exp + 1, 1, BFD_RELOC_MMIX_ADDR19);
1131
      break;
1132
 
1133
    case mmix_operands_regaddr:
1134
      /* GETA/branch: Add a frag for relaxation.  We don't do any work
1135
         around here to check if we can determine the offset right away.  */
1136
      if (n_operands != 2 || exp[1].X_op == O_register)
1137
        {
1138
          as_bad (_("invalid operands to opcode %s: `%s'"),
1139
                  instruction->name, operands);
1140
          return;
1141
        }
1142
 
1143
      if (! expand_op)
1144
        fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal, 4,
1145
                     exp + 1, 1, BFD_RELOC_MMIX_ADDR19);
1146
      else if (instruction->type == mmix_type_condbranch)
1147
        frag_var (rs_machine_dependent, BCC_MAX_LEN - 4, 0,
1148
                  ENCODE_RELAX (STATE_BCC, STATE_UNDF),
1149
                  exp[1].X_add_symbol,
1150
                  exp[1].X_add_number,
1151
                  opcodep);
1152
      else
1153
        frag_var (rs_machine_dependent, GETA_MAX_LEN - 4, 0,
1154
                  ENCODE_RELAX (STATE_GETA, STATE_UNDF),
1155
                  exp[1].X_add_symbol,
1156
                  exp[1].X_add_number,
1157
                  opcodep);
1158
      break;
1159
 
1160
    default:
1161
      break;
1162
    }
1163
 
1164
  switch (instruction->operands)
1165
    {
1166
    case mmix_operands_regs:
1167
      /* We check the number of operands here, since we're in a
1168
         FALLTHROUGH sequence in the next switch.  */
1169
      if (n_operands != 3 || exp[2].X_op == O_constant)
1170
        {
1171
          as_bad (_("invalid operands to opcode %s: `%s'"),
1172
                  instruction->name, operands);
1173
          return;
1174
        }
1175
      /* FALLTHROUGH.  */
1176
    case mmix_operands_regs_z:
1177
      if (n_operands != 3)
1178
        {
1179
          as_bad (_("invalid operands to opcode %s: `%s'"),
1180
                  instruction->name, operands);
1181
          return;
1182
        }
1183
      /* FALLTHROUGH.  */
1184
    case mmix_operands_reg_yz:
1185
    case mmix_operands_roundregs_z:
1186
    case mmix_operands_roundregs:
1187
    case mmix_operands_regs_z_opt:
1188
    case mmix_operands_neg:
1189
    case mmix_operands_regaddr:
1190
    case mmix_operands_get:
1191
    case mmix_operands_set:
1192
    case mmix_operands_save:
1193
      if (n_operands < 1
1194
          || (exp[0].X_op == O_register && exp[0].X_add_number > 255))
1195
        {
1196
          as_bad (_("invalid operands to opcode %s: `%s'"),
1197
                  instruction->name, operands);
1198
          return;
1199
        }
1200
 
1201
      if (exp[0].X_op == O_register)
1202
        opcodep[1] = exp[0].X_add_number;
1203
      else
1204
        fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 1,
1205
                     1, exp + 0, 0, BFD_RELOC_MMIX_REG);
1206
      break;
1207
 
1208
    default:
1209
      ;
1210
    }
1211
 
1212
  /* A corresponding once-over for those who take an 8-bit constant as
1213
     their first operand.  */
1214
  switch (instruction->operands)
1215
    {
1216
    case mmix_operands_pushgo:
1217
      /* PUSHGO: X is a constant, but can be expressed as a register.
1218
         We handle X here and use the common machinery of T,X,3,$ for
1219
         the rest of the operands.  */
1220
      if (n_operands < 2
1221
          || ((exp[0].X_op == O_constant || exp[0].X_op == O_register)
1222
              && (exp[0].X_add_number > 255 || exp[0].X_add_number < 0)))
1223
        {
1224
          as_bad (_("invalid operands to opcode %s: `%s'"),
1225
                  instruction->name, operands);
1226
          return;
1227
        }
1228
      else if (exp[0].X_op == O_constant || exp[0].X_op == O_register)
1229
        opcodep[1] = exp[0].X_add_number;
1230
      else
1231
        fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 1,
1232
                     1, exp + 0, 0, BFD_RELOC_MMIX_REG_OR_BYTE);
1233
      break;
1234
 
1235
    case mmix_operands_pop:
1236
      if ((n_operands == 0 || n_operands == 1) && ! mmix_gnu_syntax)
1237
        break;
1238
      /* FALLTHROUGH.  */
1239
    case mmix_operands_x_regs_z:
1240
      if (n_operands < 1
1241
          || (exp[0].X_op == O_constant
1242
              && (exp[0].X_add_number > 255
1243
                  || exp[0].X_add_number < 0)))
1244
        {
1245
          as_bad (_("invalid operands to opcode %s: `%s'"),
1246
                  instruction->name, operands);
1247
          return;
1248
        }
1249
 
1250
      if (exp[0].X_op == O_constant)
1251
        opcodep[1] = exp[0].X_add_number;
1252
      else
1253
        /* FIXME: This doesn't bring us unsignedness checking.  */
1254
        fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 1,
1255
                     1, exp + 0, 0, BFD_RELOC_8);
1256
    default:
1257
      ;
1258
    }
1259
 
1260
  /* Handle the rest.  */
1261
  switch (instruction->operands)
1262
    {
1263
    case mmix_operands_set:
1264
      /* SET: Either two registers, "$X,$Y", with Z field as zero, or
1265
         "$X,YZ", meaning change the opcode to SETL.  */
1266
      if (n_operands != 2
1267
          || (exp[1].X_op == O_constant
1268
              && (exp[1].X_add_number > 0xffff || exp[1].X_add_number < 0)))
1269
        {
1270
          as_bad (_("invalid operands to opcode %s: `%s'"),
1271
                  instruction->name, operands);
1272
          return;
1273
        }
1274
 
1275
      if (exp[1].X_op == O_constant)
1276
        {
1277
          /* There's an ambiguity with "SET $0,Y" when Y isn't defined
1278
             yet.  To keep things simple, we assume that Y is then a
1279
             register, and only change the opcode if Y is defined at this
1280
             point.
1281
 
1282
             There's no compatibility problem with mmixal, since it emits
1283
             errors if the field is not defined at this point.  */
1284
          md_number_to_chars (opcodep, SETL_INSN_BYTE, 1);
1285
 
1286
          opcodep[2] = (exp[1].X_add_number >> 8) & 255;
1287
          opcodep[3] = exp[1].X_add_number & 255;
1288
          break;
1289
        }
1290
      /* FALLTHROUGH.  */
1291
    case mmix_operands_x_regs_z:
1292
      /* SYNCD: "X,$Y,$Z|Z".  */
1293
      /* FALLTHROUGH.  */
1294
    case mmix_operands_regs:
1295
      /* Three registers, $X,$Y,$Z.  */
1296
      /* FALLTHROUGH.  */
1297
    case mmix_operands_regs_z:
1298
      /* Operands "$X,$Y,$Z|Z", number of arguments checked above.  */
1299
      /* FALLTHROUGH.  */
1300
    case mmix_operands_pushgo:
1301
      /* Operands "$X|X,$Y,$Z|Z", optional Z.  */
1302
      /* FALLTHROUGH.  */
1303
    case mmix_operands_regs_z_opt:
1304
      /* Operands "$X,$Y,$Z|Z", with $Z|Z being optional, default 0.  Any
1305
         operands not completely decided yet are postponed to later in
1306
         assembly (but not until link-time yet).  */
1307
 
1308
      if ((n_operands != 2 && n_operands != 3)
1309
          || (exp[1].X_op == O_register && exp[1].X_add_number > 255)
1310
          || (n_operands == 3
1311
              && ((exp[2].X_op == O_register
1312
                   && exp[2].X_add_number > 255
1313
                   && mmix_gnu_syntax)
1314
                  || (exp[2].X_op == O_constant
1315
                      && (exp[2].X_add_number > 255
1316
                          || exp[2].X_add_number < 0)))))
1317
        {
1318
          as_bad (_("invalid operands to opcode %s: `%s'"),
1319
                  instruction->name, operands);
1320
          return;
1321
        }
1322
 
1323
      if (n_operands == 2)
1324
        {
1325
          symbolS *sym;
1326
 
1327
          /* The last operand is immediate whenever we see just two
1328
             operands.  */
1329
          opcodep[0] |= IMM_OFFSET_BIT;
1330
 
1331
          /* Now, we could either have an implied "0" as the Z operand, or
1332
             it could be the constant of a "base address plus offset".  It
1333
             depends on whether it is allowed; only memory operations, as
1334
             signified by instruction->type and "T" and "X" operand types,
1335
             and it depends on whether we find a register in the second
1336
             operand, exp[1].  */
1337
          if (exp[1].X_op == O_register && exp[1].X_add_number <= 255)
1338
            {
1339
              /* A zero then; all done.  */
1340
              opcodep[2] = exp[1].X_add_number;
1341
              break;
1342
            }
1343
 
1344
          /* Not known as a register.  Is base address plus offset
1345
             allowed, or can we assume that it is a register anyway?  */
1346
          if ((instruction->operands != mmix_operands_regs_z_opt
1347
               && instruction->operands != mmix_operands_x_regs_z
1348
               && instruction->operands != mmix_operands_pushgo)
1349
              || (instruction->type != mmix_type_memaccess_octa
1350
                  && instruction->type != mmix_type_memaccess_tetra
1351
                  && instruction->type != mmix_type_memaccess_wyde
1352
                  && instruction->type != mmix_type_memaccess_byte
1353
                  && instruction->type != mmix_type_memaccess_block
1354
                  && instruction->type != mmix_type_jsr
1355
                  && instruction->type != mmix_type_branch))
1356
            {
1357
              fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 2,
1358
                           1, exp + 1, 0, BFD_RELOC_MMIX_REG);
1359
              break;
1360
            }
1361
 
1362
          /* To avoid getting a NULL add_symbol for constants and then
1363
             catching a SEGV in write_relocs since it doesn't handle
1364
             constants well for relocs other than PC-relative, we need to
1365
             pass expressions as symbols and use fix_new, not fix_new_exp.  */
1366
          sym = make_expr_symbol (exp + 1);
1367
 
1368
          /* Mark the symbol as being OK for a reloc.  */
1369
          symbol_get_bfdsym (sym)->flags |= BSF_KEEP;
1370
 
1371
          /* Now we know it can be a "base address plus offset".  Add
1372
             proper fixup types so we can handle this later, when we've
1373
             parsed everything.  */
1374
          fix_new (opc_fragP, opcodep - opc_fragP->fr_literal + 2,
1375
                   8, sym, 0, 0, BFD_RELOC_MMIX_BASE_PLUS_OFFSET);
1376
          break;
1377
        }
1378
 
1379
      if (exp[1].X_op == O_register)
1380
        opcodep[2] = exp[1].X_add_number;
1381
      else
1382
        fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 2,
1383
                     1, exp + 1, 0, BFD_RELOC_MMIX_REG);
1384
 
1385
      /* In mmixal compatibility mode, we allow special registers as
1386
         constants for the Z operand.  They have 256 added to their
1387
         register numbers, so the right thing will happen if we just treat
1388
         those as constants.  */
1389
      if (exp[2].X_op == O_register && exp[2].X_add_number <= 255)
1390
        opcodep[3] = exp[2].X_add_number;
1391
      else if (exp[2].X_op == O_constant
1392
               || (exp[2].X_op == O_register && exp[2].X_add_number > 255))
1393
        {
1394
          opcodep[3] = exp[2].X_add_number;
1395
          opcodep[0] |= IMM_OFFSET_BIT;
1396
        }
1397
      else
1398
        fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 3,
1399
                     1, exp + 2, 0,
1400
                     (instruction->operands == mmix_operands_set
1401
                      || instruction->operands == mmix_operands_regs)
1402
                     ? BFD_RELOC_MMIX_REG : BFD_RELOC_MMIX_REG_OR_BYTE);
1403
      break;
1404
 
1405
    case mmix_operands_pop:
1406
      /* POP, one eight and one 16-bit operand.  */
1407
      if (n_operands == 0 && ! mmix_gnu_syntax)
1408
        break;
1409
      if (n_operands == 1 && ! mmix_gnu_syntax)
1410
        goto a_single_24_bit_number_operand;
1411
      /* FALLTHROUGH.  */
1412
    case mmix_operands_reg_yz:
1413
      /* A register and a 16-bit unsigned number.  */
1414
      if (n_operands != 2
1415
          || exp[1].X_op == O_register
1416
          || (exp[1].X_op == O_constant
1417
              && (exp[1].X_add_number > 0xffff || exp[1].X_add_number < 0)))
1418
        {
1419
          as_bad (_("invalid operands to opcode %s: `%s'"),
1420
                  instruction->name, operands);
1421
          return;
1422
        }
1423
 
1424
      if (exp[1].X_op == O_constant)
1425
        {
1426
          opcodep[2] = (exp[1].X_add_number >> 8) & 255;
1427
          opcodep[3] = exp[1].X_add_number & 255;
1428
        }
1429
      else
1430
        /* FIXME: This doesn't bring us unsignedness checking.  */
1431
        fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 2,
1432
                     2, exp + 1, 0, BFD_RELOC_16);
1433
      break;
1434
 
1435
    case mmix_operands_jmp:
1436
      /* A JMP.  Everything is already done.  */
1437
      break;
1438
 
1439
    case mmix_operands_roundregs:
1440
      /* Two registers with optional rounding mode or constant in between.  */
1441
      if ((n_operands == 3 && exp[2].X_op == O_constant)
1442
          || (n_operands == 2 && exp[1].X_op == O_constant))
1443
        {
1444
          as_bad (_("invalid operands to opcode %s: `%s'"),
1445
                  instruction->name, operands);
1446
          return;
1447
        }
1448
      /* FALLTHROUGH.  */
1449
    case mmix_operands_roundregs_z:
1450
      /* Like FLOT, "$X,ROUND_MODE,$Z|Z", but the rounding mode is
1451
         optional and can be the corresponding constant.  */
1452
      {
1453
        /* Which exp index holds the second operand (not the rounding
1454
           mode).  */
1455
        int op2no = n_operands - 1;
1456
 
1457
        if ((n_operands != 2 && n_operands != 3)
1458
            || ((exp[op2no].X_op == O_register
1459
                 && exp[op2no].X_add_number > 255)
1460
                || (exp[op2no].X_op == O_constant
1461
                    && (exp[op2no].X_add_number > 255
1462
                        || exp[op2no].X_add_number < 0)))
1463
            || (n_operands == 3
1464
                /* We don't allow for the rounding mode to be deferred; it
1465
                   must be determined in the "first pass".  It cannot be a
1466
                   symbol equated to a rounding mode, but defined after
1467
                   the first use.  */
1468
                && ((exp[1].X_op == O_register
1469
                     && exp[1].X_add_number < 512)
1470
                    || (exp[1].X_op == O_constant
1471
                        && exp[1].X_add_number < 0
1472
                        && exp[1].X_add_number > 4)
1473
                    || (exp[1].X_op != O_register
1474
                        && exp[1].X_op != O_constant))))
1475
          {
1476
            as_bad (_("invalid operands to opcode %s: `%s'"),
1477
                    instruction->name, operands);
1478
            return;
1479
          }
1480
 
1481
        /* Add rounding mode if present.  */
1482
        if (n_operands == 3)
1483
          opcodep[2] = exp[1].X_add_number & 255;
1484
 
1485
        if (exp[op2no].X_op == O_register)
1486
          opcodep[3] = exp[op2no].X_add_number;
1487
        else if (exp[op2no].X_op == O_constant)
1488
          {
1489
            opcodep[3] = exp[op2no].X_add_number;
1490
            opcodep[0] |= IMM_OFFSET_BIT;
1491
          }
1492
        else
1493
          fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 3,
1494
                       1, exp + op2no, 0,
1495
                       instruction->operands == mmix_operands_roundregs
1496
                       ? BFD_RELOC_MMIX_REG
1497
                       : BFD_RELOC_MMIX_REG_OR_BYTE);
1498
        break;
1499
      }
1500
 
1501
    case mmix_operands_sync:
1502
    a_single_24_bit_number_operand:
1503
      if (n_operands != 1
1504
          || exp[0].X_op == O_register
1505
          || (exp[0].X_op == O_constant
1506
              && (exp[0].X_add_number > 0xffffff || exp[0].X_add_number < 0)))
1507
        {
1508
          as_bad (_("invalid operands to opcode %s: `%s'"),
1509
                  instruction->name, operands);
1510
          return;
1511
        }
1512
 
1513
      if (exp[0].X_op == O_constant)
1514
        {
1515
          opcodep[1] = (exp[0].X_add_number >> 16) & 255;
1516
          opcodep[2] = (exp[0].X_add_number >> 8) & 255;
1517
          opcodep[3] = exp[0].X_add_number & 255;
1518
        }
1519
      else
1520
        /* FIXME: This doesn't bring us unsignedness checking.  */
1521
        fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 1,
1522
                     3, exp + 0, 0, BFD_RELOC_24);
1523
      break;
1524
 
1525
    case mmix_operands_neg:
1526
      /* Operands "$X,Y,$Z|Z"; NEG or NEGU.  Y is optional, 0 is default.  */
1527
 
1528
      if ((n_operands != 3 && n_operands != 2)
1529
          || (n_operands == 3 && exp[1].X_op == O_register)
1530
          || ((exp[1].X_op == O_constant || exp[1].X_op == O_register)
1531
              && (exp[1].X_add_number > 255 || exp[1].X_add_number < 0))
1532
          || (n_operands == 3
1533
              && ((exp[2].X_op == O_register && exp[2].X_add_number > 255)
1534
                  || (exp[2].X_op == O_constant
1535
                      && (exp[2].X_add_number > 255
1536
                          || exp[2].X_add_number < 0)))))
1537
        {
1538
          as_bad (_("invalid operands to opcode %s: `%s'"),
1539
                  instruction->name, operands);
1540
          return;
1541
        }
1542
 
1543
      if (n_operands == 2)
1544
        {
1545
          if (exp[1].X_op == O_register)
1546
            opcodep[3] = exp[1].X_add_number;
1547
          else if (exp[1].X_op == O_constant)
1548
            {
1549
              opcodep[3] = exp[1].X_add_number;
1550
              opcodep[0] |= IMM_OFFSET_BIT;
1551
            }
1552
          else
1553
            fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 3,
1554
                         1, exp + 1, 0, BFD_RELOC_MMIX_REG_OR_BYTE);
1555
          break;
1556
        }
1557
 
1558
      if (exp[1].X_op == O_constant)
1559
        opcodep[2] = exp[1].X_add_number;
1560
      else
1561
        fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 2,
1562
                     1, exp + 1, 0, BFD_RELOC_8);
1563
 
1564
      if (exp[2].X_op == O_register)
1565
        opcodep[3] = exp[2].X_add_number;
1566
      else if (exp[2].X_op == O_constant)
1567
        {
1568
          opcodep[3] = exp[2].X_add_number;
1569
          opcodep[0] |= IMM_OFFSET_BIT;
1570
        }
1571
      else
1572
        fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 3,
1573
                     1, exp + 2, 0, BFD_RELOC_MMIX_REG_OR_BYTE);
1574
      break;
1575
 
1576
    case mmix_operands_regaddr:
1577
      /* A GETA/branch-type.  */
1578
      break;
1579
 
1580
    case mmix_operands_get:
1581
      /* "$X,spec_reg"; GET.
1582
         Like with rounding modes, we demand that the special register or
1583
         symbol is already defined when we get here at the point of use.  */
1584
      if (n_operands != 2
1585
          || (exp[1].X_op == O_register
1586
              && (exp[1].X_add_number < 256 || exp[1].X_add_number >= 512))
1587
          || (exp[1].X_op == O_constant
1588
              && (exp[1].X_add_number < 0 || exp[1].X_add_number > 256))
1589
          || (exp[1].X_op != O_constant && exp[1].X_op != O_register))
1590
        {
1591
          as_bad (_("invalid operands to opcode %s: `%s'"),
1592
                  instruction->name, operands);
1593
          return;
1594
        }
1595
 
1596
      opcodep[3] = exp[1].X_add_number - 256;
1597
      break;
1598
 
1599
    case mmix_operands_put:
1600
      /* "spec_reg,$Z|Z"; PUT.  */
1601
      if (n_operands != 2
1602
          || (exp[0].X_op == O_register
1603
              && (exp[0].X_add_number < 256 || exp[0].X_add_number >= 512))
1604
          || (exp[0].X_op == O_constant
1605
              && (exp[0].X_add_number < 0 || exp[0].X_add_number > 256))
1606
          || (exp[0].X_op != O_constant && exp[0].X_op != O_register))
1607
        {
1608
          as_bad (_("invalid operands to opcode %s: `%s'"),
1609
                  instruction->name, operands);
1610
          return;
1611
        }
1612
 
1613
      opcodep[1] = exp[0].X_add_number - 256;
1614
 
1615
      /* Note that the Y field is zero.  */
1616
 
1617
      if (exp[1].X_op == O_register)
1618
        opcodep[3] = exp[1].X_add_number;
1619
      else if (exp[1].X_op == O_constant)
1620
        {
1621
          opcodep[3] = exp[1].X_add_number;
1622
          opcodep[0] |= IMM_OFFSET_BIT;
1623
        }
1624
      else
1625
        fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 3,
1626
                     1, exp + 1, 0, BFD_RELOC_MMIX_REG_OR_BYTE);
1627
      break;
1628
 
1629
    case mmix_operands_save:
1630
      /* "$X,0"; SAVE.  */
1631
      if (n_operands != 2
1632
          || exp[1].X_op != O_constant
1633
          || exp[1].X_add_number != 0)
1634
        {
1635
          as_bad (_("invalid operands to opcode %s: `%s'"),
1636
                  instruction->name, operands);
1637
          return;
1638
        }
1639
      break;
1640
 
1641
    case mmix_operands_unsave:
1642
      if (n_operands < 2 && ! mmix_gnu_syntax)
1643
        {
1644
          if (n_operands == 1)
1645
            {
1646
              if (exp[0].X_op == O_register)
1647
                opcodep[3] = exp[0].X_add_number;
1648
              else
1649
                fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 3,
1650
                             1, exp, 0, BFD_RELOC_MMIX_REG);
1651
            }
1652
          break;
1653
        }
1654
 
1655
      /* "0,$Z"; UNSAVE.  */
1656
      if (n_operands != 2
1657
          || exp[0].X_op != O_constant
1658
          || exp[0].X_add_number != 0
1659
          || exp[1].X_op == O_constant
1660
          || (exp[1].X_op == O_register
1661
              && exp[1].X_add_number > 255))
1662
        {
1663
          as_bad (_("invalid operands to opcode %s: `%s'"),
1664
                  instruction->name, operands);
1665
          return;
1666
        }
1667
 
1668
      if (exp[1].X_op == O_register)
1669
        opcodep[3] = exp[1].X_add_number;
1670
      else
1671
        fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 3,
1672
                     1, exp + 1, 0, BFD_RELOC_MMIX_REG);
1673
      break;
1674
 
1675
    case mmix_operands_xyz_opt:
1676
      /* SWYM, TRIP, TRAP: zero, one, two or three operands.  It's
1677
         unspecified whether operands are registers or constants, but
1678
         when we find register syntax, we require operands to be literal and
1679
         within 0..255.  */
1680
      if (n_operands == 0 && ! mmix_gnu_syntax)
1681
        /* Zeros are in place - nothing needs to be done for zero
1682
           operands.  We don't allow this in GNU syntax mode, because it
1683
           was believed that the risk of missing to supply an operand is
1684
           higher than the benefit of not having to specify a zero.  */
1685
        ;
1686
      else if (n_operands == 1 && exp[0].X_op != O_register)
1687
        {
1688
          if (exp[0].X_op == O_constant)
1689
            {
1690
              if (exp[0].X_add_number > 255*256*256
1691
                  || exp[0].X_add_number < 0)
1692
                {
1693
                  as_bad (_("invalid operands to opcode %s: `%s'"),
1694
                          instruction->name, operands);
1695
                  return;
1696
                }
1697
              else
1698
                {
1699
                  opcodep[1] = (exp[0].X_add_number >> 16) & 255;
1700
                  opcodep[2] = (exp[0].X_add_number >> 8) & 255;
1701
                  opcodep[3] = exp[0].X_add_number & 255;
1702
                }
1703
            }
1704
          else
1705
            fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 1,
1706
                         3, exp, 0, BFD_RELOC_24);
1707
        }
1708
      else if (n_operands == 2
1709
               && exp[0].X_op != O_register
1710
               && exp[1].X_op != O_register)
1711
        {
1712
          /* Two operands.  */
1713
 
1714
          if (exp[0].X_op == O_constant)
1715
            {
1716
              if (exp[0].X_add_number > 255
1717
                  || exp[0].X_add_number < 0)
1718
                {
1719
                  as_bad (_("invalid operands to opcode %s: `%s'"),
1720
                          instruction->name, operands);
1721
                  return;
1722
                }
1723
              else
1724
                opcodep[1] = exp[0].X_add_number & 255;
1725
            }
1726
          else
1727
            fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 1,
1728
                         1, exp, 0, BFD_RELOC_8);
1729
 
1730
          if (exp[1].X_op == O_constant)
1731
            {
1732
              if (exp[1].X_add_number > 255*256
1733
                  || exp[1].X_add_number < 0)
1734
                {
1735
                  as_bad (_("invalid operands to opcode %s: `%s'"),
1736
                          instruction->name, operands);
1737
                  return;
1738
                }
1739
              else
1740
                {
1741
                  opcodep[2] = (exp[1].X_add_number >> 8) & 255;
1742
                  opcodep[3] = exp[1].X_add_number & 255;
1743
                }
1744
            }
1745
          else
1746
            fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 2,
1747
                         2, exp + 1, 0, BFD_RELOC_16);
1748
        }
1749
      else if (n_operands == 3
1750
               && exp[0].X_op != O_register
1751
               && exp[1].X_op != O_register
1752
               && exp[2].X_op != O_register)
1753
        {
1754
          /* Three operands.  */
1755
 
1756
          if (exp[0].X_op == O_constant)
1757
            {
1758
              if (exp[0].X_add_number > 255
1759
                  || exp[0].X_add_number < 0)
1760
                {
1761
                  as_bad (_("invalid operands to opcode %s: `%s'"),
1762
                          instruction->name, operands);
1763
                  return;
1764
                }
1765
              else
1766
                opcodep[1] = exp[0].X_add_number & 255;
1767
            }
1768
          else
1769
            fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 1,
1770
                         1, exp, 0, BFD_RELOC_8);
1771
 
1772
          if (exp[1].X_op == O_constant)
1773
            {
1774
              if (exp[1].X_add_number > 255
1775
                  || exp[1].X_add_number < 0)
1776
                {
1777
                  as_bad (_("invalid operands to opcode %s: `%s'"),
1778
                          instruction->name, operands);
1779
                  return;
1780
                }
1781
              else
1782
                opcodep[2] = exp[1].X_add_number & 255;
1783
            }
1784
          else
1785
            fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 2,
1786
                         1, exp + 1, 0, BFD_RELOC_8);
1787
 
1788
          if (exp[2].X_op == O_constant)
1789
            {
1790
              if (exp[2].X_add_number > 255
1791
                  || exp[2].X_add_number < 0)
1792
                {
1793
                  as_bad (_("invalid operands to opcode %s: `%s'"),
1794
                          instruction->name, operands);
1795
                  return;
1796
                }
1797
              else
1798
                opcodep[3] = exp[2].X_add_number & 255;
1799
            }
1800
          else
1801
            fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 3,
1802
                         1, exp + 2, 0, BFD_RELOC_8);
1803
        }
1804
      else
1805
        {
1806
          /* We can't get here for other cases.  */
1807
          gas_assert (n_operands <= 3);
1808
 
1809
          /* The meaning of operands to TRIP and TRAP is not defined (and
1810
             SWYM operands aren't enforced in mmixal, so let's avoid
1811
             that).  We add combinations not handled above here as we find
1812
             them and as they're reported.  */
1813
          if (n_operands == 3)
1814
            {
1815
              /* Don't require non-register operands.  Always generate
1816
                 fixups, so we don't have to copy lots of code and create
1817
                 maintenance problems.  TRIP is supposed to be a rare
1818
                 instruction, so the overhead should not matter.  We
1819
                 aren't allowed to fix_new_exp for an expression which is
1820
                 an O_register at this point, however.
1821
 
1822
                 Don't use BFD_RELOC_MMIX_REG_OR_BYTE as that modifies
1823
                 the insn for a register in the Z field and we want
1824
                 consistency.  */
1825
              if (exp[0].X_op == O_register)
1826
                opcodep[1] = exp[0].X_add_number;
1827
              else
1828
                fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 1,
1829
                             1, exp, 0, BFD_RELOC_8);
1830
              if (exp[1].X_op == O_register)
1831
                opcodep[2] = exp[1].X_add_number;
1832
              else
1833
                fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 2,
1834
                             1, exp + 1, 0, BFD_RELOC_8);
1835
              if (exp[2].X_op == O_register)
1836
                opcodep[3] = exp[2].X_add_number;
1837
              else
1838
                fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 3,
1839
                             1, exp + 2, 0, BFD_RELOC_8);
1840
            }
1841
          else if (n_operands == 2)
1842
            {
1843
              if (exp[0].X_op == O_register)
1844
                opcodep[1] = exp[0].X_add_number;
1845
              else
1846
                fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 1,
1847
                             1, exp, 0, BFD_RELOC_8);
1848
              if (exp[1].X_op == O_register)
1849
                opcodep[3] = exp[1].X_add_number;
1850
              else
1851
                fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 2,
1852
                             2, exp + 1, 0, BFD_RELOC_16);
1853
            }
1854
          else
1855
            {
1856
              /* We can't get here for other cases.  */
1857
              gas_assert (n_operands == 1 && exp[0].X_op == O_register);
1858
 
1859
              opcodep[3] = exp[0].X_add_number;
1860
            }
1861
        }
1862
      break;
1863
 
1864
    case mmix_operands_resume:
1865
      if (n_operands == 0 && ! mmix_gnu_syntax)
1866
        break;
1867
 
1868
      if (n_operands != 1
1869
          || exp[0].X_op == O_register
1870
          || (exp[0].X_op == O_constant
1871
              && (exp[0].X_add_number < 0
1872
                  || exp[0].X_add_number > 255)))
1873
        {
1874
          as_bad (_("invalid operands to opcode %s: `%s'"),
1875
                  instruction->name, operands);
1876
          return;
1877
        }
1878
 
1879
      if (exp[0].X_op == O_constant)
1880
        opcodep[3] = exp[0].X_add_number;
1881
      else
1882
        fix_new_exp (opc_fragP, opcodep - opc_fragP->fr_literal + 3,
1883
                     1, exp + 0, 0, BFD_RELOC_8);
1884
      break;
1885
 
1886
    case mmix_operands_pushj:
1887
      /* All is done for PUSHJ already.  */
1888
      break;
1889
 
1890
    default:
1891
      BAD_CASE (instruction->operands);
1892
    }
1893
}
1894
 
1895
/* For the benefit of insns that start with a digit, we assemble by way of
1896
   tc_unrecognized_line too, through this function.  */
1897
 
1898
int
1899
mmix_assemble_return_nonzero (char *str)
1900
{
1901
  int last_error_count = had_errors ();
1902
  char *s2 = str;
1903
  char c;
1904
 
1905
  /* Normal instruction handling downcases, so we must too.  */
1906
  while (ISALNUM (*s2))
1907
    {
1908
      if (ISUPPER ((unsigned char) *s2))
1909
        *s2 = TOLOWER (*s2);
1910
      s2++;
1911
    }
1912
 
1913
  /* Cut the line for sake of the assembly.  */
1914
  for (s2 = str; *s2 && *s2 != '\n'; s2++)
1915
    ;
1916
 
1917
  c = *s2;
1918
  *s2 = 0;
1919
  md_assemble (str);
1920
  *s2 = c;
1921
 
1922
  return had_errors () == last_error_count;
1923
}
1924
 
1925
/* The PREFIX pseudo.  */
1926
 
1927
static void
1928
s_prefix (int unused ATTRIBUTE_UNUSED)
1929
{
1930
  char *p;
1931
  int c;
1932
 
1933
  SKIP_WHITESPACE ();
1934
 
1935
  p = input_line_pointer;
1936
 
1937
  c = get_symbol_end ();
1938
 
1939
  /* Reseting prefix?  */
1940
  if (*p == ':' && p[1] == 0)
1941
    mmix_current_prefix = NULL;
1942
  else
1943
    {
1944
      /* Put this prefix on the mmix symbols obstack.  We could malloc and
1945
         free it separately, but then we'd have to worry about that.
1946
         People using up memory on prefixes have other problems.  */
1947
      obstack_grow (&mmix_sym_obstack, p, strlen (p) + 1);
1948
      p = obstack_finish (&mmix_sym_obstack);
1949
 
1950
      /* Accumulate prefixes, and strip a leading ':'.  */
1951
      if (mmix_current_prefix != NULL || *p == ':')
1952
        p = mmix_prefix_name (p);
1953
 
1954
      mmix_current_prefix = p;
1955
    }
1956
 
1957
  *input_line_pointer = c;
1958
 
1959
  mmix_handle_rest_of_empty_line ();
1960
}
1961
 
1962
/* We implement prefixes by using the tc_canonicalize_symbol_name hook,
1963
   and store each prefixed name on a (separate) obstack.  This means that
1964
   the name is on the "notes" obstack in non-prefixed form and on the
1965
   mmix_sym_obstack in prefixed form, but currently it is not worth
1966
   rewriting the whole GAS symbol handling to improve "hooking" to avoid
1967
   that.  (It might be worth a rewrite for other reasons, though).  */
1968
 
1969
char *
1970
mmix_prefix_name (char *shortname)
1971
{
1972
  if (*shortname == ':')
1973
    return shortname + 1;
1974
 
1975
  if (mmix_current_prefix == NULL)
1976
    as_fatal (_("internal: mmix_prefix_name but empty prefix"));
1977
 
1978
  if (*shortname == '$')
1979
    return shortname;
1980
 
1981
  obstack_grow (&mmix_sym_obstack, mmix_current_prefix,
1982
                strlen (mmix_current_prefix));
1983
  obstack_grow (&mmix_sym_obstack, shortname, strlen (shortname) + 1);
1984
  return obstack_finish (&mmix_sym_obstack);
1985
}
1986
 
1987
/* The GREG pseudo.  At LABEL, we have the name of a symbol that we
1988
   want to make a register symbol, and which should be initialized with
1989
   the value in the expression at INPUT_LINE_POINTER (defaulting to 0).
1990
   Either and (perhaps less meaningful) both may be missing.  LABEL must
1991
   be persistent, perhaps allocated on an obstack.  */
1992
 
1993
static void
1994
mmix_greg_internal (char *label)
1995
{
1996
  expressionS *expP = &mmix_raw_gregs[n_of_raw_gregs].exp;
1997
 
1998
  /* Don't set the section to register contents section before the
1999
     expression has been parsed; it may refer to the current position.  */
2000
  expression (expP);
2001
 
2002
  /* FIXME: Check that no expression refers to the register contents
2003
     section.  May need to be done in elf64-mmix.c.  */
2004
  if (expP->X_op == O_absent)
2005
    {
2006
      /* Default to zero if the expression was absent.  */
2007
      expP->X_op = O_constant;
2008
      expP->X_add_number = 0;
2009
      expP->X_unsigned = 0;
2010
      expP->X_add_symbol = NULL;
2011
      expP->X_op_symbol = NULL;
2012
    }
2013
 
2014
  /* We must handle prefixes here, as we save the labels and expressions
2015
     to be output later.  */
2016
  mmix_raw_gregs[n_of_raw_gregs].label
2017
    = mmix_current_prefix == NULL ? label : mmix_prefix_name (label);
2018
 
2019
  if (n_of_raw_gregs == MAX_GREGS - 1)
2020
    as_bad (_("too many GREG registers allocated (max %d)"), MAX_GREGS);
2021
  else
2022
    n_of_raw_gregs++;
2023
 
2024
  mmix_handle_rest_of_empty_line ();
2025
}
2026
 
2027
/* The ".greg label,expr" worker.  */
2028
 
2029
static void
2030
s_greg (int unused ATTRIBUTE_UNUSED)
2031
{
2032
  char *p;
2033
  char c;
2034
  p = input_line_pointer;
2035
 
2036
  /* This will skip over what can be a symbol and zero out the next
2037
     character, which we assume is a ',' or other meaningful delimiter.
2038
     What comes after that is the initializer expression for the
2039
     register.  */
2040
  c = get_symbol_end ();
2041
 
2042
  if (! is_end_of_line[(unsigned char) c])
2043
    input_line_pointer++;
2044
 
2045
  if (*p)
2046
    {
2047
      /* The label must be persistent; it's not used until after all input
2048
         has been seen.  */
2049
      obstack_grow (&mmix_sym_obstack, p, strlen (p) + 1);
2050
      mmix_greg_internal (obstack_finish (&mmix_sym_obstack));
2051
    }
2052
  else
2053
    mmix_greg_internal (NULL);
2054
}
2055
 
2056
/* The "BSPEC expr" worker.  */
2057
 
2058
static void
2059
s_bspec (int unused ATTRIBUTE_UNUSED)
2060
{
2061
  asection *expsec;
2062
  asection *sec;
2063
  char secname[sizeof (MMIX_OTHER_SPEC_SECTION_PREFIX) + 20]
2064
    = MMIX_OTHER_SPEC_SECTION_PREFIX;
2065
  expressionS exp;
2066
  int n;
2067
 
2068
  /* Get a constant expression which we can evaluate *now*.  Supporting
2069
     more complex (though assembly-time computable) expressions is
2070
     feasible but Too Much Work for something of unknown usefulness like
2071
     BSPEC-ESPEC.  */
2072
  expsec = expression (&exp);
2073
  mmix_handle_rest_of_empty_line ();
2074
 
2075
  /* Check that we don't have another BSPEC in progress.  */
2076
  if (doing_bspec)
2077
    {
2078
      as_bad (_("BSPEC already active.  Nesting is not supported."));
2079
      return;
2080
    }
2081
 
2082
  if (exp.X_op != O_constant
2083
      || expsec != absolute_section
2084
      || exp.X_add_number < 0
2085
      || exp.X_add_number > 65535)
2086
    {
2087
      as_bad (_("invalid BSPEC expression"));
2088
      exp.X_add_number = 0;
2089
    }
2090
 
2091
  n = (int) exp.X_add_number;
2092
 
2093
  sprintf (secname + strlen (MMIX_OTHER_SPEC_SECTION_PREFIX), "%d", n);
2094
  sec = bfd_get_section_by_name (stdoutput, secname);
2095
  if (sec == NULL)
2096
    {
2097
      /* We need a non-volatile name as it will be stored in the section
2098
         struct.  */
2099
      char *newsecname = xstrdup (secname);
2100
      sec = bfd_make_section (stdoutput, newsecname);
2101
 
2102
      if (sec == NULL)
2103
        as_fatal (_("can't create section %s"), newsecname);
2104
 
2105
      if (!bfd_set_section_flags (stdoutput, sec,
2106
                                  bfd_get_section_flags (stdoutput, sec)
2107
                                  | SEC_READONLY))
2108
        as_fatal (_("can't set section flags for section %s"), newsecname);
2109
    }
2110
 
2111
  /* Tell ELF about the pending section change.  */
2112
  obj_elf_section_change_hook ();
2113
  subseg_set (sec, 0);
2114
 
2115
  /* Save position for missing ESPEC.  */
2116
  as_where (&bspec_file, &bspec_line);
2117
 
2118
  doing_bspec = 1;
2119
}
2120
 
2121
/* The "ESPEC" worker.  */
2122
 
2123
static void
2124
s_espec (int unused ATTRIBUTE_UNUSED)
2125
{
2126
  /* First, check that we *do* have a BSPEC in progress.  */
2127
  if (! doing_bspec)
2128
    {
2129
      as_bad (_("ESPEC without preceding BSPEC"));
2130
      return;
2131
    }
2132
 
2133
  mmix_handle_rest_of_empty_line ();
2134
  doing_bspec = 0;
2135
 
2136
  /* When we told ELF about the section change in s_bspec, it stored the
2137
     previous section for us so we can get at it with the equivalent of a
2138
     .previous pseudo.  */
2139
  obj_elf_previous (0);
2140
}
2141
 
2142
/* The " .local expr" and " local expr" worker.  We make a BFD_MMIX_LOCAL
2143
   relocation against the current position against the expression.
2144
   Implementing this by means of contents in a section lost.  */
2145
 
2146
static void
2147
mmix_s_local (int unused ATTRIBUTE_UNUSED)
2148
{
2149
  expressionS exp;
2150
 
2151
  /* Don't set the section to register contents section before the
2152
     expression has been parsed; it may refer to the current position in
2153
     some contorted way.  */
2154
  expression (&exp);
2155
 
2156
  if (exp.X_op == O_absent)
2157
    {
2158
      as_bad (_("missing local expression"));
2159
      return;
2160
    }
2161
  else if (exp.X_op == O_register)
2162
    {
2163
      /* fix_new_exp doesn't like O_register.  Should be configurable.
2164
         We're fine with a constant here, though.  */
2165
      exp.X_op = O_constant;
2166
    }
2167
 
2168
  fix_new_exp (frag_now, 0, 0, &exp, 0, BFD_RELOC_MMIX_LOCAL);
2169
  mmix_handle_rest_of_empty_line ();
2170
}
2171
 
2172
/* Set fragP->fr_var to the initial guess of the size of a relaxable insn
2173
   and return it.  Sizes of other instructions are not known.  This
2174
   function may be called multiple times.  */
2175
 
2176
int
2177
md_estimate_size_before_relax (fragS *fragP, segT segment)
2178
{
2179
  int length;
2180
 
2181
#define HANDLE_RELAXABLE(state)                                         \
2182
 case ENCODE_RELAX (state, STATE_UNDF):                                 \
2183
   if (fragP->fr_symbol != NULL                                         \
2184
       && S_GET_SEGMENT (fragP->fr_symbol) == segment                   \
2185
       && !S_IS_WEAK (fragP->fr_symbol))                                \
2186
     {                                                                  \
2187
       /* The symbol lies in the same segment - a relaxable case.  */   \
2188
       fragP->fr_subtype                                                \
2189
         = ENCODE_RELAX (state, STATE_ZERO);                            \
2190
     }                                                                  \
2191
   break;
2192
 
2193
  switch (fragP->fr_subtype)
2194
    {
2195
      HANDLE_RELAXABLE (STATE_GETA);
2196
      HANDLE_RELAXABLE (STATE_BCC);
2197
      HANDLE_RELAXABLE (STATE_JMP);
2198
 
2199
    case ENCODE_RELAX (STATE_PUSHJ, STATE_UNDF):
2200
      if (fragP->fr_symbol != NULL
2201
          && S_GET_SEGMENT (fragP->fr_symbol) == segment
2202
          && !S_IS_WEAK (fragP->fr_symbol))
2203
        /* The symbol lies in the same segment - a relaxable case.  */
2204
        fragP->fr_subtype = ENCODE_RELAX (STATE_PUSHJ, STATE_ZERO);
2205
      else if (pushj_stubs)
2206
        /* If we're to generate stubs, assume we can reach a stub after
2207
           the section.  */
2208
        fragP->fr_subtype = ENCODE_RELAX (STATE_PUSHJSTUB, STATE_ZERO);
2209
      /* FALLTHROUGH.  */
2210
    case ENCODE_RELAX (STATE_PUSHJ, STATE_ZERO):
2211
    case ENCODE_RELAX (STATE_PUSHJSTUB, STATE_ZERO):
2212
      /* We need to distinguish different relaxation rounds.  */
2213
      seg_info (segment)->tc_segment_info_data.last_stubfrag = fragP;
2214
      break;
2215
 
2216
    case ENCODE_RELAX (STATE_GETA, STATE_ZERO):
2217
    case ENCODE_RELAX (STATE_BCC, STATE_ZERO):
2218
    case ENCODE_RELAX (STATE_JMP, STATE_ZERO):
2219
      /* When relaxing a section for the second time, we don't need to do
2220
         anything except making sure that fr_var is set right.  */
2221
      break;
2222
 
2223
    case STATE_GREG_DEF:
2224
      length = fragP->tc_frag_data != NULL ? 0 : 8;
2225
      fragP->fr_var = length;
2226
 
2227
      /* Don't consult the relax_table; it isn't valid for this
2228
         relaxation.  */
2229
      return length;
2230
      break;
2231
 
2232
    default:
2233
      BAD_CASE (fragP->fr_subtype);
2234
    }
2235
 
2236
  length = mmix_relax_table[fragP->fr_subtype].rlx_length;
2237
  fragP->fr_var = length;
2238
 
2239
  return length;
2240
}
2241
 
2242
/* Turn a string in input_line_pointer into a floating point constant of type
2243
   type, and store the appropriate bytes in *litP.  The number of LITTLENUMS
2244
   emitted is stored in *sizeP .  An error message is returned, or NULL on
2245
   OK.  */
2246
 
2247
char *
2248
md_atof (int type, char *litP, int *sizeP)
2249
{
2250
  if (type == 'r')
2251
    type = 'f';
2252
  /* FIXME: Having 'f' in mmix_flt_chars (and here) makes it
2253
     problematic to also have a forward reference in an expression.
2254
     The testsuite wants it, and it's customary.
2255
     We'll deal with the real problems when they come; we share the
2256
     problem with most other ports.  */
2257
  return ieee_md_atof (type, litP, sizeP, TRUE);
2258
}
2259
 
2260
/* Convert variable-sized frags into one or more fixups.  */
2261
 
2262
void
2263
md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED, segT sec ATTRIBUTE_UNUSED,
2264
                 fragS *fragP)
2265
{
2266
  /* Pointer to first byte in variable-sized part of the frag.  */
2267
  char *var_partp;
2268
 
2269
  /* Pointer to first opcode byte in frag.  */
2270
  char *opcodep;
2271
 
2272
  /* Size in bytes of variable-sized part of frag.  */
2273
  int var_part_size = 0;
2274
 
2275
  /* This is part of *fragP.  It contains all information about addresses
2276
     and offsets to varying parts.  */
2277
  symbolS *symbolP;
2278
  unsigned long var_part_offset;
2279
 
2280
  /* This is the frag for the opcode.  It, rather than fragP, must be used
2281
     when emitting a frag for the opcode.  */
2282
  fragS *opc_fragP = fragP->tc_frag_data;
2283
  fixS *tmpfixP;
2284
 
2285
  /* Where, in file space, does addr point?  */
2286
  bfd_vma target_address;
2287
  bfd_vma opcode_address;
2288
 
2289
  know (fragP->fr_type == rs_machine_dependent);
2290
 
2291
  var_part_offset = fragP->fr_fix;
2292
  var_partp = fragP->fr_literal + var_part_offset;
2293
  opcodep = fragP->fr_opcode;
2294
 
2295
  symbolP = fragP->fr_symbol;
2296
 
2297
  target_address
2298
    = ((symbolP ? S_GET_VALUE (symbolP) : 0) + fragP->fr_offset);
2299
 
2300
  /* The opcode that would be extended is the last four "fixed" bytes.  */
2301
  opcode_address = fragP->fr_address + fragP->fr_fix - 4;
2302
 
2303
  switch (fragP->fr_subtype)
2304
    {
2305
    case ENCODE_RELAX (STATE_PUSHJSTUB, STATE_ZERO):
2306
      /* Setting the unknown bits to 0 seems the most appropriate.  */
2307
      mmix_set_geta_branch_offset (opcodep, 0);
2308
      tmpfixP = fix_new (opc_fragP, opcodep - opc_fragP->fr_literal, 8,
2309
                         fragP->fr_symbol, fragP->fr_offset, 1,
2310
                         BFD_RELOC_MMIX_PUSHJ_STUBBABLE);
2311
      COPY_FR_WHERE_TO_FX (fragP, tmpfixP);
2312
      var_part_size = 0;
2313
      break;
2314
 
2315
    case ENCODE_RELAX (STATE_GETA, STATE_ZERO):
2316
    case ENCODE_RELAX (STATE_BCC, STATE_ZERO):
2317
    case ENCODE_RELAX (STATE_PUSHJ, STATE_ZERO):
2318
      mmix_set_geta_branch_offset (opcodep, target_address - opcode_address);
2319
      if (linkrelax)
2320
        {
2321
          tmpfixP
2322
            = fix_new (opc_fragP, opcodep - opc_fragP->fr_literal, 4,
2323
                       fragP->fr_symbol, fragP->fr_offset, 1,
2324
                       BFD_RELOC_MMIX_ADDR19);
2325
          COPY_FR_WHERE_TO_FX (fragP, tmpfixP);
2326
        }
2327
      var_part_size = 0;
2328
      break;
2329
 
2330
    case ENCODE_RELAX (STATE_JMP, STATE_ZERO):
2331
      mmix_set_jmp_offset (opcodep, target_address - opcode_address);
2332
      if (linkrelax)
2333
        {
2334
          tmpfixP
2335
            = fix_new (opc_fragP, opcodep - opc_fragP->fr_literal, 4,
2336
                       fragP->fr_symbol, fragP->fr_offset, 1,
2337
                       BFD_RELOC_MMIX_ADDR27);
2338
          COPY_FR_WHERE_TO_FX (fragP, tmpfixP);
2339
        }
2340
      var_part_size = 0;
2341
      break;
2342
 
2343
    case STATE_GREG_DEF:
2344
      if (fragP->tc_frag_data == NULL)
2345
        {
2346
          /* We must initialize data that's supposed to be "fixed up" to
2347
             avoid emitting garbage, because md_apply_fix won't do
2348
             anything for undefined symbols.  */
2349
          md_number_to_chars (var_partp, 0, 8);
2350
          tmpfixP
2351
            = fix_new (fragP, var_partp - fragP->fr_literal, 8,
2352
                       fragP->fr_symbol, fragP->fr_offset, 0, BFD_RELOC_64);
2353
          COPY_FR_WHERE_TO_FX (fragP, tmpfixP);
2354
          mmix_gregs[n_of_cooked_gregs++] = tmpfixP;
2355
          var_part_size = 8;
2356
        }
2357
      else
2358
        var_part_size = 0;
2359
      break;
2360
 
2361
#define HANDLE_MAX_RELOC(state, reloc)                                  \
2362
  case ENCODE_RELAX (state, STATE_MAX):                                 \
2363
    var_part_size                                                       \
2364
      = mmix_relax_table[ENCODE_RELAX (state, STATE_MAX)].rlx_length;   \
2365
    mmix_fill_nops (var_partp, var_part_size / 4);                      \
2366
    if (warn_on_expansion)                                              \
2367
      as_warn_where (fragP->fr_file, fragP->fr_line,                    \
2368
                     _("operand out of range, instruction expanded"));  \
2369
    tmpfixP = fix_new (fragP, var_partp - fragP->fr_literal - 4, 8,     \
2370
                       fragP->fr_symbol, fragP->fr_offset, 1, reloc);   \
2371
    COPY_FR_WHERE_TO_FX (fragP, tmpfixP);                               \
2372
    break
2373
 
2374
      HANDLE_MAX_RELOC (STATE_GETA, BFD_RELOC_MMIX_GETA);
2375
      HANDLE_MAX_RELOC (STATE_BCC, BFD_RELOC_MMIX_CBRANCH);
2376
      HANDLE_MAX_RELOC (STATE_PUSHJ, BFD_RELOC_MMIX_PUSHJ);
2377
      HANDLE_MAX_RELOC (STATE_JMP, BFD_RELOC_MMIX_JMP);
2378
 
2379
    default:
2380
      BAD_CASE (fragP->fr_subtype);
2381
      break;
2382
    }
2383
 
2384
  fragP->fr_fix += var_part_size;
2385
  fragP->fr_var = 0;
2386
}
2387
 
2388
/* Applies the desired value to the specified location.
2389
   Also sets up addends for RELA type relocations.
2390
   Stolen from tc-mcore.c.
2391
 
2392
   Note that this function isn't called when linkrelax != 0.  */
2393
 
2394
void
2395
md_apply_fix (fixS *fixP, valueT *valP, segT segment)
2396
{
2397
  char *buf  = fixP->fx_where + fixP->fx_frag->fr_literal;
2398
  /* Note: use offsetT because it is signed, valueT is unsigned.  */
2399
  offsetT val  = (offsetT) * valP;
2400
  segT symsec
2401
    = (fixP->fx_addsy == NULL
2402
       ? absolute_section : S_GET_SEGMENT (fixP->fx_addsy));
2403
 
2404
  /* If the fix is relative to a symbol which is not defined, or, (if
2405
     pcrel), not in the same segment as the fix, we cannot resolve it
2406
     here.  */
2407
  if (fixP->fx_addsy != NULL
2408
      && (! S_IS_DEFINED (fixP->fx_addsy)
2409
          || S_IS_WEAK (fixP->fx_addsy)
2410
          || (fixP->fx_pcrel && symsec != segment)
2411
          || (! fixP->fx_pcrel
2412
              && symsec != absolute_section
2413
              && ((fixP->fx_r_type != BFD_RELOC_MMIX_REG
2414
                   && fixP->fx_r_type != BFD_RELOC_MMIX_REG_OR_BYTE)
2415
                  || symsec != reg_section))))
2416
    {
2417
      fixP->fx_done = 0;
2418
      return;
2419
    }
2420
  else if (fixP->fx_r_type == BFD_RELOC_MMIX_LOCAL
2421
           || fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
2422
           || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
2423
    {
2424
      /* These are never "fixed".  */
2425
      fixP->fx_done = 0;
2426
      return;
2427
    }
2428
  else
2429
    /* We assume every other relocation is "fixed".  */
2430
    fixP->fx_done = 1;
2431
 
2432
  switch (fixP->fx_r_type)
2433
    {
2434
    case BFD_RELOC_64:
2435
    case BFD_RELOC_32:
2436
    case BFD_RELOC_24:
2437
    case BFD_RELOC_16:
2438
    case BFD_RELOC_8:
2439
    case BFD_RELOC_64_PCREL:
2440
    case BFD_RELOC_32_PCREL:
2441
    case BFD_RELOC_24_PCREL:
2442
    case BFD_RELOC_16_PCREL:
2443
    case BFD_RELOC_8_PCREL:
2444
      md_number_to_chars (buf, val, fixP->fx_size);
2445
      break;
2446
 
2447
    case BFD_RELOC_MMIX_ADDR19:
2448
      if (expand_op)
2449
        {
2450
          /* This shouldn't happen.  */
2451
          BAD_CASE (fixP->fx_r_type);
2452
          break;
2453
        }
2454
      /* FALLTHROUGH.  */
2455
    case BFD_RELOC_MMIX_GETA:
2456
    case BFD_RELOC_MMIX_CBRANCH:
2457
    case BFD_RELOC_MMIX_PUSHJ:
2458
    case BFD_RELOC_MMIX_PUSHJ_STUBBABLE:
2459
      /* If this fixup is out of range, punt to the linker to emit an
2460
         error.  This should only happen with -no-expand.  */
2461
      if (val < -(((offsetT) 1 << 19)/2)
2462
          || val >= ((offsetT) 1 << 19)/2 - 1
2463
          || (val & 3) != 0)
2464
        {
2465
          if (warn_on_expansion)
2466
            as_warn_where (fixP->fx_file, fixP->fx_line,
2467
                           _("operand out of range"));
2468
          fixP->fx_done = 0;
2469
          val = 0;
2470
        }
2471
      mmix_set_geta_branch_offset (buf, val);
2472
      break;
2473
 
2474
    case BFD_RELOC_MMIX_ADDR27:
2475
      if (expand_op)
2476
        {
2477
          /* This shouldn't happen.  */
2478
          BAD_CASE (fixP->fx_r_type);
2479
          break;
2480
        }
2481
      /* FALLTHROUGH.  */
2482
    case BFD_RELOC_MMIX_JMP:
2483
      /* If this fixup is out of range, punt to the linker to emit an
2484
         error.  This should only happen with -no-expand.  */
2485
      if (val < -(((offsetT) 1 << 27)/2)
2486
          || val >= ((offsetT) 1 << 27)/2 - 1
2487
          || (val & 3) != 0)
2488
        {
2489
          if (warn_on_expansion)
2490
            as_warn_where (fixP->fx_file, fixP->fx_line,
2491
                           _("operand out of range"));
2492
          fixP->fx_done = 0;
2493
          val = 0;
2494
        }
2495
      mmix_set_jmp_offset (buf, val);
2496
      break;
2497
 
2498
    case BFD_RELOC_MMIX_REG_OR_BYTE:
2499
      if (fixP->fx_addsy != NULL
2500
          && (S_GET_SEGMENT (fixP->fx_addsy) != reg_section
2501
              || S_GET_VALUE (fixP->fx_addsy) > 255)
2502
          && S_GET_SEGMENT (fixP->fx_addsy) != absolute_section)
2503
        {
2504
          as_bad_where (fixP->fx_file, fixP->fx_line,
2505
                        _("invalid operands"));
2506
          /* We don't want this "symbol" appearing in output, because
2507
             that will fail.  */
2508
          fixP->fx_done = 1;
2509
        }
2510
 
2511
      buf[0] = val;
2512
 
2513
      /* If this reloc is for a Z field, we need to adjust
2514
         the opcode if we got a constant here.
2515
         FIXME: Can we make this more robust?  */
2516
 
2517
      if ((fixP->fx_where & 3) == 3
2518
          && (fixP->fx_addsy == NULL
2519
              || S_GET_SEGMENT (fixP->fx_addsy) == absolute_section))
2520
        buf[-3] |= IMM_OFFSET_BIT;
2521
      break;
2522
 
2523
    case BFD_RELOC_MMIX_REG:
2524
      if (fixP->fx_addsy == NULL
2525
          || S_GET_SEGMENT (fixP->fx_addsy) != reg_section
2526
          || S_GET_VALUE (fixP->fx_addsy) > 255)
2527
        {
2528
          as_bad_where (fixP->fx_file, fixP->fx_line,
2529
                        _("invalid operands"));
2530
          fixP->fx_done = 1;
2531
        }
2532
 
2533
      *buf = val;
2534
      break;
2535
 
2536
    case BFD_RELOC_MMIX_BASE_PLUS_OFFSET:
2537
      /* These are never "fixed".  */
2538
      fixP->fx_done = 0;
2539
      return;
2540
 
2541
    case BFD_RELOC_MMIX_PUSHJ_1:
2542
    case BFD_RELOC_MMIX_PUSHJ_2:
2543
    case BFD_RELOC_MMIX_PUSHJ_3:
2544
    case BFD_RELOC_MMIX_CBRANCH_J:
2545
    case BFD_RELOC_MMIX_CBRANCH_1:
2546
    case BFD_RELOC_MMIX_CBRANCH_2:
2547
    case BFD_RELOC_MMIX_CBRANCH_3:
2548
    case BFD_RELOC_MMIX_GETA_1:
2549
    case BFD_RELOC_MMIX_GETA_2:
2550
    case BFD_RELOC_MMIX_GETA_3:
2551
    case BFD_RELOC_MMIX_JMP_1:
2552
    case BFD_RELOC_MMIX_JMP_2:
2553
    case BFD_RELOC_MMIX_JMP_3:
2554
    default:
2555
      BAD_CASE (fixP->fx_r_type);
2556
      break;
2557
    }
2558
 
2559
  if (fixP->fx_done)
2560
    /* Make sure that for completed fixups we have the value around for
2561
       use by e.g. mmix_frob_file.  */
2562
    fixP->fx_offset = val;
2563
}
2564
 
2565
/* A bsearch function for looking up a value against offsets for GREG
2566
   definitions.  */
2567
 
2568
static int
2569
cmp_greg_val_greg_symbol_fixes (const void *p1, const void *p2)
2570
{
2571
  offsetT val1 = *(offsetT *) p1;
2572
  offsetT val2 = ((struct mmix_symbol_greg_fixes *) p2)->offs;
2573
 
2574
  if (val1 >= val2 && val1 < val2 + 255)
2575
    return 0;
2576
 
2577
  if (val1 > val2)
2578
    return 1;
2579
 
2580
  return -1;
2581
}
2582
 
2583
/* Generate a machine-dependent relocation.  */
2584
 
2585
arelent *
2586
tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixP)
2587
{
2588
  bfd_signed_vma val
2589
    = fixP->fx_offset
2590
    + (fixP->fx_addsy != NULL
2591
       && !S_IS_WEAK (fixP->fx_addsy)
2592
       && !S_IS_COMMON (fixP->fx_addsy)
2593
       ? S_GET_VALUE (fixP->fx_addsy) : 0);
2594
  arelent *relP;
2595
  bfd_reloc_code_real_type code = BFD_RELOC_NONE;
2596
  char *buf  = fixP->fx_where + fixP->fx_frag->fr_literal;
2597
  symbolS *addsy = fixP->fx_addsy;
2598
  asection *addsec = addsy == NULL ? NULL : S_GET_SEGMENT (addsy);
2599
  asymbol *baddsy = addsy != NULL ? symbol_get_bfdsym (addsy) : NULL;
2600
  bfd_vma addend
2601
    = val - (baddsy == NULL || S_IS_COMMON (addsy) || S_IS_WEAK (addsy)
2602
             ? 0 : bfd_asymbol_value (baddsy));
2603
 
2604
  /* A single " LOCAL expression" in the wrong section will not work when
2605
     linking to MMO; relocations for zero-content sections are then
2606
     ignored.  Normally, relocations would modify section contents, and
2607
     you'd never think or be able to do something like that.  The
2608
     relocation resulting from a LOCAL directive doesn't have an obvious
2609
     and mandatory location.  I can't figure out a way to do this better
2610
     than just helping the user around this limitation here; hopefully the
2611
     code using the local expression is around.  Putting the LOCAL
2612
     semantics in a relocation still seems right; a section didn't do.  */
2613
  if (bfd_section_size (section->owner, section) == 0)
2614
    as_bad_where
2615
      (fixP->fx_file, fixP->fx_line,
2616
       fixP->fx_r_type == BFD_RELOC_MMIX_LOCAL
2617
       /* The BFD_RELOC_MMIX_LOCAL-specific message is supposed to be
2618
          user-friendly, though a little bit non-substantial.  */
2619
       ? _("directive LOCAL must be placed in code or data")
2620
       : _("internal confusion: relocation in a section without contents"));
2621
 
2622
  /* FIXME: Range tests for all these.  */
2623
  switch (fixP->fx_r_type)
2624
    {
2625
    case BFD_RELOC_64:
2626
    case BFD_RELOC_32:
2627
    case BFD_RELOC_24:
2628
    case BFD_RELOC_16:
2629
    case BFD_RELOC_8:
2630
      code = fixP->fx_r_type;
2631
 
2632
      if (addsy == NULL || bfd_is_abs_section (addsec))
2633
        {
2634
          /* Resolve this reloc now, as md_apply_fix would have done (not
2635
             called if -linkrelax).  There is no point in keeping a reloc
2636
             to an absolute symbol.  No reloc that is subject to
2637
             relaxation must be to an absolute symbol; difference
2638
             involving symbols in a specific section must be signalled as
2639
             an error if the relaxing cannot be expressed; having a reloc
2640
             to the resolved (now absolute) value does not help.  */
2641
          md_number_to_chars (buf, val, fixP->fx_size);
2642
          return NULL;
2643
        }
2644
      break;
2645
 
2646
    case BFD_RELOC_64_PCREL:
2647
    case BFD_RELOC_32_PCREL:
2648
    case BFD_RELOC_24_PCREL:
2649
    case BFD_RELOC_16_PCREL:
2650
    case BFD_RELOC_8_PCREL:
2651
    case BFD_RELOC_MMIX_LOCAL:
2652
    case BFD_RELOC_VTABLE_INHERIT:
2653
    case BFD_RELOC_VTABLE_ENTRY:
2654
    case BFD_RELOC_MMIX_GETA:
2655
    case BFD_RELOC_MMIX_GETA_1:
2656
    case BFD_RELOC_MMIX_GETA_2:
2657
    case BFD_RELOC_MMIX_GETA_3:
2658
    case BFD_RELOC_MMIX_CBRANCH:
2659
    case BFD_RELOC_MMIX_CBRANCH_J:
2660
    case BFD_RELOC_MMIX_CBRANCH_1:
2661
    case BFD_RELOC_MMIX_CBRANCH_2:
2662
    case BFD_RELOC_MMIX_CBRANCH_3:
2663
    case BFD_RELOC_MMIX_PUSHJ:
2664
    case BFD_RELOC_MMIX_PUSHJ_1:
2665
    case BFD_RELOC_MMIX_PUSHJ_2:
2666
    case BFD_RELOC_MMIX_PUSHJ_3:
2667
    case BFD_RELOC_MMIX_PUSHJ_STUBBABLE:
2668
    case BFD_RELOC_MMIX_JMP:
2669
    case BFD_RELOC_MMIX_JMP_1:
2670
    case BFD_RELOC_MMIX_JMP_2:
2671
    case BFD_RELOC_MMIX_JMP_3:
2672
    case BFD_RELOC_MMIX_ADDR19:
2673
    case BFD_RELOC_MMIX_ADDR27:
2674
      code = fixP->fx_r_type;
2675
      break;
2676
 
2677
    case BFD_RELOC_MMIX_REG_OR_BYTE:
2678
      /* If we have this kind of relocation to an unknown symbol or to the
2679
         register contents section (that is, to a register), then we can't
2680
         resolve the relocation here.  */
2681
      if (addsy != NULL
2682
          && (bfd_is_und_section (addsec)
2683
              || strcmp (bfd_get_section_name (addsec->owner, addsec),
2684
                         MMIX_REG_CONTENTS_SECTION_NAME) == 0))
2685
        {
2686
          code = fixP->fx_r_type;
2687
          break;
2688
        }
2689
 
2690
      /* If the relocation is not to the register section or to the
2691
         absolute section (a numeric value), then we have an error.  */
2692
      if (addsy != NULL
2693
          && (S_GET_SEGMENT (addsy) != real_reg_section
2694
              || val > 255
2695
              || val < 0)
2696
          && ! bfd_is_abs_section (addsec))
2697
        goto badop;
2698
 
2699
      /* Set the "immediate" bit of the insn if this relocation is to Z
2700
         field when the value is a numeric value, i.e. not a register.  */
2701
      if ((fixP->fx_where & 3) == 3
2702
          && (addsy == NULL || bfd_is_abs_section (addsec)))
2703
        buf[-3] |= IMM_OFFSET_BIT;
2704
 
2705
      buf[0] = val;
2706
      return NULL;
2707
 
2708
    case BFD_RELOC_MMIX_BASE_PLUS_OFFSET:
2709
      if (addsy != NULL
2710
          && strcmp (bfd_get_section_name (addsec->owner, addsec),
2711
                     MMIX_REG_CONTENTS_SECTION_NAME) == 0)
2712
        {
2713
          /* This changed into a register; the relocation is for the
2714
             register-contents section.  The constant part remains zero.  */
2715
          code = BFD_RELOC_MMIX_REG;
2716
          break;
2717
        }
2718
 
2719
      /* If we've found out that this was indeed a register, then replace
2720
         with the register number.  The constant part is already zero.
2721
 
2722
         If we encounter any other defined symbol, then we must find a
2723
         suitable register and emit a reloc.  */
2724
      if (addsy == NULL || addsec != real_reg_section)
2725
        {
2726
          struct mmix_symbol_gregs *gregs;
2727
          struct mmix_symbol_greg_fixes *fix;
2728
 
2729
          if (S_IS_DEFINED (addsy)
2730
              && !bfd_is_com_section (addsec)
2731
              && !S_IS_WEAK (addsy))
2732
            {
2733
              if (! symbol_section_p (addsy) && ! bfd_is_abs_section (addsec))
2734
                as_fatal (_("internal: BFD_RELOC_MMIX_BASE_PLUS_OFFSET not resolved to section"));
2735
 
2736
              /* If this is an absolute symbol sufficiently near
2737
                 lowest_data_loc, then we canonicalize on the data
2738
                 section.  Note that val is signed here; we may subtract
2739
                 lowest_data_loc which is unsigned.  Careful with those
2740
                 comparisons.  */
2741
              if (lowest_data_loc != (bfd_vma) -1
2742
                  && (bfd_vma) val + 256 > lowest_data_loc
2743
                  && bfd_is_abs_section (addsec))
2744
                {
2745
                  val -= (offsetT) lowest_data_loc;
2746
                  addsy = section_symbol (data_section);
2747
                }
2748
              /* Likewise text section.  */
2749
              else if (lowest_text_loc != (bfd_vma) -1
2750
                       && (bfd_vma) val + 256 > lowest_text_loc
2751
                       && bfd_is_abs_section (addsec))
2752
                {
2753
                  val -= (offsetT) lowest_text_loc;
2754
                  addsy = section_symbol (text_section);
2755
                }
2756
            }
2757
 
2758
          gregs = *symbol_get_tc (addsy);
2759
 
2760
          /* If that symbol does not have any associated GREG definitions,
2761
             we can't do anything.  */
2762
          if (gregs == NULL
2763
              || (fix = bsearch (&val, gregs->greg_fixes, gregs->n_gregs,
2764
                                 sizeof (gregs->greg_fixes[0]),
2765
                                 cmp_greg_val_greg_symbol_fixes)) == NULL
2766
              /* The register must not point *after* the address we want.  */
2767
              || fix->offs > val
2768
              /* Neither must the register point more than 255 bytes
2769
                 before the address we want.  */
2770
              || fix->offs + 255 < val)
2771
            {
2772
              /* We can either let the linker allocate GREGs
2773
                 automatically, or emit an error.  */
2774
              if (allocate_undefined_gregs_in_linker)
2775
                {
2776
                  /* The values in baddsy and addend are right.  */
2777
                  code = fixP->fx_r_type;
2778
                  break;
2779
                }
2780
              else
2781
                as_bad_where (fixP->fx_file, fixP->fx_line,
2782
                              _("no suitable GREG definition for operands"));
2783
              return NULL;
2784
            }
2785
          else
2786
            {
2787
              /* Transform the base-plus-offset reloc for the actual area
2788
                 to a reloc for the register with the address of the area.
2789
                 Put addend for register in Z operand.  */
2790
              buf[1] = val - fix->offs;
2791
              code = BFD_RELOC_MMIX_REG;
2792
              baddsy
2793
                = (bfd_get_section_by_name (stdoutput,
2794
                                            MMIX_REG_CONTENTS_SECTION_NAME)
2795
                   ->symbol);
2796
 
2797
              addend = fix->fix->fx_frag->fr_address + fix->fix->fx_where;
2798
            }
2799
        }
2800
      else if (S_GET_VALUE (addsy) > 255)
2801
        as_bad_where (fixP->fx_file, fixP->fx_line,
2802
                      _("invalid operands"));
2803
      else
2804
        {
2805
          *buf = val;
2806
          return NULL;
2807
        }
2808
      break;
2809
 
2810
    case BFD_RELOC_MMIX_REG:
2811
      if (addsy != NULL
2812
          && (bfd_is_und_section (addsec)
2813
              || strcmp (bfd_get_section_name (addsec->owner, addsec),
2814
                         MMIX_REG_CONTENTS_SECTION_NAME) == 0))
2815
        {
2816
          code = fixP->fx_r_type;
2817
          break;
2818
        }
2819
 
2820
      if (addsy != NULL
2821
          && (addsec != real_reg_section
2822
              || val > 255
2823
              || val < 0)
2824
          && ! bfd_is_und_section (addsec))
2825
        /* Drop through to error message.  */
2826
        ;
2827
      else
2828
        {
2829
          buf[0] = val;
2830
          return NULL;
2831
        }
2832
      /* FALLTHROUGH.  */
2833
 
2834
      /* The others are supposed to be handled by md_apply_fix.
2835
         FIXME: ... which isn't called when -linkrelax.  Move over
2836
         md_apply_fix code here for everything reasonable.  */
2837
    badop:
2838
    default:
2839
      as_bad_where
2840
        (fixP->fx_file, fixP->fx_line,
2841
         _("operands were not reducible at assembly-time"));
2842
 
2843
      /* Unmark this symbol as used in a reloc, so we don't bump into a BFD
2844
         assert when trying to output reg_section.  FIXME: A gas bug.  */
2845
      fixP->fx_addsy = NULL;
2846
      return NULL;
2847
    }
2848
 
2849
  relP = (arelent *) xmalloc (sizeof (arelent));
2850
  gas_assert (relP != 0);
2851
  relP->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
2852
  *relP->sym_ptr_ptr = baddsy;
2853
  relP->address = fixP->fx_frag->fr_address + fixP->fx_where;
2854
 
2855
  relP->addend = addend;
2856
 
2857
  /* If this had been a.out, we would have had a kludge for weak symbols
2858
     here.  */
2859
 
2860
  relP->howto = bfd_reloc_type_lookup (stdoutput, code);
2861
  if (! relP->howto)
2862
    {
2863
      const char *name;
2864
 
2865
      name = S_GET_NAME (addsy);
2866
      if (name == NULL)
2867
        name = _("<unknown>");
2868
      as_fatal (_("cannot generate relocation type for symbol %s, code %s"),
2869
                name, bfd_get_reloc_code_name (code));
2870
    }
2871
 
2872
  return relP;
2873
}
2874
 
2875
/* Do some reformatting of a line.  FIXME: We could transform a mmixal
2876
   line into traditional (GNU?) format, unless #NO_APP, and get rid of all
2877
   ugly labels_without_colons etc.  */
2878
 
2879
void
2880
mmix_handle_mmixal (void)
2881
{
2882
  char *insn;
2883
  char *s = input_line_pointer;
2884
  char *label = NULL;
2885
  char c;
2886
 
2887
  if (pending_label != NULL)
2888
    as_fatal (_("internal: unhandled label %s"), pending_label);
2889
 
2890
  if (mmix_gnu_syntax)
2891
    return;
2892
 
2893
  /* If we're on a line with a label, check if it's a mmixal fb-label.
2894
     Save an indicator and skip the label; it must be set only after all
2895
     fb-labels of expressions are evaluated.  */
2896
  if (ISDIGIT (s[0]) && s[1] == 'H' && ISSPACE (s[2]))
2897
    {
2898
      current_fb_label = s[0] - '0';
2899
 
2900
      /* We have to skip the label, but also preserve the newlineness of
2901
         the previous character, since the caller checks that.  It's a
2902
         mess we blame on the caller.  */
2903
      s[1] = s[-1];
2904
      s += 2;
2905
      input_line_pointer = s;
2906
 
2907
      while (*s && ISSPACE (*s) && ! is_end_of_line[(unsigned int) *s])
2908
        s++;
2909
 
2910
      /* For errors emitted here, the book-keeping is off by one; the
2911
         caller is about to bump the counters.  Adjust the error messages.  */
2912
      if (is_end_of_line[(unsigned int) *s])
2913
        {
2914
          char *name;
2915
          unsigned int line;
2916
          as_where (&name, &line);
2917
          as_bad_where (name, line + 1,
2918
                        _("[0-9]H labels may not appear alone on a line"));
2919
          current_fb_label = -1;
2920
        }
2921
      if (*s == '.')
2922
        {
2923
          char *name;
2924
          unsigned int line;
2925
          as_where (&name, &line);
2926
          as_bad_where (name, line + 1,
2927
                        _("[0-9]H labels do not mix with dot-pseudos"));
2928
          current_fb_label = -1;
2929
        }
2930
 
2931
      /* Back off to the last space before the opcode so we don't handle
2932
         the opcode as a label.  */
2933
      s--;
2934
    }
2935
  else
2936
    current_fb_label = -1;
2937
 
2938
  if (*s == '.')
2939
    {
2940
      /* If the first character is a '.', then it's a pseudodirective, not a
2941
         label.  Make GAS not handle label-without-colon on this line.  We
2942
         also don't do mmixal-specific stuff on this line.  */
2943
      label_without_colon_this_line = 0;
2944
      return;
2945
    }
2946
 
2947
  if (*s == 0 || is_end_of_line[(unsigned int) *s])
2948
    /* We avoid handling empty lines here.  */
2949
    return;
2950
 
2951
  if (is_name_beginner (*s))
2952
    label = s;
2953
 
2954
  /* If there is a label, skip over it.  */
2955
  while (*s && is_part_of_name (*s))
2956
    s++;
2957
 
2958
  /* Find the start of the instruction or pseudo following the label,
2959
     if there is one.  */
2960
  for (insn = s;
2961
       *insn && ISSPACE (*insn) && ! is_end_of_line[(unsigned int) *insn];
2962
       insn++)
2963
    /* Empty */
2964
    ;
2965
 
2966
  /* Remove a trailing ":" off labels, as they'd otherwise be considered
2967
     part of the name.  But don't do this for local labels.  */
2968
  if (s != input_line_pointer && s[-1] == ':'
2969
      && (s - 2 != input_line_pointer
2970
          || ! ISDIGIT (s[-2])))
2971
    s[-1] = ' ';
2972
  else if (label != NULL
2973
           /* For a lone label on a line, we don't attach it to the next
2974
              instruction or MMIXAL-pseudo (getting its alignment).  Thus
2975
              is acts like a "normal" :-ended label.  Ditto if it's
2976
              followed by a non-MMIXAL pseudo.  */
2977
           && !is_end_of_line[(unsigned int) *insn]
2978
           && *insn != '.')
2979
    {
2980
      /* For labels that don't end in ":", we save it so we can later give
2981
         it the same alignment and address as the associated instruction.  */
2982
 
2983
      /* Make room for the label including the ending nul.  */
2984
      int len_0 = s - label + 1;
2985
 
2986
      /* Save this label on the MMIX symbol obstack.  Saving it on an
2987
         obstack is needless for "IS"-pseudos, but it's harmless and we
2988
         avoid a little code-cluttering.  */
2989
      obstack_grow (&mmix_sym_obstack, label, len_0);
2990
      pending_label = obstack_finish (&mmix_sym_obstack);
2991
      pending_label[len_0 - 1] = 0;
2992
    }
2993
 
2994
  /* If we have a non-MMIXAL pseudo, we have not business with the rest of
2995
     the line.  */
2996
  if (*insn == '.')
2997
    return;
2998
 
2999
  /* Find local labels of operands.  Look for "[0-9][FB]" where the
3000
     characters before and after are not part of words.  Break if a single
3001
     or double quote is seen anywhere.  It means we can't have local
3002
     labels as part of list with mixed quoted and unquoted members for
3003
     mmixal compatibility but we can't have it all.  For the moment.
3004
     Replace the '<N>B' or '<N>F' with MAGIC_FB_BACKWARD_CHAR<N> and
3005
     MAGIC_FB_FORWARD_CHAR<N> respectively.  */
3006
 
3007
  /* First make sure we don't have any of the magic characters on the line
3008
     appearing as input.  */
3009
  while (*s)
3010
    {
3011
      c = *s++;
3012
      if (is_end_of_line[(unsigned int) c])
3013
        break;
3014
      if (c == MAGIC_FB_BACKWARD_CHAR || c == MAGIC_FB_FORWARD_CHAR)
3015
        as_bad (_("invalid characters in input"));
3016
    }
3017
 
3018
  /* Scan again, this time looking for ';' after operands.  */
3019
  s = insn;
3020
 
3021
  /* Skip the insn.  */
3022
  while (*s
3023
         && ! ISSPACE (*s)
3024
         && *s != ';'
3025
         && ! is_end_of_line[(unsigned int) *s])
3026
    s++;
3027
 
3028
  /* Skip the spaces after the insn.  */
3029
  while (*s
3030
         && ISSPACE (*s)
3031
         && *s != ';'
3032
         && ! is_end_of_line[(unsigned int) *s])
3033
    s++;
3034
 
3035
  /* Skip the operands.  While doing this, replace [0-9][BF] with
3036
     (MAGIC_FB_BACKWARD_CHAR|MAGIC_FB_FORWARD_CHAR)[0-9].  */
3037
  while ((c = *s) != 0
3038
         && ! ISSPACE (c)
3039
         && c != ';'
3040
         && ! is_end_of_line[(unsigned int) c])
3041
    {
3042
      if (c == '"')
3043
        {
3044
          s++;
3045
 
3046
          /* FIXME: Test-case for semi-colon in string.  */
3047
          while (*s
3048
                 && *s != '"'
3049
                 && (! is_end_of_line[(unsigned int) *s] || *s == ';'))
3050
            s++;
3051
 
3052
          if (*s == '"')
3053
            s++;
3054
        }
3055
      else if (ISDIGIT (c))
3056
        {
3057
          if ((s[1] != 'B' && s[1] != 'F')
3058
              || is_part_of_name (s[-1])
3059
              || is_part_of_name (s[2])
3060
              /* Don't treat e.g. #1F as a local-label reference.  */
3061
              || (s != input_line_pointer && s[-1] == '#'))
3062
            s++;
3063
          else
3064
            {
3065
              s[0] = (s[1] == 'B'
3066
                      ? MAGIC_FB_BACKWARD_CHAR : MAGIC_FB_FORWARD_CHAR);
3067
              s[1] = c;
3068
            }
3069
        }
3070
      else
3071
        s++;
3072
    }
3073
 
3074
  /* Skip any spaces after the operands.  */
3075
  while (*s
3076
         && ISSPACE (*s)
3077
         && *s != ';'
3078
         && !is_end_of_line[(unsigned int) *s])
3079
    s++;
3080
 
3081
  /* If we're now looking at a semi-colon, then it's an end-of-line
3082
     delimiter.  */
3083
  mmix_next_semicolon_is_eoln = (*s == ';');
3084
 
3085
  /* Make IS into an EQU by replacing it with "= ".  Only match upper-case
3086
     though; let lower-case be a syntax error.  */
3087
  s = insn;
3088
  if (s[0] == 'I' && s[1] == 'S' && ISSPACE (s[2]))
3089
    {
3090
      *s = '=';
3091
      s[1] = ' ';
3092
 
3093
      /* Since labels can start without ":", we have to handle "X IS 42"
3094
         in full here, or "X" will be parsed as a label to be set at ".".  */
3095
      input_line_pointer = s;
3096
 
3097
      /* Right after this function ends, line numbers will be bumped if
3098
         input_line_pointer[-1] = '\n'.  We want accurate line numbers for
3099
         the equals call, so we bump them before the call, and make sure
3100
         they aren't bumped afterwards.  */
3101
      bump_line_counters ();
3102
 
3103
      /* A fb-label is valid as an IS-label.  */
3104
      if (current_fb_label >= 0)
3105
        {
3106
          char *fb_name;
3107
 
3108
          /* We need to save this name on our symbol obstack, since the
3109
             string we got in fb_label_name is volatile and will change
3110
             with every call to fb_label_name, like those resulting from
3111
             parsing the IS-operand.  */
3112
          fb_name = fb_label_name (current_fb_label, 1);
3113
          obstack_grow (&mmix_sym_obstack, fb_name, strlen (fb_name) + 1);
3114
          equals (obstack_finish (&mmix_sym_obstack), 0);
3115
          fb_label_instance_inc (current_fb_label);
3116
          current_fb_label = -1;
3117
        }
3118
      else
3119
        {
3120
          if (pending_label == NULL)
3121
            as_bad (_("empty label field for IS"));
3122
          else
3123
            equals (pending_label, 0);
3124
          pending_label = NULL;
3125
        }
3126
 
3127
      /* For mmixal, we can have comments without a comment-start
3128
         character.   */
3129
      mmix_handle_rest_of_empty_line ();
3130
      input_line_pointer--;
3131
 
3132
      input_line_pointer[-1] = ' ';
3133
    }
3134
  else if (s[0] == 'G'
3135
           && s[1] == 'R'
3136
           && strncmp (s, "GREG", 4) == 0
3137
           && (ISSPACE (s[4]) || is_end_of_line[(unsigned char) s[4]]))
3138
    {
3139
      input_line_pointer = s + 4;
3140
 
3141
      /* Right after this function ends, line numbers will be bumped if
3142
         input_line_pointer[-1] = '\n'.  We want accurate line numbers for
3143
         the s_greg call, so we bump them before the call, and make sure
3144
         they aren't bumped afterwards.  */
3145
      bump_line_counters ();
3146
 
3147
      /* A fb-label is valid as a GREG-label.  */
3148
      if (current_fb_label >= 0)
3149
        {
3150
          char *fb_name;
3151
 
3152
          /* We need to save this name on our symbol obstack, since the
3153
             string we got in fb_label_name is volatile and will change
3154
             with every call to fb_label_name, like those resulting from
3155
             parsing the IS-operand.  */
3156
          fb_name = fb_label_name (current_fb_label, 1);
3157
 
3158
          /* Make sure we save the canonical name and don't get bitten by
3159
             prefixes.  */
3160
          obstack_1grow (&mmix_sym_obstack, ':');
3161
          obstack_grow (&mmix_sym_obstack, fb_name, strlen (fb_name) + 1);
3162
          mmix_greg_internal (obstack_finish (&mmix_sym_obstack));
3163
          fb_label_instance_inc (current_fb_label);
3164
          current_fb_label = -1;
3165
        }
3166
      else
3167
        mmix_greg_internal (pending_label);
3168
 
3169
      /* Back up before the end-of-line marker that was skipped in
3170
         mmix_greg_internal.  */
3171
      input_line_pointer--;
3172
      input_line_pointer[-1] = ' ';
3173
 
3174
      pending_label = NULL;
3175
    }
3176
  else if (pending_label != NULL)
3177
    {
3178
      input_line_pointer += strlen (pending_label);
3179
 
3180
      /* See comment above about getting line numbers bumped.  */
3181
      input_line_pointer[-1] = '\n';
3182
    }
3183
}
3184
 
3185
/* Give the value of an fb-label rewritten as in mmix_handle_mmixal, when
3186
   parsing an expression.
3187
 
3188
   On valid calls, input_line_pointer points at a MAGIC_FB_BACKWARD_CHAR
3189
   or MAGIC_FB_BACKWARD_CHAR, followed by an ascii digit for the label.
3190
   We fill in the label as an expression.  */
3191
 
3192
void
3193
mmix_fb_label (expressionS *expP)
3194
{
3195
  symbolS *sym;
3196
  char *fb_internal_name;
3197
 
3198
  /* This doesn't happen when not using mmixal syntax.  */
3199
  if (mmix_gnu_syntax
3200
      || (input_line_pointer[0] != MAGIC_FB_BACKWARD_CHAR
3201
          && input_line_pointer[0] != MAGIC_FB_FORWARD_CHAR))
3202
    return;
3203
 
3204
  /* The current backward reference has augmentation 0.  A forward
3205
     reference has augmentation 1, unless it's the same as a fb-label on
3206
     _this_ line, in which case we add one more so we don't refer to it.
3207
     This is the semantics of mmixal; it differs to that of common
3208
     fb-labels which refer to a here-label on the current line as a
3209
     backward reference.  */
3210
  fb_internal_name
3211
    = fb_label_name (input_line_pointer[1] - '0',
3212
                     (input_line_pointer[0] == MAGIC_FB_FORWARD_CHAR ? 1 : 0)
3213
                     + ((input_line_pointer[1] - '0' == current_fb_label
3214
                         && input_line_pointer[0] == MAGIC_FB_FORWARD_CHAR)
3215
                        ? 1 : 0));
3216
 
3217
  input_line_pointer += 2;
3218
  sym = symbol_find_or_make (fb_internal_name);
3219
 
3220
  /* We don't have to clean up unrelated fields here; we just do what the
3221
     expr machinery does, but *not* just what it does for [0-9][fb], since
3222
     we need to treat those as ordinary symbols sometimes; see testcases
3223
     err-byte2.s and fb-2.s.  */
3224
  if (S_GET_SEGMENT (sym) == absolute_section)
3225
    {
3226
      expP->X_op = O_constant;
3227
      expP->X_add_number = S_GET_VALUE (sym);
3228
    }
3229
  else
3230
    {
3231
      expP->X_op = O_symbol;
3232
      expP->X_add_symbol = sym;
3233
      expP->X_add_number = 0;
3234
    }
3235
}
3236
 
3237
/* See whether we need to force a relocation into the output file.
3238
   This is used to force out switch and PC relative relocations when
3239
   relaxing.  */
3240
 
3241
int
3242
mmix_force_relocation (fixS *fixP)
3243
{
3244
  if (fixP->fx_r_type == BFD_RELOC_MMIX_LOCAL
3245
      || fixP->fx_r_type == BFD_RELOC_MMIX_BASE_PLUS_OFFSET)
3246
    return 1;
3247
 
3248
  if (linkrelax)
3249
    return 1;
3250
 
3251
  /* All our pcrel relocations are must-keep.  Note that md_apply_fix is
3252
     called *after* this, and will handle getting rid of the presumed
3253
     reloc; a relocation isn't *forced* other than to be handled by
3254
     md_apply_fix (or tc_gen_reloc if linkrelax).  */
3255
  if (fixP->fx_pcrel)
3256
    return 1;
3257
 
3258
  return generic_force_reloc (fixP);
3259
}
3260
 
3261
/* The location from which a PC relative jump should be calculated,
3262
   given a PC relative reloc.  */
3263
 
3264
long
3265
md_pcrel_from_section (fixS *fixP, segT sec)
3266
{
3267
  if (fixP->fx_addsy != (symbolS *) NULL
3268
      && (! S_IS_DEFINED (fixP->fx_addsy)
3269
          || S_GET_SEGMENT (fixP->fx_addsy) != sec))
3270
    {
3271
      /* The symbol is undefined (or is defined but not in this section).
3272
         Let the linker figure it out.  */
3273
      return 0;
3274
    }
3275
 
3276
  return (fixP->fx_frag->fr_address + fixP->fx_where);
3277
}
3278
 
3279
/* Adjust the symbol table.  We make reg_section relative to the real
3280
   register section.  */
3281
 
3282
void
3283
mmix_adjust_symtab (void)
3284
{
3285
  symbolS *sym;
3286
  symbolS *regsec = section_symbol (reg_section);
3287
 
3288
  for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym))
3289
    if (S_GET_SEGMENT (sym) == reg_section)
3290
      {
3291
        if (sym == regsec)
3292
          {
3293
            if (S_IS_EXTERNAL (sym) || symbol_used_in_reloc_p (sym))
3294
              abort ();
3295
            symbol_remove (sym, &symbol_rootP, &symbol_lastP);
3296
          }
3297
        else
3298
          /* Change section to the *real* register section, so it gets
3299
             proper treatment when writing it out.  Only do this for
3300
             global symbols.  This also means we don't have to check for
3301
             $0..$255.  */
3302
          S_SET_SEGMENT (sym, real_reg_section);
3303
      }
3304
}
3305
 
3306
/* This is the expansion of LABELS_WITHOUT_COLONS.
3307
   We let md_start_line_hook tweak label_without_colon_this_line, and then
3308
   this function returns the tweaked value, and sets it to 1 for the next
3309
   line.  FIXME: Very, very brittle.  Not sure it works the way I
3310
   thought at the time I first wrote this.  */
3311
 
3312
int
3313
mmix_label_without_colon_this_line (void)
3314
{
3315
  int retval = label_without_colon_this_line;
3316
 
3317
  if (! mmix_gnu_syntax)
3318
    label_without_colon_this_line = 1;
3319
 
3320
  return retval;
3321
}
3322
 
3323
/* This is the expansion of md_relax_frag.  We go through the ordinary
3324
   relax table function except when the frag is for a GREG.  Then we have
3325
   to check whether there's another GREG by the same value that we can
3326
   join with.  */
3327
 
3328
long
3329
mmix_md_relax_frag (segT seg, fragS *fragP, long stretch)
3330
{
3331
  switch (fragP->fr_subtype)
3332
    {
3333
      /* Growth for this type has been handled by mmix_md_end and
3334
         correctly estimated, so there's nothing more to do here.  */
3335
    case STATE_GREG_DEF:
3336
      return 0;
3337
 
3338
    case ENCODE_RELAX (STATE_PUSHJ, STATE_ZERO):
3339
      {
3340
        /* We need to handle relaxation type ourselves, since relax_frag
3341
           doesn't update fr_subtype if there's no size increase in the
3342
           current section; when going from plain PUSHJ to a stub.  This
3343
           is otherwise functionally the same as relax_frag in write.c,
3344
           simplified for this case.  */
3345
        offsetT aim;
3346
        addressT target;
3347
        addressT address;
3348
        symbolS *symbolP;
3349
        target = fragP->fr_offset;
3350
        address = fragP->fr_address;
3351
        symbolP = fragP->fr_symbol;
3352
 
3353
        if (symbolP)
3354
          {
3355
            fragS *sym_frag;
3356
 
3357
            sym_frag = symbol_get_frag (symbolP);
3358
            know (S_GET_SEGMENT (symbolP) != absolute_section
3359
                  || sym_frag == &zero_address_frag);
3360
            target += S_GET_VALUE (symbolP);
3361
 
3362
            /* If frag has yet to be reached on this pass, assume it will
3363
               move by STRETCH just as we did.  If this is not so, it will
3364
               be because some frag between grows, and that will force
3365
               another pass.  */
3366
 
3367
            if (stretch != 0
3368
                && sym_frag->relax_marker != fragP->relax_marker
3369
                && S_GET_SEGMENT (symbolP) == seg)
3370
              target += stretch;
3371
          }
3372
 
3373
        aim = target - address - fragP->fr_fix;
3374
        if (aim >= PUSHJ_0B && aim <= PUSHJ_0F)
3375
          {
3376
            /* Target is reachable with a PUSHJ.  */
3377
            segment_info_type *seginfo = seg_info (seg);
3378
 
3379
            /* If we're at the end of a relaxation round, clear the stub
3380
               counter as initialization for the next round.  */
3381
            if (fragP == seginfo->tc_segment_info_data.last_stubfrag)
3382
              seginfo->tc_segment_info_data.nstubs = 0;
3383
            return 0;
3384
          }
3385
 
3386
        /* Not reachable.  Try a stub.  */
3387
        fragP->fr_subtype = ENCODE_RELAX (STATE_PUSHJSTUB, STATE_ZERO);
3388
      }
3389
      /* FALLTHROUGH.  */
3390
 
3391
      /* See if this PUSHJ is redirectable to a stub.  */
3392
    case ENCODE_RELAX (STATE_PUSHJSTUB, STATE_ZERO):
3393
      {
3394
        segment_info_type *seginfo = seg_info (seg);
3395
        fragS *lastfrag = seginfo->frchainP->frch_last;
3396
        relax_substateT prev_type = fragP->fr_subtype;
3397
 
3398
        /* The last frag is always an empty frag, so it suffices to look
3399
           at its address to know the ending address of this section.  */
3400
        know (lastfrag->fr_type == rs_fill
3401
              && lastfrag->fr_fix == 0
3402
              && lastfrag->fr_var == 0);
3403
 
3404
        /* For this PUSHJ to be relaxable into a call to a stub, the
3405
           distance must be no longer than 256k bytes from the PUSHJ to
3406
           the end of the section plus the maximum size of stubs so far.  */
3407
        if ((lastfrag->fr_address
3408
             + stretch
3409
             + PUSHJ_MAX_LEN * seginfo->tc_segment_info_data.nstubs)
3410
            - (fragP->fr_address + fragP->fr_fix)
3411
            > GETA_0F
3412
            || !pushj_stubs)
3413
          fragP->fr_subtype = mmix_relax_table[prev_type].rlx_more;
3414
        else
3415
          seginfo->tc_segment_info_data.nstubs++;
3416
 
3417
        /* If we're at the end of a relaxation round, clear the stub
3418
           counter as initialization for the next round.  */
3419
        if (fragP == seginfo->tc_segment_info_data.last_stubfrag)
3420
          seginfo->tc_segment_info_data.nstubs = 0;
3421
 
3422
        return
3423
           (mmix_relax_table[fragP->fr_subtype].rlx_length
3424
            - mmix_relax_table[prev_type].rlx_length);
3425
      }
3426
 
3427
    case ENCODE_RELAX (STATE_PUSHJ, STATE_MAX):
3428
      {
3429
        segment_info_type *seginfo = seg_info (seg);
3430
 
3431
        /* Need to cover all STATE_PUSHJ states to act on the last stub
3432
           frag (the end of this relax round; initialization for the
3433
           next).  */
3434
        if (fragP == seginfo->tc_segment_info_data.last_stubfrag)
3435
          seginfo->tc_segment_info_data.nstubs = 0;
3436
 
3437
        return 0;
3438
      }
3439
 
3440
    default:
3441
      return relax_frag (seg, fragP, stretch);
3442
 
3443
    case STATE_GREG_UNDF:
3444
      BAD_CASE (fragP->fr_subtype);
3445
    }
3446
 
3447
  as_fatal (_("internal: unexpected relax type %d:%d"),
3448
            fragP->fr_type, fragP->fr_subtype);
3449
  return 0;
3450
}
3451
 
3452
/* Various things we punt until all input is seen.  */
3453
 
3454
void
3455
mmix_md_end (void)
3456
{
3457
  fragS *fragP;
3458
  symbolS *mainsym;
3459
  asection *regsec;
3460
  int i;
3461
 
3462
  /* The first frag of GREG:s going into the register contents section.  */
3463
  fragS *mmix_reg_contents_frags = NULL;
3464
 
3465
  /* Reset prefix.  All labels reachable at this point must be
3466
     canonicalized.  */
3467
  mmix_current_prefix = NULL;
3468
 
3469
  if (doing_bspec)
3470
    as_bad_where (bspec_file, bspec_line, _("BSPEC without ESPEC."));
3471
 
3472
  /* Emit the low LOC setting of .text.  */
3473
  if (text_has_contents && lowest_text_loc != (bfd_vma) -1)
3474
    {
3475
      symbolS *symbolP;
3476
      char locsymbol[sizeof (":") - 1
3477
                    + sizeof (MMIX_LOC_SECTION_START_SYMBOL_PREFIX) - 1
3478
                    + sizeof (".text")];
3479
 
3480
      /* An exercise in non-ISO-C-ness, this one.  */
3481
      sprintf (locsymbol, ":%s%s", MMIX_LOC_SECTION_START_SYMBOL_PREFIX,
3482
               ".text");
3483
      symbolP
3484
        = symbol_new (locsymbol, absolute_section, lowest_text_loc,
3485
                      &zero_address_frag);
3486
      S_SET_EXTERNAL (symbolP);
3487
    }
3488
 
3489
  /* Ditto .data.  */
3490
  if (data_has_contents && lowest_data_loc != (bfd_vma) -1)
3491
    {
3492
      symbolS *symbolP;
3493
      char locsymbol[sizeof (":") - 1
3494
                     + sizeof (MMIX_LOC_SECTION_START_SYMBOL_PREFIX) - 1
3495
                     + sizeof (".data")];
3496
 
3497
      sprintf (locsymbol, ":%s%s", MMIX_LOC_SECTION_START_SYMBOL_PREFIX,
3498
               ".data");
3499
      symbolP
3500
        = symbol_new (locsymbol, absolute_section, lowest_data_loc,
3501
                      &zero_address_frag);
3502
      S_SET_EXTERNAL (symbolP);
3503
    }
3504
 
3505
  /* Unless GNU syntax mode, set "Main" to be a function, so the
3506
     disassembler doesn't get confused when we write truly
3507
     mmixal-compatible code (and don't use .type).  Similarly set it
3508
     global (regardless of -globalize-symbols), so the linker sees it as
3509
     the start symbol in ELF mode.  */
3510
  mainsym = symbol_find (MMIX_START_SYMBOL_NAME);
3511
  if (mainsym != NULL && ! mmix_gnu_syntax)
3512
    {
3513
      symbol_get_bfdsym (mainsym)->flags |= BSF_FUNCTION;
3514
      S_SET_EXTERNAL (mainsym);
3515
    }
3516
 
3517
  if (n_of_raw_gregs != 0)
3518
    {
3519
      /* Emit GREGs.  They are collected in order of appearance, but must
3520
         be emitted in opposite order to both have section address regno*8
3521
         and the same allocation order (within a file) as mmixal.  */
3522
      segT this_segment = now_seg;
3523
      subsegT this_subsegment = now_subseg;
3524
 
3525
      regsec = bfd_make_section_old_way (stdoutput,
3526
                                         MMIX_REG_CONTENTS_SECTION_NAME);
3527
      subseg_set (regsec, 0);
3528
 
3529
      /* Finally emit the initialization-value.  Emit a variable frag, which
3530
         we'll fix in md_estimate_size_before_relax.  We set the initializer
3531
         for the tc_frag_data field to NULL, so we can use that field for
3532
         relaxation purposes.  */
3533
      mmix_opcode_frag = NULL;
3534
 
3535
      frag_grow (0);
3536
      mmix_reg_contents_frags = frag_now;
3537
 
3538
      for (i = n_of_raw_gregs - 1; i >= 0; i--)
3539
        {
3540
          if (mmix_raw_gregs[i].label != NULL)
3541
            /* There's a symbol.  Let it refer to this location in the
3542
               register contents section.  The symbol must be globalized
3543
               separately.  */
3544
            colon (mmix_raw_gregs[i].label);
3545
 
3546
          frag_var (rs_machine_dependent, 8, 0, STATE_GREG_UNDF,
3547
                    make_expr_symbol (&mmix_raw_gregs[i].exp), 0, NULL);
3548
        }
3549
 
3550
      subseg_set (this_segment, this_subsegment);
3551
    }
3552
 
3553
  regsec = bfd_get_section_by_name (stdoutput, MMIX_REG_CONTENTS_SECTION_NAME);
3554
  /* Mark the section symbol as being OK for a reloc.  */
3555
  if (regsec != NULL)
3556
    regsec->symbol->flags |= BSF_KEEP;
3557
 
3558
  /* Iterate over frags resulting from GREGs and move those that evidently
3559
     have the same value together and point one to another.
3560
 
3561
     This works in time O(N^2) but since the upper bound for non-error use
3562
     is 223, it's best to keep this simpler algorithm.  */
3563
  for (fragP = mmix_reg_contents_frags; fragP != NULL; fragP = fragP->fr_next)
3564
    {
3565
      fragS **fpp;
3566
      fragS *fp = NULL;
3567
      fragS *osymfrag;
3568
      offsetT osymval;
3569
      expressionS *oexpP;
3570
      symbolS *symbolP = fragP->fr_symbol;
3571
 
3572
      if (fragP->fr_type != rs_machine_dependent
3573
          || fragP->fr_subtype != STATE_GREG_UNDF)
3574
        continue;
3575
 
3576
      /* Whatever the outcome, we will have this GREG judged merged or
3577
         non-merged.  Since the tc_frag_data is NULL at this point, we
3578
         default to non-merged.  */
3579
      fragP->fr_subtype = STATE_GREG_DEF;
3580
 
3581
      /* If we're not supposed to merge GREG definitions, then just don't
3582
         look for equivalents.  */
3583
      if (! merge_gregs)
3584
        continue;
3585
 
3586
      osymval = (offsetT) S_GET_VALUE (symbolP);
3587
      osymfrag = symbol_get_frag (symbolP);
3588
 
3589
      /* If the symbol isn't defined, we can't say that another symbol
3590
         equals this frag, then.  FIXME: We can look at the "deepest"
3591
         defined name; if a = c and b = c then obviously a == b.  */
3592
      if (! S_IS_DEFINED (symbolP))
3593
        continue;
3594
 
3595
      oexpP = symbol_get_value_expression (fragP->fr_symbol);
3596
 
3597
      /* If the initialization value is zero, then we must not merge them.  */
3598
      if (oexpP->X_op == O_constant && osymval == 0)
3599
        continue;
3600
 
3601
      /* Iterate through the frags downward this one.  If we find one that
3602
         has the same non-zero value, move it to after this one and point
3603
         to it as the equivalent.  */
3604
      for (fpp = &fragP->fr_next; *fpp != NULL; fpp = &fpp[0]->fr_next)
3605
        {
3606
          fp = *fpp;
3607
 
3608
          if (fp->fr_type != rs_machine_dependent
3609
              || fp->fr_subtype != STATE_GREG_UNDF)
3610
            continue;
3611
 
3612
          /* Calling S_GET_VALUE may simplify the symbol, changing from
3613
             expr_section etc. so call it first.  */
3614
          if ((offsetT) S_GET_VALUE (fp->fr_symbol) == osymval
3615
              && symbol_get_frag (fp->fr_symbol) == osymfrag)
3616
            {
3617
              /* Move the frag links so the one we found equivalent comes
3618
                 after the current one, carefully considering that
3619
                 sometimes fpp == &fragP->fr_next and the moves must be a
3620
                 NOP then.  */
3621
              *fpp = fp->fr_next;
3622
              fp->fr_next = fragP->fr_next;
3623
              fragP->fr_next = fp;
3624
              break;
3625
            }
3626
        }
3627
 
3628
      if (*fpp != NULL)
3629
        fragP->tc_frag_data = fp;
3630
    }
3631
}
3632
 
3633
/* qsort function for mmix_symbol_gregs.  */
3634
 
3635
static int
3636
cmp_greg_symbol_fixes (const void *parg, const void *qarg)
3637
{
3638
  const struct mmix_symbol_greg_fixes *p
3639
    = (const struct mmix_symbol_greg_fixes *) parg;
3640
  const struct mmix_symbol_greg_fixes *q
3641
    = (const struct mmix_symbol_greg_fixes *) qarg;
3642
 
3643
  return p->offs > q->offs ? 1 : p->offs < q->offs ? -1 : 0;
3644
}
3645
 
3646
/* Collect GREG definitions from mmix_gregs and hang them as lists sorted
3647
   on increasing offsets onto each section symbol or undefined symbol.
3648
 
3649
   Also, remove the register convenience section so it doesn't get output
3650
   as an ELF section.  */
3651
 
3652
void
3653
mmix_frob_file (void)
3654
{
3655
  int i;
3656
  struct mmix_symbol_gregs *all_greg_symbols[MAX_GREGS];
3657
  int n_greg_symbols = 0;
3658
 
3659
  /* Collect all greg fixups and decorate each corresponding symbol with
3660
     the greg fixups for it.  */
3661
  for (i = 0; i < n_of_cooked_gregs; i++)
3662
    {
3663
      offsetT offs;
3664
      symbolS *sym;
3665
      struct mmix_symbol_gregs *gregs;
3666
      fixS *fixP;
3667
 
3668
      fixP = mmix_gregs[i];
3669
      know (fixP->fx_r_type == BFD_RELOC_64);
3670
 
3671
      /* This case isn't doable in general anyway, methinks.  */
3672
      if (fixP->fx_subsy != NULL)
3673
        {
3674
          as_bad_where (fixP->fx_file, fixP->fx_line,
3675
                        _("GREG expression too complicated"));
3676
          continue;
3677
        }
3678
 
3679
      sym = fixP->fx_addsy;
3680
      offs = (offsetT) fixP->fx_offset;
3681
 
3682
      /* If the symbol is defined, then it must be resolved to a section
3683
         symbol at this time, or else we don't know how to handle it.  */
3684
      if (S_IS_DEFINED (sym)
3685
          && !bfd_is_com_section (S_GET_SEGMENT (sym))
3686
          && !S_IS_WEAK (sym))
3687
        {
3688
          if (! symbol_section_p (sym)
3689
              && ! bfd_is_abs_section (S_GET_SEGMENT (sym)))
3690
            as_fatal (_("internal: GREG expression not resolved to section"));
3691
 
3692
          offs += S_GET_VALUE (sym);
3693
        }
3694
 
3695
      /* If this is an absolute symbol sufficiently near lowest_data_loc,
3696
         then we canonicalize on the data section.  Note that offs is
3697
         signed here; we may subtract lowest_data_loc which is unsigned.
3698
         Careful with those comparisons.  */
3699
      if (lowest_data_loc != (bfd_vma) -1
3700
          && (bfd_vma) offs + 256 > lowest_data_loc
3701
          && bfd_is_abs_section (S_GET_SEGMENT (sym)))
3702
        {
3703
          offs -= (offsetT) lowest_data_loc;
3704
          sym = section_symbol (data_section);
3705
        }
3706
      /* Likewise text section.  */
3707
      else if (lowest_text_loc != (bfd_vma) -1
3708
               && (bfd_vma) offs + 256 > lowest_text_loc
3709
               && bfd_is_abs_section (S_GET_SEGMENT (sym)))
3710
        {
3711
          offs -= (offsetT) lowest_text_loc;
3712
          sym = section_symbol (text_section);
3713
        }
3714
 
3715
      gregs = *symbol_get_tc (sym);
3716
 
3717
      if (gregs == NULL)
3718
        {
3719
          gregs = xmalloc (sizeof (*gregs));
3720
          gregs->n_gregs = 0;
3721
          symbol_set_tc (sym, &gregs);
3722
          all_greg_symbols[n_greg_symbols++] = gregs;
3723
        }
3724
 
3725
      gregs->greg_fixes[gregs->n_gregs].fix = fixP;
3726
      gregs->greg_fixes[gregs->n_gregs++].offs = offs;
3727
    }
3728
 
3729
  /* For each symbol having a GREG definition, sort those definitions on
3730
     offset.  */
3731
  for (i = 0; i < n_greg_symbols; i++)
3732
    qsort (all_greg_symbols[i]->greg_fixes, all_greg_symbols[i]->n_gregs,
3733
           sizeof (all_greg_symbols[i]->greg_fixes[0]), cmp_greg_symbol_fixes);
3734
 
3735
  if (real_reg_section != NULL)
3736
    {
3737
      /* FIXME: Pass error state gracefully.  */
3738
      if (bfd_get_section_flags (stdoutput, real_reg_section) & SEC_HAS_CONTENTS)
3739
        as_fatal (_("register section has contents\n"));
3740
 
3741
      bfd_section_list_remove (stdoutput, real_reg_section);
3742
      --stdoutput->section_count;
3743
    }
3744
 
3745
}
3746
 
3747
/* Provide an expression for a built-in name provided when-used.
3748
   Either a symbol that is a handler; living in 0x10*[1..8] and having
3749
   name [DVWIOUZX]_Handler, or a mmixal built-in symbol.
3750
 
3751
   If the name isn't a built-in name and parsed into *EXPP, return zero.  */
3752
 
3753
int
3754
mmix_parse_predefined_name (char *name, expressionS *expP)
3755
{
3756
  char *canon_name;
3757
  char *handler_charp;
3758
  const char handler_chars[] = "DVWIOUZX";
3759
  symbolS *symp;
3760
 
3761
  if (! predefined_syms)
3762
    return 0;
3763
 
3764
  canon_name = tc_canonicalize_symbol_name (name);
3765
 
3766
  if (canon_name[1] == '_'
3767
      && strcmp (canon_name + 2, "Handler") == 0
3768
      && (handler_charp = strchr (handler_chars, *canon_name)) != NULL)
3769
    {
3770
      /* If the symbol doesn't exist, provide one relative to the .text
3771
         section.
3772
 
3773
         FIXME: We should provide separate sections, mapped in the linker
3774
         script.  */
3775
      symp = symbol_find (name);
3776
      if (symp == NULL)
3777
        symp = symbol_new (name, text_section,
3778
                           0x10 * (handler_charp + 1 - handler_chars),
3779
                           &zero_address_frag);
3780
    }
3781
  else
3782
    {
3783
      /* These symbols appear when referenced; needed for
3784
         mmixal-compatible programs.  */
3785
      unsigned int i;
3786
 
3787
      static const struct
3788
      {
3789
        const char *name;
3790
        valueT val;
3791
      } predefined_abs_syms[] =
3792
        {
3793
          {"Data_Segment", (valueT) 0x20 << 56},
3794
          {"Pool_Segment", (valueT) 0x40 << 56},
3795
          {"Stack_Segment", (valueT) 0x60 << 56},
3796
          {"StdIn", 0},
3797
          {"StdOut", 1},
3798
          {"StdErr", 2},
3799
          {"TextRead", 0},
3800
          {"TextWrite", 1},
3801
          {"BinaryRead", 2},
3802
          {"BinaryWrite", 3},
3803
          {"BinaryReadWrite", 4},
3804
          {"Halt", 0},
3805
          {"Fopen", 1},
3806
          {"Fclose", 2},
3807
          {"Fread", 3},
3808
          {"Fgets", 4},
3809
          {"Fgetws", 5},
3810
          {"Fwrite", 6},
3811
          {"Fputs", 7},
3812
          {"Fputws", 8},
3813
          {"Fseek", 9},
3814
          {"Ftell", 10},
3815
          {"D_BIT", 0x80},
3816
          {"V_BIT", 0x40},
3817
          {"W_BIT", 0x20},
3818
          {"I_BIT", 0x10},
3819
          {"O_BIT", 0x08},
3820
          {"U_BIT", 0x04},
3821
          {"Z_BIT", 0x02},
3822
          {"X_BIT", 0x01},
3823
          {"Inf", 0x7ff00000}
3824
        };
3825
 
3826
      /* If it's already in the symbol table, we shouldn't do anything.  */
3827
      symp = symbol_find (name);
3828
      if (symp != NULL)
3829
        return 0;
3830
 
3831
      for (i = 0;
3832
           i < sizeof (predefined_abs_syms) / sizeof (predefined_abs_syms[0]);
3833
           i++)
3834
        if (strcmp (canon_name, predefined_abs_syms[i].name) == 0)
3835
          {
3836
            symbol_table_insert (symbol_new (predefined_abs_syms[i].name,
3837
                                             absolute_section,
3838
                                             predefined_abs_syms[i].val,
3839
                                             &zero_address_frag));
3840
 
3841
            /* Let gas find the symbol we just created, through its
3842
               ordinary lookup.  */
3843
            return 0;
3844
          }
3845
 
3846
      /* Not one of those symbols.  Let gas handle it.  */
3847
      return 0;
3848
    }
3849
 
3850
  expP->X_op = O_symbol;
3851
  expP->X_add_number = 0;
3852
  expP->X_add_symbol = symp;
3853
  expP->X_op_symbol = NULL;
3854
 
3855
  return 1;
3856
}
3857
 
3858
/* Just check that we don't have a BSPEC/ESPEC pair active when changing
3859
   sections "normally", and get knowledge about alignment from the new
3860
   section.  */
3861
 
3862
void
3863
mmix_md_elf_section_change_hook (void)
3864
{
3865
  if (doing_bspec)
3866
    as_bad (_("section change from within a BSPEC/ESPEC pair is not supported"));
3867
 
3868
  last_alignment = bfd_get_section_alignment (now_seg->owner, now_seg);
3869
  want_unaligned = 0;
3870
}
3871
 
3872
/* The LOC worker.  This is like s_org, but we have to support changing
3873
   section too.   */
3874
 
3875
static void
3876
s_loc (int ignore ATTRIBUTE_UNUSED)
3877
{
3878
  segT section;
3879
  expressionS exp;
3880
  char *p;
3881
  symbolS *sym;
3882
  offsetT off;
3883
 
3884
  /* Must not have a BSPEC in progress.  */
3885
  if (doing_bspec)
3886
    {
3887
      as_bad (_("directive LOC from within a BSPEC/ESPEC pair is not supported"));
3888
      return;
3889
    }
3890
 
3891
  section = expression (&exp);
3892
 
3893
  if (exp.X_op == O_illegal
3894
      || exp.X_op == O_absent
3895
      || exp.X_op == O_big
3896
      || section == undefined_section)
3897
    {
3898
      as_bad (_("invalid LOC expression"));
3899
      return;
3900
    }
3901
 
3902
  if (section == absolute_section)
3903
    {
3904
      /* Translate a constant into a suitable section.  */
3905
 
3906
      if (exp.X_add_number < ((offsetT) 0x20 << 56))
3907
        {
3908
          /* Lower than Data_Segment or in the reserved area (the
3909
             segment number is >= 0x80, appearing negative) - assume
3910
             it's .text.  */
3911
          section = text_section;
3912
 
3913
          /* Save the lowest seen location, so we can pass on this
3914
             information to the linker.  We don't actually org to this
3915
             location here, we just pass on information to the linker so
3916
             it can put the code there for us.  */
3917
 
3918
          /* If there was already a loc (that has to be set lower than
3919
             this one), we org at (this - lower).  There's an implicit
3920
             "LOC 0" before any entered code.  FIXME: handled by spurious
3921
             settings of text_has_contents.  */
3922
          if (lowest_text_loc != (bfd_vma) -1
3923
              && (bfd_vma) exp.X_add_number < lowest_text_loc)
3924
            {
3925
              as_bad (_("LOC expression stepping backwards is not supported"));
3926
              exp.X_op = O_absent;
3927
            }
3928
          else
3929
            {
3930
              if (text_has_contents && lowest_text_loc == (bfd_vma) -1)
3931
                lowest_text_loc = 0;
3932
 
3933
              if (lowest_text_loc == (bfd_vma) -1)
3934
                {
3935
                  lowest_text_loc = exp.X_add_number;
3936
 
3937
                  /* We want only to change the section, not set an offset.  */
3938
                  exp.X_op = O_absent;
3939
                }
3940
              else
3941
                exp.X_add_number -= lowest_text_loc;
3942
            }
3943
        }
3944
      else
3945
        {
3946
          /* Do the same for the .data section, except we don't have
3947
             to worry about exp.X_add_number carrying a sign.  */
3948
          section = data_section;
3949
 
3950
          if (exp.X_add_number < (offsetT) lowest_data_loc)
3951
            {
3952
              as_bad (_("LOC expression stepping backwards is not supported"));
3953
              exp.X_op = O_absent;
3954
            }
3955
          else
3956
            {
3957
              if (data_has_contents && lowest_data_loc == (bfd_vma) -1)
3958
                lowest_data_loc = (bfd_vma) 0x20 << 56;
3959
 
3960
              if (lowest_data_loc == (bfd_vma) -1)
3961
                {
3962
                  lowest_data_loc = exp.X_add_number;
3963
 
3964
                  /* We want only to change the section, not set an offset.  */
3965
                  exp.X_op = O_absent;
3966
                }
3967
              else
3968
                exp.X_add_number -= lowest_data_loc;
3969
            }
3970
        }
3971
    }
3972
 
3973
  if (section != now_seg)
3974
    {
3975
      obj_elf_section_change_hook ();
3976
      subseg_set (section, 0);
3977
 
3978
      /* Call our section change hooks using the official hook.  */
3979
      md_elf_section_change_hook ();
3980
    }
3981
 
3982
  if (exp.X_op != O_absent)
3983
    {
3984
      if (exp.X_op != O_constant && exp.X_op != O_symbol)
3985
        {
3986
          /* Handle complex expressions.  */
3987
          sym = make_expr_symbol (&exp);
3988
          off = 0;
3989
        }
3990
      else
3991
        {
3992
          sym = exp.X_add_symbol;
3993
          off = exp.X_add_number;
3994
        }
3995
 
3996
      p = frag_var (rs_org, 1, 1, (relax_substateT) 0, sym, off, (char *) 0);
3997
      *p = 0;
3998
    }
3999
 
4000
  mmix_handle_rest_of_empty_line ();
4001
}
4002
 
4003
/* The BYTE worker.  We have to support sequences of mixed "strings",
4004
   numbers and other constant "first-pass" reducible expressions separated
4005
   by comma.  */
4006
 
4007
static void
4008
mmix_byte (void)
4009
{
4010
  unsigned int c;
4011
 
4012
  if (now_seg == text_section)
4013
    text_has_contents = 1;
4014
  else if (now_seg == data_section)
4015
    data_has_contents = 1;
4016
 
4017
  do
4018
    {
4019
      SKIP_WHITESPACE ();
4020
      switch (*input_line_pointer)
4021
        {
4022
        case '\"':
4023
          ++input_line_pointer;
4024
          while (is_a_char (c = next_char_of_string ()))
4025
            {
4026
              FRAG_APPEND_1_CHAR (c);
4027
            }
4028
 
4029
          if (input_line_pointer[-1] != '\"')
4030
            {
4031
              /* We will only get here in rare cases involving #NO_APP,
4032
                 where the unterminated string is not recognized by the
4033
                 preformatting pass.  */
4034
              as_bad (_("unterminated string"));
4035
              mmix_discard_rest_of_line ();
4036
              return;
4037
            }
4038
          break;
4039
 
4040
        default:
4041
          {
4042
            expressionS exp;
4043
            segT expseg = expression (&exp);
4044
 
4045
            /* We have to allow special register names as constant numbers.  */
4046
            if ((expseg != absolute_section && expseg != reg_section)
4047
                || (exp.X_op != O_constant
4048
                    && (exp.X_op != O_register
4049
                        || exp.X_add_number <= 255)))
4050
              {
4051
                as_bad (_("BYTE expression not a pure number"));
4052
                mmix_discard_rest_of_line ();
4053
                return;
4054
              }
4055
            else if ((exp.X_add_number > 255 && exp.X_op != O_register)
4056
                     || exp.X_add_number < 0)
4057
              {
4058
                /* Note that mmixal does not allow negative numbers in
4059
                   BYTE sequences, so neither should we.  */
4060
                as_bad (_("BYTE expression not in the range 0..255"));
4061
                mmix_discard_rest_of_line ();
4062
                return;
4063
              }
4064
 
4065
            FRAG_APPEND_1_CHAR (exp.X_add_number);
4066
          }
4067
          break;
4068
        }
4069
 
4070
      SKIP_WHITESPACE ();
4071
      c = *input_line_pointer++;
4072
    }
4073
  while (c == ',');
4074
 
4075
  input_line_pointer--;
4076
 
4077
  if (mmix_gnu_syntax)
4078
    demand_empty_rest_of_line ();
4079
  else
4080
    {
4081
      mmix_discard_rest_of_line ();
4082
      /* Do like demand_empty_rest_of_line and step over the end-of-line
4083
         boundary.  */
4084
      input_line_pointer++;
4085
    }
4086
 
4087
  /* Make sure we align for the next instruction.  */
4088
  last_alignment = 0;
4089
}
4090
 
4091
/* Like cons_worker, but we have to ignore "naked comments", not barf on
4092
   them.  Implements WYDE, TETRA and OCTA.  We're a little bit more
4093
   lenient than mmix_byte but FIXME: they should eventually merge.  */
4094
 
4095
static void
4096
mmix_cons (int nbytes)
4097
{
4098
  expressionS exp;
4099
 
4100
  /* If we don't have any contents, then it's ok to have a specified start
4101
     address that is not a multiple of the max data size.  We will then
4102
     align it as necessary when we get here.  Otherwise, it's a fatal sin.  */
4103
  if (now_seg == text_section)
4104
    {
4105
      if (lowest_text_loc != (bfd_vma) -1
4106
          && (lowest_text_loc & (nbytes - 1)) != 0)
4107
        {
4108
          if (text_has_contents)
4109
            as_bad (_("data item with alignment larger than location"));
4110
          else if (want_unaligned)
4111
            as_bad (_("unaligned data at an absolute location is not supported"));
4112
 
4113
          lowest_text_loc &= ~((bfd_vma) nbytes - 1);
4114
          lowest_text_loc += (bfd_vma) nbytes;
4115
        }
4116
 
4117
      text_has_contents = 1;
4118
    }
4119
  else if (now_seg == data_section)
4120
    {
4121
      if (lowest_data_loc != (bfd_vma) -1
4122
          && (lowest_data_loc & (nbytes - 1)) != 0)
4123
        {
4124
          if (data_has_contents)
4125
            as_bad (_("data item with alignment larger than location"));
4126
          else if (want_unaligned)
4127
            as_bad (_("unaligned data at an absolute location is not supported"));
4128
 
4129
          lowest_data_loc &= ~((bfd_vma) nbytes - 1);
4130
          lowest_data_loc += (bfd_vma) nbytes;
4131
        }
4132
 
4133
      data_has_contents = 1;
4134
    }
4135
 
4136
  /* Always align these unless asked not to (valid for the current pseudo).  */
4137
  if (! want_unaligned)
4138
    {
4139
      last_alignment = nbytes == 2 ? 1 : (nbytes == 4 ? 2 : 3);
4140
      frag_align (last_alignment, 0, 0);
4141
      record_alignment (now_seg, last_alignment);
4142
    }
4143
 
4144
  /* For mmixal compatibility, a label for an instruction (and emitting
4145
     pseudo) refers to the _aligned_ address.  So we have to emit the
4146
     label here.  */
4147
  if (current_fb_label >= 0)
4148
    colon (fb_label_name (current_fb_label, 1));
4149
  else if (pending_label != NULL)
4150
    {
4151
      colon (pending_label);
4152
      pending_label = NULL;
4153
    }
4154
 
4155
  SKIP_WHITESPACE ();
4156
 
4157
  if (is_end_of_line[(unsigned int) *input_line_pointer])
4158
    {
4159
      /* Default to zero if the expression was absent.  */
4160
 
4161
      exp.X_op = O_constant;
4162
      exp.X_add_number = 0;
4163
      exp.X_unsigned = 0;
4164
      exp.X_add_symbol = NULL;
4165
      exp.X_op_symbol = NULL;
4166
      emit_expr (&exp, (unsigned int) nbytes);
4167
    }
4168
  else
4169
    do
4170
      {
4171
        unsigned int c;
4172
 
4173
        switch (*input_line_pointer)
4174
          {
4175
            /* We support strings here too; each character takes up nbytes
4176
               bytes.  */
4177
          case '\"':
4178
            ++input_line_pointer;
4179
            while (is_a_char (c = next_char_of_string ()))
4180
              {
4181
                exp.X_op = O_constant;
4182
                exp.X_add_number = c;
4183
                exp.X_unsigned = 1;
4184
                emit_expr (&exp, (unsigned int) nbytes);
4185
              }
4186
 
4187
            if (input_line_pointer[-1] != '\"')
4188
              {
4189
                /* We will only get here in rare cases involving #NO_APP,
4190
                   where the unterminated string is not recognized by the
4191
                   preformatting pass.  */
4192
                as_bad (_("unterminated string"));
4193
                mmix_discard_rest_of_line ();
4194
                return;
4195
              }
4196
            break;
4197
 
4198
          default:
4199
            {
4200
              expression (&exp);
4201
              emit_expr (&exp, (unsigned int) nbytes);
4202
              SKIP_WHITESPACE ();
4203
            }
4204
            break;
4205
          }
4206
      }
4207
    while (*input_line_pointer++ == ',');
4208
 
4209
  input_line_pointer--;         /* Put terminator back into stream.  */
4210
 
4211
  mmix_handle_rest_of_empty_line ();
4212
 
4213
  /* We don't need to step up the counter for the current_fb_label here;
4214
     that's handled by the caller.  */
4215
}
4216
 
4217
/* The md_do_align worker.  At present, we just record an alignment to
4218
   nullify the automatic alignment we do for WYDE, TETRA and OCTA, as gcc
4219
   does not use the unaligned macros when attribute packed is used.
4220
   Arguably this is a GCC bug.  */
4221
 
4222
void
4223
mmix_md_do_align (int n, char *fill ATTRIBUTE_UNUSED,
4224
                  int len ATTRIBUTE_UNUSED, int max ATTRIBUTE_UNUSED)
4225
{
4226
  last_alignment = n;
4227
  want_unaligned = n == 0;
4228
}

powered by: WebSVN 2.1.0

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