1 /* tc-i370.c -- Assembler for the IBM 360/370/390 instruction set. 2 Loosely based on the ppc files by Linas Vepstas <linas (at) linas.org> 1998, 99 3 Copyright (C) 1994-2014 Free Software Foundation, Inc. 4 Written by Ian Lance Taylor, Cygnus Support. 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 3, 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, 51 Franklin Street - Fifth Floor, Boston, MA 21 02110-1301, USA. */ 22 23 /* This assembler implements a very hacked version of an elf-like thing 24 that gcc emits (when gcc is suitably hacked). To make it behave more 25 HLASM-like, try turning on the -M or --mri flag (as there are various 26 similarities between HLASM and the MRI assemblers, such as section 27 names, lack of leading . in pseudo-ops, DC and DS, etc. */ 28 29 #include "as.h" 30 #include "safe-ctype.h" 31 #include "subsegs.h" 32 #include "struc-symbol.h" 33 34 #include "opcode/i370.h" 35 36 #ifdef OBJ_ELF 37 #include "elf/i370.h" 38 #endif 39 40 /* This is the assembler for the System/390 Architecture. */ 41 42 /* Tell the main code what the endianness is. */ 43 extern int target_big_endian; 44 45 46 /* Generic assembler global variables which must be defined by all 48 targets. */ 49 50 #ifdef OBJ_ELF 51 /* This string holds the chars that always start a comment. If the 52 pre-processor is disabled, these aren't very useful. The macro 53 tc_comment_chars points to this. We use this, rather than the 54 usual comment_chars, so that we can switch for Solaris conventions. */ 55 static const char i370_eabi_comment_chars[] = "#"; 56 57 const char *i370_comment_chars = i370_eabi_comment_chars; 58 #else 59 const char comment_chars[] = "#"; 60 #endif 61 62 /* Characters which start a comment at the beginning of a line. */ 63 const char line_comment_chars[] = "#*"; 64 65 /* Characters which may be used to separate multiple commands on a 66 single line. */ 67 const char line_separator_chars[] = ";"; 68 69 /* Characters which are used to indicate an exponent in a floating 70 point number. */ 71 const char EXP_CHARS[] = "eE"; 72 73 /* Characters which mean that a number is a floating point constant, 74 as in 0d1.0. */ 75 const char FLT_CHARS[] = "dD"; 76 77 void 78 md_show_usage (FILE *stream) 79 { 80 fprintf (stream, "\ 81 S/370 options: (these have not yet been tested and may not work) \n\ 82 -u ignored\n\ 83 -mregnames Allow symbolic names for registers\n\ 84 -mno-regnames Do not allow symbolic names for registers\n"); 85 #ifdef OBJ_ELF 86 fprintf (stream, "\ 87 -mrelocatable support for GCC's -mrelocatble option\n\ 88 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\ 89 -V print assembler version number\n"); 90 #endif 91 } 92 93 /* Whether to use user friendly register names. */ 94 #define TARGET_REG_NAMES_P TRUE 95 96 static bfd_boolean reg_names_p = TARGET_REG_NAMES_P; 97 98 99 /* Predefined register names if -mregnames 101 In general, there are lots of them, in an attempt to be compatible 102 with a number of assemblers. */ 103 104 /* Structure to hold information about predefined registers. */ 105 struct pd_reg 106 { 107 char *name; 108 int value; 109 }; 110 111 /* List of registers that are pre-defined: 112 113 Each general register has predefined names of the form: 114 1. r<reg_num> which has the value <reg_num>. 115 2. r.<reg_num> which has the value <reg_num>. 116 117 Each floating point register has predefined names of the form: 118 1. f<reg_num> which has the value <reg_num>. 119 2. f.<reg_num> which has the value <reg_num>. 120 121 There are only four floating point registers, and these are 122 commonly labelled 0,2,4 and 6. Thus, there is no f1, f3, etc. 123 124 There are individual registers as well: 125 rbase or r.base has the value 3 (base register) 126 rpgt or r.pgt has the value 4 (page origin table pointer) 127 rarg or r.arg has the value 11 (argument pointer) 128 rtca or r.tca has the value 12 (table of contents pointer) 129 rtoc or r.toc has the value 12 (table of contents pointer) 130 sp or r.sp has the value 13 (stack pointer) 131 dsa or r.dsa has the value 13 (stack pointer) 132 lr has the value 14 (link reg) 133 134 The table is sorted. Suitable for searching by a binary search. */ 135 136 static const struct pd_reg pre_defined_registers[] = 137 { 138 { "arg", 11 }, /* Argument Pointer. */ 139 { "base", 3 }, /* Base Reg. */ 140 141 { "f.0", 0 }, /* Floating point registers. */ 142 { "f.2", 2 }, 143 { "f.4", 4 }, 144 { "f.6", 6 }, 145 146 { "f0", 0 }, 147 { "f2", 2 }, 148 { "f4", 4 }, 149 { "f6", 6 }, 150 151 { "dsa",13 }, /* Stack pointer. */ 152 { "lr", 14 }, /* Link Register. */ 153 { "pgt", 4 }, /* Page Origin Table Pointer. */ 154 155 { "r.0", 0 }, /* General Purpose Registers. */ 156 { "r.1", 1 }, 157 { "r.10", 10 }, 158 { "r.11", 11 }, 159 { "r.12", 12 }, 160 { "r.13", 13 }, 161 { "r.14", 14 }, 162 { "r.15", 15 }, 163 { "r.2", 2 }, 164 { "r.3", 3 }, 165 { "r.4", 4 }, 166 { "r.5", 5 }, 167 { "r.6", 6 }, 168 { "r.7", 7 }, 169 { "r.8", 8 }, 170 { "r.9", 9 }, 171 172 { "r.arg", 11 }, /* Argument Pointer. */ 173 { "r.base", 3 }, /* Base Reg. */ 174 { "r.dsa", 13 }, /* Stack Pointer. */ 175 { "r.pgt", 4 }, /* Page Origin Table Pointer. */ 176 { "r.sp", 13 }, /* Stack Pointer. */ 177 178 { "r.tca", 12 }, /* Pointer to the table of contents. */ 179 { "r.toc", 12 }, /* Pointer to the table of contents. */ 180 181 { "r0", 0 }, /* More general purpose registers. */ 182 { "r1", 1 }, 183 { "r10", 10 }, 184 { "r11", 11 }, 185 { "r12", 12 }, 186 { "r13", 13 }, 187 { "r14", 14 }, 188 { "r15", 15 }, 189 { "r2", 2 }, 190 { "r3", 3 }, 191 { "r4", 4 }, 192 { "r5", 5 }, 193 { "r6", 6 }, 194 { "r7", 7 }, 195 { "r8", 8 }, 196 { "r9", 9 }, 197 198 { "rbase", 3 }, /* Base Reg. */ 199 200 { "rtca", 12 }, /* Pointer to the table of contents. */ 201 { "rtoc", 12 }, /* Pointer to the table of contents. */ 202 203 { "sp", 13 }, /* Stack Pointer. */ 204 205 }; 206 207 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg)) 208 209 /* Given NAME, find the register number associated with that name, return 210 the integer value associated with the given name or -1 on failure. */ 211 212 static int 213 reg_name_search (const struct pd_reg *regs, 214 int regcount, 215 const char *name) 216 { 217 int middle, low, high; 218 int cmp; 219 220 low = 0; 221 high = regcount - 1; 222 223 do 224 { 225 middle = (low + high) / 2; 226 cmp = strcasecmp (name, regs[middle].name); 227 if (cmp < 0) 228 high = middle - 1; 229 else if (cmp > 0) 230 low = middle + 1; 231 else 232 return regs[middle].value; 233 } 234 while (low <= high); 235 236 return -1; 237 } 238 239 /* Summary of register_name(). 240 241 in: Input_line_pointer points to 1st char of operand. 242 243 out: An expressionS. 244 The operand may have been a register: in this case, X_op == O_register, 245 X_add_number is set to the register number, and truth is returned. 246 Input_line_pointer->(next non-blank) char after operand, or is in its 247 original state. */ 248 249 static bfd_boolean 250 register_name (expressionS *expressionP) 251 { 252 int reg_number; 253 char *name; 254 char *start; 255 char c; 256 257 /* Find the spelling of the operand. */ 258 start = name = input_line_pointer; 259 if (name[0] == '%' && ISALPHA (name[1])) 260 name = ++input_line_pointer; 261 262 else if (!reg_names_p) 263 return FALSE; 264 265 while (' ' == *name) 266 name = ++input_line_pointer; 267 268 /* If it's a number, treat it as a number. If it's alpha, look to 269 see if it's in the register table. */ 270 if (!ISALPHA (name[0])) 271 reg_number = get_single_number (); 272 else 273 { 274 c = get_symbol_end (); 275 reg_number = reg_name_search (pre_defined_registers, REG_NAME_CNT, name); 276 277 /* Put back the delimiting char. */ 278 *input_line_pointer = c; 279 } 280 281 /* If numeric, make sure its not out of bounds. */ 282 if ((0 <= reg_number) && (16 >= reg_number)) 283 { 284 expressionP->X_op = O_register; 285 expressionP->X_add_number = reg_number; 286 287 /* Make the rest nice. */ 288 expressionP->X_add_symbol = NULL; 289 expressionP->X_op_symbol = NULL; 290 return TRUE; 291 } 292 293 /* Reset the line as if we had not done anything. */ 294 input_line_pointer = start; 295 return FALSE; 296 } 297 298 /* Local variables. */ 300 301 /* The type of processor we are assembling for. This is one or more 302 of the I370_OPCODE flags defined in opcode/i370.h. */ 303 static int i370_cpu = 0; 304 305 /* The base register to use for opcode with optional operands. 306 We define two of these: "text" and "other". Normally, "text" 307 would get used in the .text section for branches, while "other" 308 gets used in the .data section for address constants. 309 310 The idea of a second base register in a different section 311 is foreign to the usual HLASM-style semantics; however, it 312 allows us to provide support for dynamically loaded libraries, 313 by allowing us to place address constants in a section other 314 than the text section. The "other" section need not be the 315 .data section, it can be any section that isn't the .text section. 316 317 Note that HLASM defines a multiple, concurrent .using semantic 318 that we do not: in calculating offsets, it uses either the most 319 recent .using directive, or the one with the smallest displacement. 320 This allows HLASM to support a quasi-block-scope-like behaviour. 321 Handy for people writing assembly by hand ... but not supported 322 by us. */ 323 static int i370_using_text_regno = -1; 324 static int i370_using_other_regno = -1; 325 326 /* The base address for address literals. */ 327 static expressionS i370_using_text_baseaddr; 328 static expressionS i370_using_other_baseaddr; 329 330 /* the "other" section, used only for syntax error detection. */ 331 static segT i370_other_section = undefined_section; 332 333 /* Opcode hash table. */ 334 static struct hash_control *i370_hash; 335 336 /* Macro hash table. */ 337 static struct hash_control *i370_macro_hash; 338 339 #ifdef OBJ_ELF 340 /* What type of shared library support to use. */ 341 static enum { SHLIB_NONE, SHLIB_PIC, SHILB_MRELOCATABLE } shlib = SHLIB_NONE; 342 #endif 343 344 /* Flags to set in the elf header. */ 345 static flagword i370_flags = 0; 346 347 #ifndef WORKING_DOT_WORD 348 int md_short_jump_size = 4; 349 int md_long_jump_size = 4; 350 #endif 351 352 #ifdef OBJ_ELF 354 const char *md_shortopts = "l:um:K:VQ:"; 355 #else 356 const char *md_shortopts = "um:"; 357 #endif 358 struct option md_longopts[] = 359 { 360 {NULL, no_argument, NULL, 0} 361 }; 362 size_t md_longopts_size = sizeof (md_longopts); 363 364 int 365 md_parse_option (int c, char *arg) 366 { 367 switch (c) 368 { 369 case 'u': 370 /* -u means that any undefined symbols should be treated as 371 external, which is the default for gas anyhow. */ 372 break; 373 374 #ifdef OBJ_ELF 375 case 'K': 376 /* Recognize -K PIC */ 377 if (strcmp (arg, "PIC") == 0 || strcmp (arg, "pic") == 0) 378 { 379 shlib = SHLIB_PIC; 380 i370_flags |= EF_I370_RELOCATABLE_LIB; 381 } 382 else 383 return 0; 384 385 break; 386 #endif 387 388 case 'm': 389 390 /* -m360 mean to assemble for the ancient 360 architecture. */ 391 if (strcmp (arg, "360") == 0 || strcmp (arg, "i360") == 0) 392 i370_cpu = I370_OPCODE_360; 393 /* -mxa means to assemble for the IBM 370 XA. */ 394 else if (strcmp (arg, "xa") == 0) 395 i370_cpu = I370_OPCODE_370_XA; 396 /* -many means to assemble for any architecture (370/XA). */ 397 else if (strcmp (arg, "any") == 0) 398 i370_cpu = I370_OPCODE_370; 399 400 else if (strcmp (arg, "regnames") == 0) 401 reg_names_p = TRUE; 402 403 else if (strcmp (arg, "no-regnames") == 0) 404 reg_names_p = FALSE; 405 406 #ifdef OBJ_ELF 407 /* -mrelocatable/-mrelocatable-lib -- warn about 408 initializations that require relocation. */ 409 else if (strcmp (arg, "relocatable") == 0) 410 { 411 shlib = SHILB_MRELOCATABLE; 412 i370_flags |= EF_I370_RELOCATABLE; 413 } 414 else if (strcmp (arg, "relocatable-lib") == 0) 415 { 416 shlib = SHILB_MRELOCATABLE; 417 i370_flags |= EF_I370_RELOCATABLE_LIB; 418 } 419 #endif 420 else 421 { 422 as_bad (_("invalid switch -m%s"), arg); 423 return 0; 424 } 425 break; 426 427 #ifdef OBJ_ELF 428 /* -V: SVR4 argument to print version ID. */ 429 case 'V': 430 print_version_id (); 431 break; 432 433 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section 434 should be emitted or not. FIXME: Not implemented. */ 435 case 'Q': 436 break; 437 438 #endif 439 440 default: 441 return 0; 442 } 443 444 return 1; 445 } 446 447 448 /* Set i370_cpu if it is not already set. 450 Currently defaults to the reasonable superset; 451 but can be made more fine grained if desred. */ 452 453 static void 454 i370_set_cpu (void) 455 { 456 const char *default_os = TARGET_OS; 457 const char *default_cpu = TARGET_CPU; 458 459 /* Override with the superset for the moment. */ 460 i370_cpu = I370_OPCODE_ESA390_SUPERSET; 461 if (i370_cpu == 0) 462 { 463 if (strcmp (default_cpu, "i360") == 0) 464 i370_cpu = I370_OPCODE_360; 465 else if (strcmp (default_cpu, "i370") == 0) 466 i370_cpu = I370_OPCODE_370; 467 else if (strcmp (default_cpu, "XA") == 0) 468 i370_cpu = I370_OPCODE_370_XA; 469 else 470 as_fatal ("Unknown default cpu = %s, os = %s", default_cpu, default_os); 471 } 472 } 473 474 /* Figure out the BFD architecture to use. 475 FIXME: specify the different 370 architectures. */ 476 477 enum bfd_architecture 478 i370_arch (void) 479 { 480 return bfd_arch_i370; 481 } 482 483 /* This function is called when the assembler starts up. It is called 484 after the options have been parsed and the output file has been 485 opened. */ 486 487 void 488 md_begin (void) 489 { 490 const struct i370_opcode *op; 491 const struct i370_opcode *op_end; 492 const struct i370_macro *macro; 493 const struct i370_macro *macro_end; 494 bfd_boolean dup_insn = FALSE; 495 496 i370_set_cpu (); 497 498 #ifdef OBJ_ELF 499 /* Set the ELF flags if desired. */ 500 if (i370_flags) 501 bfd_set_private_flags (stdoutput, i370_flags); 502 #endif 503 504 /* Insert the opcodes into a hash table. */ 505 i370_hash = hash_new (); 506 507 op_end = i370_opcodes + i370_num_opcodes; 508 for (op = i370_opcodes; op < op_end; op++) 509 { 510 know ((op->opcode.i[0] & op->mask.i[0]) == op->opcode.i[0] 511 && (op->opcode.i[1] & op->mask.i[1]) == op->opcode.i[1]); 512 513 if ((op->flags & i370_cpu) != 0) 514 { 515 const char *retval; 516 517 retval = hash_insert (i370_hash, op->name, (void *) op); 518 if (retval != (const char *) NULL) 519 { 520 as_bad (_("Internal assembler error for instruction %s"), op->name); 521 dup_insn = TRUE; 522 } 523 } 524 } 525 526 /* Insert the macros into a hash table. */ 527 i370_macro_hash = hash_new (); 528 529 macro_end = i370_macros + i370_num_macros; 530 for (macro = i370_macros; macro < macro_end; macro++) 531 { 532 if ((macro->flags & i370_cpu) != 0) 533 { 534 const char *retval; 535 536 retval = hash_insert (i370_macro_hash, macro->name, (void *) macro); 537 if (retval != (const char *) NULL) 538 { 539 as_bad (_("Internal assembler error for macro %s"), macro->name); 540 dup_insn = TRUE; 541 } 542 } 543 } 544 545 if (dup_insn) 546 abort (); 547 } 548 549 /* Insert an operand value into an instruction. */ 550 551 static i370_insn_t 552 i370_insert_operand (i370_insn_t insn, 553 const struct i370_operand *operand, 554 offsetT val) 555 { 556 if (operand->insert) 557 { 558 const char *errmsg; 559 560 /* Used for 48-bit insn's. */ 561 errmsg = NULL; 562 insn = (*operand->insert) (insn, (long) val, &errmsg); 563 if (errmsg) 564 as_bad ("%s", errmsg); 565 } 566 else 567 /* This is used only for 16, 32 bit insn's. */ 568 insn.i[0] |= (((long) val & ((1 << operand->bits) - 1)) 569 << operand->shift); 570 571 return insn; 572 } 573 574 575 #ifdef OBJ_ELF 577 /* Parse @got, etc. and return the desired relocation. 578 Currently, i370 does not support (don't really need to support) any 579 of these fancier markups ... for example, no one is going to 580 write 'L 6,=V(bogus)@got' it just doesn't make sense (at least to me). 581 So basically, we could get away with this routine returning 582 BFD_RELOC_UNUSED in all circumstances. However, I'll leave 583 in for now in case someone ambitious finds a good use for this stuff ... 584 this routine was pretty much just copied from the powerpc code ... */ 585 586 static bfd_reloc_code_real_type 587 i370_elf_suffix (char **str_p, expressionS *exp_p) 588 { 589 struct map_bfd 590 { 591 char *string; 592 int length; 593 bfd_reloc_code_real_type reloc; 594 }; 595 596 char ident[20]; 597 char *str = *str_p; 598 char *str2; 599 int ch; 600 int len; 601 struct map_bfd *ptr; 602 603 #define MAP(str,reloc) { str, sizeof (str) - 1, reloc } 604 605 static struct map_bfd mapping[] = 606 { 607 /* warnings with -mrelocatable. */ 608 MAP ("fixup", BFD_RELOC_CTOR), 609 { (char *)0, 0, BFD_RELOC_UNUSED } 610 }; 611 612 if (*str++ != '@') 613 return BFD_RELOC_UNUSED; 614 615 for (ch = *str, str2 = ident; 616 (str2 < ident + sizeof (ident) - 1 617 && (ISALNUM (ch) || ch == '@')); 618 ch = *++str) 619 *str2++ = TOLOWER (ch); 620 621 *str2 = '\0'; 622 len = str2 - ident; 623 624 ch = ident[0]; 625 for (ptr = &mapping[0]; ptr->length > 0; ptr++) 626 if (ch == ptr->string[0] 627 && len == ptr->length 628 && memcmp (ident, ptr->string, ptr->length) == 0) 629 { 630 if (exp_p->X_add_number != 0 631 && (ptr->reloc == BFD_RELOC_16_GOTOFF 632 || ptr->reloc == BFD_RELOC_LO16_GOTOFF 633 || ptr->reloc == BFD_RELOC_HI16_GOTOFF 634 || ptr->reloc == BFD_RELOC_HI16_S_GOTOFF)) 635 as_warn (_("identifier+constant@got means identifier@got+constant")); 636 637 /* Now check for identifier@suffix+constant */ 638 if (*str == '-' || *str == '+') 639 { 640 char *orig_line = input_line_pointer; 641 expressionS new_exp; 642 643 input_line_pointer = str; 644 expression (&new_exp); 645 if (new_exp.X_op == O_constant) 646 { 647 exp_p->X_add_number += new_exp.X_add_number; 648 str = input_line_pointer; 649 } 650 651 if (&input_line_pointer != str_p) 652 input_line_pointer = orig_line; 653 } 654 655 *str_p = str; 656 return ptr->reloc; 657 } 658 659 return BFD_RELOC_UNUSED; 660 } 661 662 /* Like normal .long/.short/.word, except support @got, etc. 663 Clobbers input_line_pointer, checks end-of-line. */ 664 665 static void 666 i370_elf_cons (int nbytes) /* 1=.byte, 2=.word, 4=.long. */ 667 { 668 expressionS exp; 669 bfd_reloc_code_real_type reloc; 670 671 if (is_it_end_of_statement ()) 672 { 673 demand_empty_rest_of_line (); 674 return; 675 } 676 677 do 678 { 679 expression (&exp); 680 681 if (exp.X_op == O_symbol 682 && *input_line_pointer == '@' 683 && (reloc = i370_elf_suffix (&input_line_pointer, &exp)) != BFD_RELOC_UNUSED) 684 { 685 reloc_howto_type *reloc_howto = bfd_reloc_type_lookup (stdoutput, reloc); 686 int size = bfd_get_reloc_size (reloc_howto); 687 688 if (size > nbytes) 689 as_bad (_("%s relocations do not fit in %d bytes\n"), 690 reloc_howto->name, nbytes); 691 else 692 { 693 char *p = frag_more ((int) nbytes); 694 int offset = nbytes - size; 695 696 fix_new_exp (frag_now, p - frag_now->fr_literal + offset, size, &exp, 0, reloc); 697 } 698 } 699 else 700 emit_expr (&exp, (unsigned int) nbytes); 701 } 702 while (*input_line_pointer++ == ','); 703 704 input_line_pointer--; /* Put terminator back into stream. */ 705 demand_empty_rest_of_line (); 706 } 707 708 709 /* ASCII to EBCDIC conversion table. */ 711 static unsigned char ascebc[256] = 712 { 713 /*00 NL SH SX EX ET NQ AK BL */ 714 0x00, 0x01, 0x02, 0x03, 0x37, 0x2D, 0x2E, 0x2F, 715 /*08 BS HT LF VT FF CR SO SI */ 716 0x16, 0x05, 0x15, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 717 /*10 DL D1 D2 D3 D4 NK SN EB */ 718 0x10, 0x11, 0x12, 0x13, 0x3C, 0x3D, 0x32, 0x26, 719 /*18 CN EM SB EC FS GS RS US */ 720 0x18, 0x19, 0x3F, 0x27, 0x1C, 0x1D, 0x1E, 0x1F, 721 /*20 SP ! " # $ % & ' */ 722 0x40, 0x5A, 0x7F, 0x7B, 0x5B, 0x6C, 0x50, 0x7D, 723 /*28 ( ) * + , - . / */ 724 0x4D, 0x5D, 0x5C, 0x4E, 0x6B, 0x60, 0x4B, 0x61, 725 /*30 0 1 2 3 4 5 6 7 */ 726 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 727 /*38 8 9 : ; < = > ? */ 728 0xF8, 0xF9, 0x7A, 0x5E, 0x4C, 0x7E, 0x6E, 0x6F, 729 /*40 @ A B C D E F G */ 730 0x7C, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 731 /*48 H I J K L M N O */ 732 0xC8, 0xC9, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 733 /*50 P Q R S T U V W */ 734 0xD7, 0xD8, 0xD9, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 735 /*58 X Y Z [ \ ] ^ _ */ 736 0xE7, 0xE8, 0xE9, 0xAD, 0xE0, 0xBD, 0x5F, 0x6D, 737 /*60 ` a b c d e f g */ 738 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 739 /*68 h i j k l m n o */ 740 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 741 /*70 p q r s t u v w */ 742 0x97, 0x98, 0x99, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 743 /*78 x y z { | } ~ DL */ 744 0xA7, 0xA8, 0xA9, 0xC0, 0x4F, 0xD0, 0xA1, 0x07, 745 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 746 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 747 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 748 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 749 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 750 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 751 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 752 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 753 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 754 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 755 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 756 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 757 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 758 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 759 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 760 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0xFF 761 }; 762 763 /* EBCDIC to ASCII conversion table. */ 764 unsigned char ebcasc[256] = 765 { 766 /*00 NU SH SX EX PF HT LC DL */ 767 0x00, 0x01, 0x02, 0x03, 0x00, 0x09, 0x00, 0x7F, 768 /*08 SM VT FF CR SO SI */ 769 0x00, 0x00, 0x00, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 770 /*10 DE D1 D2 TM RS NL BS IL */ 771 0x10, 0x11, 0x12, 0x13, 0x14, 0x0A, 0x08, 0x00, 772 /*18 CN EM CC C1 FS GS RS US */ 773 0x18, 0x19, 0x00, 0x00, 0x1C, 0x1D, 0x1E, 0x1F, 774 /*20 DS SS FS BP LF EB EC */ 775 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x17, 0x1B, 776 /*28 SM C2 EQ AK BL */ 777 0x00, 0x00, 0x00, 0x00, 0x05, 0x06, 0x07, 0x00, 778 /*30 SY PN RS UC ET */ 779 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 780 /*38 C3 D4 NK SU */ 781 0x00, 0x00, 0x00, 0x00, 0x14, 0x15, 0x00, 0x1A, 782 /*40 SP */ 783 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 784 /*48 . < ( + | */ 785 0x00, 0x00, 0x00, 0x2E, 0x3C, 0x28, 0x2B, 0x7C, 786 /*50 & */ 787 0x26, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 788 /*58 ! $ * ) ; ^ */ 789 0x00, 0x00, 0x21, 0x24, 0x2A, 0x29, 0x3B, 0x5E, 790 /*60 - / */ 791 0x2D, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 792 /*68 , % _ > ? */ 793 0x00, 0x00, 0x00, 0x2C, 0x25, 0x5F, 0x3E, 0x3F, 794 /*70 */ 795 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 796 /*78 ` : # @ ' = " */ 797 0x00, 0x60, 0x3A, 0x23, 0x40, 0x27, 0x3D, 0x22, 798 /*80 a b c d e f g */ 799 0x00, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 800 /*88 h i { */ 801 0x68, 0x69, 0x00, 0x7B, 0x00, 0x00, 0x00, 0x00, 802 /*90 j k l m n o p */ 803 0x00, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 804 /*98 q r } */ 805 0x71, 0x72, 0x00, 0x7D, 0x00, 0x00, 0x00, 0x00, 806 /*A0 ~ s t u v w x */ 807 0x00, 0x7E, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 808 /*A8 y z [ */ 809 0x79, 0x7A, 0x00, 0x00, 0x00, 0x5B, 0x00, 0x00, 810 /*B0 */ 811 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 812 /*B8 ] */ 813 0x00, 0x00, 0x00, 0x00, 0x00, 0x5D, 0x00, 0x00, 814 /*C0 { A B C D E F G */ 815 0x7B, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 816 /*C8 H I */ 817 0x48, 0x49, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 818 /*D0 } J K L M N O P */ 819 0x7D, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 820 /*D8 Q R */ 821 0x51, 0x52, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 822 /*E0 \ S T U V W X */ 823 0x5C, 0x00, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 824 /*E8 Y Z */ 825 0x59, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 826 /*F0 0 1 2 3 4 5 6 7 */ 827 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 828 /*F8 8 9 */ 829 0x38, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF 830 }; 831 832 /* EBCDIC translation tables needed for 3270 support. */ 833 834 static void 835 i370_ebcdic (int unused ATTRIBUTE_UNUSED) 836 { 837 char *p, *end; 838 char delim = 0; 839 size_t nbytes; 840 841 nbytes = strlen (input_line_pointer); 842 end = input_line_pointer + nbytes; 843 while ('\r' == *end) end --; 844 while ('\n' == *end) end --; 845 846 delim = *input_line_pointer; 847 if (('\'' == delim) || ('\"' == delim)) 848 { 849 input_line_pointer ++; 850 end = rindex (input_line_pointer, delim); 851 } 852 853 if (end > input_line_pointer) 854 { 855 nbytes = end - input_line_pointer +1; 856 p = frag_more (nbytes); 857 while (end > input_line_pointer) 858 { 859 *p = ascebc [(unsigned char) (*input_line_pointer)]; 860 ++p; ++input_line_pointer; 861 } 862 *p = '\0'; 863 } 864 if (delim == *input_line_pointer) ++input_line_pointer; 865 } 866 867 868 /* Stub out a couple of routines. */ 870 871 static void 872 i370_rmode (int unused ATTRIBUTE_UNUSED) 873 { 874 as_tsktsk ("rmode ignored"); 875 } 876 877 static void 878 i370_dsect (int sect) 879 { 880 char *save_line = input_line_pointer; 881 static char section[] = ".data\n"; 882 883 /* Just pretend this is .section .data. */ 884 input_line_pointer = section; 885 obj_elf_section (sect); 886 887 input_line_pointer = save_line; 888 } 889 890 static void 891 i370_csect (int unused ATTRIBUTE_UNUSED) 892 { 893 as_tsktsk ("csect not supported"); 894 } 895 896 897 /* DC Define Const is only partially supported. 899 For samplecode on what to do, look at i370_elf_cons() above. 900 This code handles pseudoops of the style 901 DC D'3.141592653' # in sysv4, .double 3.14159265 902 DC F'1' # in sysv4, .long 1. */ 903 904 static void 905 i370_dc (int unused ATTRIBUTE_UNUSED) 906 { 907 char * p, tmp[50]; 908 int nbytes=0; 909 expressionS exp; 910 char type=0; 911 char * clse; 912 913 if (is_it_end_of_statement ()) 914 { 915 demand_empty_rest_of_line (); 916 return; 917 } 918 919 /* Figure out the size. */ 920 type = *input_line_pointer++; 921 switch (type) 922 { 923 case 'H': /* 16-bit */ 924 nbytes = 2; 925 break; 926 case 'E': /* 32-bit */ 927 case 'F': /* 32-bit */ 928 nbytes = 4; 929 break; 930 case 'D': /* 64-bit */ 931 nbytes = 8; 932 break; 933 default: 934 as_bad (_("unsupported DC type")); 935 return; 936 } 937 938 /* Get rid of pesky quotes. */ 939 if ('\'' == *input_line_pointer) 940 { 941 ++input_line_pointer; 942 clse = strchr (input_line_pointer, '\''); 943 if (clse) 944 *clse= ' '; 945 else 946 as_bad (_("missing end-quote")); 947 } 948 949 if ('\"' == *input_line_pointer) 950 { 951 ++input_line_pointer; 952 clse = strchr (input_line_pointer, '\"'); 953 if (clse) 954 *clse= ' '; 955 else 956 as_bad (_("missing end-quote")); 957 } 958 959 switch (type) 960 { 961 case 'H': /* 16-bit */ 962 case 'F': /* 32-bit */ 963 expression (&exp); 964 emit_expr (&exp, nbytes); 965 break; 966 case 'E': /* 32-bit */ 967 type = 'f'; 968 case 'D': /* 64-bit */ 969 md_atof (type, tmp, &nbytes); 970 p = frag_more (nbytes); 971 memcpy (p, tmp, nbytes); 972 break; 973 default: 974 as_bad (_("unsupported DC type")); 975 return; 976 } 977 978 demand_empty_rest_of_line (); 979 } 980 981 982 /* Provide minimal support for DS Define Storage. */ 984 985 static void 986 i370_ds (int unused ATTRIBUTE_UNUSED) 987 { 988 /* DS 0H or DS 0F or DS 0D. */ 989 if ('0' == *input_line_pointer) 990 { 991 int alignment = 0; /* Left shift 1 << align. */ 992 input_line_pointer ++; 993 switch (*input_line_pointer++) 994 { 995 case 'H': /* 16-bit */ 996 alignment = 1; 997 break; 998 case 'F': /* 32-bit */ 999 alignment = 2; 1000 break; 1001 case 'D': /* 64-bit */ 1002 alignment = 3; 1003 break; 1004 default: 1005 as_bad (_("unsupported alignment")); 1006 return; 1007 } 1008 frag_align (alignment, 0, 0); 1009 record_alignment (now_seg, alignment); 1010 } 1011 else 1012 as_bad (_("this DS form not yet supported")); 1013 } 1014 1015 /* Solaris pseudo op to change to the .rodata section. */ 1016 1017 static void 1018 i370_elf_rdata (int sect) 1019 { 1020 char *save_line = input_line_pointer; 1021 static char section[] = ".rodata\n"; 1022 1023 /* Just pretend this is .section .rodata. */ 1024 input_line_pointer = section; 1025 obj_elf_section (sect); 1026 1027 input_line_pointer = save_line; 1028 } 1029 1030 /* Pseudo op to make file scope bss items. */ 1031 1032 static void 1033 i370_elf_lcomm (int unused ATTRIBUTE_UNUSED) 1034 { 1035 char *name; 1036 char c; 1037 char *p; 1038 offsetT size; 1039 symbolS *symbolP; 1040 offsetT align; 1041 segT old_sec; 1042 int old_subsec; 1043 char *pfrag; 1044 int align2; 1045 1046 name = input_line_pointer; 1047 c = get_symbol_end (); 1048 1049 /* Just after name is now '\0'. */ 1050 p = input_line_pointer; 1051 *p = c; 1052 SKIP_WHITESPACE (); 1053 if (*input_line_pointer != ',') 1054 { 1055 as_bad (_("Expected comma after symbol-name: rest of line ignored.")); 1056 ignore_rest_of_line (); 1057 return; 1058 } 1059 1060 /* Skip ','. */ 1061 input_line_pointer++; 1062 if ((size = get_absolute_expression ()) < 0) 1063 { 1064 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size); 1065 ignore_rest_of_line (); 1066 return; 1067 } 1068 1069 /* The third argument to .lcomm is the alignment. */ 1070 if (*input_line_pointer != ',') 1071 align = 8; 1072 else 1073 { 1074 ++input_line_pointer; 1075 align = get_absolute_expression (); 1076 if (align <= 0) 1077 { 1078 as_warn (_("ignoring bad alignment")); 1079 align = 8; 1080 } 1081 } 1082 1083 *p = 0; 1084 symbolP = symbol_find_or_make (name); 1085 *p = c; 1086 1087 if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP)) 1088 { 1089 as_bad (_("Ignoring attempt to re-define symbol `%s'."), 1090 S_GET_NAME (symbolP)); 1091 ignore_rest_of_line (); 1092 return; 1093 } 1094 1095 if (S_GET_VALUE (symbolP) && S_GET_VALUE (symbolP) != (valueT) size) 1096 { 1097 as_bad (_("Length of .lcomm \"%s\" is already %ld. Not changed to %ld."), 1098 S_GET_NAME (symbolP), 1099 (long) S_GET_VALUE (symbolP), 1100 (long) size); 1101 1102 ignore_rest_of_line (); 1103 return; 1104 } 1105 1106 /* Allocate_bss: */ 1107 old_sec = now_seg; 1108 old_subsec = now_subseg; 1109 if (align) 1110 { 1111 /* Convert to a power of 2 alignment. */ 1112 for (align2 = 0; (align & 1) == 0; align >>= 1, ++align2) 1113 ; 1114 if (align != 1) 1115 { 1116 as_bad (_("Common alignment not a power of 2")); 1117 ignore_rest_of_line (); 1118 return; 1119 } 1120 } 1121 else 1122 align2 = 0; 1123 1124 record_alignment (bss_section, align2); 1125 subseg_set (bss_section, 0); 1126 if (align2) 1127 frag_align (align2, 0, 0); 1128 if (S_GET_SEGMENT (symbolP) == bss_section) 1129 symbol_get_frag (symbolP)->fr_symbol = 0; 1130 symbol_set_frag (symbolP, frag_now); 1131 pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP, size, 1132 (char *) 0); 1133 *pfrag = 0; 1134 S_SET_SIZE (symbolP, size); 1135 S_SET_SEGMENT (symbolP, bss_section); 1136 subseg_set (old_sec, old_subsec); 1137 demand_empty_rest_of_line (); 1138 } 1139 1140 /* Validate any relocations emitted for -mrelocatable, possibly adding 1141 fixups for word relocations in writable segments, so we can adjust 1142 them at runtime. */ 1143 1144 static void 1145 i370_elf_validate_fix (fixS *fixp, segT seg) 1146 { 1147 if (fixp->fx_done || fixp->fx_pcrel) 1148 return; 1149 1150 switch (shlib) 1151 { 1152 case SHLIB_NONE: 1153 case SHLIB_PIC: 1154 return; 1155 1156 case SHILB_MRELOCATABLE: 1157 if (fixp->fx_r_type <= BFD_RELOC_UNUSED 1158 && fixp->fx_r_type != BFD_RELOC_16_GOTOFF 1159 && fixp->fx_r_type != BFD_RELOC_HI16_GOTOFF 1160 && fixp->fx_r_type != BFD_RELOC_LO16_GOTOFF 1161 && fixp->fx_r_type != BFD_RELOC_HI16_S_GOTOFF 1162 && fixp->fx_r_type != BFD_RELOC_32_BASEREL 1163 && fixp->fx_r_type != BFD_RELOC_LO16_BASEREL 1164 && fixp->fx_r_type != BFD_RELOC_HI16_BASEREL 1165 && fixp->fx_r_type != BFD_RELOC_HI16_S_BASEREL 1166 && strcmp (segment_name (seg), ".got2") != 0 1167 && strcmp (segment_name (seg), ".dtors") != 0 1168 && strcmp (segment_name (seg), ".ctors") != 0 1169 && strcmp (segment_name (seg), ".fixup") != 0 1170 && strcmp (segment_name (seg), ".stab") != 0 1171 && strcmp (segment_name (seg), ".gcc_except_table") != 0 1172 && strcmp (segment_name (seg), ".ex_shared") != 0) 1173 { 1174 if ((seg->flags & (SEC_READONLY | SEC_CODE)) != 0 1175 || fixp->fx_r_type != BFD_RELOC_CTOR) 1176 as_bad_where (fixp->fx_file, fixp->fx_line, 1177 "Relocation cannot be done when using -mrelocatable"); 1178 } 1179 return; 1180 default: 1181 break; 1182 } 1183 } 1184 #endif /* OBJ_ELF */ 1185 1186 1187 #define LITERAL_POOL_SUPPORT 1189 #ifdef LITERAL_POOL_SUPPORT 1190 /* Provide support for literal pools within the text section. 1191 Loosely based on similar code from tc-arm.c. 1192 We will use four symbols to locate four parts of the literal pool. 1193 These four sections contain 64,32,16 and 8-bit constants; we use 1194 four sections so that all memory access can be appropriately aligned. 1195 That is, we want to avoid mixing these together so that we don't 1196 waste space padding out to alignments. The four pointers 1197 longlong_poolP, word_poolP, etc. point to a symbol labeling the 1198 start of each pool part. 1199 1200 lit_pool_num increments from zero to infinity and uniquely id's 1201 -- its used to generate the *_poolP symbol name. */ 1202 1203 #define MAX_LITERAL_POOL_SIZE 1024 1204 1205 typedef struct literalS 1206 { 1207 struct expressionS exp; 1208 char * sym_name; 1209 char size; /* 1,2,4 or 8 */ 1210 short offset; 1211 } literalT; 1212 1213 literalT literals[MAX_LITERAL_POOL_SIZE]; 1214 int next_literal_pool_place = 0; /* Next free entry in the pool. */ 1215 1216 static symbolS *longlong_poolP = NULL; /* 64-bit pool entries. */ 1217 static symbolS *word_poolP = NULL; /* 32-bit pool entries. */ 1218 static symbolS *short_poolP = NULL; /* 16-bit pool entries. */ 1219 static symbolS *byte_poolP = NULL; /* 8-bit pool entries. */ 1220 1221 static int lit_pool_num = 1; 1222 1223 /* Create a new, empty symbol. */ 1224 static symbolS * 1225 symbol_make_empty (void) 1226 { 1227 return symbol_create (FAKE_LABEL_NAME, undefined_section, 1228 (valueT) 0, &zero_address_frag); 1229 } 1230 1231 /* Make the first argument an address-relative expression 1232 by subtracting the second argument. */ 1233 1234 static void 1235 i370_make_relative (expressionS *exx, expressionS *baseaddr) 1236 { 1237 if (O_constant == baseaddr->X_op) 1238 { 1239 exx->X_op = O_symbol; 1240 exx->X_add_number -= baseaddr->X_add_number; 1241 } 1242 else if (O_symbol == baseaddr->X_op) 1243 { 1244 exx->X_op = O_subtract; 1245 exx->X_op_symbol = baseaddr->X_add_symbol; 1246 exx->X_add_number -= baseaddr->X_add_number; 1247 } 1248 else if (O_uminus == baseaddr->X_op) 1249 { 1250 exx->X_op = O_add; 1251 exx->X_op_symbol = baseaddr->X_add_symbol; 1252 exx->X_add_number += baseaddr->X_add_number; 1253 } 1254 else 1255 as_bad (_("Missing or bad .using directive")); 1256 } 1257 /* Add an expression to the literal pool. */ 1258 1259 static void 1260 add_to_lit_pool (expressionS *exx, char *name, int sz) 1261 { 1262 int lit_count = 0; 1263 int offset_in_pool = 0; 1264 1265 /* Start a new pool, if necessary. */ 1266 if (8 == sz && NULL == longlong_poolP) 1267 longlong_poolP = symbol_make_empty (); 1268 else if (4 == sz && NULL == word_poolP) 1269 word_poolP = symbol_make_empty (); 1270 else if (2 == sz && NULL == short_poolP) 1271 short_poolP = symbol_make_empty (); 1272 else if (1 == sz && NULL == byte_poolP) 1273 byte_poolP = symbol_make_empty (); 1274 1275 /* Check if this literal value is already in the pool. 1276 FIXME: We should probably be checking expressions 1277 of type O_symbol as well. 1278 FIXME: This is probably(certainly?) broken for O_big, 1279 which includes 64-bit long-longs. */ 1280 while (lit_count < next_literal_pool_place) 1281 { 1282 if (exx->X_op == O_constant 1283 && literals[lit_count].exp.X_op == exx->X_op 1284 && literals[lit_count].exp.X_add_number == exx->X_add_number 1285 && literals[lit_count].exp.X_unsigned == exx->X_unsigned 1286 && literals[lit_count].size == sz) 1287 break; 1288 else if (literals[lit_count].sym_name 1289 && name 1290 && !strcmp (name, literals[lit_count].sym_name)) 1291 break; 1292 if (sz == literals[lit_count].size) 1293 offset_in_pool += sz; 1294 lit_count ++; 1295 } 1296 1297 if (lit_count == next_literal_pool_place) /* new entry */ 1298 { 1299 if (next_literal_pool_place > MAX_LITERAL_POOL_SIZE) 1300 as_bad (_("Literal Pool Overflow")); 1301 1302 literals[next_literal_pool_place].exp = *exx; 1303 literals[next_literal_pool_place].size = sz; 1304 literals[next_literal_pool_place].offset = offset_in_pool; 1305 if (name) 1306 literals[next_literal_pool_place].sym_name = strdup (name); 1307 else 1308 literals[next_literal_pool_place].sym_name = NULL; 1309 next_literal_pool_place++; 1310 } 1311 1312 /* ???_poolP points to the beginning of the literal pool. 1313 X_add_number is the offset from the beginning of the 1314 literal pool to this expr minus the location of the most 1315 recent .using directive. Thus, the grand total value of the 1316 expression is the distance from .using to the literal. */ 1317 if (8 == sz) 1318 exx->X_add_symbol = longlong_poolP; 1319 else if (4 == sz) 1320 exx->X_add_symbol = word_poolP; 1321 else if (2 == sz) 1322 exx->X_add_symbol = short_poolP; 1323 else if (1 == sz) 1324 exx->X_add_symbol = byte_poolP; 1325 exx->X_add_number = offset_in_pool; 1326 exx->X_op_symbol = NULL; 1327 1328 /* If the user has set up a base reg in another section, 1329 use that; otherwise use the text section. */ 1330 if (0 < i370_using_other_regno) 1331 i370_make_relative (exx, &i370_using_other_baseaddr); 1332 else 1333 i370_make_relative (exx, &i370_using_text_baseaddr); 1334 } 1335 1336 /* The symbol setup for the literal pool is done in two steps. First, 1337 a symbol that represents the start of the literal pool is created, 1338 above, in the add_to_pool() routine. This sym ???_poolP. 1339 However, we don't know what fragment its in until a bit later. 1340 So we defer the frag_now thing, and the symbol name, until .ltorg time. */ 1341 1342 /* Can't use symbol_new here, so have to create a symbol and then at 1343 a later date assign it a value. Thats what these functions do. */ 1344 1345 static void 1346 symbol_locate (symbolS *symbolP, 1347 const char *name, /* It is copied, the caller can modify. */ 1348 segT segment, /* Segment identifier (SEG_<something>). */ 1349 valueT valu, /* Symbol value. */ 1350 fragS *frag) /* Associated fragment. */ 1351 { 1352 size_t name_length; 1353 char *preserved_copy_of_name; 1354 1355 name_length = strlen (name) + 1; /* +1 for \0 */ 1356 obstack_grow (¬es, name, name_length); 1357 preserved_copy_of_name = obstack_finish (¬es); 1358 1359 S_SET_NAME (symbolP, preserved_copy_of_name); 1360 1361 S_SET_SEGMENT (symbolP, segment); 1362 S_SET_VALUE (symbolP, valu); 1363 symbol_clear_list_pointers (symbolP); 1364 1365 symbol_set_frag (symbolP, frag); 1366 1367 /* Link to end of symbol chain. */ 1368 { 1369 extern int symbol_table_frozen; 1370 1371 if (symbol_table_frozen) 1372 abort (); 1373 } 1374 1375 symbol_append (symbolP, symbol_lastP, &symbol_rootP, &symbol_lastP); 1376 1377 obj_symbol_new_hook (symbolP); 1378 1379 #ifdef tc_symbol_new_hook 1380 tc_symbol_new_hook (symbolP); 1381 #endif 1382 1383 #define DEBUG_SYMS 1384 #ifdef DEBUG_SYMS 1385 verify_symbol_chain(symbol_rootP, symbol_lastP); 1386 #endif /* DEBUG_SYMS */ 1387 } 1388 1389 /* i370_addr_offset() will convert operand expressions 1390 that appear to be absolute into thier base-register 1391 relative form. These expressions come in two types: 1392 1393 (1) of the form "* + const" * where "*" means 1394 relative offset since the last using 1395 i.e. "*" means ".-using_baseaddr" 1396 1397 (2) labels, which are never absolute, but are always 1398 relative to the last "using". Anything with an alpha 1399 character is considered to be a label (since symbols 1400 can never be operands), and since we've already handled 1401 register operands. For example, "BL .L33" branch low 1402 to .L33 RX form insn frequently terminates for-loops. */ 1403 1404 static bfd_boolean 1405 i370_addr_offset (expressionS *exx) 1406 { 1407 char *dot, *lab; 1408 int islabel = 0; 1409 int all_digits = 0; 1410 1411 /* Search for a label; anything with an alpha char will do. 1412 Local labels consist of N digits followed by either b or f. */ 1413 lab = input_line_pointer; 1414 while (*lab && (',' != *lab) && ('(' != *lab)) 1415 { 1416 if (ISDIGIT (*lab)) 1417 all_digits = 1; 1418 else if (ISALPHA (*lab)) 1419 { 1420 if (!all_digits) 1421 { 1422 islabel = 1; 1423 break; 1424 } 1425 else if (('f' == *lab) || ('b' == *lab)) 1426 { 1427 islabel = 1; 1428 break; 1429 } 1430 if (all_digits) 1431 break; 1432 } 1433 else if ('.' != *lab) 1434 break; 1435 ++lab; 1436 } 1437 1438 /* See if operand has a * in it. */ 1439 dot = strchr (input_line_pointer, '*'); 1440 1441 if (!dot && !islabel) 1442 return FALSE; 1443 1444 /* Replace * with . and let expr munch on it. */ 1445 if (dot) 1446 *dot = '.'; 1447 expression (exx); 1448 1449 /* OK, now we have to subtract the "using" location. 1450 Normally branches appear in the text section only. */ 1451 if (0 == strncmp (now_seg->name, ".text", 5) || 0 > i370_using_other_regno) 1452 i370_make_relative (exx, &i370_using_text_baseaddr); 1453 else 1454 i370_make_relative (exx, &i370_using_other_baseaddr); 1455 1456 /* Put the * back. */ 1457 if (dot) 1458 *dot = '*'; 1459 1460 return TRUE; 1461 } 1462 1463 /* Handle address constants of various sorts. */ 1464 /* The currently supported types are 1465 =A(some_symb) 1466 =V(some_extern) 1467 =X'deadbeef' hexadecimal 1468 =F'1234' 32-bit const int 1469 =H'1234' 16-bit const int. */ 1470 1471 static bfd_boolean 1472 i370_addr_cons (expressionS *exp) 1473 { 1474 char *name; 1475 char *sym_name, delim; 1476 int name_len; 1477 int hex_len = 0; 1478 int cons_len = 0; 1479 1480 name = input_line_pointer; 1481 sym_name = input_line_pointer; 1482 /* Find the spelling of the operand. */ 1483 if (name[0] == '=' && ISALPHA (name[1])) 1484 name = ++input_line_pointer; 1485 else 1486 return FALSE; 1487 1488 switch (name[0]) 1489 { 1490 case 'A': /* A == address-of. */ 1491 case 'V': /* V == extern. */ 1492 ++input_line_pointer; 1493 expression (exp); 1494 1495 /* We use a simple string name to collapse together 1496 multiple refrences to the same address literal. */ 1497 name_len = strcspn (sym_name, ", "); 1498 delim = *(sym_name + name_len); 1499 *(sym_name + name_len) = 0x0; 1500 add_to_lit_pool (exp, sym_name, 4); 1501 *(sym_name + name_len) = delim; 1502 1503 break; 1504 case 'H': 1505 case 'F': 1506 case 'X': 1507 case 'E': /* Single-precision float point. */ 1508 case 'D': /* Double-precision float point. */ 1509 1510 /* H == 16-bit fixed-point const; expression must be const. */ 1511 /* F == fixed-point const; expression must be const. */ 1512 /* X == fixed-point const; expression must be const. */ 1513 if ('H' == name[0]) cons_len = 2; 1514 else if ('F' == name[0]) cons_len = 4; 1515 else if ('X' == name[0]) cons_len = -1; 1516 else if ('E' == name[0]) cons_len = 4; 1517 else if ('D' == name[0]) cons_len = 8; 1518 1519 /* Extract length, if it is present; 1520 FIXME: assume single-digit length. */ 1521 if ('L' == name[1]) 1522 { 1523 /* Should work for ASCII and EBCDIC. */ 1524 cons_len = name[2] - '0'; 1525 input_line_pointer += 2; 1526 } 1527 1528 ++input_line_pointer; 1529 1530 /* Get rid of pesky quotes. */ 1531 if ('\'' == *input_line_pointer) 1532 { 1533 char * clse; 1534 1535 ++input_line_pointer; 1536 clse = strchr (input_line_pointer, '\''); 1537 if (clse) 1538 *clse= ' '; 1539 else 1540 as_bad (_("missing end-quote")); 1541 } 1542 if ('\"' == *input_line_pointer) 1543 { 1544 char * clse; 1545 1546 ++input_line_pointer; 1547 clse = strchr (input_line_pointer, '\"'); 1548 if (clse) 1549 *clse= ' '; 1550 else 1551 as_bad (_("missing end-quote")); 1552 } 1553 if (('X' == name[0]) || ('E' == name[0]) || ('D' == name[0])) 1554 { 1555 char tmp[50]; 1556 char *save; 1557 1558 /* The length of hex constants is specified directly with L, 1559 or implied through the number of hex digits. For example: 1560 =X'AB' one byte 1561 =X'abcd' two bytes 1562 =X'000000AB' four bytes 1563 =XL4'AB' four bytes, left-padded withn zero. */ 1564 if (('X' == name[0]) && (0 > cons_len)) 1565 { 1566 save = input_line_pointer; 1567 while (*save) 1568 { 1569 if (ISXDIGIT (*save)) 1570 hex_len++; 1571 save++; 1572 } 1573 cons_len = (hex_len+1) /2; 1574 } 1575 /* I believe this works even for =XL8'dada0000beeebaaa' 1576 which should parse out to X_op == O_big 1577 Note that floats and doubles get represented as 1578 0d3.14159265358979 or 0f 2.7. */ 1579 tmp[0] = '0'; 1580 tmp[1] = name[0]; 1581 tmp[2] = 0; 1582 strcat (tmp, input_line_pointer); 1583 save = input_line_pointer; 1584 input_line_pointer = tmp; 1585 expression (exp); 1586 input_line_pointer = save + (input_line_pointer-tmp-2); 1587 1588 /* Fix up lengths for floats and doubles. */ 1589 if (O_big == exp->X_op) 1590 exp->X_add_number = cons_len / CHARS_PER_LITTLENUM; 1591 } 1592 else 1593 expression (exp); 1594 1595 /* O_big occurs when more than 4 bytes worth gets parsed. */ 1596 if ((exp->X_op != O_constant) && (exp->X_op != O_big)) 1597 { 1598 as_bad (_("expression not a constant")); 1599 return FALSE; 1600 } 1601 add_to_lit_pool (exp, 0x0, cons_len); 1602 break; 1603 1604 default: 1605 as_bad (_("Unknown/unsupported address literal type")); 1606 return FALSE; 1607 } 1608 1609 return TRUE; 1610 } 1611 1612 1613 /* Dump the contents of the literal pool that we've accumulated so far. 1615 This aligns the pool to the size of the largest literal in the pool. */ 1616 1617 static void 1618 i370_ltorg (int ignore ATTRIBUTE_UNUSED) 1619 { 1620 int litsize; 1621 int lit_count = 0; 1622 int biggest_literal_size = 0; 1623 int biggest_align = 0; 1624 char pool_name[20]; 1625 1626 if (strncmp (now_seg->name, ".text", 5)) 1627 { 1628 if (i370_other_section == undefined_section) 1629 as_bad (_(".ltorg without prior .using in section %s"), 1630 now_seg->name); 1631 1632 if (i370_other_section != now_seg) 1633 as_bad (_(".ltorg in section %s paired to .using in section %s"), 1634 now_seg->name, i370_other_section->name); 1635 } 1636 1637 if (! longlong_poolP 1638 && ! word_poolP 1639 && ! short_poolP 1640 && ! byte_poolP) 1641 /* Nothing to do. */ 1642 return; 1643 1644 /* Find largest literal .. 2 4 or 8. */ 1645 lit_count = 0; 1646 while (lit_count < next_literal_pool_place) 1647 { 1648 if (biggest_literal_size < literals[lit_count].size) 1649 biggest_literal_size = literals[lit_count].size; 1650 lit_count ++; 1651 } 1652 if (1 == biggest_literal_size) biggest_align = 0; 1653 else if (2 == biggest_literal_size) biggest_align = 1; 1654 else if (4 == biggest_literal_size) biggest_align = 2; 1655 else if (8 == biggest_literal_size) biggest_align = 3; 1656 else as_bad (_("bad alignment of %d bytes in literal pool"), biggest_literal_size); 1657 if (0 == biggest_align) biggest_align = 1; 1658 1659 /* Align pool for short, word, double word accesses. */ 1660 frag_align (biggest_align, 0, 0); 1661 record_alignment (now_seg, biggest_align); 1662 1663 /* Note that the gas listing will print only the first five 1664 entries in the pool .... wonder how to make it print more. */ 1665 /* Output largest literals first, then the smaller ones. */ 1666 for (litsize=8; litsize; litsize /=2) 1667 { 1668 symbolS *current_poolP = NULL; 1669 switch (litsize) 1670 { 1671 case 8: 1672 current_poolP = longlong_poolP; break; 1673 case 4: 1674 current_poolP = word_poolP; break; 1675 case 2: 1676 current_poolP = short_poolP; break; 1677 case 1: 1678 current_poolP = byte_poolP; break; 1679 default: 1680 as_bad (_("bad literal size\n")); 1681 } 1682 if (NULL == current_poolP) 1683 continue; 1684 sprintf (pool_name, ".LITP%01d%06d", litsize, lit_pool_num); 1685 symbol_locate (current_poolP, pool_name, now_seg, 1686 (valueT) frag_now_fix (), frag_now); 1687 symbol_table_insert (current_poolP); 1688 1689 lit_count = 0; 1690 while (lit_count < next_literal_pool_place) 1691 { 1692 if (litsize == literals[lit_count].size) 1693 { 1694 #define EMIT_ADDR_CONS_SYMBOLS 1695 #ifdef EMIT_ADDR_CONS_SYMBOLS 1696 /* Create a bogus symbol, add it to the pool ... 1697 For the most part, I think this is a useless exercise, 1698 except that having these symbol names in the objects 1699 is vaguely useful for debugging. */ 1700 if (literals[lit_count].sym_name) 1701 { 1702 symbolS * symP = symbol_make_empty (); 1703 symbol_locate (symP, literals[lit_count].sym_name, now_seg, 1704 (valueT) frag_now_fix (), frag_now); 1705 symbol_table_insert (symP); 1706 } 1707 #endif /* EMIT_ADDR_CONS_SYMBOLS */ 1708 1709 emit_expr (&(literals[lit_count].exp), literals[lit_count].size); 1710 } 1711 lit_count ++; 1712 } 1713 } 1714 1715 next_literal_pool_place = 0; 1716 longlong_poolP = NULL; 1717 word_poolP = NULL; 1718 short_poolP = NULL; 1719 byte_poolP = NULL; 1720 lit_pool_num++; 1721 } 1722 1723 #endif /* LITERAL_POOL_SUPPORT */ 1724 1725 1726 /* Add support for the HLASM-like USING directive to indicate 1728 the base register to use ... we don't support the full 1729 hlasm semantics for this ... we merely pluck a base address 1730 and a register number out. We print a warning if using is 1731 called multiple times. I suppose we should check to see 1732 if the regno is valid. */ 1733 1734 static void 1735 i370_using (int ignore ATTRIBUTE_UNUSED) 1736 { 1737 expressionS ex, baseaddr; 1738 int iregno; 1739 char *star; 1740 1741 /* If "*" appears in a using, it means "." 1742 replace it with "." so that expr doesn't get confused. */ 1743 star = strchr (input_line_pointer, '*'); 1744 if (star) 1745 *star = '.'; 1746 1747 /* The first arg to using will usually be ".", but it can 1748 be a more complex expression too. */ 1749 expression (&baseaddr); 1750 if (star) 1751 *star = '*'; 1752 if (O_constant != baseaddr.X_op 1753 && O_symbol != baseaddr.X_op 1754 && O_uminus != baseaddr.X_op) 1755 as_bad (_(".using: base address expression illegal or too complex")); 1756 1757 if (*input_line_pointer != '\0') ++input_line_pointer; 1758 1759 /* The second arg to using had better be a register. */ 1760 register_name (&ex); 1761 demand_empty_rest_of_line (); 1762 iregno = ex.X_add_number; 1763 1764 if (0 == strncmp (now_seg->name, ".text", 5)) 1765 { 1766 i370_using_text_baseaddr = baseaddr; 1767 i370_using_text_regno = iregno; 1768 } 1769 else 1770 { 1771 i370_using_other_baseaddr = baseaddr; 1772 i370_using_other_regno = iregno; 1773 i370_other_section = now_seg; 1774 } 1775 } 1776 1777 static void 1778 i370_drop (int ignore ATTRIBUTE_UNUSED) 1779 { 1780 expressionS ex; 1781 int iregno; 1782 1783 register_name (&ex); 1784 demand_empty_rest_of_line (); 1785 iregno = ex.X_add_number; 1786 1787 if (0 == strncmp (now_seg->name, ".text", 5)) 1788 { 1789 if (iregno != i370_using_text_regno) 1790 as_bad (_("droping register %d in section %s does not match using register %d"), 1791 iregno, now_seg->name, i370_using_text_regno); 1792 1793 i370_using_text_regno = -1; 1794 i370_using_text_baseaddr.X_op = O_absent; 1795 } 1796 else 1797 { 1798 if (iregno != i370_using_other_regno) 1799 as_bad (_("droping register %d in section %s does not match using register %d"), 1800 iregno, now_seg->name, i370_using_other_regno); 1801 1802 if (i370_other_section != now_seg) 1803 as_bad (_("droping register %d in section %s previously used in section %s"), 1804 iregno, now_seg->name, i370_other_section->name); 1805 1806 i370_using_other_regno = -1; 1807 i370_using_other_baseaddr.X_op = O_absent; 1808 i370_other_section = undefined_section; 1809 } 1810 } 1811 1812 1813 /* We need to keep a list of fixups. We can't simply generate them as 1815 we go, because that would require us to first create the frag, and 1816 that would screw up references to ``.''. */ 1817 1818 struct i370_fixup 1819 { 1820 expressionS exp; 1821 int opindex; 1822 bfd_reloc_code_real_type reloc; 1823 }; 1824 1825 #define MAX_INSN_FIXUPS 5 1826 1827 /* Handle a macro. Gather all the operands, transform them as 1828 described by the macro, and call md_assemble recursively. All the 1829 operands are separated by commas; we don't accept parentheses 1830 around operands here. */ 1831 1832 static void 1833 i370_macro (char *str, const struct i370_macro *macro) 1834 { 1835 char *operands[10]; 1836 unsigned int count; 1837 char *s; 1838 unsigned int len; 1839 const char *format; 1840 int arg; 1841 char *send; 1842 char *complete; 1843 1844 /* Gather the users operands into the operands array. */ 1845 count = 0; 1846 s = str; 1847 while (1) 1848 { 1849 if (count >= sizeof operands / sizeof operands[0]) 1850 break; 1851 operands[count++] = s; 1852 s = strchr (s, ','); 1853 if (s == (char *) NULL) 1854 break; 1855 *s++ = '\0'; 1856 } 1857 1858 if (count != macro->operands) 1859 { 1860 as_bad (_("wrong number of operands")); 1861 return; 1862 } 1863 1864 /* Work out how large the string must be (the size is unbounded 1865 because it includes user input). */ 1866 len = 0; 1867 format = macro->format; 1868 while (*format != '\0') 1869 { 1870 if (*format != '%') 1871 { 1872 ++len; 1873 ++format; 1874 } 1875 else 1876 { 1877 arg = strtol (format + 1, &send, 10); 1878 know (send != format && arg >= 0 && (unsigned) arg < count); 1879 len += strlen (operands[arg]); 1880 format = send; 1881 } 1882 } 1883 1884 /* Put the string together. */ 1885 complete = s = alloca (len + 1); 1886 format = macro->format; 1887 while (*format != '\0') 1888 { 1889 if (*format != '%') 1890 *s++ = *format++; 1891 else 1892 { 1893 arg = strtol (format + 1, &send, 10); 1894 strcpy (s, operands[arg]); 1895 s += strlen (s); 1896 format = send; 1897 } 1898 } 1899 *s = '\0'; 1900 1901 /* Assemble the constructed instruction. */ 1902 md_assemble (complete); 1903 } 1904 1905 /* This routine is called for each instruction to be assembled. */ 1906 1907 void 1908 md_assemble (char *str) 1909 { 1910 char *s; 1911 const struct i370_opcode *opcode; 1912 i370_insn_t insn; 1913 const unsigned char *opindex_ptr; 1914 int have_optional_index, have_optional_basereg, have_optional_reg; 1915 int skip_optional_index, skip_optional_basereg, skip_optional_reg; 1916 int use_text=0, use_other=0; 1917 int off_by_one; 1918 struct i370_fixup fixups[MAX_INSN_FIXUPS]; 1919 int fc; 1920 char *f; 1921 int i; 1922 #ifdef OBJ_ELF 1923 bfd_reloc_code_real_type reloc; 1924 #endif 1925 1926 /* Get the opcode. */ 1927 for (s = str; *s != '\0' && ! ISSPACE (*s); s++) 1928 ; 1929 if (*s != '\0') 1930 *s++ = '\0'; 1931 1932 /* Look up the opcode in the hash table. */ 1933 opcode = (const struct i370_opcode *) hash_find (i370_hash, str); 1934 if (opcode == (const struct i370_opcode *) NULL) 1935 { 1936 const struct i370_macro *macro; 1937 1938 gas_assert (i370_macro_hash); 1939 macro = (const struct i370_macro *) hash_find (i370_macro_hash, str); 1940 if (macro == (const struct i370_macro *) NULL) 1941 as_bad (_("Unrecognized opcode: `%s'"), str); 1942 else 1943 i370_macro (s, macro); 1944 1945 return; 1946 } 1947 1948 insn = opcode->opcode; 1949 1950 str = s; 1951 while (ISSPACE (*str)) 1952 ++str; 1953 1954 /* I370 operands are either expressions or address constants. 1955 Many operand types are optional. The optional operands 1956 are always surrounded by parens, and are used to denote the base 1957 register ... e.g. "A R1, D2" or "A R1, D2(,B2) as opposed to 1958 the fully-formed "A R1, D2(X2,B2)". Note also the = sign, 1959 such as A R1,=A(i) where the address-of operator =A implies 1960 use of both a base register, and a missing index register. 1961 1962 So, before we start seriously parsing the operands, we check 1963 to see if we have an optional operand, and, if we do, we count 1964 the number of commas to see which operand should be omitted. */ 1965 1966 have_optional_index = have_optional_basereg = have_optional_reg = 0; 1967 for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++) 1968 { 1969 const struct i370_operand *operand; 1970 1971 operand = &i370_operands[*opindex_ptr]; 1972 if ((operand->flags & I370_OPERAND_INDEX) != 0) 1973 have_optional_index = 1; 1974 if ((operand->flags & I370_OPERAND_BASE) != 0) 1975 have_optional_basereg = 1; 1976 if ((operand->flags & I370_OPERAND_OPTIONAL) != 0) 1977 have_optional_reg = 1; 1978 } 1979 1980 skip_optional_index = skip_optional_basereg = skip_optional_reg = 0; 1981 if (have_optional_index || have_optional_basereg) 1982 { 1983 unsigned int opcount, nwanted; 1984 1985 /* There is an optional operand. Count the number of 1986 commas and open-parens in the input line. */ 1987 if (*str == '\0') 1988 opcount = 0; 1989 else 1990 { 1991 opcount = 1; 1992 s = str; 1993 while ((s = strpbrk (s, ",(=")) != (char *) NULL) 1994 { 1995 ++opcount; 1996 ++s; 1997 if (',' == *s) ++s; /* avoid counting things like (, */ 1998 if ('=' == *s) { ++s; --opcount; } 1999 } 2000 } 2001 2002 /* If there are fewer operands in the line then are called 2003 for by the instruction, we want to skip the optional 2004 operand. */ 2005 nwanted = strlen ((char *) opcode->operands); 2006 if (have_optional_index) 2007 { 2008 if (opcount < nwanted) 2009 skip_optional_index = 1; 2010 if (have_optional_basereg && ((opcount+1) < nwanted)) 2011 skip_optional_basereg = 1; 2012 if (have_optional_reg && ((opcount+1) < nwanted)) 2013 skip_optional_reg = 1; 2014 } 2015 else 2016 { 2017 if (have_optional_basereg && (opcount < nwanted)) 2018 skip_optional_basereg = 1; 2019 if (have_optional_reg && (opcount < nwanted)) 2020 skip_optional_reg = 1; 2021 } 2022 } 2023 2024 /* Perform some off-by-one hacks on the length field of certain instructions. 2025 Its such a shame to have to do this, but the problem is that HLASM got 2026 defined so that the lengths differ by one from the actual machine instructions. 2027 this code should probably be moved to a special inster-operand routine. 2028 Sigh. Affected instructions are Compare Logical, Move and Exclusive OR 2029 hack alert -- aren't *all* SS instructions affected ?? */ 2030 off_by_one = 0; 2031 if (0 == strcasecmp ("CLC", opcode->name) 2032 || 0 == strcasecmp ("ED", opcode->name) 2033 || 0 == strcasecmp ("EDMK", opcode->name) 2034 || 0 == strcasecmp ("MVC", opcode->name) 2035 || 0 == strcasecmp ("MVCIN", opcode->name) 2036 || 0 == strcasecmp ("MVN", opcode->name) 2037 || 0 == strcasecmp ("MVZ", opcode->name) 2038 || 0 == strcasecmp ("NC", opcode->name) 2039 || 0 == strcasecmp ("OC", opcode->name) 2040 || 0 == strcasecmp ("XC", opcode->name)) 2041 off_by_one = 1; 2042 2043 /* Gather the operands. */ 2044 fc = 0; 2045 for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++) 2046 { 2047 const struct i370_operand *operand; 2048 char *hold; 2049 expressionS ex; 2050 2051 operand = &i370_operands[*opindex_ptr]; 2052 2053 /* If this is an index operand, and we are skipping it, 2054 just insert a zero. */ 2055 if (skip_optional_index && 2056 ((operand->flags & I370_OPERAND_INDEX) != 0)) 2057 { 2058 insn = i370_insert_operand (insn, operand, 0); 2059 continue; 2060 } 2061 2062 /* If this is the base operand, and we are skipping it, 2063 just insert the current using basreg. */ 2064 if (skip_optional_basereg && 2065 ((operand->flags & I370_OPERAND_BASE) != 0)) 2066 { 2067 int basereg = -1; 2068 if (use_text) 2069 { 2070 if (0 == strncmp (now_seg->name, ".text", 5) 2071 || 0 > i370_using_other_regno) 2072 basereg = i370_using_text_regno; 2073 else 2074 basereg = i370_using_other_regno; 2075 } 2076 else if (use_other) 2077 { 2078 if (0 > i370_using_other_regno) 2079 basereg = i370_using_text_regno; 2080 else 2081 basereg = i370_using_other_regno; 2082 } 2083 if (0 > basereg) 2084 as_bad (_("not using any base register")); 2085 2086 insn = i370_insert_operand (insn, operand, basereg); 2087 continue; 2088 } 2089 2090 /* If this is an optional operand, and we are skipping it, 2091 Use zero (since a non-zero value would denote a register) */ 2092 if (skip_optional_reg 2093 && ((operand->flags & I370_OPERAND_OPTIONAL) != 0)) 2094 { 2095 insn = i370_insert_operand (insn, operand, 0); 2096 continue; 2097 } 2098 2099 /* Gather the operand. */ 2100 hold = input_line_pointer; 2101 input_line_pointer = str; 2102 2103 /* Register names are only allowed where there are registers. */ 2104 if ((operand->flags & I370_OPERAND_GPR) != 0) 2105 { 2106 /* Quickie hack to get past things like (,r13). */ 2107 if (skip_optional_index && (',' == *input_line_pointer)) 2108 { 2109 *input_line_pointer = ' '; 2110 input_line_pointer ++; 2111 } 2112 2113 if (! register_name (&ex)) 2114 as_bad (_("expecting a register for operand %d"), 2115 (int) (opindex_ptr - opcode->operands + 1)); 2116 } 2117 2118 /* Check for an address constant expression. */ 2119 /* We will put PSW-relative addresses in the text section, 2120 and address literals in the .data (or other) section. */ 2121 else if (i370_addr_cons (&ex)) 2122 use_other = 1; 2123 else if (i370_addr_offset (&ex)) 2124 use_text = 1; 2125 else expression (&ex); 2126 2127 str = input_line_pointer; 2128 input_line_pointer = hold; 2129 2130 /* Perform some off-by-one hacks on the length field of certain instructions. 2131 Its such a shame to have to do this, but the problem is that HLASM got 2132 defined so that the programmer specifies a length that is one greater 2133 than what the machine instruction wants. Sigh. */ 2134 if (off_by_one && (0 == strcasecmp ("SS L", operand->name))) 2135 ex.X_add_number --; 2136 2137 if (ex.X_op == O_illegal) 2138 as_bad (_("illegal operand")); 2139 else if (ex.X_op == O_absent) 2140 as_bad (_("missing operand")); 2141 else if (ex.X_op == O_register) 2142 insn = i370_insert_operand (insn, operand, ex.X_add_number); 2143 else if (ex.X_op == O_constant) 2144 { 2145 #ifdef OBJ_ELF 2146 /* Allow @HA, @L, @H on constants. 2147 Well actually, no we don't; there really don't make sense 2148 (at least not to me) for the i370. However, this code is 2149 left here for any dubious future expansion reasons. */ 2150 char *orig_str = str; 2151 2152 if ((reloc = i370_elf_suffix (&str, &ex)) != BFD_RELOC_UNUSED) 2153 switch (reloc) 2154 { 2155 default: 2156 str = orig_str; 2157 break; 2158 2159 case BFD_RELOC_LO16: 2160 /* X_unsigned is the default, so if the user has done 2161 something which cleared it, we always produce a 2162 signed value. */ 2163 ex.X_add_number = (((ex.X_add_number & 0xffff) 2164 ^ 0x8000) 2165 - 0x8000); 2166 break; 2167 2168 case BFD_RELOC_HI16: 2169 ex.X_add_number = (ex.X_add_number >> 16) & 0xffff; 2170 break; 2171 2172 case BFD_RELOC_HI16_S: 2173 ex.X_add_number = (((ex.X_add_number >> 16) & 0xffff) 2174 + ((ex.X_add_number >> 15) & 1)); 2175 break; 2176 } 2177 #endif 2178 insn = i370_insert_operand (insn, operand, ex.X_add_number); 2179 } 2180 #ifdef OBJ_ELF 2181 else if ((reloc = i370_elf_suffix (&str, &ex)) != BFD_RELOC_UNUSED) 2182 { 2183 as_tsktsk ("md_assemble(): suffixed relocations not supported\n"); 2184 2185 /* We need to generate a fixup for this expression. */ 2186 if (fc >= MAX_INSN_FIXUPS) 2187 as_fatal ("too many fixups"); 2188 fixups[fc].exp = ex; 2189 fixups[fc].opindex = 0; 2190 fixups[fc].reloc = reloc; 2191 ++fc; 2192 } 2193 #endif /* OBJ_ELF */ 2194 else 2195 { 2196 /* We need to generate a fixup for this expression. */ 2197 /* Typically, the expression will just be a symbol ... 2198 printf ("insn %s needs fixup for %s \n", 2199 opcode->name, ex.X_add_symbol->bsym->name); */ 2200 2201 if (fc >= MAX_INSN_FIXUPS) 2202 as_fatal ("too many fixups"); 2203 fixups[fc].exp = ex; 2204 fixups[fc].opindex = *opindex_ptr; 2205 fixups[fc].reloc = BFD_RELOC_UNUSED; 2206 ++fc; 2207 } 2208 2209 /* Skip over delimiter (close paren, or comma). */ 2210 if ((')' == *str) && (',' == *(str+1))) 2211 ++str; 2212 if (*str != '\0') 2213 ++str; 2214 } 2215 2216 while (ISSPACE (*str)) 2217 ++str; 2218 2219 if (*str != '\0') 2220 as_bad (_("junk at end of line: `%s'"), str); 2221 2222 /* Write out the instruction. */ 2223 f = frag_more (opcode->len); 2224 if (4 >= opcode->len) 2225 md_number_to_chars (f, insn.i[0], opcode->len); 2226 else 2227 { 2228 md_number_to_chars (f, insn.i[0], 4); 2229 2230 if (6 == opcode->len) 2231 md_number_to_chars ((f + 4), ((insn.i[1])>>16), 2); 2232 else 2233 { 2234 /* Not used --- don't have any 8 byte instructions. */ 2235 as_bad (_("Internal Error: bad instruction length")); 2236 md_number_to_chars ((f + 4), insn.i[1], opcode->len -4); 2237 } 2238 } 2239 2240 /* Create any fixups. At this point we do not use a 2241 bfd_reloc_code_real_type, but instead just use the 2242 BFD_RELOC_UNUSED plus the operand index. This lets us easily 2243 handle fixups for any operand type, although that is admittedly 2244 not a very exciting feature. We pick a BFD reloc type in 2245 md_apply_fix. */ 2246 for (i = 0; i < fc; i++) 2247 { 2248 const struct i370_operand *operand; 2249 2250 operand = &i370_operands[fixups[i].opindex]; 2251 if (fixups[i].reloc != BFD_RELOC_UNUSED) 2252 { 2253 reloc_howto_type *reloc_howto = bfd_reloc_type_lookup (stdoutput, fixups[i].reloc); 2254 int size; 2255 fixS *fixP; 2256 2257 if (!reloc_howto) 2258 abort (); 2259 2260 size = bfd_get_reloc_size (reloc_howto); 2261 2262 if (size < 1 || size > 4) 2263 abort (); 2264 2265 printf (" gwana doo fixup %d \n", i); 2266 fixP = fix_new_exp (frag_now, f - frag_now->fr_literal, size, 2267 &fixups[i].exp, reloc_howto->pc_relative, 2268 fixups[i].reloc); 2269 2270 /* Turn off complaints that the addend is too large for things like 2271 foo+100000@ha. */ 2272 switch (fixups[i].reloc) 2273 { 2274 case BFD_RELOC_16_GOTOFF: 2275 case BFD_RELOC_LO16: 2276 case BFD_RELOC_HI16: 2277 case BFD_RELOC_HI16_S: 2278 fixP->fx_no_overflow = 1; 2279 break; 2280 default: 2281 break; 2282 } 2283 } 2284 else 2285 { 2286 fix_new_exp (frag_now, f - frag_now->fr_literal, opcode->len, 2287 &fixups[i].exp, 2288 (operand->flags & I370_OPERAND_RELATIVE) != 0, 2289 ((bfd_reloc_code_real_type) 2290 (fixups[i].opindex + (int) BFD_RELOC_UNUSED))); 2291 } 2292 } 2293 } 2294 2295 2296 /* Pseudo-op handling. */ 2298 2299 /* The .byte pseudo-op. This is similar to the normal .byte 2300 pseudo-op, but it can also take a single ASCII string. */ 2301 2302 static void 2303 i370_byte (int ignore ATTRIBUTE_UNUSED) 2304 { 2305 if (*input_line_pointer != '\"') 2306 { 2307 cons (1); 2308 return; 2309 } 2310 2311 /* Gather characters. A real double quote is doubled. Unusual 2312 characters are not permitted. */ 2313 ++input_line_pointer; 2314 while (1) 2315 { 2316 char c; 2317 2318 c = *input_line_pointer++; 2319 2320 if (c == '\"') 2321 { 2322 if (*input_line_pointer != '\"') 2323 break; 2324 ++input_line_pointer; 2325 } 2326 2327 FRAG_APPEND_1_CHAR (c); 2328 } 2329 2330 demand_empty_rest_of_line (); 2331 } 2332 2333 /* The .tc pseudo-op. This is used when generating XCOFF and ELF. 2335 This takes two or more arguments. 2336 2337 When generating XCOFF output, the first argument is the name to 2338 give to this location in the toc; this will be a symbol with class 2339 TC. The rest of the arguments are 4 byte values to actually put at 2340 this location in the TOC; often there is just one more argument, a 2341 relocatable symbol reference. 2342 2343 When not generating XCOFF output, the arguments are the same, but 2344 the first argument is simply ignored. */ 2345 2346 static void 2347 i370_tc (int ignore ATTRIBUTE_UNUSED) 2348 { 2349 2350 /* Skip the TOC symbol name. */ 2351 while (is_part_of_name (*input_line_pointer) 2352 || *input_line_pointer == '[' 2353 || *input_line_pointer == ']' 2354 || *input_line_pointer == '{' 2355 || *input_line_pointer == '}') 2356 ++input_line_pointer; 2357 2358 /* Align to a four byte boundary. */ 2359 frag_align (2, 0, 0); 2360 record_alignment (now_seg, 2); 2361 2362 if (*input_line_pointer != ',') 2363 demand_empty_rest_of_line (); 2364 else 2365 { 2366 ++input_line_pointer; 2367 cons (4); 2368 } 2369 } 2370 2371 char * 2373 md_atof (int type, char *litp, int *sizep) 2374 { 2375 /* 360/370/390 have two float formats: an old, funky 360 single-precision 2376 format, and the ieee format. Support only the ieee format. */ 2377 return ieee_md_atof (type, litp, sizep, TRUE); 2378 } 2379 2380 /* Write a value out to the object file, using the appropriate 2381 endianness. */ 2382 2383 void 2384 md_number_to_chars (char *buf, valueT val, int n) 2385 { 2386 number_to_chars_bigendian (buf, val, n); 2387 } 2388 2389 /* Align a section (I don't know why this is machine dependent). */ 2390 2391 valueT 2392 md_section_align (asection *seg, valueT addr) 2393 { 2394 int align = bfd_get_section_alignment (stdoutput, seg); 2395 2396 return (addr + (1 << align) - 1) & (-1 << align); 2397 } 2398 2399 /* We don't have any form of relaxing. */ 2400 2401 int 2402 md_estimate_size_before_relax (fragS *fragp ATTRIBUTE_UNUSED, 2403 asection *seg ATTRIBUTE_UNUSED) 2404 { 2405 abort (); 2406 return 0; 2407 } 2408 2409 /* Convert a machine dependent frag. We never generate these. */ 2410 2411 void 2412 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED, 2413 asection *sec ATTRIBUTE_UNUSED, 2414 fragS *fragp ATTRIBUTE_UNUSED) 2415 { 2416 abort (); 2417 } 2418 2419 /* We have no need to default values of symbols. */ 2420 2421 symbolS * 2422 md_undefined_symbol (char *name ATTRIBUTE_UNUSED) 2423 { 2424 return 0; 2425 } 2426 2427 /* Functions concerning relocs. */ 2429 2430 /* The location from which a PC relative jump should be calculated, 2431 given a PC relative reloc. */ 2432 2433 long 2434 md_pcrel_from_section (fixS *fixp, segT sec ATTRIBUTE_UNUSED) 2435 { 2436 return fixp->fx_frag->fr_address + fixp->fx_where; 2437 } 2438 2439 /* Apply a fixup to the object code. This is called for all the 2440 fixups we generated by the call to fix_new_exp, above. In the call 2441 above we used a reloc code which was the largest legal reloc code 2442 plus the operand index. Here we undo that to recover the operand 2443 index. At this point all symbol values should be fully resolved, 2444 and we attempt to completely resolve the reloc. If we can not do 2445 that, we determine the correct reloc code and put it back in the 2446 fixup. 2447 2448 See gas/cgen.c for more sample code and explanations of what's 2449 going on here. */ 2450 2451 void 2452 md_apply_fix (fixS *fixP, valueT * valP, segT seg) 2453 { 2454 valueT value = * valP; 2455 2456 if (fixP->fx_addsy != NULL) 2457 { 2458 #ifdef DEBUG 2459 printf ("\nmd_apply_fix: symbol %s at 0x%x (%s:%d) val=0x%x addend=0x%x\n", 2460 S_GET_NAME (fixP->fx_addsy), 2461 fixP->fx_frag->fr_address + fixP->fx_where, 2462 fixP->fx_file, fixP->fx_line, 2463 S_GET_VALUE (fixP->fx_addsy), value); 2464 #endif 2465 } 2466 else 2467 fixP->fx_done = 1; 2468 2469 /* Apply fixups to operands. Note that there should be no relocations 2470 for any operands, since no instruction ever takes an operand 2471 that requires reloc. */ 2472 if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED) 2473 { 2474 int opindex; 2475 const struct i370_operand *operand; 2476 char *where; 2477 i370_insn_t insn; 2478 2479 opindex = (int) fixP->fx_r_type - (int) BFD_RELOC_UNUSED; 2480 2481 operand = &i370_operands[opindex]; 2482 2483 #ifdef DEBUG 2484 printf ("\nmd_apply_fix: fixup operand %s at 0x%x in %s:%d addend=0x%x\n", 2485 operand->name, 2486 fixP->fx_frag->fr_address + fixP->fx_where, 2487 fixP->fx_file, fixP->fx_line, 2488 value); 2489 #endif 2490 /* Fetch the instruction, insert the fully resolved operand 2491 value, and stuff the instruction back again. 2492 fisxp->fx_size is the length of the instruction. */ 2493 where = fixP->fx_frag->fr_literal + fixP->fx_where; 2494 insn.i[0] = bfd_getb32 ((unsigned char *) where); 2495 2496 if (6 <= fixP->fx_size) 2497 /* Deal with 48-bit insn's. */ 2498 insn.i[1] = bfd_getb32 (((unsigned char *) where)+4); 2499 2500 insn = i370_insert_operand (insn, operand, (offsetT) value); 2501 bfd_putb32 ((bfd_vma) insn.i[0], (unsigned char *) where); 2502 2503 if (6 <= fixP->fx_size) 2504 /* Deal with 48-bit insn's. */ 2505 bfd_putb32 ((bfd_vma) insn.i[1], (((unsigned char *) where)+4)); 2506 2507 /* We are done, right? right !! */ 2508 fixP->fx_done = 1; 2509 if (fixP->fx_done) 2510 /* Nothing else to do here. */ 2511 return; 2512 2513 /* Determine a BFD reloc value based on the operand information. 2514 We are only prepared to turn a few of the operands into 2515 relocs. In fact, we support *zero* operand relocations ... 2516 Why? Because we are not expecting the compiler to generate 2517 any operands that need relocation. Due to the 12-bit naturew of 2518 i370 addressing, this would be unusual. */ 2519 { 2520 char *sfile; 2521 unsigned int sline; 2522 2523 /* Use expr_symbol_where to see if this is an expression 2524 symbol. */ 2525 if (expr_symbol_where (fixP->fx_addsy, &sfile, &sline)) 2526 as_bad_where (fixP->fx_file, fixP->fx_line, 2527 "unresolved expression that must be resolved"); 2528 else 2529 as_bad_where (fixP->fx_file, fixP->fx_line, 2530 "unsupported relocation type"); 2531 fixP->fx_done = 1; 2532 return; 2533 } 2534 } 2535 else 2536 { 2537 /* We branch to here if the fixup is not to a symbol that 2538 appears in an instruction operand, but is rather some 2539 declared storage. */ 2540 #ifdef OBJ_ELF 2541 i370_elf_validate_fix (fixP, seg); 2542 #endif 2543 #ifdef DEBUG 2544 printf ("md_apply_fix: reloc case %d in segment %s %s:%d\n", 2545 fixP->fx_r_type, segment_name (seg), fixP->fx_file, fixP->fx_line); 2546 printf ("\tcurrent fixup value is 0x%x \n", value); 2547 #endif 2548 switch (fixP->fx_r_type) 2549 { 2550 case BFD_RELOC_32: 2551 case BFD_RELOC_CTOR: 2552 if (fixP->fx_pcrel) 2553 fixP->fx_r_type = BFD_RELOC_32_PCREL; 2554 /* Fall through. */ 2555 2556 case BFD_RELOC_RVA: 2557 case BFD_RELOC_32_PCREL: 2558 case BFD_RELOC_32_BASEREL: 2559 #ifdef DEBUG 2560 printf ("\t32 bit relocation at 0x%x\n", 2561 fixP->fx_frag->fr_address + fixP->fx_where); 2562 #endif 2563 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where, 2564 value, 4); 2565 break; 2566 2567 case BFD_RELOC_LO16: 2568 case BFD_RELOC_16: 2569 if (fixP->fx_pcrel) 2570 as_bad_where (fixP->fx_file, fixP->fx_line, 2571 "cannot emit PC relative %s relocation%s%s", 2572 bfd_get_reloc_code_name (fixP->fx_r_type), 2573 fixP->fx_addsy != NULL ? " against " : "", 2574 (fixP->fx_addsy != NULL 2575 ? S_GET_NAME (fixP->fx_addsy) 2576 : "")); 2577 2578 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where, 2579 value, 2); 2580 break; 2581 2582 /* This case happens when you write, for example, 2583 lis %r3,(L1-L2)@ha 2584 where L1 and L2 are defined later. */ 2585 case BFD_RELOC_HI16: 2586 if (fixP->fx_pcrel) 2587 abort (); 2588 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where, 2589 value >> 16, 2); 2590 break; 2591 case BFD_RELOC_HI16_S: 2592 if (fixP->fx_pcrel) 2593 abort (); 2594 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where, 2595 (value + 0x8000) >> 16, 2); 2596 break; 2597 2598 case BFD_RELOC_8: 2599 if (fixP->fx_pcrel) 2600 abort (); 2601 2602 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where, 2603 value, 1); 2604 break; 2605 2606 default: 2607 fprintf (stderr, 2608 "Gas failure, reloc value %d\n", fixP->fx_r_type); 2609 fflush (stderr); 2610 abort (); 2611 } 2612 } 2613 2614 fixP->fx_addnumber = value; 2615 } 2616 2617 /* Generate a reloc for a fixup. */ 2618 2619 arelent * 2620 tc_gen_reloc (asection *seg ATTRIBUTE_UNUSED, fixS *fixp) 2621 { 2622 arelent *reloc; 2623 2624 reloc = xmalloc (sizeof (arelent)); 2625 2626 reloc->sym_ptr_ptr = xmalloc (sizeof (asymbol *)); 2627 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy); 2628 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where; 2629 reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type); 2630 if (reloc->howto == (reloc_howto_type *) NULL) 2631 { 2632 as_bad_where (fixp->fx_file, fixp->fx_line, 2633 "reloc %d not supported by object file format", (int)fixp->fx_r_type); 2634 return NULL; 2635 } 2636 reloc->addend = fixp->fx_addnumber; 2637 2638 #ifdef DEBUG 2639 printf ("\ngen_reloc(): sym %s (%s:%d) at addr 0x%x addend=0x%x\n", 2640 fixp->fx_addsy->bsym->name, 2641 fixp->fx_file, fixp->fx_line, 2642 reloc->address, reloc->addend); 2643 #endif 2644 2645 return reloc; 2646 } 2647 2648 /* The target specific pseudo-ops which we support. */ 2649 2650 const pseudo_typeS md_pseudo_table[] = 2651 { 2652 /* Pseudo-ops which must be overridden. */ 2653 { "byte", i370_byte, 0 }, 2654 2655 { "dc", i370_dc, 0 }, 2656 { "ds", i370_ds, 0 }, 2657 { "rmode", i370_rmode, 0 }, 2658 { "csect", i370_csect, 0 }, 2659 { "dsect", i370_dsect, 0 }, 2660 2661 /* enable ebcdic strings e.g. for 3270 support */ 2662 { "ebcdic", i370_ebcdic, 0 }, 2663 2664 #ifdef OBJ_ELF 2665 { "long", i370_elf_cons, 4 }, 2666 { "word", i370_elf_cons, 4 }, 2667 { "short", i370_elf_cons, 2 }, 2668 { "rdata", i370_elf_rdata, 0 }, 2669 { "rodata", i370_elf_rdata, 0 }, 2670 { "lcomm", i370_elf_lcomm, 0 }, 2671 #endif 2672 2673 /* This pseudo-op is used even when not generating XCOFF output. */ 2674 { "tc", i370_tc, 0 }, 2675 2676 /* dump the literal pool */ 2677 { "ltorg", i370_ltorg, 0 }, 2678 2679 /* support the hlasm-style USING directive */ 2680 { "using", i370_using, 0 }, 2681 { "drop", i370_drop, 0 }, 2682 2683 { NULL, NULL, 0 } 2684 }; 2685
