• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 (&notes, 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