1 /* ns32k.c -- Assemble on the National Semiconductor 32k series
2 Copyright (C) 1987-2016 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to the Free
18 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
21 /*#define SHOW_NUM 1*//* Uncomment for debugging. */
24 #include "opcode/ns32k.h"
29 #define IIF_ENTRIES 13 /* Number of entries in iif. */
30 #define PRIVATE_SIZE 256 /* Size of my garbage memory. */
32 #define DEFAULT -1 /* addr_mode returns this value when
33 plain constant or label is
36 #define IIF(ptr,a1,c1,e1,g1,i1,k1,m1,o1,q1,s1,u1) \
37 iif.iifP[ptr].type = a1; \
38 iif.iifP[ptr].size = c1; \
39 iif.iifP[ptr].object = e1; \
40 iif.iifP[ptr].object_adjust = g1; \
41 iif.iifP[ptr].pcrel = i1; \
42 iif.iifP[ptr].pcrel_adjust = k1; \
43 iif.iifP[ptr].im_disp = m1; \
44 iif.iifP[ptr].relax_substate = o1; \
45 iif.iifP[ptr].bit_fixP = q1; \
46 iif.iifP[ptr].addr_mode = s1; \
47 iif.iifP[ptr].bsr = u1;
49 #ifdef SEQUENT_COMPATABILITY
50 #define LINE_COMMENT_CHARS "|"
51 #define ABSOLUTE_PREFIX '@'
52 #define IMMEDIATE_PREFIX '#'
55 #ifndef LINE_COMMENT_CHARS
56 #define LINE_COMMENT_CHARS "#"
59 const char comment_chars[] = "#";
60 const char line_comment_chars[] = LINE_COMMENT_CHARS;
61 const char line_separator_chars[] = ";";
62 static int default_disp_size = 4; /* Displacement size for external refs. */
64 #if !defined(ABSOLUTE_PREFIX) && !defined(IMMEDIATE_PREFIX)
65 #define ABSOLUTE_PREFIX '@' /* One or the other MUST be defined. */
70 signed char mode; /* Addressing mode of operand (0-31). */
71 signed char scaled_mode; /* Mode combined with scaled mode. */
72 char scaled_reg; /* Register used in scaled+1 (1-8). */
73 char float_flag; /* Set if R0..R7 was F0..F7 ie a
74 floating-point-register. */
75 char am_size; /* Estimated max size of general addr-mode
77 char im_disp; /* If im_disp==1 we have a displacement. */
78 char pcrel; /* 1 if pcrel, this is really redundant info. */
79 char disp_suffix[2]; /* Length of displacement(s), 0=undefined. */
80 char *disp[2]; /* Pointer(s) at displacement(s)
81 or immediates(s) (ascii). */
82 char index_byte; /* Index byte. */
84 typedef struct addr_mode addr_modeS;
86 char *freeptr, *freeptr_static; /* Points at some number of free bytes. */
87 struct hash_control *inst_hash_handle;
89 struct ns32k_opcode *desc; /* Pointer at description of instruction. */
90 addr_modeS addr_modeP;
91 const char EXP_CHARS[] = "eE";
92 const char FLT_CHARS[] = "fd"; /* We don't want to support lowercase,
95 /* UPPERCASE denotes live names when an instruction is built, IIF is
96 used as an intermediate form to store the actual parts of the
97 instruction. A ns32k machine instruction can be divided into a
98 couple of sub PARTs. When an instruction is assembled the
99 appropriate PART get an assignment. When an IIF has been completed
100 it is converted to a FRAGment as specified in AS.H. */
102 /* Internal structs. */
112 int type; /* How to interpret object. */
113 int size; /* Estimated max size of object. */
114 unsigned long object; /* Binary data. */
115 int object_adjust; /* Number added to object. */
116 int pcrel; /* True if object is pcrel. */
117 int pcrel_adjust; /* Length in bytes from the instruction
118 start to the displacement. */
119 int im_disp; /* True if the object is a displacement. */
120 relax_substateT relax_substate;/*Initial relaxsubstate. */
121 bit_fixS *bit_fixP; /* Pointer at bit_fix struct. */
122 int addr_mode; /* What addrmode do we associate with this
124 char bsr; /* Sequent hack. */
125 } iif_entryT; /* Internal Instruction Format. */
129 int instr_size; /* Max size of instruction in bytes. */
130 iif_entryT iifP[IIF_ENTRIES + 1];
133 struct int_ins_form iif;
136 /* Description of the PARTs in IIF
138 0 total length in bytes of entries in iif
151 For every entry there is a datalength in bytes. This is stored in size[n].
152 0, the objectlength is not explicitly given by the instruction
153 and the operand is undefined. This is a case for relaxation.
154 Reserve 4 bytes for the final object.
156 1, the entry contains one byte
157 2, the entry contains two bytes
158 3, the entry contains three bytes
159 4, the entry contains four bytes
162 Furthermore, every entry has a data type identifier in type[n].
164 0, the entry is void, ignore it.
165 1, the entry is a binary number.
166 2, the entry is a pointer at an expression.
167 Where expression may be as simple as a single '1',
168 and as complicated as foo-bar+12,
169 foo and bar may be undefined but suffixed by :{b|w|d} to
170 control the length of the object.
172 3, the entry is a pointer at a bignum struct
174 The low-order-byte corresponds to low physical memory.
175 Obviously a FRAGment must be created for each valid disp in PART whose
176 datalength is undefined (to bad) .
177 The case where just the expression is undefined is less severe and is
178 handled by fix. Here the number of bytes in the objectfile is known.
179 With this representation we simplify the assembly and separates the
180 machine dependent/independent parts in a more clean way (said OE). */
182 struct ns32k_option opt1[] = /* restore, exit. */
194 struct ns32k_option opt2[] = /* save, enter. */
206 struct ns32k_option opt3[] = /* setcfg. */
214 struct ns32k_option opt4[] = /* cinv. */
221 struct ns32k_option opt5[] = /* String inst. */
228 struct ns32k_option opt6[] = /* Plain reg ext,cvtp etc. */
241 #if !defined(NS32032) && !defined(NS32532)
245 struct ns32k_option cpureg_532[] = /* lpr spr. */
258 {"intbase", 0xe, 0xff},
262 struct ns32k_option mmureg_532[] = /* lmr smr. */
269 {"ivar0", 0xe, 0xff},
270 {"ivar1", 0xf, 0xff},
274 struct ns32k_option cpureg_032[] = /* lpr spr. */
281 {"intbase", 0xe, 0xff},
285 struct ns32k_option mmureg_032[] = /* lmr smr. */
301 struct ns32k_option *cpureg = cpureg_532;
302 struct ns32k_option *mmureg = mmureg_532;
304 struct ns32k_option *cpureg = cpureg_032;
305 struct ns32k_option *mmureg = mmureg_032;
309 const pseudo_typeS md_pseudo_table[] =
310 { /* So far empty. */
314 #define IND(x,y) (((x)<<2)+(y))
316 /* Those are index's to relax groups in md_relax_table ie it must be
317 multiplied by 4 to point at a group start. Viz IND(x,y) Se function
318 relax_segment in write.c for more info. */
323 /* Those are index's to entries in a relax group. */
329 /* Those limits are calculated from the displacement start in memory.
330 The ns32k uses the beginning of the instruction as displacement
331 base. This type of displacements could be handled here by moving
332 the limit window up or down. I choose to use an internal
333 displacement base-adjust as there are other routines that must
334 consider this. Also, as we have two various offset-adjusts in the
335 ns32k (acb versus br/brs/jsr/bcond), two set of limits would have
336 had to be used. Now we dont have to think about that. */
338 const relax_typeS md_relax_table[] =
345 {(63), (-64), 1, IND (BRANCH, WORD)},
346 {(8192), (-8192), 2, IND (BRANCH, DOUBLE)},
351 /* Array used to test if mode contains displacements.
352 Value is true if mode contains displacement. */
355 {0, 0, 0, 0, 0, 0, 0, 0,
356 1, 1, 1, 1, 1, 1, 1, 1,
357 1, 1, 1, 0, 0, 1, 1, 0,
358 1, 1, 1, 1, 1, 1, 1, 1};
360 /* Array used to calculate max size of displacements. */
365 /* Parse a general operand into an addressingmode struct
367 In: pointer at operand in ascii form
368 pointer at addr_mode struct for result
369 the level of recursion. (always 0 or 1)
371 Out: data in addr_mode struct. */
374 addr_mode (char *operand,
375 addr_modeS *addrmodeP,
384 mode = DEFAULT; /* Default. */
385 addrmodeP->scaled_mode = 0; /* Why not. */
386 addrmodeP->scaled_reg = 0; /* If 0, not scaled index. */
387 addrmodeP->float_flag = 0;
388 addrmodeP->am_size = 0;
389 addrmodeP->im_disp = 0;
390 addrmodeP->pcrel = 0; /* Not set in this function. */
391 addrmodeP->disp_suffix[0] = 0;
392 addrmodeP->disp_suffix[1] = 0;
393 addrmodeP->disp[0] = NULL;
394 addrmodeP->disp[1] = NULL;
404 /* The following three case statements controls the mode-chars
405 this is the place to ed if you want to change them. */
406 #ifdef ABSOLUTE_PREFIX
407 case ABSOLUTE_PREFIX:
408 if (str[strl - 1] == ']')
410 addrmodeP->mode = 21; /* absolute */
411 addrmodeP->disp[0] = str + 1;
414 #ifdef IMMEDIATE_PREFIX
415 case IMMEDIATE_PREFIX:
416 if (str[strl - 1] == ']')
418 addrmodeP->mode = 20; /* immediate */
419 addrmodeP->disp[0] = str + 1;
423 if (str[strl - 1] != ']')
429 if (str[2] != '\000')
431 addrmodeP->mode = 27; /* pc-relative */
432 addrmodeP->disp[0] = str + 2;
436 as_bad (_("Invalid syntax in PC-relative addressing mode"));
442 if (str[strl - 1] != ']')
444 if ((!strncmp (str, "ext(", 4)) && strl > 7)
446 addrmodeP->disp[0] = str + 4;
450 { /* disp[0]'s termination point. */
457 while (j < strl && i != 0);
458 if (i != 0 || !(str[j + 1] == '-' || str[j + 1] == '+'))
460 as_bad (_("Invalid syntax in External addressing mode"));
463 str[j] = '\000'; /* null terminate disp[0] */
464 addrmodeP->disp[1] = str + j + 2;
465 addrmodeP->mode = 22;
483 addrmodeP->float_flag = 1;
486 if (str[1] >= '0' && str[1] < '8')
488 addrmodeP->mode = str[1] - '0';
498 if (!strncmp (str, "tos", 3))
500 addrmodeP->mode = 23; /* TopOfStack */
511 if (str[strl - 1] == ')')
513 if (str[strl - 2] == ')')
515 if (!strncmp (&str[strl - 5], "(fp", 3))
516 mode = 16; /* Memory Relative. */
517 else if (!strncmp (&str[strl - 5], "(sp", 3))
519 else if (!strncmp (&str[strl - 5], "(sb", 3))
524 /* Memory relative. */
525 addrmodeP->mode = mode;
526 j = strl - 5; /* Temp for end of disp[0]. */
532 if (str[strl] == ')')
534 if (str[strl] == '(')
537 while (strl > -1 && i != 0);
541 as_bad (_("Invalid syntax in Memory Relative addressing mode"));
545 addrmodeP->disp[1] = str;
546 addrmodeP->disp[0] = str + strl + 1;
547 str[j] = '\000'; /* Null terminate disp[0] . */
548 str[strl] = '\000'; /* Null terminate disp[1]. */
554 switch (str[strl - 3])
558 if (str[strl - 2] >= '0'
559 && str[strl - 2] < '8'
560 && str[strl - 4] == '(')
562 addrmodeP->mode = str[strl - 2] - '0' + 8;
563 addrmodeP->disp[0] = str;
565 return -1; /* reg rel */
570 if (!strncmp (&str[strl - 4], "(fp", 3))
572 else if (!strncmp (&str[strl - 4], "(sp", 3))
574 else if (!strncmp (&str[strl - 4], "(sb", 3))
576 else if (!strncmp (&str[strl - 4], "(pc", 3))
581 addrmodeP->mode = mode;
582 addrmodeP->disp[0] = str;
583 str[strl - 4] = '\0';
585 return -1; /* Memory space. */
590 /* No trailing ')' do we have a ']' ? */
591 if (str[strl - 1] == ']')
593 switch (str[strl - 2])
608 as_bad (_("Invalid scaled-indexed mode, use (b,w,d,q)"));
610 if (str[strl - 3] != ':' || str[strl - 6] != '['
611 || str[strl - 5] == 'r' || str[strl - 4] < '0'
612 || str[strl - 4] > '7')
613 as_bad (_("Syntax in scaled-indexed mode, use [Rn:m] where n=[0..7] m={b,w,d,q}"));
614 } /* Scaled index. */
616 if (recursive_level > 0)
618 as_bad (_("Scaled-indexed addressing mode combined with scaled-index"));
622 addrmodeP->am_size += 1; /* scaled index byte. */
623 j = str[strl - 4] - '0'; /* store temporary. */
624 str[strl - 6] = '\000'; /* nullterminate for recursive call. */
625 i = addr_mode (str, addrmodeP, 1);
627 if (!i || addrmodeP->mode == 20)
629 as_bad (_("Invalid or illegal addressing mode combined with scaled-index"));
633 addrmodeP->scaled_mode = addrmodeP->mode; /* Store the inferior mode. */
634 addrmodeP->mode = mode;
635 addrmodeP->scaled_reg = j + 1;
641 addrmodeP->mode = DEFAULT; /* Default to whatever. */
642 addrmodeP->disp[0] = str;
648 evaluate_expr (expressionS *resultP, char *ptr)
652 tmp_line = input_line_pointer;
653 input_line_pointer = ptr;
654 expression (resultP);
655 input_line_pointer = tmp_line;
658 /* ptr points at string addr_modeP points at struct with result This
659 routine calls addr_mode to determine the general addr.mode of the
660 operand. When this is ready it parses the displacements for size
661 specifying suffixes and determines size of immediate mode via
662 ns32k-opcode. Also builds index bytes if needed. */
665 get_addr_mode (char *ptr, addr_modeS *addrmodeP)
669 addr_mode (ptr, addrmodeP, 0);
671 if (addrmodeP->mode == DEFAULT || addrmodeP->scaled_mode == -1)
673 /* Resolve ambiguous operands, this shouldn't be necessary if
674 one uses standard NSC operand syntax. But the sequent
675 compiler doesn't!!! This finds a proper addressing mode
676 if it is implicitly stated. See ns32k-opcode.h. */
677 (void) evaluate_expr (&exprP, ptr); /* This call takes time Sigh! */
679 if (addrmodeP->mode == DEFAULT)
681 if (exprP.X_add_symbol || exprP.X_op_symbol)
682 addrmodeP->mode = desc->default_model; /* We have a label. */
684 addrmodeP->mode = desc->default_modec; /* We have a constant. */
688 if (exprP.X_add_symbol || exprP.X_op_symbol)
689 addrmodeP->scaled_mode = desc->default_model;
691 addrmodeP->scaled_mode = desc->default_modec;
694 /* Must put this mess down in addr_mode to handle the scaled
698 /* It appears as the sequent compiler wants an absolute when we have
699 a label without @. Constants becomes immediates besides the addr
700 case. Think it does so with local labels too, not optimum, pcrel
701 is better. When I have time I will make gas check this and
702 select pcrel when possible Actually that is trivial. */
703 if ((tmp = addrmodeP->scaled_reg))
704 { /* Build indexbyte. */
705 tmp--; /* Remember regnumber comes incremented for
707 tmp |= addrmodeP->scaled_mode << 3;
708 addrmodeP->index_byte = (char) tmp;
709 addrmodeP->am_size += 1;
712 gas_assert (addrmodeP->mode >= 0);
713 if (disp_test[(unsigned int) addrmodeP->mode])
722 /* There was a displacement, probe for length specifying suffix. */
723 addrmodeP->pcrel = 0;
725 gas_assert (addrmodeP->mode >= 0);
726 if (disp_test[(unsigned int) addrmodeP->mode])
728 /* There is a displacement. */
729 if (addrmodeP->mode == 27 || addrmodeP->scaled_mode == 27)
730 /* Do we have pcrel. mode. */
731 addrmodeP->pcrel = 1;
733 addrmodeP->im_disp = 1;
735 for (i = 0; i < 2; i++)
737 suffix_sub = suffix = 0;
739 if ((toP = addrmodeP->disp[i]))
741 /* Suffix of expression, the largest size rules. */
744 while ((c = *fromP++))
752 as_warn (_("Premature end of suffix -- Defaulting to d"));
765 as_warn (_("Bad suffix after ':' use {b|w|d} Defaulting to d"));
770 toP --; /* So we write over the ':' */
772 if (suffix < suffix_sub)
777 *toP = '\0'; /* Terminate properly. */
778 addrmodeP->disp_suffix[i] = suffix;
779 addrmodeP->am_size += suffix ? suffix : 4;
786 if (addrmodeP->mode == 20)
788 /* Look in ns32k_opcode for size. */
789 addrmodeP->disp_suffix[0] = addrmodeP->am_size = desc->im_size;
790 addrmodeP->im_disp = 0;
794 return addrmodeP->mode;
797 /* Read an optionlist. */
800 optlist (char *str, /* The string to extract options from. */
801 struct ns32k_option *optionP, /* How to search the string. */
802 unsigned long *default_map) /* Default pattern and output. */
804 int i, j, k, strlen1, strlen2;
805 const char *patternP, *strP;
807 strlen1 = strlen (str);
810 as_fatal (_("Very short instr to option, ie you can't do it on a NULLstr"));
812 for (i = 0; optionP[i].pattern != 0; i++)
814 strlen2 = strlen (optionP[i].pattern);
816 for (j = 0; j < strlen1; j++)
818 patternP = optionP[i].pattern;
821 for (k = 0; k < strlen2; k++)
823 if (*(strP++) != *(patternP++))
829 *default_map |= optionP[i].or;
830 *default_map &= optionP[i].and;
836 /* Search struct for symbols.
837 This function is used to get the short integer form of reg names in
838 the instructions lmr, smr, lpr, spr return true if str is found in
842 list_search (char *str, /* The string to match. */
843 struct ns32k_option *optionP, /* List to search. */
844 unsigned long *default_map) /* Default pattern and output. */
848 for (i = 0; optionP[i].pattern != 0; i++)
850 if (!strncmp (optionP[i].pattern, str, 20))
852 /* Use strncmp to be safe. */
853 *default_map |= optionP[i].or;
854 *default_map &= optionP[i].and;
860 as_bad (_("No such entry in list. (cpu/mmu register)"));
864 /* Create a bit_fixS in obstack 'notes'.
865 This struct is used to profile the normal fix. If the bit_fixP is a
866 valid pointer (not NULL) the bit_fix data will be used to format
870 bit_fix_new (int size, /* Length of bitfield. */
871 int offset, /* Bit offset to bitfield. */
872 long min, /* Signextended min for bitfield. */
873 long max, /* Signextended max for bitfield. */
874 long add, /* Add mask, used for huffman prefix. */
875 long base_type, /* 0 or 1, if 1 it's exploded to opcode ptr. */
880 bit_fixP = XOBNEW (¬es, bit_fixS);
882 bit_fixP->fx_bit_size = size;
883 bit_fixP->fx_bit_offset = offset;
884 bit_fixP->fx_bit_base = base_type;
885 bit_fixP->fx_bit_base_adj = base_adj;
886 bit_fixP->fx_bit_max = max;
887 bit_fixP->fx_bit_min = min;
888 bit_fixP->fx_bit_add = add;
893 /* Convert operands to iif-format and adds bitfields to the opcode.
894 Operands are parsed in such an order that the opcode is updated from
895 its most significant bit, that is when the operand need to alter the
897 Be careful not to put to objects in the same iif-slot. */
900 encode_operand (int argc,
902 const char *operandsP,
904 char im_size ATTRIBUTE_UNUSED,
909 int pcrel, b, loop, pcrel_adjust;
912 for (loop = 0; loop < argc; loop++)
914 /* What operand are we supposed to work on. */
915 i = operandsP[loop << 1] - '1';
917 as_fatal (_("Internal consistency error. check ns32k-opcode.h"));
923 switch ((d = operandsP[(loop << 1) + 1]))
925 case 'f': /* Operand of sfsr turns out to be a nasty
928 case 'Z': /* Float not immediate. */
929 case 'F': /* 32 bit float general form. */
930 case 'L': /* 64 bit float. */
931 case 'I': /* Integer not immediate. */
934 case 'D': /* Double-word. */
935 case 'A': /* Double-word gen-address-form ie no regs
937 get_addr_mode (argv[i], &addr_modeP);
939 if ((addr_modeP.mode == 20) &&
940 (d == 'I' || d == 'Z' || d == 'A'))
941 as_fatal (d == 'A'? _("Address of immediate operand"):
942 _("Invalid immediate write operand."));
944 if (opcode_bit_ptr == desc->opcode_size)
949 for (j = b; j < (b + 2); j++)
951 if (addr_modeP.disp[j - b])
955 addr_modeP.disp_suffix[j - b],
956 (unsigned long) addr_modeP.disp[j - b],
963 (addr_modeP.scaled_reg ? addr_modeP.scaled_mode
970 iif.iifP[1].object |= ((long) addr_modeP.mode) << opcode_bit_ptr;
972 if (addr_modeP.scaled_reg)
975 IIF (j, 1, 1, (unsigned long) addr_modeP.index_byte,
976 0, 0, 0, 0, 0, NULL, -1, 0);
980 case 'b': /* Multiple instruction disp. */
981 freeptr++; /* OVE:this is an useful hack. */
982 sprintf (freeptr, "((%s-1)*%d)", argv[i], desc->im_size);
984 pcrel -= 1; /* Make pcrel 0 in spite of what case 'p':
987 case 'p': /* Displacement - pc relative addressing. */
990 case 'd': /* Displacement. */
991 iif.instr_size += suffixP[i] ? suffixP[i] : 4;
992 IIF (12, 2, suffixP[i], (unsigned long) argv[i], 0,
993 pcrel, pcrel_adjust, 1, IND (BRANCH, BYTE), NULL, -1, 0);
995 case 'H': /* Sequent-hack: the linker wants a bit set
998 iif.instr_size += suffixP[i] ? suffixP[i] : 4;
999 IIF (12, 2, suffixP[i], (unsigned long) argv[i], 0,
1000 pcrel, pcrel_adjust, 1, IND (BRANCH, BYTE), NULL, -1, 1);
1002 case 'q': /* quick */
1003 opcode_bit_ptr -= 4;
1004 IIF (11, 2, 42, (unsigned long) argv[i], 0, 0, 0, 0, 0,
1005 bit_fix_new (4, opcode_bit_ptr, -8, 7, 0, 1, 0), -1, 0);
1007 case 'r': /* Register number (3 bits). */
1008 list_search (argv[i], opt6, &tmp);
1009 opcode_bit_ptr -= 3;
1010 iif.iifP[1].object |= tmp << opcode_bit_ptr;
1012 case 'O': /* Setcfg instruction optionslist. */
1013 optlist (argv[i], opt3, &tmp);
1014 opcode_bit_ptr -= 4;
1015 iif.iifP[1].object |= tmp << 15;
1017 case 'C': /* Cinv instruction optionslist. */
1018 optlist (argv[i], opt4, &tmp);
1019 opcode_bit_ptr -= 4;
1020 iif.iifP[1].object |= tmp << 15; /* Insert the regtype in opcode. */
1022 case 'S': /* String instruction options list. */
1023 optlist (argv[i], opt5, &tmp);
1024 opcode_bit_ptr -= 4;
1025 iif.iifP[1].object |= tmp << 15;
1028 case 'U': /* Register list. */
1029 IIF (10, 1, 1, 0, 0, 0, 0, 0, 0, NULL, -1, 0);
1030 switch (operandsP[(i << 1) + 1])
1032 case 'u': /* Restore, exit. */
1033 optlist (argv[i], opt1, &iif.iifP[10].object);
1035 case 'U': /* Save, enter. */
1036 optlist (argv[i], opt2, &iif.iifP[10].object);
1039 iif.instr_size += 1;
1041 case 'M': /* MMU register. */
1042 list_search (argv[i], mmureg, &tmp);
1043 opcode_bit_ptr -= 4;
1044 iif.iifP[1].object |= tmp << opcode_bit_ptr;
1046 case 'P': /* CPU register. */
1047 list_search (argv[i], cpureg, &tmp);
1048 opcode_bit_ptr -= 4;
1049 iif.iifP[1].object |= tmp << opcode_bit_ptr;
1051 case 'g': /* Inss exts. */
1052 iif.instr_size += 1; /* 1 byte is allocated after the opcode. */
1054 (unsigned long) argv[i], /* i always 2 here. */
1056 bit_fix_new (3, 5, 0, 7, 0, 0, 0), /* A bit_fix is targeted to
1062 (unsigned long) argv[i], /* i always 3 here. */
1064 bit_fix_new (5, 0, 1, 32, -1, 0, -1), -1, 0);
1067 iif.instr_size += 1;
1068 b = 2 + i; /* Put the extension byte after opcode. */
1069 IIF (b, 2, 1, 0, 0, 0, 0, 0, 0, 0, -1, 0);
1072 as_fatal (_("Bad opcode-table-option, check in file ns32k-opcode.h"));
1077 /* in: instruction line
1078 out: internal structure of instruction
1079 that has been prepared for direct conversion to fragment(s) and
1080 fixes in a systematical fashion
1081 Return-value = recursive_level. */
1082 /* Build iif of one assembly text line. */
1085 parse (const char *line, int recursive_level)
1087 const char *lineptr;
1088 char c, suffix_separator;
1093 char suffix[MAX_ARGS], *argv[MAX_ARGS]; /* No more than 4 operands. */
1095 if (recursive_level <= 0)
1097 /* Called from md_assemble. */
1098 for (lineptr = line; (*lineptr) != '\0' && (*lineptr) != ' '; lineptr++)
1102 *(char *) lineptr = '\0';
1104 if (!(desc = (struct ns32k_opcode *) hash_find (inst_hash_handle, line)))
1105 as_fatal (_("No such opcode"));
1107 *(char *) lineptr = c;
1114 if (*desc->operands)
1116 if (*lineptr++ != '\0')
1121 while (*lineptr != '\0')
1123 if (desc->operands[argc << 1])
1126 arg_type = desc->operands[(argc << 1) + 1];
1134 /* The operand is supposed to be a displacement. */
1135 /* Hackwarning: do not forget to update the 4
1136 cases above when editing ns32k-opcode.h. */
1137 suffix_separator = ':';
1140 /* If this char occurs we loose. */
1141 suffix_separator = '\255';
1145 suffix[argc] = 0; /* 0 when no ':' is encountered. */
1146 argv[argc] = freeptr;
1149 while ((c = *lineptr) != '\0' && c != sep)
1165 if (c == suffix_separator)
1167 /* ':' - label/suffix separator. */
1180 as_warn (_("Bad suffix, defaulting to d"));
1182 if (lineptr[1] == '\0' || lineptr[1] == sep)
1201 if (*lineptr == '\0')
1207 as_fatal (_("Too many operands passed to instruction"));
1212 if (argc != strlen (desc->operands) / 2)
1214 if (strlen (desc->default_args))
1216 /* We can apply default, don't goof. */
1217 if (parse (desc->default_args, 1) != 1)
1218 /* Check error in default. */
1219 as_fatal (_("Wrong numbers of operands in default, check ns32k-opcodes.h"));
1222 as_fatal (_("Wrong number of operands"));
1225 for (i = 0; i < IIF_ENTRIES; i++)
1226 /* Mark all entries as void. */
1227 iif.iifP[i].type = 0;
1229 /* Build opcode iif-entry. */
1230 iif.instr_size = desc->opcode_size / 8;
1231 IIF (1, 1, iif.instr_size, desc->opcode_seed, 0, 0, 0, 0, 0, 0, -1, 0);
1233 /* This call encodes operands to iif format. */
1235 encode_operand (argc, argv, &desc->operands[0],
1236 &suffix[0], desc->im_size, desc->opcode_size);
1238 return recursive_level;
1241 /* This functionality should really be in the bfd library. */
1243 static bfd_reloc_code_real_type
1244 reloc (int size, int pcrel, int type)
1246 int length, rel_index;
1247 bfd_reloc_code_real_type relocs[] =
1249 BFD_RELOC_NS32K_IMM_8,
1250 BFD_RELOC_NS32K_IMM_16,
1251 BFD_RELOC_NS32K_IMM_32,
1252 BFD_RELOC_NS32K_IMM_8_PCREL,
1253 BFD_RELOC_NS32K_IMM_16_PCREL,
1254 BFD_RELOC_NS32K_IMM_32_PCREL,
1256 /* ns32k displacements. */
1257 BFD_RELOC_NS32K_DISP_8,
1258 BFD_RELOC_NS32K_DISP_16,
1259 BFD_RELOC_NS32K_DISP_32,
1260 BFD_RELOC_NS32K_DISP_8_PCREL,
1261 BFD_RELOC_NS32K_DISP_16_PCREL,
1262 BFD_RELOC_NS32K_DISP_32_PCREL,
1264 /* Normal 2's complement. */
1289 rel_index = length + 3 * pcrel + 6 * type;
1291 if (rel_index >= 0 && (unsigned int) rel_index < sizeof (relocs) / sizeof (relocs[0]))
1292 return relocs[rel_index];
1295 as_bad (_("Can not do %d byte pc-relative relocation for storage type %d"),
1298 as_bad (_("Can not do %d byte relocation for storage type %d"),
1301 return BFD_RELOC_NONE;
1306 fix_new_ns32k (fragS *frag, /* Which frag? */
1307 int where, /* Where in that frag? */
1308 int size, /* 1, 2 or 4 usually. */
1309 symbolS *add_symbol, /* X_add_symbol. */
1310 long offset, /* X_add_number. */
1311 int pcrel, /* True if PC-relative relocation. */
1312 char im_disp, /* True if the value to write is a
1314 bit_fixS *bit_fixP, /* Pointer at struct of bit_fix's, ignored if
1316 char bsr, /* Sequent-linker-hack: 1 when relocobject is
1319 unsigned int opcode_offset)
1321 fixS *fixP = fix_new (frag, where, size, add_symbol,
1323 bit_fixP ? NO_RELOC : reloc (size, pcrel, im_disp)
1326 fix_opcode_frag (fixP) = opcode_frag;
1327 fix_opcode_offset (fixP) = opcode_offset;
1328 fix_im_disp (fixP) = im_disp;
1329 fix_bsr (fixP) = bsr;
1330 fix_bit_fixP (fixP) = bit_fixP;
1331 /* We have a MD overflow check for displacements. */
1332 fixP->fx_no_overflow = (im_disp != 0);
1336 fix_new_ns32k_exp (fragS *frag, /* Which frag? */
1337 int where, /* Where in that frag? */
1338 int size, /* 1, 2 or 4 usually. */
1339 expressionS *exp, /* Expression. */
1340 int pcrel, /* True if PC-relative relocation. */
1341 char im_disp, /* True if the value to write is a
1343 bit_fixS *bit_fixP, /* Pointer at struct of bit_fix's, ignored if
1345 char bsr, /* Sequent-linker-hack: 1 when relocobject is
1348 unsigned int opcode_offset)
1350 fixS *fixP = fix_new_exp (frag, where, size, exp, pcrel,
1351 bit_fixP ? NO_RELOC : reloc (size, pcrel, im_disp)
1354 fix_opcode_frag (fixP) = opcode_frag;
1355 fix_opcode_offset (fixP) = opcode_offset;
1356 fix_im_disp (fixP) = im_disp;
1357 fix_bsr (fixP) = bsr;
1358 fix_bit_fixP (fixP) = bit_fixP;
1359 /* We have a MD overflow check for displacements. */
1360 fixP->fx_no_overflow = (im_disp != 0);
1363 /* Convert number to chars in correct order. */
1366 md_number_to_chars (char *buf, valueT value, int nbytes)
1368 number_to_chars_littleendian (buf, value, nbytes);
1371 /* This is a variant of md_numbers_to_chars. The reason for its'
1372 existence is the fact that ns32k uses Huffman coded
1373 displacements. This implies that the bit order is reversed in
1374 displacements and that they are prefixed with a size-tag.
1378 10xxxxxx xxxxxxxx word
1379 11xxxxxx xxxxxxxx xxxxxxxx xxxxxxxx double word
1381 This must be taken care of and we do it here! */
1384 md_number_to_disp (char *buf, long val, int n)
1389 if (val < -64 || val > 63)
1390 as_bad (_("value of %ld out of byte displacement range."), val);
1393 printf ("%x ", val & 0xff);
1399 if (val < -8192 || val > 8191)
1400 as_bad (_("value of %ld out of word displacement range."), val);
1404 printf ("%x ", val >> 8 & 0xff);
1406 *buf++ = (val >> 8);
1408 printf ("%x ", val & 0xff);
1414 if (val < -0x20000000 || val >= 0x20000000)
1415 as_bad (_("value of %ld out of double word displacement range."), val);
1418 printf ("%x ", val >> 24 & 0xff);
1420 *buf++ = (val >> 24);
1422 printf ("%x ", val >> 16 & 0xff);
1424 *buf++ = (val >> 16);
1426 printf ("%x ", val >> 8 & 0xff);
1428 *buf++ = (val >> 8);
1430 printf ("%x ", val & 0xff);
1436 as_fatal (_("Internal logic error. line %d, file \"%s\""),
1437 __LINE__, __FILE__);
1442 md_number_to_imm (char *buf, long val, int n)
1448 printf ("%x ", val & 0xff);
1455 printf ("%x ", val >> 8 & 0xff);
1457 *buf++ = (val >> 8);
1459 printf ("%x ", val & 0xff);
1466 printf ("%x ", val >> 24 & 0xff);
1468 *buf++ = (val >> 24);
1470 printf ("%x ", val >> 16 & 0xff);
1472 *buf++ = (val >> 16);
1474 printf ("%x ", val >> 8 & 0xff);
1476 *buf++ = (val >> 8);
1478 printf ("%x ", val & 0xff);
1484 as_fatal (_("Internal logic error. line %d, file \"%s\""),
1485 __LINE__, __FILE__);
1489 /* Fast bitfiddling support. */
1490 /* Mask used to zero bitfield before oring in the true field. */
1492 static unsigned long l_mask[] =
1494 0xffffffff, 0xfffffffe, 0xfffffffc, 0xfffffff8,
1495 0xfffffff0, 0xffffffe0, 0xffffffc0, 0xffffff80,
1496 0xffffff00, 0xfffffe00, 0xfffffc00, 0xfffff800,
1497 0xfffff000, 0xffffe000, 0xffffc000, 0xffff8000,
1498 0xffff0000, 0xfffe0000, 0xfffc0000, 0xfff80000,
1499 0xfff00000, 0xffe00000, 0xffc00000, 0xff800000,
1500 0xff000000, 0xfe000000, 0xfc000000, 0xf8000000,
1501 0xf0000000, 0xe0000000, 0xc0000000, 0x80000000,
1503 static unsigned long r_mask[] =
1505 0x00000000, 0x00000001, 0x00000003, 0x00000007,
1506 0x0000000f, 0x0000001f, 0x0000003f, 0x0000007f,
1507 0x000000ff, 0x000001ff, 0x000003ff, 0x000007ff,
1508 0x00000fff, 0x00001fff, 0x00003fff, 0x00007fff,
1509 0x0000ffff, 0x0001ffff, 0x0003ffff, 0x0007ffff,
1510 0x000fffff, 0x001fffff, 0x003fffff, 0x007fffff,
1511 0x00ffffff, 0x01ffffff, 0x03ffffff, 0x07ffffff,
1512 0x0fffffff, 0x1fffffff, 0x3fffffff, 0x7fffffff,
1514 #define MASK_BITS 31
1515 /* Insert bitfield described by field_ptr and val at buf
1516 This routine is written for modification of the first 4 bytes pointed
1517 to by buf, to yield speed.
1518 The ifdef stuff is for selection between a ns32k-dependent routine
1519 and a general version. (My advice: use the general version!). */
1522 md_number_to_field (char *buf, long val, bit_fixS *field_ptr)
1524 unsigned long object;
1526 /* Define ENDIAN on a ns32k machine. */
1528 unsigned long *mem_ptr;
1533 if (field_ptr->fx_bit_min <= val && val <= field_ptr->fx_bit_max)
1536 if (field_ptr->fx_bit_base)
1538 mem_ptr = (unsigned long *) field_ptr->fx_bit_base;
1540 mem_ptr = (unsigned long *) buf;
1542 mem_ptr = ((unsigned long *)
1543 ((char *) mem_ptr + field_ptr->fx_bit_base_adj));
1545 if (field_ptr->fx_bit_base)
1546 mem_ptr = (char *) field_ptr->fx_bit_base;
1550 mem_ptr += field_ptr->fx_bit_base_adj;
1553 /* We have a nice ns32k machine with lowbyte at low-physical mem. */
1554 object = *mem_ptr; /* get some bytes */
1555 #else /* OVE Goof! the machine is a m68k or dito. */
1556 /* That takes more byte fiddling. */
1558 object |= mem_ptr[3] & 0xff;
1560 object |= mem_ptr[2] & 0xff;
1562 object |= mem_ptr[1] & 0xff;
1564 object |= mem_ptr[0] & 0xff;
1567 mask |= (r_mask[field_ptr->fx_bit_offset]);
1568 mask |= (l_mask[field_ptr->fx_bit_offset + field_ptr->fx_bit_size]);
1570 val += field_ptr->fx_bit_add;
1571 object |= ((val << field_ptr->fx_bit_offset) & (mask ^ 0xffffffff));
1575 mem_ptr[0] = (char) object;
1577 mem_ptr[1] = (char) object;
1579 mem_ptr[2] = (char) object;
1581 mem_ptr[3] = (char) object;
1585 as_bad (_("Bit field out of range"));
1588 /* Convert iif to fragments. From this point we start to dribble with
1589 functions in other files than this one.(Except hash.c) So, if it's
1590 possible to make an iif for an other CPU, you don't need to know
1591 what frags, relax, obstacks, etc is in order to port this
1592 assembler. You only need to know if it's possible to reduce your
1593 cpu-instruction to iif-format (takes some work) and adopt the other
1594 md_? parts according to given instructions Note that iif was
1595 invented for the clean ns32k`s architecture. */
1597 /* GAS for the ns32k has a problem. PC relative displacements are
1598 relative to the address of the opcode, not the address of the
1599 operand. We used to keep track of the offset between the operand
1600 and the opcode in pcrel_adjust for each frag and each fix. However,
1601 we get into trouble where there are two or more pc-relative
1602 operands and the size of the first one can't be determined. Then in
1603 the relax phase, the size of the first operand will change and
1604 pcrel_adjust will no longer be correct. The current solution is
1605 keep a pointer to the frag with the opcode in it and the offset in
1606 that frag for each frag and each fix. Then, when needed, we can
1607 always figure out how far it is between the opcode and the pcrel
1608 object. See also md_pcrel_adjust and md_fix_pcrel_adjust. For
1609 objects not part of an instruction, the pointer to the opcode frag
1618 unsigned int inst_offset;
1626 frag_grow (iif.instr_size); /* This is important. */
1627 memP = frag_more (0);
1629 inst_offset = (memP - frag_now->fr_literal);
1630 inst_frag = frag_now;
1632 for (i = 0; i < IIF_ENTRIES; i++)
1634 if ((type = iif.iifP[i].type))
1636 /* The object exist, so handle it. */
1637 switch (size = iif.iifP[i].size)
1641 /* It's a bitfix that operates on an existing object. */
1642 if (iif.iifP[i].bit_fixP->fx_bit_base)
1643 /* Expand fx_bit_base to point at opcode. */
1644 iif.iifP[i].bit_fixP->fx_bit_base = (long) inst_opcode;
1647 case 8: /* bignum or doublefloat. */
1652 /* The final size in objectmemory is known. */
1653 memP = frag_more (size);
1654 j = iif.iifP[i].bit_fixP;
1658 case 1: /* The object is pure binary. */
1660 md_number_to_field (memP, exprP.X_add_number, j);
1662 else if (iif.iifP[i].pcrel)
1663 fix_new_ns32k (frag_now,
1664 (long) (memP - frag_now->fr_literal),
1669 iif.iifP[i].im_disp,
1671 iif.iifP[i].bsr, /* Sequent hack. */
1672 inst_frag, inst_offset);
1675 /* Good, just put them bytes out. */
1676 switch (iif.iifP[i].im_disp)
1679 md_number_to_chars (memP, iif.iifP[i].object, size);
1682 md_number_to_disp (memP, iif.iifP[i].object, size);
1685 as_fatal (_("iif convert internal pcrel/binary"));
1691 /* The object is a pointer at an expression, so
1692 unpack it, note that bignums may result from the
1694 evaluate_expr (&exprP, (char *) iif.iifP[i].object);
1695 if (exprP.X_op == O_big || size == 8)
1697 if ((k = exprP.X_add_number) > 0)
1699 /* We have a bignum ie a quad. This can only
1700 happens in a long suffixed instruction. */
1702 as_bad (_("Bignum too big for long"));
1707 for (l = 0; k > 0; k--, l += 2)
1708 md_number_to_chars (memP + l,
1709 generic_bignum[l >> 1],
1710 sizeof (LITTLENUM_TYPE));
1715 LITTLENUM_TYPE words[4];
1720 gen_to_words (words, 2, 8);
1721 md_number_to_imm (memP, (long) words[0],
1722 sizeof (LITTLENUM_TYPE));
1723 md_number_to_imm (memP + sizeof (LITTLENUM_TYPE),
1725 sizeof (LITTLENUM_TYPE));
1728 gen_to_words (words, 4, 11);
1729 md_number_to_imm (memP, (long) words[0],
1730 sizeof (LITTLENUM_TYPE));
1731 md_number_to_imm (memP + sizeof (LITTLENUM_TYPE),
1733 sizeof (LITTLENUM_TYPE));
1734 md_number_to_imm ((memP + 2
1735 * sizeof (LITTLENUM_TYPE)),
1737 sizeof (LITTLENUM_TYPE));
1738 md_number_to_imm ((memP + 3
1739 * sizeof (LITTLENUM_TYPE)),
1741 sizeof (LITTLENUM_TYPE));
1747 if (exprP.X_add_symbol ||
1748 exprP.X_op_symbol ||
1751 /* The expression was undefined due to an
1752 undefined label. Create a fix so we can fix
1753 the object later. */
1754 exprP.X_add_number += iif.iifP[i].object_adjust;
1755 fix_new_ns32k_exp (frag_now,
1756 (long) (memP - frag_now->fr_literal),
1760 iif.iifP[i].im_disp,
1763 inst_frag, inst_offset);
1766 md_number_to_field (memP, exprP.X_add_number, j);
1769 /* Good, just put them bytes out. */
1770 switch (iif.iifP[i].im_disp)
1773 md_number_to_imm (memP, exprP.X_add_number, size);
1776 md_number_to_disp (memP, exprP.X_add_number, size);
1779 as_fatal (_("iif convert internal pcrel/pointer"));
1784 as_fatal (_("Internal logic error in iif.iifP[n].type"));
1789 /* Too bad, the object may be undefined as far as its
1790 final nsize in object memory is concerned. The size
1791 of the object in objectmemory is not explicitly
1792 given. If the object is defined its length can be
1793 determined and a fix can replace the frag. */
1795 evaluate_expr (&exprP, (char *) iif.iifP[i].object);
1797 if ((exprP.X_add_symbol || exprP.X_op_symbol) &&
1800 /* Size is unknown until link time so have to default. */
1801 size = default_disp_size; /* Normally 4 bytes. */
1802 memP = frag_more (size);
1803 fix_new_ns32k_exp (frag_now,
1804 (long) (memP - frag_now->fr_literal),
1807 0, /* never iif.iifP[i].pcrel, */
1808 1, /* always iif.iifP[i].im_disp */
1812 break; /* Exit this absolute hack. */
1815 if (exprP.X_add_symbol || exprP.X_op_symbol)
1818 if (exprP.X_op_symbol)
1819 /* We cant relax this case. */
1820 as_fatal (_("Can't relax difference"));
1823 /* Size is not important. This gets fixed by
1824 relax, but we assume 0 in what follows. */
1825 memP = frag_more (4); /* Max size. */
1829 fragS *old_frag = frag_now;
1830 frag_variant (rs_machine_dependent,
1833 IND (BRANCH, UNDEF), /* Expecting
1838 frag_opcode_frag (old_frag) = inst_frag;
1839 frag_opcode_offset (old_frag) = inst_offset;
1840 frag_bsr (old_frag) = iif.iifP[i].bsr;
1846 /* This duplicates code in md_number_to_disp. */
1847 if (-64 <= exprP.X_add_number && exprP.X_add_number <= 63)
1851 if (-8192 <= exprP.X_add_number
1852 && exprP.X_add_number <= 8191)
1856 if (-0x20000000 <= exprP.X_add_number
1857 && exprP.X_add_number<=0x1fffffff)
1861 as_bad (_("Displacement too large for :d"));
1867 memP = frag_more (size);
1868 md_number_to_disp (memP, exprP.X_add_number, size);
1874 as_fatal (_("Internal logic error in iif.iifP[].type"));
1881 md_assemble (char *line)
1883 freeptr = freeptr_static;
1884 parse (line, 0); /* Explode line to more fix form in iif. */
1885 convert_iif (); /* Convert iif to frags, fix's etc. */
1887 printf (" \t\t\t%s\n", line);
1894 /* Build a hashtable of the instructions. */
1895 const struct ns32k_opcode *ptr;
1897 const struct ns32k_opcode *endop;
1899 inst_hash_handle = hash_new ();
1901 endop = ns32k_opcodes + sizeof (ns32k_opcodes) / sizeof (ns32k_opcodes[0]);
1902 for (ptr = ns32k_opcodes; ptr < endop; ptr++)
1904 if ((status = hash_insert (inst_hash_handle, ptr->name, (char *) ptr)))
1906 as_fatal (_("Can't hash %s: %s"), ptr->name, status);
1909 /* Some private space please! */
1910 freeptr_static = XNEWVEC (char, PRIVATE_SIZE);
1913 /* Turn the string pointed to by litP into a floating point constant
1914 of type TYPE, and emit the appropriate bytes. The number of
1915 LITTLENUMS emitted is stored in *SIZEP. An error message is
1916 returned, or NULL on OK. */
1919 md_atof (int type, char *litP, int *sizeP)
1921 return ieee_md_atof (type, litP, sizeP, FALSE);
1925 md_pcrel_adjust (fragS *fragP)
1928 addressT opcode_address;
1929 unsigned int offset;
1931 opcode_frag = frag_opcode_frag (fragP);
1932 if (opcode_frag == 0)
1935 offset = frag_opcode_offset (fragP);
1936 opcode_address = offset + opcode_frag->fr_address;
1938 return fragP->fr_address + fragP->fr_fix - opcode_address;
1942 md_fix_pcrel_adjust (fixS *fixP)
1945 addressT opcode_address;
1946 unsigned int offset;
1948 opcode_frag = fix_opcode_frag (fixP);
1949 if (opcode_frag == 0)
1952 offset = fix_opcode_offset (fixP);
1953 opcode_address = offset + opcode_frag->fr_address;
1955 return fixP->fx_where + fixP->fx_frag->fr_address - opcode_address;
1958 /* Apply a fixS (fixup of an instruction or data that we didn't have
1959 enough info to complete immediately) to the data in a frag.
1961 On the ns32k, everything is in a different format, so we have broken
1962 out separate functions for each kind of thing we could be fixing.
1963 They all get called from here. */
1966 md_apply_fix (fixS *fixP, valueT * valP, segT seg ATTRIBUTE_UNUSED)
1968 long val = * (long *) valP;
1969 char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
1971 if (fix_bit_fixP (fixP))
1972 /* Bitfields to fix, sigh. */
1973 md_number_to_field (buf, val, fix_bit_fixP (fixP));
1974 else switch (fix_im_disp (fixP))
1977 /* Immediate field. */
1978 md_number_to_imm (buf, val, fixP->fx_size);
1982 /* Displacement field. */
1983 /* Calculate offset. */
1984 md_number_to_disp (buf,
1985 (fixP->fx_pcrel ? val + md_fix_pcrel_adjust (fixP)
1986 : val), fixP->fx_size);
1990 /* Pointer in a data object. */
1991 md_number_to_chars (buf, val, fixP->fx_size);
1995 if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0)
1999 /* Convert a relaxed displacement to ditto in final output. */
2002 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED,
2003 segT sec ATTRIBUTE_UNUSED,
2008 /* Address in gas core of the place to store the displacement. */
2009 char *buffer_address = fragP->fr_fix + fragP->fr_literal;
2010 /* Address in object code of the displacement. */
2013 switch (fragP->fr_subtype)
2015 case IND (BRANCH, BYTE):
2018 case IND (BRANCH, WORD):
2021 case IND (BRANCH, DOUBLE):
2029 know (fragP->fr_symbol);
2031 object_address = fragP->fr_fix + fragP->fr_address;
2033 /* The displacement of the address, from current location. */
2034 disp = (S_GET_VALUE (fragP->fr_symbol) + fragP->fr_offset) - object_address;
2035 disp += md_pcrel_adjust (fragP);
2037 md_number_to_disp (buffer_address, (long) disp, (int) ext);
2038 fragP->fr_fix += ext;
2041 /* This function returns the estimated size a variable object will occupy,
2042 one can say that we tries to guess the size of the objects before we
2043 actually know it. */
2046 md_estimate_size_before_relax (fragS *fragP, segT segment)
2048 if (fragP->fr_subtype == IND (BRANCH, UNDEF))
2050 if (S_GET_SEGMENT (fragP->fr_symbol) != segment)
2052 /* We don't relax symbols defined in another segment. The
2053 thing to do is to assume the object will occupy 4 bytes. */
2054 fix_new_ns32k (fragP,
2055 (int) (fragP->fr_fix),
2062 frag_bsr(fragP), /* Sequent hack. */
2063 frag_opcode_frag (fragP),
2064 frag_opcode_offset (fragP));
2070 /* Relaxable case. Set up the initial guess for the variable
2071 part of the frag. */
2072 fragP->fr_subtype = IND (BRANCH, BYTE);
2075 if (fragP->fr_subtype >= sizeof (md_relax_table) / sizeof (md_relax_table[0]))
2078 /* Return the size of the variable part of the frag. */
2079 return md_relax_table[fragP->fr_subtype].rlx_length;
2082 int md_short_jump_size = 3;
2083 int md_long_jump_size = 5;
2086 md_create_short_jump (char *ptr,
2089 fragS *frag ATTRIBUTE_UNUSED,
2090 symbolS *to_symbol ATTRIBUTE_UNUSED)
2094 offset = to_addr - from_addr;
2095 md_number_to_chars (ptr, (valueT) 0xEA, 1);
2096 md_number_to_disp (ptr + 1, (valueT) offset, 2);
2100 md_create_long_jump (char *ptr,
2103 fragS *frag ATTRIBUTE_UNUSED,
2104 symbolS *to_symbol ATTRIBUTE_UNUSED)
2108 offset = to_addr - from_addr;
2109 md_number_to_chars (ptr, (valueT) 0xEA, 1);
2110 md_number_to_disp (ptr + 1, (valueT) offset, 4);
2113 const char *md_shortopts = "m:";
2115 struct option md_longopts[] =
2117 #define OPTION_DISP_SIZE (OPTION_MD_BASE)
2118 {"disp-size-default", required_argument , NULL, OPTION_DISP_SIZE},
2119 {NULL, no_argument, NULL, 0}
2122 size_t md_longopts_size = sizeof (md_longopts);
2125 md_parse_option (int c, const char *arg)
2130 if (!strcmp (arg, "32032"))
2132 cpureg = cpureg_032;
2133 mmureg = mmureg_032;
2135 else if (!strcmp (arg, "32532"))
2137 cpureg = cpureg_532;
2138 mmureg = mmureg_532;
2142 as_warn (_("invalid architecture option -m%s, ignored"), arg);
2146 case OPTION_DISP_SIZE:
2148 int size = atoi(arg);
2151 case 1: case 2: case 4:
2152 default_disp_size = size;
2155 as_warn (_("invalid default displacement size \"%s\". Defaulting to %d."),
2156 arg, default_disp_size);
2169 md_show_usage (FILE *stream)
2171 fprintf (stream, _("\
2173 -m32032 | -m32532 select variant of NS32K architecture\n\
2174 --disp-size-default=<1|2|4>\n"));
2177 /* This is TC_CONS_FIX_NEW, called by emit_expr in read.c. */
2180 cons_fix_new_ns32k (fragS *frag, /* Which frag? */
2181 int where, /* Where in that frag? */
2182 int size, /* 1, 2 or 4 usually. */
2183 expressionS *exp, /* Expression. */
2184 bfd_reloc_code_real_type r ATTRIBUTE_UNUSED)
2186 fix_new_ns32k_exp (frag, where, size, exp,
2190 /* We have no need to default values of symbols. */
2193 md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
2198 /* Round up a section size to the appropriate boundary. */
2201 md_section_align (segT segment ATTRIBUTE_UNUSED, valueT size)
2203 return size; /* Byte alignment is fine. */
2206 /* Exactly what point is a PC-relative offset relative TO? On the
2207 ns32k, they're relative to the start of the instruction. */
2210 md_pcrel_from (fixS *fixP)
2214 res = fixP->fx_where + fixP->fx_frag->fr_address;
2215 #ifdef SEQUENT_COMPATABILITY
2216 if (frag_bsr (fixP->fx_frag))
2217 res += 0x12 /* FOO Kludge alert! */
2223 tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp)
2226 bfd_reloc_code_real_type code;
2228 code = reloc (fixp->fx_size, fixp->fx_pcrel, fix_im_disp (fixp));
2230 rel = XNEW (arelent);
2231 rel->sym_ptr_ptr = XNEW (asymbol *);
2232 *rel->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
2233 rel->address = fixp->fx_frag->fr_address + fixp->fx_where;
2235 rel->addend = fixp->fx_addnumber;
2239 rel->howto = bfd_reloc_type_lookup (stdoutput, code);
2244 name = S_GET_NAME (fixp->fx_addsy);
2246 name = _("<unknown>");
2247 as_fatal (_("Cannot find relocation type for symbol %s, code %d"),