1 /* ns32k.c -- Assemble on the National Semiconductor 32k series 2 Copyright (C) 1987-2018 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 data length in bytes. This is stored in size[n]. 152 0, the object length 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 data length 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 object file 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 don't 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 addressing mode 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 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 /* Fall through. */ 436 default: 437 as_bad (_("Invalid syntax in PC-relative addressing mode")); 438 return 0; 439 } 440 } 441 break; 442 case 'e': 443 if (str[strl - 1] != ']') 444 { 445 if ((!strncmp (str, "ext(", 4)) && strl > 7) 446 { /* external */ 447 addrmodeP->disp[0] = str + 4; 448 i = 0; 449 j = 2; 450 do 451 { /* disp[0]'s termination point. */ 452 j += 1; 453 if (str[j] == '(') 454 i++; 455 if (str[j] == ')') 456 i--; 457 } 458 while (j < strl && i != 0); 459 if (i != 0 || !(str[j + 1] == '-' || str[j + 1] == '+')) 460 { 461 as_bad (_("Invalid syntax in External addressing mode")); 462 return (0); 463 } 464 str[j] = '\000'; /* null terminate disp[0] */ 465 addrmodeP->disp[1] = str + j + 2; 466 addrmodeP->mode = 22; 467 return -1; 468 } 469 } 470 break; 471 472 default: 473 ; 474 } 475 476 strl = strlen (str); 477 478 switch (strl) 479 { 480 case 2: 481 switch (str[0]) 482 { 483 case 'f': 484 addrmodeP->float_flag = 1; 485 /* Fall through. */ 486 case 'r': 487 if (str[1] >= '0' && str[1] < '8') 488 { 489 addrmodeP->mode = str[1] - '0'; 490 return -1; 491 } 492 break; 493 default: 494 break; 495 } 496 /* Drop through. */ 497 498 case 3: 499 if (!strncmp (str, "tos", 3)) 500 { 501 addrmodeP->mode = 23; /* TopOfStack */ 502 return -1; 503 } 504 break; 505 506 default: 507 break; 508 } 509 510 if (strl > 4) 511 { 512 if (str[strl - 1] == ')') 513 { 514 if (str[strl - 2] == ')') 515 { 516 if (!strncmp (&str[strl - 5], "(fp", 3)) 517 mode = 16; /* Memory Relative. */ 518 else if (!strncmp (&str[strl - 5], "(sp", 3)) 519 mode = 17; 520 else if (!strncmp (&str[strl - 5], "(sb", 3)) 521 mode = 18; 522 523 if (mode != DEFAULT) 524 { 525 /* Memory relative. */ 526 addrmodeP->mode = mode; 527 j = strl - 5; /* Temp for end of disp[0]. */ 528 i = 0; 529 530 do 531 { 532 strl -= 1; 533 if (str[strl] == ')') 534 i++; 535 if (str[strl] == '(') 536 i--; 537 } 538 while (strl > -1 && i != 0); 539 540 if (i != 0) 541 { 542 as_bad (_("Invalid syntax in Memory Relative addressing mode")); 543 return (0); 544 } 545 546 addrmodeP->disp[1] = str; 547 addrmodeP->disp[0] = str + strl + 1; 548 str[j] = '\000'; /* Null terminate disp[0] . */ 549 str[strl] = '\000'; /* Null terminate disp[1]. */ 550 551 return -1; 552 } 553 } 554 555 switch (str[strl - 3]) 556 { 557 case 'r': 558 case 'R': 559 if (str[strl - 2] >= '0' 560 && str[strl - 2] < '8' 561 && str[strl - 4] == '(') 562 { 563 addrmodeP->mode = str[strl - 2] - '0' + 8; 564 addrmodeP->disp[0] = str; 565 str[strl - 4] = 0; 566 return -1; /* reg rel */ 567 } 568 /* Fall through. */ 569 570 default: 571 if (!strncmp (&str[strl - 4], "(fp", 3)) 572 mode = 24; 573 else if (!strncmp (&str[strl - 4], "(sp", 3)) 574 mode = 25; 575 else if (!strncmp (&str[strl - 4], "(sb", 3)) 576 mode = 26; 577 else if (!strncmp (&str[strl - 4], "(pc", 3)) 578 mode = 27; 579 580 if (mode != DEFAULT) 581 { 582 addrmodeP->mode = mode; 583 addrmodeP->disp[0] = str; 584 str[strl - 4] = '\0'; 585 586 return -1; /* Memory space. */ 587 } 588 } 589 } 590 591 /* No trailing ')' do we have a ']' ? */ 592 if (str[strl - 1] == ']') 593 { 594 switch (str[strl - 2]) 595 { 596 case 'b': 597 mode = 28; 598 break; 599 case 'w': 600 mode = 29; 601 break; 602 case 'd': 603 mode = 30; 604 break; 605 case 'q': 606 mode = 31; 607 break; 608 default: 609 as_bad (_("Invalid scaled-indexed mode, use (b,w,d,q)")); 610 611 if (str[strl - 3] != ':' || str[strl - 6] != '[' 612 || str[strl - 5] == 'r' || str[strl - 4] < '0' 613 || str[strl - 4] > '7') 614 as_bad (_("Syntax in scaled-indexed mode, use [Rn:m] where n=[0..7] m={b,w,d,q}")); 615 } /* Scaled index. */ 616 617 if (recursive_level > 0) 618 { 619 as_bad (_("Scaled-indexed addressing mode combined with scaled-index")); 620 return 0; 621 } 622 623 addrmodeP->am_size += 1; /* scaled index byte. */ 624 j = str[strl - 4] - '0'; /* store temporary. */ 625 str[strl - 6] = '\000'; /* null terminate for recursive call. */ 626 i = addr_mode (str, addrmodeP, 1); 627 628 if (!i || addrmodeP->mode == 20) 629 { 630 as_bad (_("Invalid or illegal addressing mode combined with scaled-index")); 631 return 0; 632 } 633 634 addrmodeP->scaled_mode = addrmodeP->mode; /* Store the inferior mode. */ 635 addrmodeP->mode = mode; 636 addrmodeP->scaled_reg = j + 1; 637 638 return -1; 639 } 640 } 641 642 addrmodeP->mode = DEFAULT; /* Default to whatever. */ 643 addrmodeP->disp[0] = str; 644 645 return -1; 646 } 647 648 static void 649 evaluate_expr (expressionS *resultP, char *ptr) 650 { 651 char *tmp_line; 652 653 tmp_line = input_line_pointer; 654 input_line_pointer = ptr; 655 expression (resultP); 656 input_line_pointer = tmp_line; 657 } 658 659 /* ptr points at string addr_modeP points at struct with result This 660 routine calls addr_mode to determine the general addr.mode of the 661 operand. When this is ready it parses the displacements for size 662 specifying suffixes and determines size of immediate mode via 663 ns32k-opcode. Also builds index bytes if needed. */ 664 665 static int 666 get_addr_mode (char *ptr, addr_modeS *addrmodeP) 667 { 668 int tmp; 669 670 addr_mode (ptr, addrmodeP, 0); 671 672 if (addrmodeP->mode == DEFAULT || addrmodeP->scaled_mode == -1) 673 { 674 /* Resolve ambiguous operands, this shouldn't be necessary if 675 one uses standard NSC operand syntax. But the sequent 676 compiler doesn't!!! This finds a proper addressing mode 677 if it is implicitly stated. See ns32k-opcode.h. */ 678 (void) evaluate_expr (&exprP, ptr); /* This call takes time Sigh! */ 679 680 if (addrmodeP->mode == DEFAULT) 681 { 682 if (exprP.X_add_symbol || exprP.X_op_symbol) 683 addrmodeP->mode = desc->default_model; /* We have a label. */ 684 else 685 addrmodeP->mode = desc->default_modec; /* We have a constant. */ 686 } 687 else 688 { 689 if (exprP.X_add_symbol || exprP.X_op_symbol) 690 addrmodeP->scaled_mode = desc->default_model; 691 else 692 addrmodeP->scaled_mode = desc->default_modec; 693 } 694 695 /* Must put this mess down in addr_mode to handle the scaled 696 case better. */ 697 } 698 699 /* It appears as the sequent compiler wants an absolute when we have 700 a label without @. Constants becomes immediates besides the addr 701 case. Think it does so with local labels too, not optimum, pcrel 702 is better. When I have time I will make gas check this and 703 select pcrel when possible Actually that is trivial. */ 704 if ((tmp = addrmodeP->scaled_reg)) 705 { /* Build indexbyte. */ 706 tmp--; /* Remember regnumber comes incremented for 707 flag purpose. */ 708 tmp |= addrmodeP->scaled_mode << 3; 709 addrmodeP->index_byte = (char) tmp; 710 addrmodeP->am_size += 1; 711 } 712 713 gas_assert (addrmodeP->mode >= 0); 714 if (disp_test[(unsigned int) addrmodeP->mode]) 715 { 716 char c; 717 char suffix; 718 char suffix_sub; 719 int i; 720 char *toP; 721 char *fromP; 722 723 /* There was a displacement, probe for length specifying suffix. */ 724 addrmodeP->pcrel = 0; 725 726 gas_assert (addrmodeP->mode >= 0); 727 if (disp_test[(unsigned int) addrmodeP->mode]) 728 { 729 /* There is a displacement. */ 730 if (addrmodeP->mode == 27 || addrmodeP->scaled_mode == 27) 731 /* Do we have pcrel. mode. */ 732 addrmodeP->pcrel = 1; 733 734 addrmodeP->im_disp = 1; 735 736 for (i = 0; i < 2; i++) 737 { 738 suffix_sub = suffix = 0; 739 740 if ((toP = addrmodeP->disp[i])) 741 { 742 /* Suffix of expression, the largest size rules. */ 743 fromP = toP; 744 745 while ((c = *fromP++)) 746 { 747 *toP++ = c; 748 if (c == ':') 749 { 750 switch (*fromP) 751 { 752 case '\0': 753 as_warn (_("Premature end of suffix -- Defaulting to d")); 754 suffix = 4; 755 continue; 756 case 'b': 757 suffix_sub = 1; 758 break; 759 case 'w': 760 suffix_sub = 2; 761 break; 762 case 'd': 763 suffix_sub = 4; 764 break; 765 default: 766 as_warn (_("Bad suffix after ':' use {b|w|d} Defaulting to d")); 767 suffix = 4; 768 } 769 770 fromP ++; 771 toP --; /* So we write over the ':' */ 772 773 if (suffix < suffix_sub) 774 suffix = suffix_sub; 775 } 776 } 777 778 *toP = '\0'; /* Terminate properly. */ 779 addrmodeP->disp_suffix[i] = suffix; 780 addrmodeP->am_size += suffix ? suffix : 4; 781 } 782 } 783 } 784 } 785 else 786 { 787 if (addrmodeP->mode == 20) 788 { 789 /* Look in ns32k_opcode for size. */ 790 addrmodeP->disp_suffix[0] = addrmodeP->am_size = desc->im_size; 791 addrmodeP->im_disp = 0; 792 } 793 } 794 795 return addrmodeP->mode; 796 } 797 798 /* Read an option list. */ 799 800 static void 801 optlist (char *str, /* The string to extract options from. */ 802 struct ns32k_option *optionP, /* How to search the string. */ 803 unsigned long *default_map) /* Default pattern and output. */ 804 { 805 int i, j, k, strlen1, strlen2; 806 const char *patternP, *strP; 807 808 strlen1 = strlen (str); 809 810 if (strlen1 < 1) 811 as_fatal (_("Very short instr to option, ie you can't do it on a NULLstr")); 812 813 for (i = 0; optionP[i].pattern != 0; i++) 814 { 815 strlen2 = strlen (optionP[i].pattern); 816 817 for (j = 0; j < strlen1; j++) 818 { 819 patternP = optionP[i].pattern; 820 strP = &str[j]; 821 822 for (k = 0; k < strlen2; k++) 823 { 824 if (*(strP++) != *(patternP++)) 825 break; 826 } 827 828 if (k == strlen2) 829 { /* match */ 830 *default_map |= optionP[i].or; 831 *default_map &= optionP[i].and; 832 } 833 } 834 } 835 } 836 837 /* Search struct for symbols. 838 This function is used to get the short integer form of reg names in 839 the instructions lmr, smr, lpr, spr return true if str is found in 840 list. */ 841 842 static int 843 list_search (char *str, /* The string to match. */ 844 struct ns32k_option *optionP, /* List to search. */ 845 unsigned long *default_map) /* Default pattern and output. */ 846 { 847 int i; 848 849 for (i = 0; optionP[i].pattern != 0; i++) 850 { 851 if (!strncmp (optionP[i].pattern, str, 20)) 852 { 853 /* Use strncmp to be safe. */ 854 *default_map |= optionP[i].or; 855 *default_map &= optionP[i].and; 856 857 return -1; 858 } 859 } 860 861 as_bad (_("No such entry in list. (cpu/mmu register)")); 862 return 0; 863 } 864 865 /* Create a bit_fixS in obstack 'notes'. 866 This struct is used to profile the normal fix. If the bit_fixP is a 867 valid pointer (not NULL) the bit_fix data will be used to format 868 the fix. */ 869 870 static bit_fixS * 871 bit_fix_new (int size, /* Length of bitfield. */ 872 int offset, /* Bit offset to bitfield. */ 873 long min, /* Signextended min for bitfield. */ 874 long max, /* Signextended max for bitfield. */ 875 long add, /* Add mask, used for huffman prefix. */ 876 long base_type, /* 0 or 1, if 1 it's exploded to opcode ptr. */ 877 long base_adj) 878 { 879 bit_fixS *bit_fixP; 880 881 bit_fixP = XOBNEW (¬es, bit_fixS); 882 883 bit_fixP->fx_bit_size = size; 884 bit_fixP->fx_bit_offset = offset; 885 bit_fixP->fx_bit_base = base_type; 886 bit_fixP->fx_bit_base_adj = base_adj; 887 bit_fixP->fx_bit_max = max; 888 bit_fixP->fx_bit_min = min; 889 bit_fixP->fx_bit_add = add; 890 891 return bit_fixP; 892 } 893 894 /* Convert operands to iif-format and adds bitfields to the opcode. 895 Operands are parsed in such an order that the opcode is updated from 896 its most significant bit, that is when the operand need to alter the 897 opcode. 898 Be careful not to put to objects in the same iif-slot. */ 899 900 static void 901 encode_operand (int argc, 902 char **argv, 903 const char *operandsP, 904 const char *suffixP, 905 char im_size ATTRIBUTE_UNUSED, 906 char opcode_bit_ptr) 907 { 908 int i, j; 909 char d; 910 int pcrel, b, loop, pcrel_adjust; 911 unsigned long tmp; 912 913 for (loop = 0; loop < argc; loop++) 914 { 915 /* What operand are we supposed to work on. */ 916 i = operandsP[loop << 1] - '1'; 917 if (i > 3) 918 as_fatal (_("Internal consistency error. check ns32k-opcode.h")); 919 920 pcrel = 0; 921 pcrel_adjust = 0; 922 tmp = 0; 923 924 switch ((d = operandsP[(loop << 1) + 1])) 925 { 926 case 'f': /* Operand of sfsr turns out to be a nasty 927 special-case. */ 928 opcode_bit_ptr -= 5; 929 /* Fall through. */ 930 case 'Z': /* Float not immediate. */ 931 case 'F': /* 32 bit float general form. */ 932 case 'L': /* 64 bit float. */ 933 case 'I': /* Integer not immediate. */ 934 case 'B': /* Byte */ 935 case 'W': /* Word */ 936 case 'D': /* Double-word. */ 937 case 'A': /* Double-word gen-address-form ie no regs 938 allowed. */ 939 get_addr_mode (argv[i], &addr_modeP); 940 941 if ((addr_modeP.mode == 20) && 942 (d == 'I' || d == 'Z' || d == 'A')) 943 as_fatal (d == 'A'? _("Address of immediate operand"): 944 _("Invalid immediate write operand.")); 945 946 if (opcode_bit_ptr == desc->opcode_size) 947 b = 4; 948 else 949 b = 6; 950 951 for (j = b; j < (b + 2); j++) 952 { 953 if (addr_modeP.disp[j - b]) 954 { 955 IIF (j, 956 2, 957 addr_modeP.disp_suffix[j - b], 958 (unsigned long) addr_modeP.disp[j - b], 959 0, 960 addr_modeP.pcrel, 961 iif.instr_size, 962 addr_modeP.im_disp, 963 IND (BRANCH, BYTE), 964 NULL, 965 (addr_modeP.scaled_reg ? addr_modeP.scaled_mode 966 : addr_modeP.mode), 967 0); 968 } 969 } 970 971 opcode_bit_ptr -= 5; 972 iif.iifP[1].object |= ((long) addr_modeP.mode) << opcode_bit_ptr; 973 974 if (addr_modeP.scaled_reg) 975 { 976 j = b / 2; 977 IIF (j, 1, 1, (unsigned long) addr_modeP.index_byte, 978 0, 0, 0, 0, 0, NULL, -1, 0); 979 } 980 break; 981 982 case 'b': /* Multiple instruction disp. */ 983 freeptr++; /* OVE:this is an useful hack. */ 984 sprintf (freeptr, "((%s-1)*%d)", argv[i], desc->im_size); 985 argv[i] = freeptr; 986 pcrel -= 1; /* Make pcrel 0 in spite of what case 'p': 987 wants. */ 988 /* fallthru */ 989 case 'p': /* Displacement - pc relative addressing. */ 990 pcrel += 1; 991 /* fallthru */ 992 case 'd': /* Displacement. */ 993 iif.instr_size += suffixP[i] ? suffixP[i] : 4; 994 IIF (12, 2, suffixP[i], (unsigned long) argv[i], 0, 995 pcrel, pcrel_adjust, 1, IND (BRANCH, BYTE), NULL, -1, 0); 996 break; 997 case 'H': /* Sequent-hack: the linker wants a bit set 998 when bsr. */ 999 pcrel = 1; 1000 iif.instr_size += suffixP[i] ? suffixP[i] : 4; 1001 IIF (12, 2, suffixP[i], (unsigned long) argv[i], 0, 1002 pcrel, pcrel_adjust, 1, IND (BRANCH, BYTE), NULL, -1, 1); 1003 break; 1004 case 'q': /* quick */ 1005 opcode_bit_ptr -= 4; 1006 IIF (11, 2, 42, (unsigned long) argv[i], 0, 0, 0, 0, 0, 1007 bit_fix_new (4, opcode_bit_ptr, -8, 7, 0, 1, 0), -1, 0); 1008 break; 1009 case 'r': /* Register number (3 bits). */ 1010 list_search (argv[i], opt6, &tmp); 1011 opcode_bit_ptr -= 3; 1012 iif.iifP[1].object |= tmp << opcode_bit_ptr; 1013 break; 1014 case 'O': /* Setcfg instruction options list. */ 1015 optlist (argv[i], opt3, &tmp); 1016 opcode_bit_ptr -= 4; 1017 iif.iifP[1].object |= tmp << 15; 1018 break; 1019 case 'C': /* Cinv instruction options list. */ 1020 optlist (argv[i], opt4, &tmp); 1021 opcode_bit_ptr -= 4; 1022 iif.iifP[1].object |= tmp << 15; /* Insert the regtype in opcode. */ 1023 break; 1024 case 'S': /* String instruction options list. */ 1025 optlist (argv[i], opt5, &tmp); 1026 opcode_bit_ptr -= 4; 1027 iif.iifP[1].object |= tmp << 15; 1028 break; 1029 case 'u': 1030 case 'U': /* Register list. */ 1031 IIF (10, 1, 1, 0, 0, 0, 0, 0, 0, NULL, -1, 0); 1032 switch (operandsP[(i << 1) + 1]) 1033 { 1034 case 'u': /* Restore, exit. */ 1035 optlist (argv[i], opt1, &iif.iifP[10].object); 1036 break; 1037 case 'U': /* Save, enter. */ 1038 optlist (argv[i], opt2, &iif.iifP[10].object); 1039 break; 1040 } 1041 iif.instr_size += 1; 1042 break; 1043 case 'M': /* MMU register. */ 1044 list_search (argv[i], mmureg, &tmp); 1045 opcode_bit_ptr -= 4; 1046 iif.iifP[1].object |= tmp << opcode_bit_ptr; 1047 break; 1048 case 'P': /* CPU register. */ 1049 list_search (argv[i], cpureg, &tmp); 1050 opcode_bit_ptr -= 4; 1051 iif.iifP[1].object |= tmp << opcode_bit_ptr; 1052 break; 1053 case 'g': /* Inss exts. */ 1054 iif.instr_size += 1; /* 1 byte is allocated after the opcode. */ 1055 IIF (10, 2, 1, 1056 (unsigned long) argv[i], /* i always 2 here. */ 1057 0, 0, 0, 0, 0, 1058 bit_fix_new (3, 5, 0, 7, 0, 0, 0), /* A bit_fix is targeted to 1059 the byte. */ 1060 -1, 0); 1061 break; 1062 case 'G': 1063 IIF (11, 2, 42, 1064 (unsigned long) argv[i], /* i always 3 here. */ 1065 0, 0, 0, 0, 0, 1066 bit_fix_new (5, 0, 1, 32, -1, 0, -1), -1, 0); 1067 break; 1068 case 'i': 1069 iif.instr_size += 1; 1070 b = 2 + i; /* Put the extension byte after opcode. */ 1071 IIF (b, 2, 1, 0, 0, 0, 0, 0, 0, 0, -1, 0); 1072 break; 1073 default: 1074 as_fatal (_("Bad opcode-table-option, check in file ns32k-opcode.h")); 1075 } 1076 } 1077 } 1078 1079 /* in: instruction line 1080 out: internal structure of instruction 1081 that has been prepared for direct conversion to fragment(s) and 1082 fixes in a systematical fashion 1083 Return-value = recursive_level. */ 1084 /* Build iif of one assembly text line. */ 1085 1086 static int 1087 parse (const char *line, 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 lineptr = line; 1113 1114 argc = 0; 1115 1116 if (*desc->operands) 1117 { 1118 if (*lineptr++ != '\0') 1119 { 1120 sqr = '['; 1121 sep = ','; 1122 1123 while (*lineptr != '\0') 1124 { 1125 if (desc->operands[argc << 1]) 1126 { 1127 suffix[argc] = 0; 1128 arg_type = desc->operands[(argc << 1) + 1]; 1129 1130 switch (arg_type) 1131 { 1132 case 'd': 1133 case 'b': 1134 case 'p': 1135 case 'H': 1136 /* The operand is supposed to be a displacement. */ 1137 /* Hackwarning: do not forget to update the 4 1138 cases above when editing ns32k-opcode.h. */ 1139 suffix_separator = ':'; 1140 break; 1141 default: 1142 /* If this char occurs we loose. */ 1143 suffix_separator = '\255'; 1144 break; 1145 } 1146 1147 suffix[argc] = 0; /* 0 when no ':' is encountered. */ 1148 argv[argc] = freeptr; 1149 *freeptr = '\0'; 1150 1151 while ((c = *lineptr) != '\0' && c != sep) 1152 { 1153 if (c == sqr) 1154 { 1155 if (sqr == '[') 1156 { 1157 sqr = ']'; 1158 sep = '\0'; 1159 } 1160 else 1161 { 1162 sqr = '['; 1163 sep = ','; 1164 } 1165 } 1166 1167 if (c == suffix_separator) 1168 { 1169 /* ':' - label/suffix separator. */ 1170 switch (lineptr[1]) 1171 { 1172 case 'b': 1173 suffix[argc] = 1; 1174 break; 1175 case 'w': 1176 suffix[argc] = 2; 1177 break; 1178 case 'd': 1179 suffix[argc] = 4; 1180 break; 1181 default: 1182 as_warn (_("Bad suffix, defaulting to d")); 1183 suffix[argc] = 4; 1184 if (lineptr[1] == '\0' || lineptr[1] == sep) 1185 { 1186 lineptr += 1; 1187 continue; 1188 } 1189 break; 1190 } 1191 1192 lineptr += 2; 1193 continue; 1194 } 1195 1196 *freeptr++ = c; 1197 lineptr++; 1198 } 1199 1200 *freeptr++ = '\0'; 1201 argc += 1; 1202 1203 if (*lineptr == '\0') 1204 continue; 1205 1206 lineptr += 1; 1207 } 1208 else 1209 as_fatal (_("Too many operands passed to instruction")); 1210 } 1211 } 1212 } 1213 1214 if (argc != strlen (desc->operands) / 2) 1215 { 1216 if (strlen (desc->default_args)) 1217 { 1218 /* We can apply default, don't goof. */ 1219 if (parse (desc->default_args, 1) != 1) 1220 /* Check error in default. */ 1221 as_fatal (_("Wrong numbers of operands in default, check ns32k-opcodes.h")); 1222 } 1223 else 1224 as_fatal (_("Wrong number of operands")); 1225 } 1226 1227 for (i = 0; i < IIF_ENTRIES; i++) 1228 /* Mark all entries as void. */ 1229 iif.iifP[i].type = 0; 1230 1231 /* Build opcode iif-entry. */ 1232 iif.instr_size = desc->opcode_size / 8; 1233 IIF (1, 1, iif.instr_size, desc->opcode_seed, 0, 0, 0, 0, 0, 0, -1, 0); 1234 1235 /* This call encodes operands to iif format. */ 1236 if (argc) 1237 encode_operand (argc, argv, &desc->operands[0], 1238 &suffix[0], desc->im_size, desc->opcode_size); 1239 1240 return recursive_level; 1241 } 1242 1243 /* This functionality should really be in the bfd library. */ 1244 1245 static bfd_reloc_code_real_type 1246 reloc (int size, int pcrel, int type) 1247 { 1248 int length, rel_index; 1249 bfd_reloc_code_real_type relocs[] = 1250 { 1251 BFD_RELOC_NS32K_IMM_8, 1252 BFD_RELOC_NS32K_IMM_16, 1253 BFD_RELOC_NS32K_IMM_32, 1254 BFD_RELOC_NS32K_IMM_8_PCREL, 1255 BFD_RELOC_NS32K_IMM_16_PCREL, 1256 BFD_RELOC_NS32K_IMM_32_PCREL, 1257 1258 /* ns32k displacements. */ 1259 BFD_RELOC_NS32K_DISP_8, 1260 BFD_RELOC_NS32K_DISP_16, 1261 BFD_RELOC_NS32K_DISP_32, 1262 BFD_RELOC_NS32K_DISP_8_PCREL, 1263 BFD_RELOC_NS32K_DISP_16_PCREL, 1264 BFD_RELOC_NS32K_DISP_32_PCREL, 1265 1266 /* Normal 2's complement. */ 1267 BFD_RELOC_8, 1268 BFD_RELOC_16, 1269 BFD_RELOC_32, 1270 BFD_RELOC_8_PCREL, 1271 BFD_RELOC_16_PCREL, 1272 BFD_RELOC_32_PCREL 1273 }; 1274 1275 switch (size) 1276 { 1277 case 1: 1278 length = 0; 1279 break; 1280 case 2: 1281 length = 1; 1282 break; 1283 case 4: 1284 length = 2; 1285 break; 1286 default: 1287 length = -1; 1288 break; 1289 } 1290 1291 rel_index = length + 3 * pcrel + 6 * type; 1292 1293 if (rel_index >= 0 && (unsigned int) rel_index < sizeof (relocs) / sizeof (relocs[0])) 1294 return relocs[rel_index]; 1295 1296 if (pcrel) 1297 as_bad (_("Can not do %d byte pc-relative relocation for storage type %d"), 1298 size, type); 1299 else 1300 as_bad (_("Can not do %d byte relocation for storage type %d"), 1301 size, type); 1302 1303 return BFD_RELOC_NONE; 1304 1305 } 1306 1307 static void 1308 fix_new_ns32k (fragS *frag, /* Which frag? */ 1309 int where, /* Where in that frag? */ 1310 int size, /* 1, 2 or 4 usually. */ 1311 symbolS *add_symbol, /* X_add_symbol. */ 1312 long offset, /* X_add_number. */ 1313 int pcrel, /* True if PC-relative relocation. */ 1314 char im_disp, /* True if the value to write is a 1315 displacement. */ 1316 bit_fixS *bit_fixP, /* Pointer at struct of bit_fix's, ignored if 1317 NULL. */ 1318 char bsr, /* Sequent-linker-hack: 1 when relocobject is 1319 a bsr. */ 1320 fragS *opcode_frag, 1321 unsigned int opcode_offset) 1322 { 1323 fixS *fixP = fix_new (frag, where, size, add_symbol, 1324 offset, pcrel, 1325 bit_fixP ? NO_RELOC : reloc (size, pcrel, im_disp) 1326 ); 1327 1328 fix_opcode_frag (fixP) = opcode_frag; 1329 fix_opcode_offset (fixP) = opcode_offset; 1330 fix_im_disp (fixP) = im_disp; 1331 fix_bsr (fixP) = bsr; 1332 fix_bit_fixP (fixP) = bit_fixP; 1333 /* We have a MD overflow check for displacements. */ 1334 fixP->fx_no_overflow = (im_disp != 0); 1335 } 1336 1337 static void 1338 fix_new_ns32k_exp (fragS *frag, /* Which frag? */ 1339 int where, /* Where in that frag? */ 1340 int size, /* 1, 2 or 4 usually. */ 1341 expressionS *exp, /* Expression. */ 1342 int pcrel, /* True if PC-relative relocation. */ 1343 char im_disp, /* True if the value to write is a 1344 displacement. */ 1345 bit_fixS *bit_fixP, /* Pointer at struct of bit_fix's, ignored if 1346 NULL. */ 1347 char bsr, /* Sequent-linker-hack: 1 when relocobject is 1348 a bsr. */ 1349 fragS *opcode_frag, 1350 unsigned int opcode_offset) 1351 { 1352 fixS *fixP = fix_new_exp (frag, where, size, exp, pcrel, 1353 bit_fixP ? NO_RELOC : reloc (size, pcrel, im_disp) 1354 ); 1355 1356 fix_opcode_frag (fixP) = opcode_frag; 1357 fix_opcode_offset (fixP) = opcode_offset; 1358 fix_im_disp (fixP) = im_disp; 1359 fix_bsr (fixP) = bsr; 1360 fix_bit_fixP (fixP) = bit_fixP; 1361 /* We have a MD overflow check for displacements. */ 1362 fixP->fx_no_overflow = (im_disp != 0); 1363 } 1364 1365 /* Convert number to chars in correct order. */ 1366 1367 void 1368 md_number_to_chars (char *buf, valueT value, int nbytes) 1369 { 1370 number_to_chars_littleendian (buf, value, nbytes); 1371 } 1372 1373 /* This is a variant of md_numbers_to_chars. The reason for its 1374 existence is the fact that ns32k uses Huffman coded 1375 displacements. This implies that the bit order is reversed in 1376 displacements and that they are prefixed with a size-tag. 1377 1378 binary: msb -> lsb 1379 0xxxxxxx byte 1380 10xxxxxx xxxxxxxx word 1381 11xxxxxx xxxxxxxx xxxxxxxx xxxxxxxx double word 1382 1383 This must be taken care of and we do it here! */ 1384 1385 static void 1386 md_number_to_disp (char *buf, long val, int n) 1387 { 1388 switch (n) 1389 { 1390 case 1: 1391 if (val < -64 || val > 63) 1392 as_bad (_("value of %ld out of byte displacement range."), val); 1393 val &= 0x7f; 1394 #ifdef SHOW_NUM 1395 printf ("%x ", val & 0xff); 1396 #endif 1397 *buf++ = val; 1398 break; 1399 1400 case 2: 1401 if (val < -8192 || val > 8191) 1402 as_bad (_("value of %ld out of word displacement range."), val); 1403 val &= 0x3fff; 1404 val |= 0x8000; 1405 #ifdef SHOW_NUM 1406 printf ("%x ", val >> 8 & 0xff); 1407 #endif 1408 *buf++ = (val >> 8); 1409 #ifdef SHOW_NUM 1410 printf ("%x ", val & 0xff); 1411 #endif 1412 *buf++ = val; 1413 break; 1414 1415 case 4: 1416 if (val < -0x20000000 || val >= 0x20000000) 1417 as_bad (_("value of %ld out of double word displacement range."), val); 1418 val |= 0xc0000000; 1419 #ifdef SHOW_NUM 1420 printf ("%x ", val >> 24 & 0xff); 1421 #endif 1422 *buf++ = (val >> 24); 1423 #ifdef SHOW_NUM 1424 printf ("%x ", val >> 16 & 0xff); 1425 #endif 1426 *buf++ = (val >> 16); 1427 #ifdef SHOW_NUM 1428 printf ("%x ", val >> 8 & 0xff); 1429 #endif 1430 *buf++ = (val >> 8); 1431 #ifdef SHOW_NUM 1432 printf ("%x ", val & 0xff); 1433 #endif 1434 *buf++ = val; 1435 break; 1436 1437 default: 1438 as_fatal (_("Internal logic error. Line %d, file: \"%s\""), 1439 __LINE__, __FILE__); 1440 } 1441 } 1442 1443 static void 1444 md_number_to_imm (char *buf, long val, int n) 1445 { 1446 switch (n) 1447 { 1448 case 1: 1449 #ifdef SHOW_NUM 1450 printf ("%x ", val & 0xff); 1451 #endif 1452 *buf++ = val; 1453 break; 1454 1455 case 2: 1456 #ifdef SHOW_NUM 1457 printf ("%x ", val >> 8 & 0xff); 1458 #endif 1459 *buf++ = (val >> 8); 1460 #ifdef SHOW_NUM 1461 printf ("%x ", val & 0xff); 1462 #endif 1463 *buf++ = val; 1464 break; 1465 1466 case 4: 1467 #ifdef SHOW_NUM 1468 printf ("%x ", val >> 24 & 0xff); 1469 #endif 1470 *buf++ = (val >> 24); 1471 #ifdef SHOW_NUM 1472 printf ("%x ", val >> 16 & 0xff); 1473 #endif 1474 *buf++ = (val >> 16); 1475 #ifdef SHOW_NUM 1476 printf ("%x ", val >> 8 & 0xff); 1477 #endif 1478 *buf++ = (val >> 8); 1479 #ifdef SHOW_NUM 1480 printf ("%x ", val & 0xff); 1481 #endif 1482 *buf++ = val; 1483 break; 1484 1485 default: 1486 as_fatal (_("Internal logic error. line %d, file \"%s\""), 1487 __LINE__, __FILE__); 1488 } 1489 } 1490 1491 /* Fast bitfiddling support. */ 1492 /* Mask used to zero bitfield before oring in the true field. */ 1493 1494 static unsigned long l_mask[] = 1495 { 1496 0xffffffff, 0xfffffffe, 0xfffffffc, 0xfffffff8, 1497 0xfffffff0, 0xffffffe0, 0xffffffc0, 0xffffff80, 1498 0xffffff00, 0xfffffe00, 0xfffffc00, 0xfffff800, 1499 0xfffff000, 0xffffe000, 0xffffc000, 0xffff8000, 1500 0xffff0000, 0xfffe0000, 0xfffc0000, 0xfff80000, 1501 0xfff00000, 0xffe00000, 0xffc00000, 0xff800000, 1502 0xff000000, 0xfe000000, 0xfc000000, 0xf8000000, 1503 0xf0000000, 0xe0000000, 0xc0000000, 0x80000000, 1504 }; 1505 static unsigned long r_mask[] = 1506 { 1507 0x00000000, 0x00000001, 0x00000003, 0x00000007, 1508 0x0000000f, 0x0000001f, 0x0000003f, 0x0000007f, 1509 0x000000ff, 0x000001ff, 0x000003ff, 0x000007ff, 1510 0x00000fff, 0x00001fff, 0x00003fff, 0x00007fff, 1511 0x0000ffff, 0x0001ffff, 0x0003ffff, 0x0007ffff, 1512 0x000fffff, 0x001fffff, 0x003fffff, 0x007fffff, 1513 0x00ffffff, 0x01ffffff, 0x03ffffff, 0x07ffffff, 1514 0x0fffffff, 0x1fffffff, 0x3fffffff, 0x7fffffff, 1515 }; 1516 #define MASK_BITS 31 1517 /* Insert bitfield described by field_ptr and val at buf 1518 This routine is written for modification of the first 4 bytes pointed 1519 to by buf, to yield speed. 1520 The ifdef stuff is for selection between a ns32k-dependent routine 1521 and a general version. (My advice: use the general version!). */ 1522 1523 static void 1524 md_number_to_field (char *buf, long val, bit_fixS *field_ptr) 1525 { 1526 unsigned long object; 1527 unsigned long mask; 1528 /* Define ENDIAN on a ns32k machine. */ 1529 #ifdef ENDIAN 1530 unsigned long *mem_ptr; 1531 #else 1532 char *mem_ptr; 1533 #endif 1534 1535 if (field_ptr->fx_bit_min <= val && val <= field_ptr->fx_bit_max) 1536 { 1537 #ifdef ENDIAN 1538 if (field_ptr->fx_bit_base) 1539 /* Override buf. */ 1540 mem_ptr = (unsigned long *) field_ptr->fx_bit_base; 1541 else 1542 mem_ptr = (unsigned long *) buf; 1543 1544 mem_ptr = ((unsigned long *) 1545 ((char *) mem_ptr + field_ptr->fx_bit_base_adj)); 1546 #else 1547 if (field_ptr->fx_bit_base) 1548 mem_ptr = (char *) field_ptr->fx_bit_base; 1549 else 1550 mem_ptr = buf; 1551 1552 mem_ptr += field_ptr->fx_bit_base_adj; 1553 #endif 1554 #ifdef ENDIAN 1555 /* We have a nice ns32k machine with lowbyte at low-physical mem. */ 1556 object = *mem_ptr; /* get some bytes */ 1557 #else /* OVE Goof! the machine is a m68k or dito. */ 1558 /* That takes more byte fiddling. */ 1559 object = 0; 1560 object |= mem_ptr[3] & 0xff; 1561 object <<= 8; 1562 object |= mem_ptr[2] & 0xff; 1563 object <<= 8; 1564 object |= mem_ptr[1] & 0xff; 1565 object <<= 8; 1566 object |= mem_ptr[0] & 0xff; 1567 #endif 1568 mask = 0; 1569 mask |= (r_mask[field_ptr->fx_bit_offset]); 1570 mask |= (l_mask[field_ptr->fx_bit_offset + field_ptr->fx_bit_size]); 1571 object &= mask; 1572 val += field_ptr->fx_bit_add; 1573 object |= ((val << field_ptr->fx_bit_offset) & (mask ^ 0xffffffff)); 1574 #ifdef ENDIAN 1575 *mem_ptr = object; 1576 #else 1577 mem_ptr[0] = (char) object; 1578 object >>= 8; 1579 mem_ptr[1] = (char) object; 1580 object >>= 8; 1581 mem_ptr[2] = (char) object; 1582 object >>= 8; 1583 mem_ptr[3] = (char) object; 1584 #endif 1585 } 1586 else 1587 as_bad (_("Bit field out of range")); 1588 } 1589 1590 /* Convert iif to fragments. From this point we start to dribble with 1591 functions in other files than this one.(Except hash.c) So, if it's 1592 possible to make an iif for an other CPU, you don't need to know 1593 what frags, relax, obstacks, etc is in order to port this 1594 assembler. You only need to know if it's possible to reduce your 1595 cpu-instruction to iif-format (takes some work) and adopt the other 1596 md_? parts according to given instructions Note that iif was 1597 invented for the clean ns32k`s architecture. */ 1598 1599 /* GAS for the ns32k has a problem. PC relative displacements are 1600 relative to the address of the opcode, not the address of the 1601 operand. We used to keep track of the offset between the operand 1602 and the opcode in pcrel_adjust for each frag and each fix. However, 1603 we get into trouble where there are two or more pc-relative 1604 operands and the size of the first one can't be determined. Then in 1605 the relax phase, the size of the first operand will change and 1606 pcrel_adjust will no longer be correct. The current solution is 1607 keep a pointer to the frag with the opcode in it and the offset in 1608 that frag for each frag and each fix. Then, when needed, we can 1609 always figure out how far it is between the opcode and the pcrel 1610 object. See also md_pcrel_adjust and md_fix_pcrel_adjust. For 1611 objects not part of an instruction, the pointer to the opcode frag 1612 is always zero. */ 1613 1614 static void 1615 convert_iif (void) 1616 { 1617 int i; 1618 bit_fixS *j; 1619 fragS *inst_frag; 1620 unsigned int inst_offset; 1621 char *inst_opcode; 1622 char *memP; 1623 int l; 1624 int k; 1625 char type; 1626 char size = 0; 1627 1628 frag_grow (iif.instr_size); /* This is important. */ 1629 memP = frag_more (0); 1630 inst_opcode = memP; 1631 inst_offset = (memP - frag_now->fr_literal); 1632 inst_frag = frag_now; 1633 1634 for (i = 0; i < IIF_ENTRIES; i++) 1635 { 1636 if ((type = iif.iifP[i].type)) 1637 { 1638 /* The object exist, so handle it. */ 1639 switch (size = iif.iifP[i].size) 1640 { 1641 case 42: 1642 size = 0; 1643 /* It's a bitfix that operates on an existing object. */ 1644 if (iif.iifP[i].bit_fixP->fx_bit_base) 1645 /* Expand fx_bit_base to point at opcode. */ 1646 iif.iifP[i].bit_fixP->fx_bit_base = (long) inst_opcode; 1647 /* Fall through. */ 1648 1649 case 8: /* bignum or doublefloat. */ 1650 case 1: 1651 case 2: 1652 case 3: 1653 case 4: 1654 /* The final size in objectmemory is known. */ 1655 memP = frag_more (size); 1656 j = iif.iifP[i].bit_fixP; 1657 1658 switch (type) 1659 { 1660 case 1: /* The object is pure binary. */ 1661 if (j) 1662 md_number_to_field (memP, exprP.X_add_number, j); 1663 1664 else if (iif.iifP[i].pcrel) 1665 fix_new_ns32k (frag_now, 1666 (long) (memP - frag_now->fr_literal), 1667 size, 1668 0, 1669 iif.iifP[i].object, 1670 iif.iifP[i].pcrel, 1671 iif.iifP[i].im_disp, 1672 0, 1673 iif.iifP[i].bsr, /* Sequent hack. */ 1674 inst_frag, inst_offset); 1675 else 1676 { 1677 /* Good, just put them bytes out. */ 1678 switch (iif.iifP[i].im_disp) 1679 { 1680 case 0: 1681 md_number_to_chars (memP, iif.iifP[i].object, size); 1682 break; 1683 case 1: 1684 md_number_to_disp (memP, iif.iifP[i].object, size); 1685 break; 1686 default: 1687 as_fatal (_("iif convert internal pcrel/binary")); 1688 } 1689 } 1690 break; 1691 1692 case 2: 1693 /* The object is a pointer at an expression, so 1694 unpack it, note that bignums may result from the 1695 expression. */ 1696 evaluate_expr (&exprP, (char *) iif.iifP[i].object); 1697 if (exprP.X_op == O_big || size == 8) 1698 { 1699 if ((k = exprP.X_add_number) > 0) 1700 { 1701 /* We have a bignum ie a quad. This can only 1702 happens in a long suffixed instruction. */ 1703 if (k * 2 > size) 1704 as_bad (_("Bignum too big for long")); 1705 1706 if (k == 3) 1707 memP += 2; 1708 1709 for (l = 0; k > 0; k--, l += 2) 1710 md_number_to_chars (memP + l, 1711 generic_bignum[l >> 1], 1712 sizeof (LITTLENUM_TYPE)); 1713 } 1714 else 1715 { 1716 /* flonum. */ 1717 LITTLENUM_TYPE words[4]; 1718 1719 switch (size) 1720 { 1721 case 4: 1722 gen_to_words (words, 2, 8); 1723 md_number_to_imm (memP, (long) words[0], 1724 sizeof (LITTLENUM_TYPE)); 1725 md_number_to_imm (memP + sizeof (LITTLENUM_TYPE), 1726 (long) words[1], 1727 sizeof (LITTLENUM_TYPE)); 1728 break; 1729 case 8: 1730 gen_to_words (words, 4, 11); 1731 md_number_to_imm (memP, (long) words[0], 1732 sizeof (LITTLENUM_TYPE)); 1733 md_number_to_imm (memP + sizeof (LITTLENUM_TYPE), 1734 (long) words[1], 1735 sizeof (LITTLENUM_TYPE)); 1736 md_number_to_imm ((memP + 2 1737 * sizeof (LITTLENUM_TYPE)), 1738 (long) words[2], 1739 sizeof (LITTLENUM_TYPE)); 1740 md_number_to_imm ((memP + 3 1741 * sizeof (LITTLENUM_TYPE)), 1742 (long) words[3], 1743 sizeof (LITTLENUM_TYPE)); 1744 break; 1745 } 1746 } 1747 break; 1748 } 1749 if (exprP.X_add_symbol || 1750 exprP.X_op_symbol || 1751 iif.iifP[i].pcrel) 1752 { 1753 /* The expression was undefined due to an 1754 undefined label. Create a fix so we can fix 1755 the object later. */ 1756 exprP.X_add_number += iif.iifP[i].object_adjust; 1757 fix_new_ns32k_exp (frag_now, 1758 (long) (memP - frag_now->fr_literal), 1759 size, 1760 &exprP, 1761 iif.iifP[i].pcrel, 1762 iif.iifP[i].im_disp, 1763 j, 1764 iif.iifP[i].bsr, 1765 inst_frag, inst_offset); 1766 } 1767 else if (j) 1768 md_number_to_field (memP, exprP.X_add_number, j); 1769 else 1770 { 1771 /* Good, just put them bytes out. */ 1772 switch (iif.iifP[i].im_disp) 1773 { 1774 case 0: 1775 md_number_to_imm (memP, exprP.X_add_number, size); 1776 break; 1777 case 1: 1778 md_number_to_disp (memP, exprP.X_add_number, size); 1779 break; 1780 default: 1781 as_fatal (_("iif convert internal pcrel/pointer")); 1782 } 1783 } 1784 break; 1785 default: 1786 as_fatal (_("Internal logic error in iif.iifP[n].type")); 1787 } 1788 break; 1789 1790 case 0: 1791 /* Too bad, the object may be undefined as far as its 1792 final nsize in object memory is concerned. The size 1793 of the object in objectmemory is not explicitly 1794 given. If the object is defined its length can be 1795 determined and a fix can replace the frag. */ 1796 { 1797 evaluate_expr (&exprP, (char *) iif.iifP[i].object); 1798 1799 if ((exprP.X_add_symbol || exprP.X_op_symbol) && 1800 !iif.iifP[i].pcrel) 1801 { 1802 /* Size is unknown until link time so have to default. */ 1803 size = default_disp_size; /* Normally 4 bytes. */ 1804 memP = frag_more (size); 1805 fix_new_ns32k_exp (frag_now, 1806 (long) (memP - frag_now->fr_literal), 1807 size, 1808 &exprP, 1809 0, /* never iif.iifP[i].pcrel, */ 1810 1, /* always iif.iifP[i].im_disp */ 1811 (bit_fixS *) 0, 0, 1812 inst_frag, 1813 inst_offset); 1814 break; /* Exit this absolute hack. */ 1815 } 1816 1817 if (exprP.X_add_symbol || exprP.X_op_symbol) 1818 { 1819 /* Frag it. */ 1820 if (exprP.X_op_symbol) 1821 /* We can't relax this case. */ 1822 as_fatal (_("Can't relax difference")); 1823 else 1824 { 1825 /* Size is not important. This gets fixed by 1826 relax, but we assume 0 in what follows. */ 1827 memP = frag_more (4); /* Max size. */ 1828 size = 0; 1829 1830 { 1831 fragS *old_frag = frag_now; 1832 frag_variant (rs_machine_dependent, 1833 4, /* Max size. */ 1834 0, /* Size. */ 1835 IND (BRANCH, UNDEF), /* Expecting 1836 the worst. */ 1837 exprP.X_add_symbol, 1838 exprP.X_add_number, 1839 inst_opcode); 1840 frag_opcode_frag (old_frag) = inst_frag; 1841 frag_opcode_offset (old_frag) = inst_offset; 1842 frag_bsr (old_frag) = iif.iifP[i].bsr; 1843 } 1844 } 1845 } 1846 else 1847 { 1848 /* This duplicates code in md_number_to_disp. */ 1849 if (-64 <= exprP.X_add_number && exprP.X_add_number <= 63) 1850 size = 1; 1851 else 1852 { 1853 if (-8192 <= exprP.X_add_number 1854 && exprP.X_add_number <= 8191) 1855 size = 2; 1856 else 1857 { 1858 if (-0x20000000 <= exprP.X_add_number 1859 && exprP.X_add_number<=0x1fffffff) 1860 size = 4; 1861 else 1862 { 1863 as_bad (_("Displacement too large for :d")); 1864 size = 4; 1865 } 1866 } 1867 } 1868 1869 memP = frag_more (size); 1870 md_number_to_disp (memP, exprP.X_add_number, size); 1871 } 1872 } 1873 break; 1874 1875 default: 1876 as_fatal (_("Internal logic error in iif.iifP[].type")); 1877 } 1878 } 1879 } 1880 } 1881 1882 void 1883 md_assemble (char *line) 1884 { 1885 freeptr = freeptr_static; 1886 parse (line, 0); /* Explode line to more fix form in iif. */ 1887 convert_iif (); /* Convert iif to frags, fix's etc. */ 1888 #ifdef SHOW_NUM 1889 printf (" \t\t\t%s\n", line); 1890 #endif 1891 } 1892 1893 void 1894 md_begin (void) 1895 { 1896 /* Build a hashtable of the instructions. */ 1897 const struct ns32k_opcode *ptr; 1898 const char *status; 1899 const struct ns32k_opcode *endop; 1900 1901 inst_hash_handle = hash_new (); 1902 1903 endop = ns32k_opcodes + sizeof (ns32k_opcodes) / sizeof (ns32k_opcodes[0]); 1904 for (ptr = ns32k_opcodes; ptr < endop; ptr++) 1905 { 1906 if ((status = hash_insert (inst_hash_handle, ptr->name, (char *) ptr))) 1907 /* Fatal. */ 1908 as_fatal (_("Can't hash %s: %s"), ptr->name, status); 1909 } 1910 1911 /* Some private space please! */ 1912 freeptr_static = XNEWVEC (char, PRIVATE_SIZE); 1913 } 1914 1915 /* Turn the string pointed to by litP into a floating point constant 1916 of type TYPE, and emit the appropriate bytes. The number of 1917 LITTLENUMS emitted is stored in *SIZEP. An error message is 1918 returned, or NULL on OK. */ 1919 1920 const char * 1921 md_atof (int type, char *litP, int *sizeP) 1922 { 1923 return ieee_md_atof (type, litP, sizeP, FALSE); 1924 } 1925 1926 int 1927 md_pcrel_adjust (fragS *fragP) 1928 { 1929 fragS *opcode_frag; 1930 addressT opcode_address; 1931 unsigned int offset; 1932 1933 opcode_frag = frag_opcode_frag (fragP); 1934 if (opcode_frag == 0) 1935 return 0; 1936 1937 offset = frag_opcode_offset (fragP); 1938 opcode_address = offset + opcode_frag->fr_address; 1939 1940 return fragP->fr_address + fragP->fr_fix - opcode_address; 1941 } 1942 1943 static int 1944 md_fix_pcrel_adjust (fixS *fixP) 1945 { 1946 fragS *opcode_frag; 1947 addressT opcode_address; 1948 unsigned int offset; 1949 1950 opcode_frag = fix_opcode_frag (fixP); 1951 if (opcode_frag == 0) 1952 return 0; 1953 1954 offset = fix_opcode_offset (fixP); 1955 opcode_address = offset + opcode_frag->fr_address; 1956 1957 return fixP->fx_where + fixP->fx_frag->fr_address - opcode_address; 1958 } 1959 1960 /* Apply a fixS (fixup of an instruction or data that we didn't have 1961 enough info to complete immediately) to the data in a frag. 1962 1963 On the ns32k, everything is in a different format, so we have broken 1964 out separate functions for each kind of thing we could be fixing. 1965 They all get called from here. */ 1966 1967 void 1968 md_apply_fix (fixS *fixP, valueT * valP, segT seg ATTRIBUTE_UNUSED) 1969 { 1970 long val = * (long *) valP; 1971 char *buf = fixP->fx_where + fixP->fx_frag->fr_literal; 1972 1973 if (fix_bit_fixP (fixP)) 1974 /* Bitfields to fix, sigh. */ 1975 md_number_to_field (buf, val, fix_bit_fixP (fixP)); 1976 else switch (fix_im_disp (fixP)) 1977 { 1978 case 0: 1979 /* Immediate field. */ 1980 md_number_to_imm (buf, val, fixP->fx_size); 1981 break; 1982 1983 case 1: 1984 /* Displacement field. */ 1985 /* Calculate offset. */ 1986 md_number_to_disp (buf, 1987 (fixP->fx_pcrel ? val + md_fix_pcrel_adjust (fixP) 1988 : val), fixP->fx_size); 1989 break; 1990 1991 case 2: 1992 /* Pointer in a data object. */ 1993 md_number_to_chars (buf, val, fixP->fx_size); 1994 break; 1995 } 1996 1997 if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0) 1998 fixP->fx_done = 1; 1999 } 2000 2001 /* Convert a relaxed displacement to ditto in final output. */ 2002 2003 void 2004 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED, 2005 segT sec ATTRIBUTE_UNUSED, 2006 fragS *fragP) 2007 { 2008 long disp; 2009 long ext = 0; 2010 /* Address in gas core of the place to store the displacement. */ 2011 char *buffer_address = fragP->fr_fix + fragP->fr_literal; 2012 /* Address in object code of the displacement. */ 2013 int object_address; 2014 2015 switch (fragP->fr_subtype) 2016 { 2017 case IND (BRANCH, BYTE): 2018 ext = 1; 2019 break; 2020 case IND (BRANCH, WORD): 2021 ext = 2; 2022 break; 2023 case IND (BRANCH, DOUBLE): 2024 ext = 4; 2025 break; 2026 } 2027 2028 if (ext == 0) 2029 return; 2030 2031 know (fragP->fr_symbol); 2032 2033 object_address = fragP->fr_fix + fragP->fr_address; 2034 2035 /* The displacement of the address, from current location. */ 2036 disp = (S_GET_VALUE (fragP->fr_symbol) + fragP->fr_offset) - object_address; 2037 disp += md_pcrel_adjust (fragP); 2038 2039 md_number_to_disp (buffer_address, (long) disp, (int) ext); 2040 fragP->fr_fix += ext; 2041 } 2042 2043 /* This function returns the estimated size a variable object will occupy, 2044 one can say that we tries to guess the size of the objects before we 2045 actually know it. */ 2046 2047 int 2048 md_estimate_size_before_relax (fragS *fragP, segT segment) 2049 { 2050 if (fragP->fr_subtype == IND (BRANCH, UNDEF)) 2051 { 2052 if (S_GET_SEGMENT (fragP->fr_symbol) != segment) 2053 { 2054 /* We don't relax symbols defined in another segment. The 2055 thing to do is to assume the object will occupy 4 bytes. */ 2056 fix_new_ns32k (fragP, 2057 (int) (fragP->fr_fix), 2058 4, 2059 fragP->fr_symbol, 2060 fragP->fr_offset, 2061 1, 2062 1, 2063 0, 2064 frag_bsr(fragP), /* Sequent hack. */ 2065 frag_opcode_frag (fragP), 2066 frag_opcode_offset (fragP)); 2067 fragP->fr_fix += 4; 2068 frag_wane (fragP); 2069 return 4; 2070 } 2071 2072 /* Relaxable case. Set up the initial guess for the variable 2073 part of the frag. */ 2074 fragP->fr_subtype = IND (BRANCH, BYTE); 2075 } 2076 2077 if (fragP->fr_subtype >= sizeof (md_relax_table) / sizeof (md_relax_table[0])) 2078 abort (); 2079 2080 /* Return the size of the variable part of the frag. */ 2081 return md_relax_table[fragP->fr_subtype].rlx_length; 2082 } 2083 2084 int md_short_jump_size = 3; 2085 int md_long_jump_size = 5; 2086 2087 void 2088 md_create_short_jump (char *ptr, 2089 addressT from_addr, 2090 addressT to_addr, 2091 fragS *frag ATTRIBUTE_UNUSED, 2092 symbolS *to_symbol ATTRIBUTE_UNUSED) 2093 { 2094 valueT offset; 2095 2096 offset = to_addr - from_addr; 2097 md_number_to_chars (ptr, (valueT) 0xEA, 1); 2098 md_number_to_disp (ptr + 1, (valueT) offset, 2); 2099 } 2100 2101 void 2102 md_create_long_jump (char *ptr, 2103 addressT from_addr, 2104 addressT to_addr, 2105 fragS *frag ATTRIBUTE_UNUSED, 2106 symbolS *to_symbol ATTRIBUTE_UNUSED) 2107 { 2108 valueT offset; 2109 2110 offset = to_addr - from_addr; 2111 md_number_to_chars (ptr, (valueT) 0xEA, 1); 2112 md_number_to_disp (ptr + 1, (valueT) offset, 4); 2113 } 2114 2115 const char *md_shortopts = "m:"; 2116 2117 struct option md_longopts[] = 2118 { 2119 #define OPTION_DISP_SIZE (OPTION_MD_BASE) 2120 {"disp-size-default", required_argument , NULL, OPTION_DISP_SIZE}, 2121 {NULL, no_argument, NULL, 0} 2122 }; 2123 2124 size_t md_longopts_size = sizeof (md_longopts); 2125 2126 int 2127 md_parse_option (int c, const char *arg) 2128 { 2129 switch (c) 2130 { 2131 case 'm': 2132 if (!strcmp (arg, "32032")) 2133 { 2134 cpureg = cpureg_032; 2135 mmureg = mmureg_032; 2136 } 2137 else if (!strcmp (arg, "32532")) 2138 { 2139 cpureg = cpureg_532; 2140 mmureg = mmureg_532; 2141 } 2142 else 2143 { 2144 as_warn (_("invalid architecture option -m%s, ignored"), arg); 2145 return 0; 2146 } 2147 break; 2148 case OPTION_DISP_SIZE: 2149 { 2150 int size = atoi(arg); 2151 switch (size) 2152 { 2153 case 1: case 2: case 4: 2154 default_disp_size = size; 2155 break; 2156 default: 2157 as_warn (_("invalid default displacement size \"%s\". Defaulting to %d."), 2158 arg, default_disp_size); 2159 } 2160 break; 2161 } 2162 2163 default: 2164 return 0; 2165 } 2166 2167 return 1; 2168 } 2169 2170 void 2171 md_show_usage (FILE *stream) 2172 { 2173 fprintf (stream, _("\ 2174 NS32K options:\n\ 2175 -m32032 | -m32532 select variant of NS32K architecture\n\ 2176 --disp-size-default=<1|2|4>\n")); 2177 } 2178 2179 /* This is TC_CONS_FIX_NEW, called by emit_expr in read.c. */ 2180 2181 void 2182 cons_fix_new_ns32k (fragS *frag, /* Which frag? */ 2183 int where, /* Where in that frag? */ 2184 int size, /* 1, 2 or 4 usually. */ 2185 expressionS *exp, /* Expression. */ 2186 bfd_reloc_code_real_type r ATTRIBUTE_UNUSED) 2187 { 2188 fix_new_ns32k_exp (frag, where, size, exp, 2189 0, 2, 0, 0, 0, 0); 2190 } 2191 2192 /* We have no need to default values of symbols. */ 2193 2194 symbolS * 2195 md_undefined_symbol (char *name ATTRIBUTE_UNUSED) 2196 { 2197 return 0; 2198 } 2199 2200 /* Round up a section size to the appropriate boundary. */ 2201 2202 valueT 2203 md_section_align (segT segment ATTRIBUTE_UNUSED, valueT size) 2204 { 2205 return size; /* Byte alignment is fine. */ 2206 } 2207 2208 /* Exactly what point is a PC-relative offset relative TO? On the 2209 ns32k, they're relative to the start of the instruction. */ 2210 2211 long 2212 md_pcrel_from (fixS *fixP) 2213 { 2214 long res; 2215 2216 res = fixP->fx_where + fixP->fx_frag->fr_address; 2217 #ifdef SEQUENT_COMPATABILITY 2218 if (frag_bsr (fixP->fx_frag)) 2219 res += 0x12 /* FOO Kludge alert! */ 2220 #endif 2221 return res; 2222 } 2223 2224 arelent * 2225 tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp) 2226 { 2227 arelent *rel; 2228 bfd_reloc_code_real_type code; 2229 2230 code = reloc (fixp->fx_size, fixp->fx_pcrel, fix_im_disp (fixp)); 2231 2232 rel = XNEW (arelent); 2233 rel->sym_ptr_ptr = XNEW (asymbol *); 2234 *rel->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy); 2235 rel->address = fixp->fx_frag->fr_address + fixp->fx_where; 2236 if (fixp->fx_pcrel) 2237 rel->addend = fixp->fx_addnumber; 2238 else 2239 rel->addend = 0; 2240 2241 rel->howto = bfd_reloc_type_lookup (stdoutput, code); 2242 if (!rel->howto) 2243 { 2244 const char *name; 2245 2246 name = S_GET_NAME (fixp->fx_addsy); 2247 if (name == NULL) 2248 name = _("<unknown>"); 2249 as_fatal (_("Cannot find relocation type for symbol %s, code %d"), 2250 name, (int) code); 2251 } 2252 2253 return rel; 2254 } 2255