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