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