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, 2006, 2007
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 3, or (at your option)
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
23 /*#define SHOW_NUM 1*//* Uncomment for debugging. */
26 #include "opcode/ns32k.h"
31 #define IIF_ENTRIES 13 /* Number of entries in iif. */
32 #define PRIVATE_SIZE 256 /* Size of my garbage memory. */
34 #define DEFAULT -1 /* addr_mode returns this value when
35 plain constant or label is
38 #define IIF(ptr,a1,c1,e1,g1,i1,k1,m1,o1,q1,s1,u1) \
39 iif.iifP[ptr].type = a1; \
40 iif.iifP[ptr].size = c1; \
41 iif.iifP[ptr].object = e1; \
42 iif.iifP[ptr].object_adjust = g1; \
43 iif.iifP[ptr].pcrel = i1; \
44 iif.iifP[ptr].pcrel_adjust = k1; \
45 iif.iifP[ptr].im_disp = m1; \
46 iif.iifP[ptr].relax_substate = o1; \
47 iif.iifP[ptr].bit_fixP = q1; \
48 iif.iifP[ptr].addr_mode = s1; \
49 iif.iifP[ptr].bsr = u1;
51 #ifdef SEQUENT_COMPATABILITY
52 #define LINE_COMMENT_CHARS "|"
53 #define ABSOLUTE_PREFIX '@'
54 #define IMMEDIATE_PREFIX '#'
57 #ifndef LINE_COMMENT_CHARS
58 #define LINE_COMMENT_CHARS "#"
61 const char comment_chars
[] = "#";
62 const char line_comment_chars
[] = LINE_COMMENT_CHARS
;
63 const char line_separator_chars
[] = ";";
64 static int default_disp_size
= 4; /* Displacement size for external refs. */
66 #if !defined(ABSOLUTE_PREFIX) && !defined(IMMEDIATE_PREFIX)
67 #define ABSOLUTE_PREFIX '@' /* One or the other MUST be defined. */
72 signed char mode
; /* Addressing mode of operand (0-31). */
73 signed char scaled_mode
; /* Mode combined with scaled mode. */
74 char scaled_reg
; /* Register used in scaled+1 (1-8). */
75 char float_flag
; /* Set if R0..R7 was F0..F7 ie a
76 floating-point-register. */
77 char am_size
; /* Estimated max size of general addr-mode
79 char im_disp
; /* If im_disp==1 we have a displacement. */
80 char pcrel
; /* 1 if pcrel, this is really redundant info. */
81 char disp_suffix
[2]; /* Length of displacement(s), 0=undefined. */
82 char *disp
[2]; /* Pointer(s) at displacement(s)
83 or immediates(s) (ascii). */
84 char index_byte
; /* Index byte. */
86 typedef struct addr_mode addr_modeS
;
88 char *freeptr
, *freeptr_static
; /* Points at some number of free bytes. */
89 struct hash_control
*inst_hash_handle
;
91 struct ns32k_opcode
*desc
; /* Pointer at description of instruction. */
92 addr_modeS addr_modeP
;
93 const char EXP_CHARS
[] = "eE";
94 const char FLT_CHARS
[] = "fd"; /* We don't want to support lowercase,
97 /* UPPERCASE denotes live names when an instruction is built, IIF is
98 used as an intermediate form to store the actual parts of the
99 instruction. A ns32k machine instruction can be divided into a
100 couple of sub PARTs. When an instruction is assembled the
101 appropriate PART get an assignment. When an IIF has been completed
102 it is converted to a FRAGment as specified in AS.H. */
104 /* Internal structs. */
114 int type
; /* How to interpret object. */
115 int size
; /* Estimated max size of object. */
116 unsigned long object
; /* Binary data. */
117 int object_adjust
; /* Number added to object. */
118 int pcrel
; /* True if object is pcrel. */
119 int pcrel_adjust
; /* Length in bytes from the instruction
120 start to the displacement. */
121 int im_disp
; /* True if the object is a displacement. */
122 relax_substateT relax_substate
;/*Initial relaxsubstate. */
123 bit_fixS
*bit_fixP
; /* Pointer at bit_fix struct. */
124 int addr_mode
; /* What addrmode do we associate with this
126 char bsr
; /* Sequent hack. */
127 } iif_entryT
; /* Internal Instruction Format. */
131 int instr_size
; /* Max size of instruction in bytes. */
132 iif_entryT iifP
[IIF_ENTRIES
+ 1];
135 struct int_ins_form iif
;
137 char *input_line_pointer
;
139 /* Description of the PARTs in IIF
141 0 total length in bytes of entries in iif
154 For every entry there is a datalength in bytes. This is stored in size[n].
155 0, the objectlength is not explicitly given by the instruction
156 and the operand is undefined. This is a case for relaxation.
157 Reserve 4 bytes for the final object.
159 1, the entry contains one byte
160 2, the entry contains two bytes
161 3, the entry contains three bytes
162 4, the entry contains four bytes
165 Furthermore, every entry has a data type identifier in type[n].
167 0, the entry is void, ignore it.
168 1, the entry is a binary number.
169 2, the entry is a pointer at an expression.
170 Where expression may be as simple as a single '1',
171 and as complicated as foo-bar+12,
172 foo and bar may be undefined but suffixed by :{b|w|d} to
173 control the length of the object.
175 3, the entry is a pointer at a bignum struct
177 The low-order-byte corresponds to low physical memory.
178 Obviously a FRAGment must be created for each valid disp in PART whose
179 datalength is undefined (to bad) .
180 The case where just the expression is undefined is less severe and is
181 handled by fix. Here the number of bytes in the objectfile is known.
182 With this representation we simplify the assembly and separates the
183 machine dependent/independent parts in a more clean way (said OE). */
185 struct ns32k_option opt1
[] = /* restore, exit. */
197 struct ns32k_option opt2
[] = /* save, enter. */
209 struct ns32k_option opt3
[] = /* setcfg. */
217 struct ns32k_option opt4
[] = /* cinv. */
224 struct ns32k_option opt5
[] = /* String inst. */
231 struct ns32k_option opt6
[] = /* Plain reg ext,cvtp etc. */
244 #if !defined(NS32032) && !defined(NS32532)
248 struct ns32k_option cpureg_532
[] = /* lpr spr. */
261 {"intbase", 0xe, 0xff},
265 struct ns32k_option mmureg_532
[] = /* lmr smr. */
272 {"ivar0", 0xe, 0xff},
273 {"ivar1", 0xf, 0xff},
277 struct ns32k_option cpureg_032
[] = /* lpr spr. */
284 {"intbase", 0xe, 0xff},
288 struct ns32k_option mmureg_032
[] = /* lmr smr. */
304 struct ns32k_option
*cpureg
= cpureg_532
;
305 struct ns32k_option
*mmureg
= mmureg_532
;
307 struct ns32k_option
*cpureg
= cpureg_032
;
308 struct ns32k_option
*mmureg
= mmureg_032
;
312 const pseudo_typeS md_pseudo_table
[] =
313 { /* So far empty. */
317 #define IND(x,y) (((x)<<2)+(y))
319 /* Those are index's to relax groups in md_relax_table ie it must be
320 multiplied by 4 to point at a group start. Viz IND(x,y) Se function
321 relax_segment in write.c for more info. */
326 /* Those are index's to entries in a relax group. */
332 /* Those limits are calculated from the displacement start in memory.
333 The ns32k uses the beginning of the instruction as displacement
334 base. This type of displacements could be handled here by moving
335 the limit window up or down. I choose to use an internal
336 displacement base-adjust as there are other routines that must
337 consider this. Also, as we have two various offset-adjusts in the
338 ns32k (acb versus br/brs/jsr/bcond), two set of limits would have
339 had to be used. Now we dont have to think about that. */
341 const relax_typeS md_relax_table
[] =
348 {(63), (-64), 1, IND (BRANCH
, WORD
)},
349 {(8192), (-8192), 2, IND (BRANCH
, DOUBLE
)},
354 /* Array used to test if mode contains displacements.
355 Value is true if mode contains displacement. */
358 {0, 0, 0, 0, 0, 0, 0, 0,
359 1, 1, 1, 1, 1, 1, 1, 1,
360 1, 1, 1, 0, 0, 1, 1, 0,
361 1, 1, 1, 1, 1, 1, 1, 1};
363 /* Array used to calculate max size of displacements. */
368 /* Parse a general operand into an addressingmode struct
370 In: pointer at operand in ascii form
371 pointer at addr_mode struct for result
372 the level of recursion. (always 0 or 1)
374 Out: data in addr_mode struct. */
377 addr_mode (char *operand
,
378 addr_modeS
*addr_modeP
,
387 mode
= DEFAULT
; /* Default. */
388 addr_modeP
->scaled_mode
= 0; /* Why not. */
389 addr_modeP
->scaled_reg
= 0; /* If 0, not scaled index. */
390 addr_modeP
->float_flag
= 0;
391 addr_modeP
->am_size
= 0;
392 addr_modeP
->im_disp
= 0;
393 addr_modeP
->pcrel
= 0; /* Not set in this function. */
394 addr_modeP
->disp_suffix
[0] = 0;
395 addr_modeP
->disp_suffix
[1] = 0;
396 addr_modeP
->disp
[0] = NULL
;
397 addr_modeP
->disp
[1] = NULL
;
407 /* The following three case statements controls the mode-chars
408 this is the place to ed if you want to change them. */
409 #ifdef ABSOLUTE_PREFIX
410 case ABSOLUTE_PREFIX
:
411 if (str
[strl
- 1] == ']')
413 addr_modeP
->mode
= 21; /* absolute */
414 addr_modeP
->disp
[0] = str
+ 1;
417 #ifdef IMMEDIATE_PREFIX
418 case IMMEDIATE_PREFIX
:
419 if (str
[strl
- 1] == ']')
421 addr_modeP
->mode
= 20; /* immediate */
422 addr_modeP
->disp
[0] = str
+ 1;
426 if (str
[strl
- 1] != ']')
432 if (str
[2] != '\000')
434 addr_modeP
->mode
= 27; /* pc-relative */
435 addr_modeP
->disp
[0] = str
+ 2;
439 as_bad (_("Invalid syntax in PC-relative addressing mode"));
445 if (str
[strl
- 1] != ']')
447 if ((!strncmp (str
, "ext(", 4)) && strl
> 7)
449 addr_modeP
->disp
[0] = str
+ 4;
453 { /* disp[0]'s termination point. */
460 while (j
< strl
&& i
!= 0);
461 if (i
!= 0 || !(str
[j
+ 1] == '-' || str
[j
+ 1] == '+'))
463 as_bad (_("Invalid syntax in External addressing mode"));
466 str
[j
] = '\000'; /* null terminate disp[0] */
467 addr_modeP
->disp
[1] = str
+ j
+ 2;
468 addr_modeP
->mode
= 22;
486 addr_modeP
->float_flag
= 1;
489 if (str
[1] >= '0' && str
[1] < '8')
491 addr_modeP
->mode
= str
[1] - '0';
501 if (!strncmp (str
, "tos", 3))
503 addr_modeP
->mode
= 23; /* TopOfStack */
514 if (str
[strl
- 1] == ')')
516 if (str
[strl
- 2] == ')')
518 if (!strncmp (&str
[strl
- 5], "(fp", 3))
519 mode
= 16; /* Memory Relative. */
520 else if (!strncmp (&str
[strl
- 5], "(sp", 3))
522 else if (!strncmp (&str
[strl
- 5], "(sb", 3))
527 /* Memory relative. */
528 addr_modeP
->mode
= mode
;
529 j
= strl
- 5; /* Temp for end of disp[0]. */
535 if (str
[strl
] == ')')
537 if (str
[strl
] == '(')
540 while (strl
> -1 && i
!= 0);
544 as_bad (_("Invalid syntax in Memory Relative addressing mode"));
548 addr_modeP
->disp
[1] = str
;
549 addr_modeP
->disp
[0] = str
+ strl
+ 1;
550 str
[j
] = '\000'; /* Null terminate disp[0] . */
551 str
[strl
] = '\000'; /* Null terminate disp[1]. */
557 switch (str
[strl
- 3])
561 if (str
[strl
- 2] >= '0'
562 && str
[strl
- 2] < '8'
563 && str
[strl
- 4] == '(')
565 addr_modeP
->mode
= str
[strl
- 2] - '0' + 8;
566 addr_modeP
->disp
[0] = str
;
568 return -1; /* reg rel */
573 if (!strncmp (&str
[strl
- 4], "(fp", 3))
575 else if (!strncmp (&str
[strl
- 4], "(sp", 3))
577 else if (!strncmp (&str
[strl
- 4], "(sb", 3))
579 else if (!strncmp (&str
[strl
- 4], "(pc", 3))
584 addr_modeP
->mode
= mode
;
585 addr_modeP
->disp
[0] = str
;
586 str
[strl
- 4] = '\0';
588 return -1; /* Memory space. */
593 /* No trailing ')' do we have a ']' ? */
594 if (str
[strl
- 1] == ']')
596 switch (str
[strl
- 2])
611 as_bad (_("Invalid scaled-indexed mode, use (b,w,d,q)"));
613 if (str
[strl
- 3] != ':' || str
[strl
- 6] != '['
614 || str
[strl
- 5] == 'r' || str
[strl
- 4] < '0'
615 || str
[strl
- 4] > '7')
616 as_bad (_("Syntax in scaled-indexed mode, use [Rn:m] where n=[0..7] m={b,w,d,q}"));
617 } /* Scaled index. */
619 if (recursive_level
> 0)
621 as_bad (_("Scaled-indexed addressing mode combined with scaled-index"));
625 addr_modeP
->am_size
+= 1; /* scaled index byte. */
626 j
= str
[strl
- 4] - '0'; /* store temporary. */
627 str
[strl
- 6] = '\000'; /* nullterminate for recursive call. */
628 i
= addr_mode (str
, addr_modeP
, 1);
630 if (!i
|| addr_modeP
->mode
== 20)
632 as_bad (_("Invalid or illegal addressing mode combined with scaled-index"));
636 addr_modeP
->scaled_mode
= addr_modeP
->mode
; /* Store the inferior mode. */
637 addr_modeP
->mode
= mode
;
638 addr_modeP
->scaled_reg
= j
+ 1;
644 addr_modeP
->mode
= DEFAULT
; /* Default to whatever. */
645 addr_modeP
->disp
[0] = str
;
651 evaluate_expr (expressionS
*resultP
, char *ptr
)
655 tmp_line
= input_line_pointer
;
656 input_line_pointer
= ptr
;
657 expression (resultP
);
658 input_line_pointer
= tmp_line
;
661 /* ptr points at string addr_modeP points at struct with result This
662 routine calls addr_mode to determine the general addr.mode of the
663 operand. When this is ready it parses the displacements for size
664 specifying suffixes and determines size of immediate mode via
665 ns32k-opcode. Also builds index bytes if needed. */
668 get_addr_mode (char *ptr
, addr_modeS
*addr_modeP
)
672 addr_mode (ptr
, addr_modeP
, 0);
674 if (addr_modeP
->mode
== DEFAULT
|| addr_modeP
->scaled_mode
== -1)
676 /* Resolve ambiguous operands, this shouldn't be necessary if
677 one uses standard NSC operand syntax. But the sequent
678 compiler doesn't!!! This finds a proper addressing mode
679 if it is implicitly stated. See ns32k-opcode.h. */
680 (void) evaluate_expr (&exprP
, ptr
); /* This call takes time Sigh! */
682 if (addr_modeP
->mode
== DEFAULT
)
684 if (exprP
.X_add_symbol
|| exprP
.X_op_symbol
)
685 addr_modeP
->mode
= desc
->default_model
; /* We have a label. */
687 addr_modeP
->mode
= desc
->default_modec
; /* We have a constant. */
691 if (exprP
.X_add_symbol
|| exprP
.X_op_symbol
)
692 addr_modeP
->scaled_mode
= desc
->default_model
;
694 addr_modeP
->scaled_mode
= desc
->default_modec
;
697 /* Must put this mess down in addr_mode to handle the scaled
701 /* It appears as the sequent compiler wants an absolute when we have
702 a label without @. Constants becomes immediates besides the addr
703 case. Think it does so with local labels too, not optimum, pcrel
704 is better. When I have time I will make gas check this and
705 select pcrel when possible Actually that is trivial. */
706 if ((tmp
= addr_modeP
->scaled_reg
))
707 { /* Build indexbyte. */
708 tmp
--; /* Remember regnumber comes incremented for
710 tmp
|= addr_modeP
->scaled_mode
<< 3;
711 addr_modeP
->index_byte
= (char) tmp
;
712 addr_modeP
->am_size
+= 1;
715 assert (addr_modeP
->mode
>= 0);
716 if (disp_test
[(unsigned int) addr_modeP
->mode
])
725 /* There was a displacement, probe for length specifying suffix. */
726 addr_modeP
->pcrel
= 0;
728 assert(addr_modeP
->mode
>= 0);
729 if (disp_test
[(unsigned int) addr_modeP
->mode
])
731 /* There is a displacement. */
732 if (addr_modeP
->mode
== 27 || addr_modeP
->scaled_mode
== 27)
733 /* Do we have pcrel. mode. */
734 addr_modeP
->pcrel
= 1;
736 addr_modeP
->im_disp
= 1;
738 for (i
= 0; i
< 2; i
++)
740 suffix_sub
= suffix
= 0;
742 if ((toP
= addr_modeP
->disp
[i
]))
744 /* Suffix of expression, the largest size rules. */
747 while ((c
= *fromP
++))
755 as_warn (_("Premature end of suffix -- Defaulting to d"));
768 as_warn (_("Bad suffix after ':' use {b|w|d} Defaulting to d"));
773 toP
--; /* So we write over the ':' */
775 if (suffix
< suffix_sub
)
780 *toP
= '\0'; /* Terminate properly. */
781 addr_modeP
->disp_suffix
[i
] = suffix
;
782 addr_modeP
->am_size
+= suffix
? suffix
: 4;
789 if (addr_modeP
->mode
== 20)
791 /* Look in ns32k_opcode for size. */
792 addr_modeP
->disp_suffix
[0] = addr_modeP
->am_size
= desc
->im_size
;
793 addr_modeP
->im_disp
= 0;
797 return addr_modeP
->mode
;
800 /* Read an optionlist. */
803 optlist (char *str
, /* The string to extract options from. */
804 struct ns32k_option
*optionP
, /* How to search the string. */
805 unsigned long *default_map
) /* Default pattern and output. */
807 int i
, j
, k
, strlen1
, strlen2
;
808 char *patternP
, *strP
;
810 strlen1
= strlen (str
);
813 as_fatal (_("Very short instr to option, ie you can't do it on a NULLstr"));
815 for (i
= 0; optionP
[i
].pattern
!= 0; i
++)
817 strlen2
= strlen (optionP
[i
].pattern
);
819 for (j
= 0; j
< strlen1
; j
++)
821 patternP
= optionP
[i
].pattern
;
824 for (k
= 0; k
< strlen2
; k
++)
826 if (*(strP
++) != *(patternP
++))
832 *default_map
|= optionP
[i
].or;
833 *default_map
&= optionP
[i
].and;
839 /* Search struct for symbols.
840 This function is used to get the short integer form of reg names in
841 the instructions lmr, smr, lpr, spr return true if str is found in
845 list_search (char *str
, /* The string to match. */
846 struct ns32k_option
*optionP
, /* List to search. */
847 unsigned long *default_map
) /* Default pattern and output. */
851 for (i
= 0; optionP
[i
].pattern
!= 0; i
++)
853 if (!strncmp (optionP
[i
].pattern
, str
, 20))
855 /* Use strncmp to be safe. */
856 *default_map
|= optionP
[i
].or;
857 *default_map
&= optionP
[i
].and;
863 as_bad (_("No such entry in list. (cpu/mmu register)"));
867 /* Create a bit_fixS in obstack 'notes'.
868 This struct is used to profile the normal fix. If the bit_fixP is a
869 valid pointer (not NULL) the bit_fix data will be used to format
873 bit_fix_new (int size
, /* Length of bitfield. */
874 int offset
, /* Bit offset to bitfield. */
875 long min
, /* Signextended min for bitfield. */
876 long max
, /* Signextended max for bitfield. */
877 long add
, /* Add mask, used for huffman prefix. */
878 long base_type
, /* 0 or 1, if 1 it's exploded to opcode ptr. */
883 bit_fixP
= (bit_fixS
*) obstack_alloc (¬es
, sizeof (bit_fixS
));
885 bit_fixP
->fx_bit_size
= size
;
886 bit_fixP
->fx_bit_offset
= offset
;
887 bit_fixP
->fx_bit_base
= base_type
;
888 bit_fixP
->fx_bit_base_adj
= base_adj
;
889 bit_fixP
->fx_bit_max
= max
;
890 bit_fixP
->fx_bit_min
= min
;
891 bit_fixP
->fx_bit_add
= add
;
896 /* Convert operands to iif-format and adds bitfields to the opcode.
897 Operands are parsed in such an order that the opcode is updated from
898 its most significant bit, that is when the operand need to alter the
900 Be careful not to put to objects in the same iif-slot. */
903 encode_operand (int argc
,
905 const char *operandsP
,
907 char im_size ATTRIBUTE_UNUSED
,
912 int pcrel
, b
, loop
, pcrel_adjust
;
915 for (loop
= 0; loop
< argc
; loop
++)
917 /* What operand are we supposed to work on. */
918 i
= operandsP
[loop
<< 1] - '1';
920 as_fatal (_("Internal consistency error. check ns32k-opcode.h"));
926 switch ((d
= operandsP
[(loop
<< 1) + 1]))
928 case 'f': /* Operand of sfsr turns out to be a nasty
931 case 'Z': /* Float not immediate. */
932 case 'F': /* 32 bit float general form. */
933 case 'L': /* 64 bit float. */
934 case 'I': /* Integer not immediate. */
937 case 'D': /* Double-word. */
938 case 'A': /* Double-word gen-address-form ie no regs
940 get_addr_mode (argv
[i
], &addr_modeP
);
942 if ((addr_modeP
.mode
== 20) &&
943 (d
== 'I' || d
== 'Z' || d
== 'A'))
944 as_fatal (d
== 'A'? _("Address of immediate operand"):
945 _("Invalid immediate write operand."));
947 if (opcode_bit_ptr
== desc
->opcode_size
)
952 for (j
= b
; j
< (b
+ 2); j
++)
954 if (addr_modeP
.disp
[j
- b
])
958 addr_modeP
.disp_suffix
[j
- b
],
959 (unsigned long) addr_modeP
.disp
[j
- b
],
966 (addr_modeP
.scaled_reg
? addr_modeP
.scaled_mode
973 iif
.iifP
[1].object
|= ((long) addr_modeP
.mode
) << opcode_bit_ptr
;
975 if (addr_modeP
.scaled_reg
)
978 IIF (j
, 1, 1, (unsigned long) addr_modeP
.index_byte
,
979 0, 0, 0, 0, 0, NULL
, -1, 0);
983 case 'b': /* Multiple instruction disp. */
984 freeptr
++; /* OVE:this is an useful hack. */
985 sprintf (freeptr
, "((%s-1)*%d)", argv
[i
], desc
->im_size
);
987 pcrel
-= 1; /* Make pcrel 0 in spite of what case 'p':
990 case 'p': /* Displacement - pc relative addressing. */
993 case 'd': /* Displacement. */
994 iif
.instr_size
+= suffixP
[i
] ? suffixP
[i
] : 4;
995 IIF (12, 2, suffixP
[i
], (unsigned long) argv
[i
], 0,
996 pcrel
, pcrel_adjust
, 1, IND (BRANCH
, BYTE
), NULL
, -1, 0);
998 case 'H': /* Sequent-hack: the linker wants a bit set
1001 iif
.instr_size
+= suffixP
[i
] ? suffixP
[i
] : 4;
1002 IIF (12, 2, suffixP
[i
], (unsigned long) argv
[i
], 0,
1003 pcrel
, pcrel_adjust
, 1, IND (BRANCH
, BYTE
), NULL
, -1, 1);
1005 case 'q': /* quick */
1006 opcode_bit_ptr
-= 4;
1007 IIF (11, 2, 42, (unsigned long) argv
[i
], 0, 0, 0, 0, 0,
1008 bit_fix_new (4, opcode_bit_ptr
, -8, 7, 0, 1, 0), -1, 0);
1010 case 'r': /* Register number (3 bits). */
1011 list_search (argv
[i
], opt6
, &tmp
);
1012 opcode_bit_ptr
-= 3;
1013 iif
.iifP
[1].object
|= tmp
<< opcode_bit_ptr
;
1015 case 'O': /* Setcfg instruction optionslist. */
1016 optlist (argv
[i
], opt3
, &tmp
);
1017 opcode_bit_ptr
-= 4;
1018 iif
.iifP
[1].object
|= tmp
<< 15;
1020 case 'C': /* Cinv instruction optionslist. */
1021 optlist (argv
[i
], opt4
, &tmp
);
1022 opcode_bit_ptr
-= 4;
1023 iif
.iifP
[1].object
|= tmp
<< 15; /* Insert the regtype in opcode. */
1025 case 'S': /* String instruction options list. */
1026 optlist (argv
[i
], opt5
, &tmp
);
1027 opcode_bit_ptr
-= 4;
1028 iif
.iifP
[1].object
|= tmp
<< 15;
1031 case 'U': /* Register list. */
1032 IIF (10, 1, 1, 0, 0, 0, 0, 0, 0, NULL
, -1, 0);
1033 switch (operandsP
[(i
<< 1) + 1])
1035 case 'u': /* Restore, exit. */
1036 optlist (argv
[i
], opt1
, &iif
.iifP
[10].object
);
1038 case 'U': /* Save, enter. */
1039 optlist (argv
[i
], opt2
, &iif
.iifP
[10].object
);
1042 iif
.instr_size
+= 1;
1044 case 'M': /* MMU register. */
1045 list_search (argv
[i
], mmureg
, &tmp
);
1046 opcode_bit_ptr
-= 4;
1047 iif
.iifP
[1].object
|= tmp
<< opcode_bit_ptr
;
1049 case 'P': /* CPU register. */
1050 list_search (argv
[i
], cpureg
, &tmp
);
1051 opcode_bit_ptr
-= 4;
1052 iif
.iifP
[1].object
|= tmp
<< opcode_bit_ptr
;
1054 case 'g': /* Inss exts. */
1055 iif
.instr_size
+= 1; /* 1 byte is allocated after the opcode. */
1057 (unsigned long) argv
[i
], /* i always 2 here. */
1059 bit_fix_new (3, 5, 0, 7, 0, 0, 0), /* A bit_fix is targeted to
1065 (unsigned long) argv
[i
], /* i always 3 here. */
1067 bit_fix_new (5, 0, 1, 32, -1, 0, -1), -1, 0);
1070 iif
.instr_size
+= 1;
1071 b
= 2 + i
; /* Put the extension byte after opcode. */
1072 IIF (b
, 2, 1, 0, 0, 0, 0, 0, 0, 0, -1, 0);
1075 as_fatal (_("Bad opcode-table-option, check in file ns32k-opcode.h"));
1080 /* in: instruction line
1081 out: internal structure of instruction
1082 that has been prepared for direct conversion to fragment(s) and
1083 fixes in a systematical fashion
1084 Return-value = recursive_level. */
1085 /* Build iif of one assembly text line. */
1088 parse (const char *line
, int recursive_level
)
1090 const char *lineptr
;
1091 char c
, suffix_separator
;
1096 char suffix
[MAX_ARGS
], *argv
[MAX_ARGS
]; /* No more than 4 operands. */
1098 if (recursive_level
<= 0)
1100 /* Called from md_assemble. */
1101 for (lineptr
= line
; (*lineptr
) != '\0' && (*lineptr
) != ' '; lineptr
++)
1105 *(char *) lineptr
= '\0';
1107 if (!(desc
= (struct ns32k_opcode
*) hash_find (inst_hash_handle
, line
)))
1108 as_fatal (_("No such opcode"));
1110 *(char *) lineptr
= c
;
1117 if (*desc
->operands
)
1119 if (*lineptr
++ != '\0')
1124 while (*lineptr
!= '\0')
1126 if (desc
->operands
[argc
<< 1])
1129 arg_type
= desc
->operands
[(argc
<< 1) + 1];
1137 /* The operand is supposed to be a displacement. */
1138 /* Hackwarning: do not forget to update the 4
1139 cases above when editing ns32k-opcode.h. */
1140 suffix_separator
= ':';
1143 /* If this char occurs we loose. */
1144 suffix_separator
= '\255';
1148 suffix
[argc
] = 0; /* 0 when no ':' is encountered. */
1149 argv
[argc
] = freeptr
;
1152 while ((c
= *lineptr
) != '\0' && c
!= sep
)
1168 if (c
== suffix_separator
)
1170 /* ':' - label/suffix separator. */
1183 as_warn (_("Bad suffix, defaulting to d"));
1185 if (lineptr
[1] == '\0' || lineptr
[1] == sep
)
1204 if (*lineptr
== '\0')
1210 as_fatal (_("Too many operands passed to instruction"));
1215 if (argc
!= strlen (desc
->operands
) / 2)
1217 if (strlen (desc
->default_args
))
1219 /* We can apply default, don't goof. */
1220 if (parse (desc
->default_args
, 1) != 1)
1221 /* Check error in default. */
1222 as_fatal (_("Wrong numbers of operands in default, check ns32k-opcodes.h"));
1225 as_fatal (_("Wrong number of operands"));
1228 for (i
= 0; i
< IIF_ENTRIES
; i
++)
1229 /* Mark all entries as void. */
1230 iif
.iifP
[i
].type
= 0;
1232 /* Build opcode iif-entry. */
1233 iif
.instr_size
= desc
->opcode_size
/ 8;
1234 IIF (1, 1, iif
.instr_size
, desc
->opcode_seed
, 0, 0, 0, 0, 0, 0, -1, 0);
1236 /* This call encodes operands to iif format. */
1238 encode_operand (argc
, argv
, &desc
->operands
[0],
1239 &suffix
[0], desc
->im_size
, desc
->opcode_size
);
1241 return recursive_level
;
1244 /* This functionality should really be in the bfd library. */
1246 static bfd_reloc_code_real_type
1247 reloc (int size
, int pcrel
, int type
)
1250 bfd_reloc_code_real_type relocs
[] =
1252 BFD_RELOC_NS32K_IMM_8
,
1253 BFD_RELOC_NS32K_IMM_16
,
1254 BFD_RELOC_NS32K_IMM_32
,
1255 BFD_RELOC_NS32K_IMM_8_PCREL
,
1256 BFD_RELOC_NS32K_IMM_16_PCREL
,
1257 BFD_RELOC_NS32K_IMM_32_PCREL
,
1259 /* ns32k displacements. */
1260 BFD_RELOC_NS32K_DISP_8
,
1261 BFD_RELOC_NS32K_DISP_16
,
1262 BFD_RELOC_NS32K_DISP_32
,
1263 BFD_RELOC_NS32K_DISP_8_PCREL
,
1264 BFD_RELOC_NS32K_DISP_16_PCREL
,
1265 BFD_RELOC_NS32K_DISP_32_PCREL
,
1267 /* Normal 2's complement. */
1292 index
= length
+ 3 * pcrel
+ 6 * type
;
1294 if (index
>= 0 && (unsigned int) index
< sizeof (relocs
) / sizeof (relocs
[0]))
1295 return relocs
[index
];
1298 as_bad (_("Can not do %d byte pc-relative relocation for storage type %d"),
1301 as_bad (_("Can not do %d byte relocation for storage type %d"),
1304 return BFD_RELOC_NONE
;
1309 fix_new_ns32k (fragS
*frag
, /* Which frag? */
1310 int where
, /* Where in that frag? */
1311 int size
, /* 1, 2 or 4 usually. */
1312 symbolS
*add_symbol
, /* X_add_symbol. */
1313 long offset
, /* X_add_number. */
1314 int pcrel
, /* True if PC-relative relocation. */
1315 char im_disp
, /* True if the value to write is a
1317 bit_fixS
*bit_fixP
, /* Pointer at struct of bit_fix's, ignored if
1319 char bsr
, /* Sequent-linker-hack: 1 when relocobject is
1322 unsigned int opcode_offset
)
1324 fixS
*fixP
= fix_new (frag
, where
, size
, add_symbol
,
1326 bit_fixP
? NO_RELOC
: reloc (size
, pcrel
, im_disp
)
1329 fix_opcode_frag (fixP
) = opcode_frag
;
1330 fix_opcode_offset (fixP
) = opcode_offset
;
1331 fix_im_disp (fixP
) = im_disp
;
1332 fix_bsr (fixP
) = bsr
;
1333 fix_bit_fixP (fixP
) = bit_fixP
;
1334 /* We have a MD overflow check for displacements. */
1335 fixP
->fx_no_overflow
= (im_disp
!= 0);
1339 fix_new_ns32k_exp (fragS
*frag
, /* Which frag? */
1340 int where
, /* Where in that frag? */
1341 int size
, /* 1, 2 or 4 usually. */
1342 expressionS
*exp
, /* Expression. */
1343 int pcrel
, /* True if PC-relative relocation. */
1344 char im_disp
, /* True if the value to write is a
1346 bit_fixS
*bit_fixP
, /* Pointer at struct of bit_fix's, ignored if
1348 char bsr
, /* Sequent-linker-hack: 1 when relocobject is
1351 unsigned int opcode_offset
)
1353 fixS
*fixP
= fix_new_exp (frag
, where
, size
, exp
, pcrel
,
1354 bit_fixP
? NO_RELOC
: reloc (size
, pcrel
, im_disp
)
1357 fix_opcode_frag (fixP
) = opcode_frag
;
1358 fix_opcode_offset (fixP
) = opcode_offset
;
1359 fix_im_disp (fixP
) = im_disp
;
1360 fix_bsr (fixP
) = bsr
;
1361 fix_bit_fixP (fixP
) = bit_fixP
;
1362 /* We have a MD overflow check for displacements. */
1363 fixP
->fx_no_overflow
= (im_disp
!= 0);
1366 /* Convert number to chars in correct order. */
1369 md_number_to_chars (char *buf
, valueT value
, int nbytes
)
1371 number_to_chars_littleendian (buf
, value
, nbytes
);
1374 /* This is a variant of md_numbers_to_chars. The reason for its'
1375 existence is the fact that ns32k uses Huffman coded
1376 displacements. This implies that the bit order is reversed in
1377 displacements and that they are prefixed with a size-tag.
1381 10xxxxxx xxxxxxxx word
1382 11xxxxxx xxxxxxxx xxxxxxxx xxxxxxxx double word
1384 This must be taken care of and we do it here! */
1387 md_number_to_disp (char *buf
, long val
, int n
)
1392 if (val
< -64 || val
> 63)
1393 as_bad (_("value of %ld out of byte displacement range."), val
);
1396 printf ("%x ", val
& 0xff);
1402 if (val
< -8192 || val
> 8191)
1403 as_bad (_("value of %ld out of word displacement range."), val
);
1407 printf ("%x ", val
>> 8 & 0xff);
1409 *buf
++ = (val
>> 8);
1411 printf ("%x ", val
& 0xff);
1417 if (val
< -0x20000000 || val
>= 0x20000000)
1418 as_bad (_("value of %ld out of double word displacement range."), val
);
1421 printf ("%x ", val
>> 24 & 0xff);
1423 *buf
++ = (val
>> 24);
1425 printf ("%x ", val
>> 16 & 0xff);
1427 *buf
++ = (val
>> 16);
1429 printf ("%x ", val
>> 8 & 0xff);
1431 *buf
++ = (val
>> 8);
1433 printf ("%x ", val
& 0xff);
1439 as_fatal (_("Internal logic error. line %d, file \"%s\""),
1440 __LINE__
, __FILE__
);
1445 md_number_to_imm (char *buf
, long val
, int n
)
1451 printf ("%x ", val
& 0xff);
1458 printf ("%x ", val
>> 8 & 0xff);
1460 *buf
++ = (val
>> 8);
1462 printf ("%x ", val
& 0xff);
1469 printf ("%x ", val
>> 24 & 0xff);
1471 *buf
++ = (val
>> 24);
1473 printf ("%x ", val
>> 16 & 0xff);
1475 *buf
++ = (val
>> 16);
1477 printf ("%x ", val
>> 8 & 0xff);
1479 *buf
++ = (val
>> 8);
1481 printf ("%x ", val
& 0xff);
1487 as_fatal (_("Internal logic error. line %d, file \"%s\""),
1488 __LINE__
, __FILE__
);
1492 /* Fast bitfiddling support. */
1493 /* Mask used to zero bitfield before oring in the true field. */
1495 static unsigned long l_mask
[] =
1497 0xffffffff, 0xfffffffe, 0xfffffffc, 0xfffffff8,
1498 0xfffffff0, 0xffffffe0, 0xffffffc0, 0xffffff80,
1499 0xffffff00, 0xfffffe00, 0xfffffc00, 0xfffff800,
1500 0xfffff000, 0xffffe000, 0xffffc000, 0xffff8000,
1501 0xffff0000, 0xfffe0000, 0xfffc0000, 0xfff80000,
1502 0xfff00000, 0xffe00000, 0xffc00000, 0xff800000,
1503 0xff000000, 0xfe000000, 0xfc000000, 0xf8000000,
1504 0xf0000000, 0xe0000000, 0xc0000000, 0x80000000,
1506 static unsigned long r_mask
[] =
1508 0x00000000, 0x00000001, 0x00000003, 0x00000007,
1509 0x0000000f, 0x0000001f, 0x0000003f, 0x0000007f,
1510 0x000000ff, 0x000001ff, 0x000003ff, 0x000007ff,
1511 0x00000fff, 0x00001fff, 0x00003fff, 0x00007fff,
1512 0x0000ffff, 0x0001ffff, 0x0003ffff, 0x0007ffff,
1513 0x000fffff, 0x001fffff, 0x003fffff, 0x007fffff,
1514 0x00ffffff, 0x01ffffff, 0x03ffffff, 0x07ffffff,
1515 0x0fffffff, 0x1fffffff, 0x3fffffff, 0x7fffffff,
1517 #define MASK_BITS 31
1518 /* Insert bitfield described by field_ptr and val at buf
1519 This routine is written for modification of the first 4 bytes pointed
1520 to by buf, to yield speed.
1521 The ifdef stuff is for selection between a ns32k-dependent routine
1522 and a general version. (My advice: use the general version!). */
1525 md_number_to_field (char *buf
, long val
, bit_fixS
*field_ptr
)
1527 unsigned long object
;
1529 /* Define ENDIAN on a ns32k machine. */
1531 unsigned long *mem_ptr
;
1536 if (field_ptr
->fx_bit_min
<= val
&& val
<= field_ptr
->fx_bit_max
)
1539 if (field_ptr
->fx_bit_base
)
1541 mem_ptr
= (unsigned long *) field_ptr
->fx_bit_base
;
1543 mem_ptr
= (unsigned long *) buf
;
1545 mem_ptr
= ((unsigned long *)
1546 ((char *) mem_ptr
+ field_ptr
->fx_bit_base_adj
));
1548 if (field_ptr
->fx_bit_base
)
1549 mem_ptr
= (char *) field_ptr
->fx_bit_base
;
1553 mem_ptr
+= field_ptr
->fx_bit_base_adj
;
1556 /* We have a nice ns32k machine with lowbyte at low-physical mem. */
1557 object
= *mem_ptr
; /* get some bytes */
1558 #else /* OVE Goof! the machine is a m68k or dito. */
1559 /* That takes more byte fiddling. */
1561 object
|= mem_ptr
[3] & 0xff;
1563 object
|= mem_ptr
[2] & 0xff;
1565 object
|= mem_ptr
[1] & 0xff;
1567 object
|= mem_ptr
[0] & 0xff;
1570 mask
|= (r_mask
[field_ptr
->fx_bit_offset
]);
1571 mask
|= (l_mask
[field_ptr
->fx_bit_offset
+ field_ptr
->fx_bit_size
]);
1573 val
+= field_ptr
->fx_bit_add
;
1574 object
|= ((val
<< field_ptr
->fx_bit_offset
) & (mask
^ 0xffffffff));
1578 mem_ptr
[0] = (char) object
;
1580 mem_ptr
[1] = (char) object
;
1582 mem_ptr
[2] = (char) object
;
1584 mem_ptr
[3] = (char) object
;
1588 as_bad (_("Bit field out of range"));
1591 /* Convert iif to fragments. From this point we start to dribble with
1592 functions in other files than this one.(Except hash.c) So, if it's
1593 possible to make an iif for an other CPU, you don't need to know
1594 what frags, relax, obstacks, etc is in order to port this
1595 assembler. You only need to know if it's possible to reduce your
1596 cpu-instruction to iif-format (takes some work) and adopt the other
1597 md_? parts according to given instructions Note that iif was
1598 invented for the clean ns32k`s architecture. */
1600 /* GAS for the ns32k has a problem. PC relative displacements are
1601 relative to the address of the opcode, not the address of the
1602 operand. We used to keep track of the offset between the operand
1603 and the opcode in pcrel_adjust for each frag and each fix. However,
1604 we get into trouble where there are two or more pc-relative
1605 operands and the size of the first one can't be determined. Then in
1606 the relax phase, the size of the first operand will change and
1607 pcrel_adjust will no longer be correct. The current solution is
1608 keep a pointer to the frag with the opcode in it and the offset in
1609 that frag for each frag and each fix. Then, when needed, we can
1610 always figure out how far it is between the opcode and the pcrel
1611 object. See also md_pcrel_adjust and md_fix_pcrel_adjust. For
1612 objects not part of an instruction, the pointer to the opcode frag
1621 unsigned int inst_offset
;
1629 frag_grow (iif
.instr_size
); /* This is important. */
1630 memP
= frag_more (0);
1632 inst_offset
= (memP
- frag_now
->fr_literal
);
1633 inst_frag
= frag_now
;
1635 for (i
= 0; i
< IIF_ENTRIES
; i
++)
1637 if ((type
= iif
.iifP
[i
].type
))
1639 /* The object exist, so handle it. */
1640 switch (size
= iif
.iifP
[i
].size
)
1644 /* It's a bitfix that operates on an existing object. */
1645 if (iif
.iifP
[i
].bit_fixP
->fx_bit_base
)
1646 /* Expand fx_bit_base to point at opcode. */
1647 iif
.iifP
[i
].bit_fixP
->fx_bit_base
= (long) inst_opcode
;
1650 case 8: /* bignum or doublefloat. */
1655 /* The final size in objectmemory is known. */
1656 memP
= frag_more (size
);
1657 j
= iif
.iifP
[i
].bit_fixP
;
1661 case 1: /* The object is pure binary. */
1663 md_number_to_field (memP
, exprP
.X_add_number
, j
);
1665 else if (iif
.iifP
[i
].pcrel
)
1666 fix_new_ns32k (frag_now
,
1667 (long) (memP
- frag_now
->fr_literal
),
1672 iif
.iifP
[i
].im_disp
,
1674 iif
.iifP
[i
].bsr
, /* Sequent hack. */
1675 inst_frag
, inst_offset
);
1678 /* Good, just put them bytes out. */
1679 switch (iif
.iifP
[i
].im_disp
)
1682 md_number_to_chars (memP
, iif
.iifP
[i
].object
, size
);
1685 md_number_to_disp (memP
, iif
.iifP
[i
].object
, size
);
1688 as_fatal (_("iif convert internal pcrel/binary"));
1694 /* The object is a pointer at an expression, so
1695 unpack it, note that bignums may result from the
1697 evaluate_expr (&exprP
, (char *) iif
.iifP
[i
].object
);
1698 if (exprP
.X_op
== O_big
|| size
== 8)
1700 if ((k
= exprP
.X_add_number
) > 0)
1702 /* We have a bignum ie a quad. This can only
1703 happens in a long suffixed instruction. */
1705 as_bad (_("Bignum too big for long"));
1710 for (l
= 0; k
> 0; k
--, l
+= 2)
1711 md_number_to_chars (memP
+ l
,
1712 generic_bignum
[l
>> 1],
1713 sizeof (LITTLENUM_TYPE
));
1718 LITTLENUM_TYPE words
[4];
1723 gen_to_words (words
, 2, 8);
1724 md_number_to_imm (memP
, (long) words
[0],
1725 sizeof (LITTLENUM_TYPE
));
1726 md_number_to_imm (memP
+ sizeof (LITTLENUM_TYPE
),
1728 sizeof (LITTLENUM_TYPE
));
1731 gen_to_words (words
, 4, 11);
1732 md_number_to_imm (memP
, (long) words
[0],
1733 sizeof (LITTLENUM_TYPE
));
1734 md_number_to_imm (memP
+ sizeof (LITTLENUM_TYPE
),
1736 sizeof (LITTLENUM_TYPE
));
1737 md_number_to_imm ((memP
+ 2
1738 * sizeof (LITTLENUM_TYPE
)),
1740 sizeof (LITTLENUM_TYPE
));
1741 md_number_to_imm ((memP
+ 3
1742 * sizeof (LITTLENUM_TYPE
)),
1744 sizeof (LITTLENUM_TYPE
));
1750 if (exprP
.X_add_symbol
||
1751 exprP
.X_op_symbol
||
1754 /* The expression was undefined due to an
1755 undefined label. Create a fix so we can fix
1756 the object later. */
1757 exprP
.X_add_number
+= iif
.iifP
[i
].object_adjust
;
1758 fix_new_ns32k_exp (frag_now
,
1759 (long) (memP
- frag_now
->fr_literal
),
1763 iif
.iifP
[i
].im_disp
,
1766 inst_frag
, inst_offset
);
1769 md_number_to_field (memP
, exprP
.X_add_number
, j
);
1772 /* Good, just put them bytes out. */
1773 switch (iif
.iifP
[i
].im_disp
)
1776 md_number_to_imm (memP
, exprP
.X_add_number
, size
);
1779 md_number_to_disp (memP
, exprP
.X_add_number
, size
);
1782 as_fatal (_("iif convert internal pcrel/pointer"));
1787 as_fatal (_("Internal logic error in iif.iifP[n].type"));
1792 /* Too bad, the object may be undefined as far as its
1793 final nsize in object memory is concerned. The size
1794 of the object in objectmemory is not explicitly
1795 given. If the object is defined its length can be
1796 determined and a fix can replace the frag. */
1798 evaluate_expr (&exprP
, (char *) iif
.iifP
[i
].object
);
1800 if ((exprP
.X_add_symbol
|| exprP
.X_op_symbol
) &&
1803 /* Size is unknown until link time so have to default. */
1804 size
= default_disp_size
; /* Normally 4 bytes. */
1805 memP
= frag_more (size
);
1806 fix_new_ns32k_exp (frag_now
,
1807 (long) (memP
- frag_now
->fr_literal
),
1810 0, /* never iif.iifP[i].pcrel, */
1811 1, /* always iif.iifP[i].im_disp */
1815 break; /* Exit this absolute hack. */
1818 if (exprP
.X_add_symbol
|| exprP
.X_op_symbol
)
1821 if (exprP
.X_op_symbol
)
1822 /* We cant relax this case. */
1823 as_fatal (_("Can't relax difference"));
1826 /* Size is not important. This gets fixed by
1827 relax, but we assume 0 in what follows. */
1828 memP
= frag_more (4); /* Max size. */
1832 fragS
*old_frag
= frag_now
;
1833 frag_variant (rs_machine_dependent
,
1836 IND (BRANCH
, UNDEF
), /* Expecting
1841 frag_opcode_frag (old_frag
) = inst_frag
;
1842 frag_opcode_offset (old_frag
) = inst_offset
;
1843 frag_bsr (old_frag
) = iif
.iifP
[i
].bsr
;
1849 /* This duplicates code in md_number_to_disp. */
1850 if (-64 <= exprP
.X_add_number
&& exprP
.X_add_number
<= 63)
1854 if (-8192 <= exprP
.X_add_number
1855 && exprP
.X_add_number
<= 8191)
1859 if (-0x20000000 <= exprP
.X_add_number
1860 && exprP
.X_add_number
<=0x1fffffff)
1864 as_bad (_("Displacement too large for :d"));
1870 memP
= frag_more (size
);
1871 md_number_to_disp (memP
, exprP
.X_add_number
, size
);
1877 as_fatal (_("Internal logic error in iif.iifP[].type"));
1884 md_assemble (char *line
)
1886 freeptr
= freeptr_static
;
1887 parse (line
, 0); /* Explode line to more fix form in iif. */
1888 convert_iif (); /* Convert iif to frags, fix's etc. */
1890 printf (" \t\t\t%s\n", line
);
1897 /* Build a hashtable of the instructions. */
1898 const struct ns32k_opcode
*ptr
;
1900 const struct ns32k_opcode
*endop
;
1902 inst_hash_handle
= hash_new ();
1904 endop
= ns32k_opcodes
+ sizeof (ns32k_opcodes
) / sizeof (ns32k_opcodes
[0]);
1905 for (ptr
= ns32k_opcodes
; ptr
< endop
; ptr
++)
1907 if ((stat
= hash_insert (inst_hash_handle
, ptr
->name
, (char *) ptr
)))
1909 as_fatal (_("Can't hash %s: %s"), ptr
->name
, stat
);
1912 /* Some private space please! */
1913 freeptr_static
= (char *) malloc (PRIVATE_SIZE
);
1916 /* Must be equal to MAX_PRECISON in atof-ieee.c. */
1917 #define MAX_LITTLENUMS 6
1919 /* Turn the string pointed to by litP into a floating point constant
1920 of type TYPE, and emit the appropriate bytes. The number of
1921 LITTLENUMS emitted is stored in *SIZEP. An error message is
1922 returned, or NULL on OK. */
1925 md_atof (int type
, char *litP
, int *sizeP
)
1928 LITTLENUM_TYPE words
[MAX_LITTLENUMS
];
1929 LITTLENUM_TYPE
*wordP
;
1943 return _("Bad call to MD_ATOF()");
1946 t
= atof_ieee (input_line_pointer
, type
, words
);
1948 input_line_pointer
= t
;
1950 *sizeP
= prec
* sizeof (LITTLENUM_TYPE
);
1952 for (wordP
= words
+ prec
; prec
--;)
1954 md_number_to_chars (litP
, (long) (*--wordP
), sizeof (LITTLENUM_TYPE
));
1955 litP
+= sizeof (LITTLENUM_TYPE
);
1962 md_pcrel_adjust (fragS
*fragP
)
1965 addressT opcode_address
;
1966 unsigned int offset
;
1968 opcode_frag
= frag_opcode_frag (fragP
);
1969 if (opcode_frag
== 0)
1972 offset
= frag_opcode_offset (fragP
);
1973 opcode_address
= offset
+ opcode_frag
->fr_address
;
1975 return fragP
->fr_address
+ fragP
->fr_fix
- opcode_address
;
1979 md_fix_pcrel_adjust (fixS
*fixP
)
1982 addressT opcode_address
;
1983 unsigned int offset
;
1985 opcode_frag
= fix_opcode_frag (fixP
);
1986 if (opcode_frag
== 0)
1989 offset
= fix_opcode_offset (fixP
);
1990 opcode_address
= offset
+ opcode_frag
->fr_address
;
1992 return fixP
->fx_where
+ fixP
->fx_frag
->fr_address
- opcode_address
;
1995 /* Apply a fixS (fixup of an instruction or data that we didn't have
1996 enough info to complete immediately) to the data in a frag.
1998 On the ns32k, everything is in a different format, so we have broken
1999 out separate functions for each kind of thing we could be fixing.
2000 They all get called from here. */
2003 md_apply_fix (fixS
*fixP
, valueT
* valP
, segT seg ATTRIBUTE_UNUSED
)
2005 long val
= * (long *) valP
;
2006 char *buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
2008 if (fix_bit_fixP (fixP
))
2009 /* Bitfields to fix, sigh. */
2010 md_number_to_field (buf
, val
, fix_bit_fixP (fixP
));
2011 else switch (fix_im_disp (fixP
))
2014 /* Immediate field. */
2015 md_number_to_imm (buf
, val
, fixP
->fx_size
);
2019 /* Displacement field. */
2020 /* Calculate offset. */
2021 md_number_to_disp (buf
,
2022 (fixP
->fx_pcrel
? val
+ md_fix_pcrel_adjust (fixP
)
2023 : val
), fixP
->fx_size
);
2027 /* Pointer in a data object. */
2028 md_number_to_chars (buf
, val
, fixP
->fx_size
);
2032 if (fixP
->fx_addsy
== NULL
&& fixP
->fx_pcrel
== 0)
2036 /* Convert a relaxed displacement to ditto in final output. */
2039 md_convert_frag (bfd
*abfd ATTRIBUTE_UNUSED
,
2040 segT sec ATTRIBUTE_UNUSED
,
2045 /* Address in gas core of the place to store the displacement. */
2046 char *buffer_address
= fragP
->fr_fix
+ fragP
->fr_literal
;
2047 /* Address in object code of the displacement. */
2050 switch (fragP
->fr_subtype
)
2052 case IND (BRANCH
, BYTE
):
2055 case IND (BRANCH
, WORD
):
2058 case IND (BRANCH
, DOUBLE
):
2066 know (fragP
->fr_symbol
);
2068 object_address
= fragP
->fr_fix
+ fragP
->fr_address
;
2070 /* The displacement of the address, from current location. */
2071 disp
= (S_GET_VALUE (fragP
->fr_symbol
) + fragP
->fr_offset
) - object_address
;
2072 disp
+= md_pcrel_adjust (fragP
);
2074 md_number_to_disp (buffer_address
, (long) disp
, (int) ext
);
2075 fragP
->fr_fix
+= ext
;
2078 /* This function returns the estimated size a variable object will occupy,
2079 one can say that we tries to guess the size of the objects before we
2080 actually know it. */
2083 md_estimate_size_before_relax (fragS
*fragP
, segT segment
)
2085 if (fragP
->fr_subtype
== IND (BRANCH
, UNDEF
))
2087 if (S_GET_SEGMENT (fragP
->fr_symbol
) != segment
)
2089 /* We don't relax symbols defined in another segment. The
2090 thing to do is to assume the object will occupy 4 bytes. */
2091 fix_new_ns32k (fragP
,
2092 (int) (fragP
->fr_fix
),
2099 frag_bsr(fragP
), /* Sequent hack. */
2100 frag_opcode_frag (fragP
),
2101 frag_opcode_offset (fragP
));
2107 /* Relaxable case. Set up the initial guess for the variable
2108 part of the frag. */
2109 fragP
->fr_subtype
= IND (BRANCH
, BYTE
);
2112 if (fragP
->fr_subtype
>= sizeof (md_relax_table
) / sizeof (md_relax_table
[0]))
2115 /* Return the size of the variable part of the frag. */
2116 return md_relax_table
[fragP
->fr_subtype
].rlx_length
;
2119 int md_short_jump_size
= 3;
2120 int md_long_jump_size
= 5;
2123 md_create_short_jump (char *ptr
,
2126 fragS
*frag ATTRIBUTE_UNUSED
,
2127 symbolS
*to_symbol ATTRIBUTE_UNUSED
)
2131 offset
= to_addr
- from_addr
;
2132 md_number_to_chars (ptr
, (valueT
) 0xEA, 1);
2133 md_number_to_disp (ptr
+ 1, (valueT
) offset
, 2);
2137 md_create_long_jump (char *ptr
,
2140 fragS
*frag ATTRIBUTE_UNUSED
,
2141 symbolS
*to_symbol ATTRIBUTE_UNUSED
)
2145 offset
= to_addr
- from_addr
;
2146 md_number_to_chars (ptr
, (valueT
) 0xEA, 1);
2147 md_number_to_disp (ptr
+ 1, (valueT
) offset
, 4);
2150 const char *md_shortopts
= "m:";
2152 struct option md_longopts
[] =
2154 #define OPTION_DISP_SIZE (OPTION_MD_BASE)
2155 {"disp-size-default", required_argument
, NULL
, OPTION_DISP_SIZE
},
2156 {NULL
, no_argument
, NULL
, 0}
2159 size_t md_longopts_size
= sizeof (md_longopts
);
2162 md_parse_option (int c
, char *arg
)
2167 if (!strcmp (arg
, "32032"))
2169 cpureg
= cpureg_032
;
2170 mmureg
= mmureg_032
;
2172 else if (!strcmp (arg
, "32532"))
2174 cpureg
= cpureg_532
;
2175 mmureg
= mmureg_532
;
2179 as_warn (_("invalid architecture option -m%s, ignored"), arg
);
2183 case OPTION_DISP_SIZE
:
2185 int size
= atoi(arg
);
2188 case 1: case 2: case 4:
2189 default_disp_size
= size
;
2192 as_warn (_("invalid default displacement size \"%s\". Defaulting to %d."),
2193 arg
, default_disp_size
);
2206 md_show_usage (FILE *stream
)
2208 fprintf (stream
, _("\
2210 -m32032 | -m32532 select variant of NS32K architecture\n\
2211 --disp-size-default=<1|2|4>\n"));
2214 /* This is TC_CONS_FIX_NEW, called by emit_expr in read.c. */
2217 cons_fix_new_ns32k (fragS
*frag
, /* Which frag? */
2218 int where
, /* Where in that frag? */
2219 int size
, /* 1, 2 or 4 usually. */
2220 expressionS
*exp
) /* Expression. */
2222 fix_new_ns32k_exp (frag
, where
, size
, exp
,
2226 /* We have no need to default values of symbols. */
2229 md_undefined_symbol (char *name ATTRIBUTE_UNUSED
)
2234 /* Round up a section size to the appropriate boundary. */
2237 md_section_align (segT segment ATTRIBUTE_UNUSED
, valueT size
)
2239 return size
; /* Byte alignment is fine. */
2242 /* Exactly what point is a PC-relative offset relative TO? On the
2243 ns32k, they're relative to the start of the instruction. */
2246 md_pcrel_from (fixS
*fixP
)
2250 res
= fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
2251 #ifdef SEQUENT_COMPATABILITY
2252 if (frag_bsr (fixP
->fx_frag
))
2253 res
+= 0x12 /* FOO Kludge alert! */
2259 tc_gen_reloc (asection
*section ATTRIBUTE_UNUSED
, fixS
*fixp
)
2262 bfd_reloc_code_real_type code
;
2264 code
= reloc (fixp
->fx_size
, fixp
->fx_pcrel
, fix_im_disp (fixp
));
2266 rel
= xmalloc (sizeof (arelent
));
2267 rel
->sym_ptr_ptr
= xmalloc (sizeof (asymbol
*));
2268 *rel
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
2269 rel
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
2271 rel
->addend
= fixp
->fx_addnumber
;
2275 rel
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
2280 name
= S_GET_NAME (fixp
->fx_addsy
);
2282 name
= _("<unknown>");
2283 as_fatal (_("Cannot find relocation type for symbol %s, code %d"),