1 /* ns32k.c -- Assemble on the National Semiconductor 32k series
2 Copyright (C) 1987-2016 Free Software Foundation, Inc.
3
4 This file is part of GAS, the GNU Assembler.
5
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)
9 any later version.
10
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.
15
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
19 02110-1301, USA. */
20
21 /*#define SHOW_NUM 1*//* Uncomment for debugging. */
22
23 #include "as.h"
24 #include "opcode/ns32k.h"
25
26 #include "obstack.h"
27
28 /* Macros. */
29 #define IIF_ENTRIES 13 /* Number of entries in iif. */
30 #define PRIVATE_SIZE 256 /* Size of my garbage memory. */
31 #define MAX_ARGS 4
32 #define DEFAULT -1 /* addr_mode returns this value when
33 plain constant or label is
34 encountered. */
35
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;
48
49 #ifdef SEQUENT_COMPATABILITY
50 #define LINE_COMMENT_CHARS "|"
51 #define ABSOLUTE_PREFIX '@'
52 #define IMMEDIATE_PREFIX '#'
53 #endif
54
55 #ifndef LINE_COMMENT_CHARS
56 #define LINE_COMMENT_CHARS "#"
57 #endif
58
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. */
63
64 #if !defined(ABSOLUTE_PREFIX) && !defined(IMMEDIATE_PREFIX)
65 #define ABSOLUTE_PREFIX '@' /* One or the other MUST be defined. */
66 #endif
67
68 struct addr_mode
69 {
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
76 parts. */
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. */
83 };
84 typedef struct addr_mode addr_modeS;
85
86 char *freeptr, *freeptr_static; /* Points at some number of free bytes. */
87 struct hash_control *inst_hash_handle;
88
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,
93 do we? */
94
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. */
101
102 /* Internal structs. */
103 struct ns32k_option
104 {
105 const char *pattern;
106 unsigned long or;
107 unsigned long and;
108 };
109
110 typedef struct
111 {
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
123 iif-entry. */
124 char bsr; /* Sequent hack. */
125 } iif_entryT; /* Internal Instruction Format. */
126
127 struct int_ins_form
128 {
129 int instr_size; /* Max size of instruction in bytes. */
130 iif_entryT iifP[IIF_ENTRIES + 1];
131 };
132
133 struct int_ins_form iif;
134 expressionS exprP;
135
136 /* Description of the PARTs in IIF
137 object[n]:
138 0 total length in bytes of entries in iif
139 1 opcode
140 2 index_byte_a
141 3 index_byte_b
142 4 disp_a_1
143 5 disp_a_2
144 6 disp_b_1
145 7 disp_b_2
146 8 imm_a
147 9 imm_b
148 10 implied1
149 11 implied2
150
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.
155
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
160 etc
161
162 Furthermore, every entry has a data type identifier in type[n].
163
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.
171
172 3, the entry is a pointer at a bignum struct
173
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). */
181
182 struct ns32k_option opt1[] = /* restore, exit. */
183 {
184 {"r0", 0x80, 0xff},
185 {"r1", 0x40, 0xff},
186 {"r2", 0x20, 0xff},
187 {"r3", 0x10, 0xff},
188 {"r4", 0x08, 0xff},
189 {"r5", 0x04, 0xff},
190 {"r6", 0x02, 0xff},
191 {"r7", 0x01, 0xff},
192 {0, 0x00, 0xff}
193 };
194 struct ns32k_option opt2[] = /* save, enter. */
195 {
196 {"r0", 0x01, 0xff},
197 {"r1", 0x02, 0xff},
198 {"r2", 0x04, 0xff},
199 {"r3", 0x08, 0xff},
200 {"r4", 0x10, 0xff},
201 {"r5", 0x20, 0xff},
202 {"r6", 0x40, 0xff},
203 {"r7", 0x80, 0xff},
204 {0, 0x00, 0xff}
205 };
206 struct ns32k_option opt3[] = /* setcfg. */
207 {
208 {"c", 0x8, 0xff},
209 {"m", 0x4, 0xff},
210 {"f", 0x2, 0xff},
211 {"i", 0x1, 0xff},
212 {0, 0x0, 0xff}
213 };
214 struct ns32k_option opt4[] = /* cinv. */
215 {
216 {"a", 0x4, 0xff},
217 {"i", 0x2, 0xff},
218 {"d", 0x1, 0xff},
219 {0, 0x0, 0xff}
220 };
221 struct ns32k_option opt5[] = /* String inst. */
222 {
223 {"b", 0x2, 0xff},
224 {"u", 0xc, 0xff},
225 {"w", 0x4, 0xff},
226 {0, 0x0, 0xff}
227 };
228 struct ns32k_option opt6[] = /* Plain reg ext,cvtp etc. */
229 {
230 {"r0", 0x00, 0xff},
231 {"r1", 0x01, 0xff},
232 {"r2", 0x02, 0xff},
233 {"r3", 0x03, 0xff},
234 {"r4", 0x04, 0xff},
235 {"r5", 0x05, 0xff},
236 {"r6", 0x06, 0xff},
237 {"r7", 0x07, 0xff},
238 {0, 0x00, 0xff}
239 };
240
241 #if !defined(NS32032) && !defined(NS32532)
242 #define NS32532
243 #endif
244
245 struct ns32k_option cpureg_532[] = /* lpr spr. */
246 {
247 {"us", 0x0, 0xff},
248 {"dcr", 0x1, 0xff},
249 {"bpc", 0x2, 0xff},
250 {"dsr", 0x3, 0xff},
251 {"car", 0x4, 0xff},
252 {"fp", 0x8, 0xff},
253 {"sp", 0x9, 0xff},
254 {"sb", 0xa, 0xff},
255 {"usp", 0xb, 0xff},
256 {"cfg", 0xc, 0xff},
257 {"psr", 0xd, 0xff},
258 {"intbase", 0xe, 0xff},
259 {"mod", 0xf, 0xff},
260 {0, 0x00, 0xff}
261 };
262 struct ns32k_option mmureg_532[] = /* lmr smr. */
263 {
264 {"mcr", 0x9, 0xff},
265 {"msr", 0xa, 0xff},
266 {"tear", 0xb, 0xff},
267 {"ptb0", 0xc, 0xff},
268 {"ptb1", 0xd, 0xff},
269 {"ivar0", 0xe, 0xff},
270 {"ivar1", 0xf, 0xff},
271 {0, 0x0, 0xff}
272 };
273
274 struct ns32k_option cpureg_032[] = /* lpr spr. */
275 {
276 {"upsr", 0x0, 0xff},
277 {"fp", 0x8, 0xff},
278 {"sp", 0x9, 0xff},
279 {"sb", 0xa, 0xff},
280 {"psr", 0xd, 0xff},
281 {"intbase", 0xe, 0xff},
282 {"mod", 0xf, 0xff},
283 {0, 0x0, 0xff}
284 };
285 struct ns32k_option mmureg_032[] = /* lmr smr. */
286 {
287 {"bpr0", 0x0, 0xff},
288 {"bpr1", 0x1, 0xff},
289 {"pf0", 0x4, 0xff},
290 {"pf1", 0x5, 0xff},
291 {"sc", 0x8, 0xff},
292 {"msr", 0xa, 0xff},
293 {"bcnt", 0xb, 0xff},
294 {"ptb0", 0xc, 0xff},
295 {"ptb1", 0xd, 0xff},
296 {"eia", 0xf, 0xff},
297 {0, 0x0, 0xff}
298 };
299
300 #if defined(NS32532)
301 struct ns32k_option *cpureg = cpureg_532;
302 struct ns32k_option *mmureg = mmureg_532;
303 #else
304 struct ns32k_option *cpureg = cpureg_032;
305 struct ns32k_option *mmureg = mmureg_032;
306 #endif
307
308
309 const pseudo_typeS md_pseudo_table[] =
310 { /* So far empty. */
311 {0, 0, 0}
312 };
313
314 #define IND(x,y) (((x)<<2)+(y))
315
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. */
319
320 #define BRANCH 1
321 #define PCREL 2
322
323 /* Those are index's to entries in a relax group. */
324
325 #define BYTE 0
326 #define WORD 1
327 #define DOUBLE 2
328 #define UNDEF 3
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. */
337
338 const relax_typeS md_relax_table[] =
339 {
340 {1, 1, 0, 0},
341 {1, 1, 0, 0},
342 {1, 1, 0, 0},
343 {1, 1, 0, 0},
344
345 {(63), (-64), 1, IND (BRANCH, WORD)},
346 {(8192), (-8192), 2, IND (BRANCH, DOUBLE)},
347 {0, 0, 4, 0},
348 {1, 1, 0, 0}
349 };
350
351 /* Array used to test if mode contains displacements.
352 Value is true if mode contains displacement. */
353
354 char disp_test[] =
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};
359
360 /* Array used to calculate max size of displacements. */
361
362 char disp_size[] =
363 {4, 1, 2, 0, 4};
364
365 /* Parse a general operand into an addressingmode struct
366
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)
370
371 Out: data in addr_mode struct. */
372
373 static int
addr_mode(char * operand,addr_modeS * addrmodeP,int recursive_level)374 addr_mode (char *operand,
375 addr_modeS *addrmodeP,
376 int recursive_level)
377 {
378 char *str;
379 int i;
380 int strl;
381 int mode;
382 int j;
383
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;
395 str = operand;
396
397 if (str[0] == 0)
398 return 0;
399
400 strl = strlen (str);
401
402 switch (str[0])
403 {
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] == ']')
409 break;
410 addrmodeP->mode = 21; /* absolute */
411 addrmodeP->disp[0] = str + 1;
412 return -1;
413 #endif
414 #ifdef IMMEDIATE_PREFIX
415 case IMMEDIATE_PREFIX:
416 if (str[strl - 1] == ']')
417 break;
418 addrmodeP->mode = 20; /* immediate */
419 addrmodeP->disp[0] = str + 1;
420 return -1;
421 #endif
422 case '.':
423 if (str[strl - 1] != ']')
424 {
425 switch (str[1])
426 {
427 case '-':
428 case '+':
429 if (str[2] != '\000')
430 {
431 addrmodeP->mode = 27; /* pc-relative */
432 addrmodeP->disp[0] = str + 2;
433 return -1;
434 }
435 default:
436 as_bad (_("Invalid syntax in PC-relative addressing mode"));
437 return 0;
438 }
439 }
440 break;
441 case 'e':
442 if (str[strl - 1] != ']')
443 {
444 if ((!strncmp (str, "ext(", 4)) && strl > 7)
445 { /* external */
446 addrmodeP->disp[0] = str + 4;
447 i = 0;
448 j = 2;
449 do
450 { /* disp[0]'s termination point. */
451 j += 1;
452 if (str[j] == '(')
453 i++;
454 if (str[j] == ')')
455 i--;
456 }
457 while (j < strl && i != 0);
458 if (i != 0 || !(str[j + 1] == '-' || str[j + 1] == '+'))
459 {
460 as_bad (_("Invalid syntax in External addressing mode"));
461 return (0);
462 }
463 str[j] = '\000'; /* null terminate disp[0] */
464 addrmodeP->disp[1] = str + j + 2;
465 addrmodeP->mode = 22;
466 return -1;
467 }
468 }
469 break;
470
471 default:
472 ;
473 }
474
475 strl = strlen (str);
476
477 switch (strl)
478 {
479 case 2:
480 switch (str[0])
481 {
482 case 'f':
483 addrmodeP->float_flag = 1;
484 /* Drop through. */
485 case 'r':
486 if (str[1] >= '0' && str[1] < '8')
487 {
488 addrmodeP->mode = str[1] - '0';
489 return -1;
490 }
491 break;
492 default:
493 break;
494 }
495 /* Drop through. */
496
497 case 3:
498 if (!strncmp (str, "tos", 3))
499 {
500 addrmodeP->mode = 23; /* TopOfStack */
501 return -1;
502 }
503 break;
504
505 default:
506 break;
507 }
508
509 if (strl > 4)
510 {
511 if (str[strl - 1] == ')')
512 {
513 if (str[strl - 2] == ')')
514 {
515 if (!strncmp (&str[strl - 5], "(fp", 3))
516 mode = 16; /* Memory Relative. */
517 else if (!strncmp (&str[strl - 5], "(sp", 3))
518 mode = 17;
519 else if (!strncmp (&str[strl - 5], "(sb", 3))
520 mode = 18;
521
522 if (mode != DEFAULT)
523 {
524 /* Memory relative. */
525 addrmodeP->mode = mode;
526 j = strl - 5; /* Temp for end of disp[0]. */
527 i = 0;
528
529 do
530 {
531 strl -= 1;
532 if (str[strl] == ')')
533 i++;
534 if (str[strl] == '(')
535 i--;
536 }
537 while (strl > -1 && i != 0);
538
539 if (i != 0)
540 {
541 as_bad (_("Invalid syntax in Memory Relative addressing mode"));
542 return (0);
543 }
544
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]. */
549
550 return -1;
551 }
552 }
553
554 switch (str[strl - 3])
555 {
556 case 'r':
557 case 'R':
558 if (str[strl - 2] >= '0'
559 && str[strl - 2] < '8'
560 && str[strl - 4] == '(')
561 {
562 addrmodeP->mode = str[strl - 2] - '0' + 8;
563 addrmodeP->disp[0] = str;
564 str[strl - 4] = 0;
565 return -1; /* reg rel */
566 }
567 /* Drop through. */
568
569 default:
570 if (!strncmp (&str[strl - 4], "(fp", 3))
571 mode = 24;
572 else if (!strncmp (&str[strl - 4], "(sp", 3))
573 mode = 25;
574 else if (!strncmp (&str[strl - 4], "(sb", 3))
575 mode = 26;
576 else if (!strncmp (&str[strl - 4], "(pc", 3))
577 mode = 27;
578
579 if (mode != DEFAULT)
580 {
581 addrmodeP->mode = mode;
582 addrmodeP->disp[0] = str;
583 str[strl - 4] = '\0';
584
585 return -1; /* Memory space. */
586 }
587 }
588 }
589
590 /* No trailing ')' do we have a ']' ? */
591 if (str[strl - 1] == ']')
592 {
593 switch (str[strl - 2])
594 {
595 case 'b':
596 mode = 28;
597 break;
598 case 'w':
599 mode = 29;
600 break;
601 case 'd':
602 mode = 30;
603 break;
604 case 'q':
605 mode = 31;
606 break;
607 default:
608 as_bad (_("Invalid scaled-indexed mode, use (b,w,d,q)"));
609
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. */
615
616 if (recursive_level > 0)
617 {
618 as_bad (_("Scaled-indexed addressing mode combined with scaled-index"));
619 return 0;
620 }
621
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);
626
627 if (!i || addrmodeP->mode == 20)
628 {
629 as_bad (_("Invalid or illegal addressing mode combined with scaled-index"));
630 return 0;
631 }
632
633 addrmodeP->scaled_mode = addrmodeP->mode; /* Store the inferior mode. */
634 addrmodeP->mode = mode;
635 addrmodeP->scaled_reg = j + 1;
636
637 return -1;
638 }
639 }
640
641 addrmodeP->mode = DEFAULT; /* Default to whatever. */
642 addrmodeP->disp[0] = str;
643
644 return -1;
645 }
646
647 static void
evaluate_expr(expressionS * resultP,char * ptr)648 evaluate_expr (expressionS *resultP, char *ptr)
649 {
650 char *tmp_line;
651
652 tmp_line = input_line_pointer;
653 input_line_pointer = ptr;
654 expression (resultP);
655 input_line_pointer = tmp_line;
656 }
657
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. */
663
664 static int
get_addr_mode(char * ptr,addr_modeS * addrmodeP)665 get_addr_mode (char *ptr, addr_modeS *addrmodeP)
666 {
667 int tmp;
668
669 addr_mode (ptr, addrmodeP, 0);
670
671 if (addrmodeP->mode == DEFAULT || addrmodeP->scaled_mode == -1)
672 {
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! */
678
679 if (addrmodeP->mode == DEFAULT)
680 {
681 if (exprP.X_add_symbol || exprP.X_op_symbol)
682 addrmodeP->mode = desc->default_model; /* We have a label. */
683 else
684 addrmodeP->mode = desc->default_modec; /* We have a constant. */
685 }
686 else
687 {
688 if (exprP.X_add_symbol || exprP.X_op_symbol)
689 addrmodeP->scaled_mode = desc->default_model;
690 else
691 addrmodeP->scaled_mode = desc->default_modec;
692 }
693
694 /* Must put this mess down in addr_mode to handle the scaled
695 case better. */
696 }
697
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
706 flagpurpose. */
707 tmp |= addrmodeP->scaled_mode << 3;
708 addrmodeP->index_byte = (char) tmp;
709 addrmodeP->am_size += 1;
710 }
711
712 gas_assert (addrmodeP->mode >= 0);
713 if (disp_test[(unsigned int) addrmodeP->mode])
714 {
715 char c;
716 char suffix;
717 char suffix_sub;
718 int i;
719 char *toP;
720 char *fromP;
721
722 /* There was a displacement, probe for length specifying suffix. */
723 addrmodeP->pcrel = 0;
724
725 gas_assert (addrmodeP->mode >= 0);
726 if (disp_test[(unsigned int) addrmodeP->mode])
727 {
728 /* There is a displacement. */
729 if (addrmodeP->mode == 27 || addrmodeP->scaled_mode == 27)
730 /* Do we have pcrel. mode. */
731 addrmodeP->pcrel = 1;
732
733 addrmodeP->im_disp = 1;
734
735 for (i = 0; i < 2; i++)
736 {
737 suffix_sub = suffix = 0;
738
739 if ((toP = addrmodeP->disp[i]))
740 {
741 /* Suffix of expression, the largest size rules. */
742 fromP = toP;
743
744 while ((c = *fromP++))
745 {
746 *toP++ = c;
747 if (c == ':')
748 {
749 switch (*fromP)
750 {
751 case '\0':
752 as_warn (_("Premature end of suffix -- Defaulting to d"));
753 suffix = 4;
754 continue;
755 case 'b':
756 suffix_sub = 1;
757 break;
758 case 'w':
759 suffix_sub = 2;
760 break;
761 case 'd':
762 suffix_sub = 4;
763 break;
764 default:
765 as_warn (_("Bad suffix after ':' use {b|w|d} Defaulting to d"));
766 suffix = 4;
767 }
768
769 fromP ++;
770 toP --; /* So we write over the ':' */
771
772 if (suffix < suffix_sub)
773 suffix = suffix_sub;
774 }
775 }
776
777 *toP = '\0'; /* Terminate properly. */
778 addrmodeP->disp_suffix[i] = suffix;
779 addrmodeP->am_size += suffix ? suffix : 4;
780 }
781 }
782 }
783 }
784 else
785 {
786 if (addrmodeP->mode == 20)
787 {
788 /* Look in ns32k_opcode for size. */
789 addrmodeP->disp_suffix[0] = addrmodeP->am_size = desc->im_size;
790 addrmodeP->im_disp = 0;
791 }
792 }
793
794 return addrmodeP->mode;
795 }
796
797 /* Read an optionlist. */
798
799 static void
optlist(char * str,struct ns32k_option * optionP,unsigned long * default_map)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. */
803 {
804 int i, j, k, strlen1, strlen2;
805 const char *patternP, *strP;
806
807 strlen1 = strlen (str);
808
809 if (strlen1 < 1)
810 as_fatal (_("Very short instr to option, ie you can't do it on a NULLstr"));
811
812 for (i = 0; optionP[i].pattern != 0; i++)
813 {
814 strlen2 = strlen (optionP[i].pattern);
815
816 for (j = 0; j < strlen1; j++)
817 {
818 patternP = optionP[i].pattern;
819 strP = &str[j];
820
821 for (k = 0; k < strlen2; k++)
822 {
823 if (*(strP++) != *(patternP++))
824 break;
825 }
826
827 if (k == strlen2)
828 { /* match */
829 *default_map |= optionP[i].or;
830 *default_map &= optionP[i].and;
831 }
832 }
833 }
834 }
835
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
839 list. */
840
841 static int
list_search(char * str,struct ns32k_option * optionP,unsigned long * default_map)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. */
845 {
846 int i;
847
848 for (i = 0; optionP[i].pattern != 0; i++)
849 {
850 if (!strncmp (optionP[i].pattern, str, 20))
851 {
852 /* Use strncmp to be safe. */
853 *default_map |= optionP[i].or;
854 *default_map &= optionP[i].and;
855
856 return -1;
857 }
858 }
859
860 as_bad (_("No such entry in list. (cpu/mmu register)"));
861 return 0;
862 }
863
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
867 the fix. */
868
869 static bit_fixS *
bit_fix_new(int size,int offset,long min,long max,long add,long base_type,long base_adj)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. */
876 long base_adj)
877 {
878 bit_fixS *bit_fixP;
879
880 bit_fixP = XOBNEW (¬es, bit_fixS);
881
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;
889
890 return bit_fixP;
891 }
892
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
896 opcode.
897 Be careful not to put to objects in the same iif-slot. */
898
899 static void
encode_operand(int argc,char ** argv,const char * operandsP,const char * suffixP,char im_size ATTRIBUTE_UNUSED,char opcode_bit_ptr)900 encode_operand (int argc,
901 char **argv,
902 const char *operandsP,
903 const char *suffixP,
904 char im_size ATTRIBUTE_UNUSED,
905 char opcode_bit_ptr)
906 {
907 int i, j;
908 char d;
909 int pcrel, b, loop, pcrel_adjust;
910 unsigned long tmp;
911
912 for (loop = 0; loop < argc; loop++)
913 {
914 /* What operand are we supposed to work on. */
915 i = operandsP[loop << 1] - '1';
916 if (i > 3)
917 as_fatal (_("Internal consistency error. check ns32k-opcode.h"));
918
919 pcrel = 0;
920 pcrel_adjust = 0;
921 tmp = 0;
922
923 switch ((d = operandsP[(loop << 1) + 1]))
924 {
925 case 'f': /* Operand of sfsr turns out to be a nasty
926 specialcase. */
927 opcode_bit_ptr -= 5;
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. */
932 case 'B': /* Byte */
933 case 'W': /* Word */
934 case 'D': /* Double-word. */
935 case 'A': /* Double-word gen-address-form ie no regs
936 allowed. */
937 get_addr_mode (argv[i], &addr_modeP);
938
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."));
943
944 if (opcode_bit_ptr == desc->opcode_size)
945 b = 4;
946 else
947 b = 6;
948
949 for (j = b; j < (b + 2); j++)
950 {
951 if (addr_modeP.disp[j - b])
952 {
953 IIF (j,
954 2,
955 addr_modeP.disp_suffix[j - b],
956 (unsigned long) addr_modeP.disp[j - b],
957 0,
958 addr_modeP.pcrel,
959 iif.instr_size,
960 addr_modeP.im_disp,
961 IND (BRANCH, BYTE),
962 NULL,
963 (addr_modeP.scaled_reg ? addr_modeP.scaled_mode
964 : addr_modeP.mode),
965 0);
966 }
967 }
968
969 opcode_bit_ptr -= 5;
970 iif.iifP[1].object |= ((long) addr_modeP.mode) << opcode_bit_ptr;
971
972 if (addr_modeP.scaled_reg)
973 {
974 j = b / 2;
975 IIF (j, 1, 1, (unsigned long) addr_modeP.index_byte,
976 0, 0, 0, 0, 0, NULL, -1, 0);
977 }
978 break;
979
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);
983 argv[i] = freeptr;
984 pcrel -= 1; /* Make pcrel 0 in spite of what case 'p':
985 wants. */
986 /* fall thru */
987 case 'p': /* Displacement - pc relative addressing. */
988 pcrel += 1;
989 /* fall thru */
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);
994 break;
995 case 'H': /* Sequent-hack: the linker wants a bit set
996 when bsr. */
997 pcrel = 1;
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);
1001 break;
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);
1006 break;
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;
1011 break;
1012 case 'O': /* Setcfg instruction optionslist. */
1013 optlist (argv[i], opt3, &tmp);
1014 opcode_bit_ptr -= 4;
1015 iif.iifP[1].object |= tmp << 15;
1016 break;
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. */
1021 break;
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;
1026 break;
1027 case 'u':
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])
1031 {
1032 case 'u': /* Restore, exit. */
1033 optlist (argv[i], opt1, &iif.iifP[10].object);
1034 break;
1035 case 'U': /* Save, enter. */
1036 optlist (argv[i], opt2, &iif.iifP[10].object);
1037 break;
1038 }
1039 iif.instr_size += 1;
1040 break;
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;
1045 break;
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;
1050 break;
1051 case 'g': /* Inss exts. */
1052 iif.instr_size += 1; /* 1 byte is allocated after the opcode. */
1053 IIF (10, 2, 1,
1054 (unsigned long) argv[i], /* i always 2 here. */
1055 0, 0, 0, 0, 0,
1056 bit_fix_new (3, 5, 0, 7, 0, 0, 0), /* A bit_fix is targeted to
1057 the byte. */
1058 -1, 0);
1059 break;
1060 case 'G':
1061 IIF (11, 2, 42,
1062 (unsigned long) argv[i], /* i always 3 here. */
1063 0, 0, 0, 0, 0,
1064 bit_fix_new (5, 0, 1, 32, -1, 0, -1), -1, 0);
1065 break;
1066 case 'i':
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);
1070 break;
1071 default:
1072 as_fatal (_("Bad opcode-table-option, check in file ns32k-opcode.h"));
1073 }
1074 }
1075 }
1076
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. */
1083
1084 static int
parse(const char * line,int recursive_level)1085 parse (const char *line, int recursive_level)
1086 {
1087 const char *lineptr;
1088 char c, suffix_separator;
1089 int i;
1090 unsigned int argc;
1091 int arg_type;
1092 char sqr, sep;
1093 char suffix[MAX_ARGS], *argv[MAX_ARGS]; /* No more than 4 operands. */
1094
1095 if (recursive_level <= 0)
1096 {
1097 /* Called from md_assemble. */
1098 for (lineptr = line; (*lineptr) != '\0' && (*lineptr) != ' '; lineptr++)
1099 continue;
1100
1101 c = *lineptr;
1102 *(char *) lineptr = '\0';
1103
1104 if (!(desc = (struct ns32k_opcode *) hash_find (inst_hash_handle, line)))
1105 as_fatal (_("No such opcode"));
1106
1107 *(char *) lineptr = c;
1108 }
1109 else
1110 lineptr = line;
1111
1112 argc = 0;
1113
1114 if (*desc->operands)
1115 {
1116 if (*lineptr++ != '\0')
1117 {
1118 sqr = '[';
1119 sep = ',';
1120
1121 while (*lineptr != '\0')
1122 {
1123 if (desc->operands[argc << 1])
1124 {
1125 suffix[argc] = 0;
1126 arg_type = desc->operands[(argc << 1) + 1];
1127
1128 switch (arg_type)
1129 {
1130 case 'd':
1131 case 'b':
1132 case 'p':
1133 case 'H':
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 = ':';
1138 break;
1139 default:
1140 /* If this char occurs we loose. */
1141 suffix_separator = '\255';
1142 break;
1143 }
1144
1145 suffix[argc] = 0; /* 0 when no ':' is encountered. */
1146 argv[argc] = freeptr;
1147 *freeptr = '\0';
1148
1149 while ((c = *lineptr) != '\0' && c != sep)
1150 {
1151 if (c == sqr)
1152 {
1153 if (sqr == '[')
1154 {
1155 sqr = ']';
1156 sep = '\0';
1157 }
1158 else
1159 {
1160 sqr = '[';
1161 sep = ',';
1162 }
1163 }
1164
1165 if (c == suffix_separator)
1166 {
1167 /* ':' - label/suffix separator. */
1168 switch (lineptr[1])
1169 {
1170 case 'b':
1171 suffix[argc] = 1;
1172 break;
1173 case 'w':
1174 suffix[argc] = 2;
1175 break;
1176 case 'd':
1177 suffix[argc] = 4;
1178 break;
1179 default:
1180 as_warn (_("Bad suffix, defaulting to d"));
1181 suffix[argc] = 4;
1182 if (lineptr[1] == '\0' || lineptr[1] == sep)
1183 {
1184 lineptr += 1;
1185 continue;
1186 }
1187 break;
1188 }
1189
1190 lineptr += 2;
1191 continue;
1192 }
1193
1194 *freeptr++ = c;
1195 lineptr++;
1196 }
1197
1198 *freeptr++ = '\0';
1199 argc += 1;
1200
1201 if (*lineptr == '\0')
1202 continue;
1203
1204 lineptr += 1;
1205 }
1206 else
1207 as_fatal (_("Too many operands passed to instruction"));
1208 }
1209 }
1210 }
1211
1212 if (argc != strlen (desc->operands) / 2)
1213 {
1214 if (strlen (desc->default_args))
1215 {
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"));
1220 }
1221 else
1222 as_fatal (_("Wrong number of operands"));
1223 }
1224
1225 for (i = 0; i < IIF_ENTRIES; i++)
1226 /* Mark all entries as void. */
1227 iif.iifP[i].type = 0;
1228
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);
1232
1233 /* This call encodes operands to iif format. */
1234 if (argc)
1235 encode_operand (argc, argv, &desc->operands[0],
1236 &suffix[0], desc->im_size, desc->opcode_size);
1237
1238 return recursive_level;
1239 }
1240
1241 /* This functionality should really be in the bfd library. */
1242
1243 static bfd_reloc_code_real_type
reloc(int size,int pcrel,int type)1244 reloc (int size, int pcrel, int type)
1245 {
1246 int length, rel_index;
1247 bfd_reloc_code_real_type relocs[] =
1248 {
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,
1255
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,
1263
1264 /* Normal 2's complement. */
1265 BFD_RELOC_8,
1266 BFD_RELOC_16,
1267 BFD_RELOC_32,
1268 BFD_RELOC_8_PCREL,
1269 BFD_RELOC_16_PCREL,
1270 BFD_RELOC_32_PCREL
1271 };
1272
1273 switch (size)
1274 {
1275 case 1:
1276 length = 0;
1277 break;
1278 case 2:
1279 length = 1;
1280 break;
1281 case 4:
1282 length = 2;
1283 break;
1284 default:
1285 length = -1;
1286 break;
1287 }
1288
1289 rel_index = length + 3 * pcrel + 6 * type;
1290
1291 if (rel_index >= 0 && (unsigned int) rel_index < sizeof (relocs) / sizeof (relocs[0]))
1292 return relocs[rel_index];
1293
1294 if (pcrel)
1295 as_bad (_("Can not do %d byte pc-relative relocation for storage type %d"),
1296 size, type);
1297 else
1298 as_bad (_("Can not do %d byte relocation for storage type %d"),
1299 size, type);
1300
1301 return BFD_RELOC_NONE;
1302
1303 }
1304
1305 static void
fix_new_ns32k(fragS * frag,int where,int size,symbolS * add_symbol,long offset,int pcrel,char im_disp,bit_fixS * bit_fixP,char bsr,fragS * opcode_frag,unsigned int opcode_offset)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
1313 displacement. */
1314 bit_fixS *bit_fixP, /* Pointer at struct of bit_fix's, ignored if
1315 NULL. */
1316 char bsr, /* Sequent-linker-hack: 1 when relocobject is
1317 a bsr. */
1318 fragS *opcode_frag,
1319 unsigned int opcode_offset)
1320 {
1321 fixS *fixP = fix_new (frag, where, size, add_symbol,
1322 offset, pcrel,
1323 bit_fixP ? NO_RELOC : reloc (size, pcrel, im_disp)
1324 );
1325
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);
1333 }
1334
1335 static void
fix_new_ns32k_exp(fragS * frag,int where,int size,expressionS * exp,int pcrel,char im_disp,bit_fixS * bit_fixP,char bsr,fragS * opcode_frag,unsigned int opcode_offset)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
1342 displacement. */
1343 bit_fixS *bit_fixP, /* Pointer at struct of bit_fix's, ignored if
1344 NULL. */
1345 char bsr, /* Sequent-linker-hack: 1 when relocobject is
1346 a bsr. */
1347 fragS *opcode_frag,
1348 unsigned int opcode_offset)
1349 {
1350 fixS *fixP = fix_new_exp (frag, where, size, exp, pcrel,
1351 bit_fixP ? NO_RELOC : reloc (size, pcrel, im_disp)
1352 );
1353
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);
1361 }
1362
1363 /* Convert number to chars in correct order. */
1364
1365 void
md_number_to_chars(char * buf,valueT value,int nbytes)1366 md_number_to_chars (char *buf, valueT value, int nbytes)
1367 {
1368 number_to_chars_littleendian (buf, value, nbytes);
1369 }
1370
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.
1375
1376 binary: msb -> lsb
1377 0xxxxxxx byte
1378 10xxxxxx xxxxxxxx word
1379 11xxxxxx xxxxxxxx xxxxxxxx xxxxxxxx double word
1380
1381 This must be taken care of and we do it here! */
1382
1383 static void
md_number_to_disp(char * buf,long val,int n)1384 md_number_to_disp (char *buf, long val, int n)
1385 {
1386 switch (n)
1387 {
1388 case 1:
1389 if (val < -64 || val > 63)
1390 as_bad (_("value of %ld out of byte displacement range."), val);
1391 val &= 0x7f;
1392 #ifdef SHOW_NUM
1393 printf ("%x ", val & 0xff);
1394 #endif
1395 *buf++ = val;
1396 break;
1397
1398 case 2:
1399 if (val < -8192 || val > 8191)
1400 as_bad (_("value of %ld out of word displacement range."), val);
1401 val &= 0x3fff;
1402 val |= 0x8000;
1403 #ifdef SHOW_NUM
1404 printf ("%x ", val >> 8 & 0xff);
1405 #endif
1406 *buf++ = (val >> 8);
1407 #ifdef SHOW_NUM
1408 printf ("%x ", val & 0xff);
1409 #endif
1410 *buf++ = val;
1411 break;
1412
1413 case 4:
1414 if (val < -0x20000000 || val >= 0x20000000)
1415 as_bad (_("value of %ld out of double word displacement range."), val);
1416 val |= 0xc0000000;
1417 #ifdef SHOW_NUM
1418 printf ("%x ", val >> 24 & 0xff);
1419 #endif
1420 *buf++ = (val >> 24);
1421 #ifdef SHOW_NUM
1422 printf ("%x ", val >> 16 & 0xff);
1423 #endif
1424 *buf++ = (val >> 16);
1425 #ifdef SHOW_NUM
1426 printf ("%x ", val >> 8 & 0xff);
1427 #endif
1428 *buf++ = (val >> 8);
1429 #ifdef SHOW_NUM
1430 printf ("%x ", val & 0xff);
1431 #endif
1432 *buf++ = val;
1433 break;
1434
1435 default:
1436 as_fatal (_("Internal logic error. line %d, file \"%s\""),
1437 __LINE__, __FILE__);
1438 }
1439 }
1440
1441 static void
md_number_to_imm(char * buf,long val,int n)1442 md_number_to_imm (char *buf, long val, int n)
1443 {
1444 switch (n)
1445 {
1446 case 1:
1447 #ifdef SHOW_NUM
1448 printf ("%x ", val & 0xff);
1449 #endif
1450 *buf++ = val;
1451 break;
1452
1453 case 2:
1454 #ifdef SHOW_NUM
1455 printf ("%x ", val >> 8 & 0xff);
1456 #endif
1457 *buf++ = (val >> 8);
1458 #ifdef SHOW_NUM
1459 printf ("%x ", val & 0xff);
1460 #endif
1461 *buf++ = val;
1462 break;
1463
1464 case 4:
1465 #ifdef SHOW_NUM
1466 printf ("%x ", val >> 24 & 0xff);
1467 #endif
1468 *buf++ = (val >> 24);
1469 #ifdef SHOW_NUM
1470 printf ("%x ", val >> 16 & 0xff);
1471 #endif
1472 *buf++ = (val >> 16);
1473 #ifdef SHOW_NUM
1474 printf ("%x ", val >> 8 & 0xff);
1475 #endif
1476 *buf++ = (val >> 8);
1477 #ifdef SHOW_NUM
1478 printf ("%x ", val & 0xff);
1479 #endif
1480 *buf++ = val;
1481 break;
1482
1483 default:
1484 as_fatal (_("Internal logic error. line %d, file \"%s\""),
1485 __LINE__, __FILE__);
1486 }
1487 }
1488
1489 /* Fast bitfiddling support. */
1490 /* Mask used to zero bitfield before oring in the true field. */
1491
1492 static unsigned long l_mask[] =
1493 {
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,
1502 };
1503 static unsigned long r_mask[] =
1504 {
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,
1513 };
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!). */
1520
1521 static void
md_number_to_field(char * buf,long val,bit_fixS * field_ptr)1522 md_number_to_field (char *buf, long val, bit_fixS *field_ptr)
1523 {
1524 unsigned long object;
1525 unsigned long mask;
1526 /* Define ENDIAN on a ns32k machine. */
1527 #ifdef ENDIAN
1528 unsigned long *mem_ptr;
1529 #else
1530 char *mem_ptr;
1531 #endif
1532
1533 if (field_ptr->fx_bit_min <= val && val <= field_ptr->fx_bit_max)
1534 {
1535 #ifdef ENDIAN
1536 if (field_ptr->fx_bit_base)
1537 /* Override buf. */
1538 mem_ptr = (unsigned long *) field_ptr->fx_bit_base;
1539 else
1540 mem_ptr = (unsigned long *) buf;
1541
1542 mem_ptr = ((unsigned long *)
1543 ((char *) mem_ptr + field_ptr->fx_bit_base_adj));
1544 #else
1545 if (field_ptr->fx_bit_base)
1546 mem_ptr = (char *) field_ptr->fx_bit_base;
1547 else
1548 mem_ptr = buf;
1549
1550 mem_ptr += field_ptr->fx_bit_base_adj;
1551 #endif
1552 #ifdef ENDIAN
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. */
1557 object = 0;
1558 object |= mem_ptr[3] & 0xff;
1559 object <<= 8;
1560 object |= mem_ptr[2] & 0xff;
1561 object <<= 8;
1562 object |= mem_ptr[1] & 0xff;
1563 object <<= 8;
1564 object |= mem_ptr[0] & 0xff;
1565 #endif
1566 mask = 0;
1567 mask |= (r_mask[field_ptr->fx_bit_offset]);
1568 mask |= (l_mask[field_ptr->fx_bit_offset + field_ptr->fx_bit_size]);
1569 object &= mask;
1570 val += field_ptr->fx_bit_add;
1571 object |= ((val << field_ptr->fx_bit_offset) & (mask ^ 0xffffffff));
1572 #ifdef ENDIAN
1573 *mem_ptr = object;
1574 #else
1575 mem_ptr[0] = (char) object;
1576 object >>= 8;
1577 mem_ptr[1] = (char) object;
1578 object >>= 8;
1579 mem_ptr[2] = (char) object;
1580 object >>= 8;
1581 mem_ptr[3] = (char) object;
1582 #endif
1583 }
1584 else
1585 as_bad (_("Bit field out of range"));
1586 }
1587
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. */
1596
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
1610 is always zero. */
1611
1612 static void
convert_iif(void)1613 convert_iif (void)
1614 {
1615 int i;
1616 bit_fixS *j;
1617 fragS *inst_frag;
1618 unsigned int inst_offset;
1619 char *inst_opcode;
1620 char *memP;
1621 int l;
1622 int k;
1623 char type;
1624 char size = 0;
1625
1626 frag_grow (iif.instr_size); /* This is important. */
1627 memP = frag_more (0);
1628 inst_opcode = memP;
1629 inst_offset = (memP - frag_now->fr_literal);
1630 inst_frag = frag_now;
1631
1632 for (i = 0; i < IIF_ENTRIES; i++)
1633 {
1634 if ((type = iif.iifP[i].type))
1635 {
1636 /* The object exist, so handle it. */
1637 switch (size = iif.iifP[i].size)
1638 {
1639 case 42:
1640 size = 0;
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;
1645 /* Fall through. */
1646
1647 case 8: /* bignum or doublefloat. */
1648 case 1:
1649 case 2:
1650 case 3:
1651 case 4:
1652 /* The final size in objectmemory is known. */
1653 memP = frag_more (size);
1654 j = iif.iifP[i].bit_fixP;
1655
1656 switch (type)
1657 {
1658 case 1: /* The object is pure binary. */
1659 if (j)
1660 md_number_to_field (memP, exprP.X_add_number, j);
1661
1662 else if (iif.iifP[i].pcrel)
1663 fix_new_ns32k (frag_now,
1664 (long) (memP - frag_now->fr_literal),
1665 size,
1666 0,
1667 iif.iifP[i].object,
1668 iif.iifP[i].pcrel,
1669 iif.iifP[i].im_disp,
1670 0,
1671 iif.iifP[i].bsr, /* Sequent hack. */
1672 inst_frag, inst_offset);
1673 else
1674 {
1675 /* Good, just put them bytes out. */
1676 switch (iif.iifP[i].im_disp)
1677 {
1678 case 0:
1679 md_number_to_chars (memP, iif.iifP[i].object, size);
1680 break;
1681 case 1:
1682 md_number_to_disp (memP, iif.iifP[i].object, size);
1683 break;
1684 default:
1685 as_fatal (_("iif convert internal pcrel/binary"));
1686 }
1687 }
1688 break;
1689
1690 case 2:
1691 /* The object is a pointer at an expression, so
1692 unpack it, note that bignums may result from the
1693 expression. */
1694 evaluate_expr (&exprP, (char *) iif.iifP[i].object);
1695 if (exprP.X_op == O_big || size == 8)
1696 {
1697 if ((k = exprP.X_add_number) > 0)
1698 {
1699 /* We have a bignum ie a quad. This can only
1700 happens in a long suffixed instruction. */
1701 if (k * 2 > size)
1702 as_bad (_("Bignum too big for long"));
1703
1704 if (k == 3)
1705 memP += 2;
1706
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));
1711 }
1712 else
1713 {
1714 /* flonum. */
1715 LITTLENUM_TYPE words[4];
1716
1717 switch (size)
1718 {
1719 case 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),
1724 (long) words[1],
1725 sizeof (LITTLENUM_TYPE));
1726 break;
1727 case 8:
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),
1732 (long) words[1],
1733 sizeof (LITTLENUM_TYPE));
1734 md_number_to_imm ((memP + 2
1735 * sizeof (LITTLENUM_TYPE)),
1736 (long) words[2],
1737 sizeof (LITTLENUM_TYPE));
1738 md_number_to_imm ((memP + 3
1739 * sizeof (LITTLENUM_TYPE)),
1740 (long) words[3],
1741 sizeof (LITTLENUM_TYPE));
1742 break;
1743 }
1744 }
1745 break;
1746 }
1747 if (exprP.X_add_symbol ||
1748 exprP.X_op_symbol ||
1749 iif.iifP[i].pcrel)
1750 {
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),
1757 size,
1758 &exprP,
1759 iif.iifP[i].pcrel,
1760 iif.iifP[i].im_disp,
1761 j,
1762 iif.iifP[i].bsr,
1763 inst_frag, inst_offset);
1764 }
1765 else if (j)
1766 md_number_to_field (memP, exprP.X_add_number, j);
1767 else
1768 {
1769 /* Good, just put them bytes out. */
1770 switch (iif.iifP[i].im_disp)
1771 {
1772 case 0:
1773 md_number_to_imm (memP, exprP.X_add_number, size);
1774 break;
1775 case 1:
1776 md_number_to_disp (memP, exprP.X_add_number, size);
1777 break;
1778 default:
1779 as_fatal (_("iif convert internal pcrel/pointer"));
1780 }
1781 }
1782 break;
1783 default:
1784 as_fatal (_("Internal logic error in iif.iifP[n].type"));
1785 }
1786 break;
1787
1788 case 0:
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. */
1794 {
1795 evaluate_expr (&exprP, (char *) iif.iifP[i].object);
1796
1797 if ((exprP.X_add_symbol || exprP.X_op_symbol) &&
1798 !iif.iifP[i].pcrel)
1799 {
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),
1805 size,
1806 &exprP,
1807 0, /* never iif.iifP[i].pcrel, */
1808 1, /* always iif.iifP[i].im_disp */
1809 (bit_fixS *) 0, 0,
1810 inst_frag,
1811 inst_offset);
1812 break; /* Exit this absolute hack. */
1813 }
1814
1815 if (exprP.X_add_symbol || exprP.X_op_symbol)
1816 {
1817 /* Frag it. */
1818 if (exprP.X_op_symbol)
1819 /* We cant relax this case. */
1820 as_fatal (_("Can't relax difference"));
1821 else
1822 {
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. */
1826 size = 0;
1827
1828 {
1829 fragS *old_frag = frag_now;
1830 frag_variant (rs_machine_dependent,
1831 4, /* Max size. */
1832 0, /* Size. */
1833 IND (BRANCH, UNDEF), /* Expecting
1834 the worst. */
1835 exprP.X_add_symbol,
1836 exprP.X_add_number,
1837 inst_opcode);
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;
1841 }
1842 }
1843 }
1844 else
1845 {
1846 /* This duplicates code in md_number_to_disp. */
1847 if (-64 <= exprP.X_add_number && exprP.X_add_number <= 63)
1848 size = 1;
1849 else
1850 {
1851 if (-8192 <= exprP.X_add_number
1852 && exprP.X_add_number <= 8191)
1853 size = 2;
1854 else
1855 {
1856 if (-0x20000000 <= exprP.X_add_number
1857 && exprP.X_add_number<=0x1fffffff)
1858 size = 4;
1859 else
1860 {
1861 as_bad (_("Displacement too large for :d"));
1862 size = 4;
1863 }
1864 }
1865 }
1866
1867 memP = frag_more (size);
1868 md_number_to_disp (memP, exprP.X_add_number, size);
1869 }
1870 }
1871 break;
1872
1873 default:
1874 as_fatal (_("Internal logic error in iif.iifP[].type"));
1875 }
1876 }
1877 }
1878 }
1879
1880 void
md_assemble(char * line)1881 md_assemble (char *line)
1882 {
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. */
1886 #ifdef SHOW_NUM
1887 printf (" \t\t\t%s\n", line);
1888 #endif
1889 }
1890
1891 void
md_begin(void)1892 md_begin (void)
1893 {
1894 /* Build a hashtable of the instructions. */
1895 const struct ns32k_opcode *ptr;
1896 const char *status;
1897 const struct ns32k_opcode *endop;
1898
1899 inst_hash_handle = hash_new ();
1900
1901 endop = ns32k_opcodes + sizeof (ns32k_opcodes) / sizeof (ns32k_opcodes[0]);
1902 for (ptr = ns32k_opcodes; ptr < endop; ptr++)
1903 {
1904 if ((status = hash_insert (inst_hash_handle, ptr->name, (char *) ptr)))
1905 /* Fatal. */
1906 as_fatal (_("Can't hash %s: %s"), ptr->name, status);
1907 }
1908
1909 /* Some private space please! */
1910 freeptr_static = XNEWVEC (char, PRIVATE_SIZE);
1911 }
1912
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. */
1917
1918 const char *
md_atof(int type,char * litP,int * sizeP)1919 md_atof (int type, char *litP, int *sizeP)
1920 {
1921 return ieee_md_atof (type, litP, sizeP, FALSE);
1922 }
1923
1924 int
md_pcrel_adjust(fragS * fragP)1925 md_pcrel_adjust (fragS *fragP)
1926 {
1927 fragS *opcode_frag;
1928 addressT opcode_address;
1929 unsigned int offset;
1930
1931 opcode_frag = frag_opcode_frag (fragP);
1932 if (opcode_frag == 0)
1933 return 0;
1934
1935 offset = frag_opcode_offset (fragP);
1936 opcode_address = offset + opcode_frag->fr_address;
1937
1938 return fragP->fr_address + fragP->fr_fix - opcode_address;
1939 }
1940
1941 static int
md_fix_pcrel_adjust(fixS * fixP)1942 md_fix_pcrel_adjust (fixS *fixP)
1943 {
1944 fragS *opcode_frag;
1945 addressT opcode_address;
1946 unsigned int offset;
1947
1948 opcode_frag = fix_opcode_frag (fixP);
1949 if (opcode_frag == 0)
1950 return 0;
1951
1952 offset = fix_opcode_offset (fixP);
1953 opcode_address = offset + opcode_frag->fr_address;
1954
1955 return fixP->fx_where + fixP->fx_frag->fr_address - opcode_address;
1956 }
1957
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.
1960
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. */
1964
1965 void
md_apply_fix(fixS * fixP,valueT * valP,segT seg ATTRIBUTE_UNUSED)1966 md_apply_fix (fixS *fixP, valueT * valP, segT seg ATTRIBUTE_UNUSED)
1967 {
1968 long val = * (long *) valP;
1969 char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
1970
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))
1975 {
1976 case 0:
1977 /* Immediate field. */
1978 md_number_to_imm (buf, val, fixP->fx_size);
1979 break;
1980
1981 case 1:
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);
1987 break;
1988
1989 case 2:
1990 /* Pointer in a data object. */
1991 md_number_to_chars (buf, val, fixP->fx_size);
1992 break;
1993 }
1994
1995 if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0)
1996 fixP->fx_done = 1;
1997 }
1998
1999 /* Convert a relaxed displacement to ditto in final output. */
2000
2001 void
md_convert_frag(bfd * abfd ATTRIBUTE_UNUSED,segT sec ATTRIBUTE_UNUSED,fragS * fragP)2002 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED,
2003 segT sec ATTRIBUTE_UNUSED,
2004 fragS *fragP)
2005 {
2006 long disp;
2007 long ext = 0;
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. */
2011 int object_address;
2012
2013 switch (fragP->fr_subtype)
2014 {
2015 case IND (BRANCH, BYTE):
2016 ext = 1;
2017 break;
2018 case IND (BRANCH, WORD):
2019 ext = 2;
2020 break;
2021 case IND (BRANCH, DOUBLE):
2022 ext = 4;
2023 break;
2024 }
2025
2026 if (ext == 0)
2027 return;
2028
2029 know (fragP->fr_symbol);
2030
2031 object_address = fragP->fr_fix + fragP->fr_address;
2032
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);
2036
2037 md_number_to_disp (buffer_address, (long) disp, (int) ext);
2038 fragP->fr_fix += ext;
2039 }
2040
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. */
2044
2045 int
md_estimate_size_before_relax(fragS * fragP,segT segment)2046 md_estimate_size_before_relax (fragS *fragP, segT segment)
2047 {
2048 if (fragP->fr_subtype == IND (BRANCH, UNDEF))
2049 {
2050 if (S_GET_SEGMENT (fragP->fr_symbol) != segment)
2051 {
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),
2056 4,
2057 fragP->fr_symbol,
2058 fragP->fr_offset,
2059 1,
2060 1,
2061 0,
2062 frag_bsr(fragP), /* Sequent hack. */
2063 frag_opcode_frag (fragP),
2064 frag_opcode_offset (fragP));
2065 fragP->fr_fix += 4;
2066 frag_wane (fragP);
2067 return 4;
2068 }
2069
2070 /* Relaxable case. Set up the initial guess for the variable
2071 part of the frag. */
2072 fragP->fr_subtype = IND (BRANCH, BYTE);
2073 }
2074
2075 if (fragP->fr_subtype >= sizeof (md_relax_table) / sizeof (md_relax_table[0]))
2076 abort ();
2077
2078 /* Return the size of the variable part of the frag. */
2079 return md_relax_table[fragP->fr_subtype].rlx_length;
2080 }
2081
2082 int md_short_jump_size = 3;
2083 int md_long_jump_size = 5;
2084
2085 void
md_create_short_jump(char * ptr,addressT from_addr,addressT to_addr,fragS * frag ATTRIBUTE_UNUSED,symbolS * to_symbol ATTRIBUTE_UNUSED)2086 md_create_short_jump (char *ptr,
2087 addressT from_addr,
2088 addressT to_addr,
2089 fragS *frag ATTRIBUTE_UNUSED,
2090 symbolS *to_symbol ATTRIBUTE_UNUSED)
2091 {
2092 valueT offset;
2093
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);
2097 }
2098
2099 void
md_create_long_jump(char * ptr,addressT from_addr,addressT to_addr,fragS * frag ATTRIBUTE_UNUSED,symbolS * to_symbol ATTRIBUTE_UNUSED)2100 md_create_long_jump (char *ptr,
2101 addressT from_addr,
2102 addressT to_addr,
2103 fragS *frag ATTRIBUTE_UNUSED,
2104 symbolS *to_symbol ATTRIBUTE_UNUSED)
2105 {
2106 valueT offset;
2107
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);
2111 }
2112
2113 const char *md_shortopts = "m:";
2114
2115 struct option md_longopts[] =
2116 {
2117 #define OPTION_DISP_SIZE (OPTION_MD_BASE)
2118 {"disp-size-default", required_argument , NULL, OPTION_DISP_SIZE},
2119 {NULL, no_argument, NULL, 0}
2120 };
2121
2122 size_t md_longopts_size = sizeof (md_longopts);
2123
2124 int
md_parse_option(int c,const char * arg)2125 md_parse_option (int c, const char *arg)
2126 {
2127 switch (c)
2128 {
2129 case 'm':
2130 if (!strcmp (arg, "32032"))
2131 {
2132 cpureg = cpureg_032;
2133 mmureg = mmureg_032;
2134 }
2135 else if (!strcmp (arg, "32532"))
2136 {
2137 cpureg = cpureg_532;
2138 mmureg = mmureg_532;
2139 }
2140 else
2141 {
2142 as_warn (_("invalid architecture option -m%s, ignored"), arg);
2143 return 0;
2144 }
2145 break;
2146 case OPTION_DISP_SIZE:
2147 {
2148 int size = atoi(arg);
2149 switch (size)
2150 {
2151 case 1: case 2: case 4:
2152 default_disp_size = size;
2153 break;
2154 default:
2155 as_warn (_("invalid default displacement size \"%s\". Defaulting to %d."),
2156 arg, default_disp_size);
2157 }
2158 break;
2159 }
2160
2161 default:
2162 return 0;
2163 }
2164
2165 return 1;
2166 }
2167
2168 void
md_show_usage(FILE * stream)2169 md_show_usage (FILE *stream)
2170 {
2171 fprintf (stream, _("\
2172 NS32K options:\n\
2173 -m32032 | -m32532 select variant of NS32K architecture\n\
2174 --disp-size-default=<1|2|4>\n"));
2175 }
2176
2177 /* This is TC_CONS_FIX_NEW, called by emit_expr in read.c. */
2178
2179 void
cons_fix_new_ns32k(fragS * frag,int where,int size,expressionS * exp,bfd_reloc_code_real_type r ATTRIBUTE_UNUSED)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)
2185 {
2186 fix_new_ns32k_exp (frag, where, size, exp,
2187 0, 2, 0, 0, 0, 0);
2188 }
2189
2190 /* We have no need to default values of symbols. */
2191
2192 symbolS *
md_undefined_symbol(char * name ATTRIBUTE_UNUSED)2193 md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
2194 {
2195 return 0;
2196 }
2197
2198 /* Round up a section size to the appropriate boundary. */
2199
2200 valueT
md_section_align(segT segment ATTRIBUTE_UNUSED,valueT size)2201 md_section_align (segT segment ATTRIBUTE_UNUSED, valueT size)
2202 {
2203 return size; /* Byte alignment is fine. */
2204 }
2205
2206 /* Exactly what point is a PC-relative offset relative TO? On the
2207 ns32k, they're relative to the start of the instruction. */
2208
2209 long
md_pcrel_from(fixS * fixP)2210 md_pcrel_from (fixS *fixP)
2211 {
2212 long res;
2213
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! */
2218 #endif
2219 return res;
2220 }
2221
2222 arelent *
tc_gen_reloc(asection * section ATTRIBUTE_UNUSED,fixS * fixp)2223 tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp)
2224 {
2225 arelent *rel;
2226 bfd_reloc_code_real_type code;
2227
2228 code = reloc (fixp->fx_size, fixp->fx_pcrel, fix_im_disp (fixp));
2229
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;
2234 if (fixp->fx_pcrel)
2235 rel->addend = fixp->fx_addnumber;
2236 else
2237 rel->addend = 0;
2238
2239 rel->howto = bfd_reloc_type_lookup (stdoutput, code);
2240 if (!rel->howto)
2241 {
2242 const char *name;
2243
2244 name = S_GET_NAME (fixp->fx_addsy);
2245 if (name == NULL)
2246 name = _("<unknown>");
2247 as_fatal (_("Cannot find relocation type for symbol %s, code %d"),
2248 name, (int) code);
2249 }
2250
2251 return rel;
2252 }
2253