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