tc-s390.c revision 130562
1/* tc-s390.c -- Assemble for the S390 2 Copyright 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. 3 Contributed by Martin Schwidefsky (schwidefsky@de.ibm.com). 4 5 This file is part of GAS, the GNU Assembler. 6 7 GAS is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 2, or (at your option) 10 any later version. 11 12 GAS is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with GAS; see the file COPYING. If not, write to the Free 19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA 20 02111-1307, USA. */ 21 22#include <stdio.h> 23#include "as.h" 24#include "safe-ctype.h" 25#include "subsegs.h" 26#include "struc-symbol.h" 27#include "dwarf2dbg.h" 28#include "dw2gencfi.h" 29 30#include "opcode/s390.h" 31#include "elf/s390.h" 32 33/* The default architecture. */ 34#ifndef DEFAULT_ARCH 35#define DEFAULT_ARCH "s390" 36#endif 37static char *default_arch = DEFAULT_ARCH; 38/* Either 32 or 64, selects file format. */ 39static int s390_arch_size = 0; 40 41static unsigned int current_mode_mask = 0; 42static unsigned int current_cpu = -1U; 43 44/* Whether to use user friendly register names. Default is TRUE. */ 45#ifndef TARGET_REG_NAMES_P 46#define TARGET_REG_NAMES_P TRUE 47#endif 48 49static bfd_boolean reg_names_p = TARGET_REG_NAMES_P; 50 51/* Set to TRUE if we want to warn about zero base/index registers. */ 52static bfd_boolean warn_areg_zero = FALSE; 53 54/* Generic assembler global variables which must be defined by all 55 targets. */ 56 57const char comment_chars[] = "#"; 58 59/* Characters which start a comment at the beginning of a line. */ 60const char line_comment_chars[] = "#"; 61 62/* Characters which may be used to separate multiple commands on a 63 single line. */ 64const char line_separator_chars[] = ";"; 65 66/* Characters which are used to indicate an exponent in a floating 67 point number. */ 68const char EXP_CHARS[] = "eE"; 69 70/* Characters which mean that a number is a floating point constant, 71 as in 0d1.0. */ 72const char FLT_CHARS[] = "dD"; 73 74/* The dwarf2 data alignment, adjusted for 32 or 64 bit. */ 75int s390_cie_data_alignment; 76 77/* The target specific pseudo-ops which we support. */ 78 79/* Define the prototypes for the pseudo-ops */ 80static void s390_byte PARAMS ((int)); 81static void s390_elf_cons PARAMS ((int)); 82static void s390_bss PARAMS ((int)); 83static void s390_insn PARAMS ((int)); 84static void s390_literals PARAMS ((int)); 85 86const pseudo_typeS md_pseudo_table[] = 87{ 88 { "align", s_align_bytes, 0 }, 89 /* Pseudo-ops which must be defined. */ 90 { "bss", s390_bss, 0 }, 91 { "insn", s390_insn, 0 }, 92 /* Pseudo-ops which must be overridden. */ 93 { "byte", s390_byte, 0 }, 94 { "short", s390_elf_cons, 2 }, 95 { "long", s390_elf_cons, 4 }, 96 { "quad", s390_elf_cons, 8 }, 97 { "ltorg", s390_literals, 0 }, 98 { "string", stringer, 2 }, 99 { NULL, NULL, 0 } 100}; 101 102 103/* Structure to hold information about predefined registers. */ 104struct pd_reg 105 { 106 char *name; 107 int value; 108 }; 109 110/* List of registers that are pre-defined: 111 112 Each access register has a predefined name of the form: 113 a<reg_num> which has the value <reg_num>. 114 115 Each control register has a predefined name of the form: 116 c<reg_num> which has the value <reg_num>. 117 118 Each general register has a predefined name of the form: 119 r<reg_num> which has the value <reg_num>. 120 121 Each floating point register a has predefined name of the form: 122 f<reg_num> which has the value <reg_num>. 123 124 There are individual registers as well: 125 sp has the value 15 126 lit has the value 12 127 128 The table is sorted. Suitable for searching by a binary search. */ 129 130static const struct pd_reg pre_defined_registers[] = 131{ 132 { "a0", 0 }, /* Access registers */ 133 { "a1", 1 }, 134 { "a10", 10 }, 135 { "a11", 11 }, 136 { "a12", 12 }, 137 { "a13", 13 }, 138 { "a14", 14 }, 139 { "a15", 15 }, 140 { "a2", 2 }, 141 { "a3", 3 }, 142 { "a4", 4 }, 143 { "a5", 5 }, 144 { "a6", 6 }, 145 { "a7", 7 }, 146 { "a8", 8 }, 147 { "a9", 9 }, 148 149 { "c0", 0 }, /* Control registers */ 150 { "c1", 1 }, 151 { "c10", 10 }, 152 { "c11", 11 }, 153 { "c12", 12 }, 154 { "c13", 13 }, 155 { "c14", 14 }, 156 { "c15", 15 }, 157 { "c2", 2 }, 158 { "c3", 3 }, 159 { "c4", 4 }, 160 { "c5", 5 }, 161 { "c6", 6 }, 162 { "c7", 7 }, 163 { "c8", 8 }, 164 { "c9", 9 }, 165 166 { "f0", 0 }, /* Floating point registers */ 167 { "f1", 1 }, 168 { "f10", 10 }, 169 { "f11", 11 }, 170 { "f12", 12 }, 171 { "f13", 13 }, 172 { "f14", 14 }, 173 { "f15", 15 }, 174 { "f2", 2 }, 175 { "f3", 3 }, 176 { "f4", 4 }, 177 { "f5", 5 }, 178 { "f6", 6 }, 179 { "f7", 7 }, 180 { "f8", 8 }, 181 { "f9", 9 }, 182 183 { "lit", 13 }, /* Pointer to literal pool */ 184 185 { "r0", 0 }, /* General purpose registers */ 186 { "r1", 1 }, 187 { "r10", 10 }, 188 { "r11", 11 }, 189 { "r12", 12 }, 190 { "r13", 13 }, 191 { "r14", 14 }, 192 { "r15", 15 }, 193 { "r2", 2 }, 194 { "r3", 3 }, 195 { "r4", 4 }, 196 { "r5", 5 }, 197 { "r6", 6 }, 198 { "r7", 7 }, 199 { "r8", 8 }, 200 { "r9", 9 }, 201 202 { "sp", 15 }, /* Stack pointer */ 203 204}; 205 206#define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg)) 207 208static int reg_name_search 209 PARAMS ((const struct pd_reg *, int, const char *)); 210static bfd_boolean register_name PARAMS ((expressionS *)); 211static void init_default_arch PARAMS ((void)); 212static void s390_insert_operand 213 PARAMS ((unsigned char *, const struct s390_operand *, offsetT, char *, 214 unsigned int)); 215static char *md_gather_operands 216 PARAMS ((char *, unsigned char *, const struct s390_opcode *)); 217 218/* Given NAME, find the register number associated with that name, return 219 the integer value associated with the given name or -1 on failure. */ 220 221static int 222reg_name_search (regs, regcount, name) 223 const struct pd_reg *regs; 224 int regcount; 225 const char *name; 226{ 227 int middle, low, high; 228 int cmp; 229 230 low = 0; 231 high = regcount - 1; 232 233 do 234 { 235 middle = (low + high) / 2; 236 cmp = strcasecmp (name, regs[middle].name); 237 if (cmp < 0) 238 high = middle - 1; 239 else if (cmp > 0) 240 low = middle + 1; 241 else 242 return regs[middle].value; 243 } 244 while (low <= high); 245 246 return -1; 247} 248 249 250/* 251 * Summary of register_name(). 252 * 253 * in: Input_line_pointer points to 1st char of operand. 254 * 255 * out: A expressionS. 256 * The operand may have been a register: in this case, X_op == O_register, 257 * X_add_number is set to the register number, and truth is returned. 258 * Input_line_pointer->(next non-blank) char after operand, or is in its 259 * original state. 260 */ 261 262static bfd_boolean 263register_name (expressionP) 264 expressionS *expressionP; 265{ 266 int reg_number; 267 char *name; 268 char *start; 269 char c; 270 271 /* Find the spelling of the operand. */ 272 start = name = input_line_pointer; 273 if (name[0] == '%' && ISALPHA (name[1])) 274 name = ++input_line_pointer; 275 else 276 return FALSE; 277 278 c = get_symbol_end (); 279 reg_number = reg_name_search (pre_defined_registers, REG_NAME_CNT, name); 280 281 /* Put back the delimiting char. */ 282 *input_line_pointer = c; 283 284 /* Look to see if it's in the register table. */ 285 if (reg_number >= 0) 286 { 287 expressionP->X_op = O_register; 288 expressionP->X_add_number = reg_number; 289 290 /* Make the rest nice. */ 291 expressionP->X_add_symbol = NULL; 292 expressionP->X_op_symbol = NULL; 293 return TRUE; 294 } 295 296 /* Reset the line as if we had not done anything. */ 297 input_line_pointer = start; 298 return FALSE; 299} 300 301/* Local variables. */ 302 303/* Opformat hash table. */ 304static struct hash_control *s390_opformat_hash; 305 306/* Opcode hash table. */ 307static struct hash_control *s390_opcode_hash; 308 309/* Flags to set in the elf header */ 310static flagword s390_flags = 0; 311 312symbolS *GOT_symbol; /* Pre-defined "_GLOBAL_OFFSET_TABLE_" */ 313 314#ifndef WORKING_DOT_WORD 315const int md_short_jump_size = 4; 316const int md_long_jump_size = 4; 317#endif 318 319const char *md_shortopts = "A:m:kVQ:"; 320struct option md_longopts[] = { 321 {NULL, no_argument, NULL, 0} 322}; 323size_t md_longopts_size = sizeof (md_longopts); 324 325/* Initialize the default opcode arch and word size from the default 326 architecture name if not specified by an option. */ 327static void 328init_default_arch () 329{ 330 if (strcmp (default_arch, "s390") == 0) 331 { 332 if (s390_arch_size == 0) 333 s390_arch_size = 32; 334 } 335 else if (strcmp (default_arch, "s390x") == 0) 336 { 337 if (s390_arch_size == 0) 338 s390_arch_size = 64; 339 } 340 else 341 as_fatal ("Invalid default architecture, broken assembler."); 342 343 if (current_mode_mask == 0) 344 { 345 if (s390_arch_size == 32) 346 current_mode_mask = 1 << S390_OPCODE_ESA; 347 else 348 current_mode_mask = 1 << S390_OPCODE_ZARCH; 349 } 350 if (current_cpu == -1U) 351 { 352 if (current_mode_mask == (1 << S390_OPCODE_ESA)) 353 current_cpu = S390_OPCODE_G5; 354 else 355 current_cpu = S390_OPCODE_Z900; 356 } 357} 358 359/* Called by TARGET_FORMAT. */ 360const char * 361s390_target_format () 362{ 363 /* We don't get a chance to initialize anything before we're called, 364 so handle that now. */ 365 init_default_arch (); 366 367 return s390_arch_size == 64 ? "elf64-s390" : "elf32-s390"; 368} 369 370int 371md_parse_option (c, arg) 372 int c; 373 char *arg; 374{ 375 switch (c) 376 { 377 /* -k: Ignore for FreeBSD compatibility. */ 378 case 'k': 379 break; 380 case 'm': 381 if (arg != NULL && strcmp (arg, "regnames") == 0) 382 reg_names_p = TRUE; 383 384 else if (arg != NULL && strcmp (arg, "no-regnames") == 0) 385 reg_names_p = FALSE; 386 387 else if (arg != NULL && strcmp (arg, "warn-areg-zero") == 0) 388 warn_areg_zero = TRUE; 389 390 else if (arg != NULL && strcmp (arg, "31") == 0) 391 s390_arch_size = 32; 392 393 else if (arg != NULL && strcmp (arg, "64") == 0) 394 s390_arch_size = 64; 395 396 else if (arg != NULL && strcmp (arg, "esa") == 0) 397 current_mode_mask = 1 << S390_OPCODE_ESA; 398 399 else if (arg != NULL && strcmp (arg, "zarch") == 0) 400 current_mode_mask = 1 << S390_OPCODE_ZARCH; 401 402 else if (arg != NULL && strncmp (arg, "arch=", 5) == 0) 403 { 404 if (strcmp (arg + 5, "g5") == 0) 405 current_cpu = S390_OPCODE_G5; 406 else if (strcmp (arg + 5, "g6") == 0) 407 current_cpu = S390_OPCODE_G6; 408 else if (strcmp (arg + 5, "z900") == 0) 409 current_cpu = S390_OPCODE_Z900; 410 else if (strcmp (arg + 5, "z990") == 0) 411 current_cpu = S390_OPCODE_Z990; 412 else 413 { 414 as_bad (_("invalid switch -m%s"), arg); 415 return 0; 416 } 417 } 418 419 else 420 { 421 as_bad (_("invalid switch -m%s"), arg); 422 return 0; 423 } 424 break; 425 426 case 'A': 427 /* Option -A is deprecated. Still available for compatibility. */ 428 if (arg != NULL && strcmp (arg, "esa") == 0) 429 current_cpu = S390_OPCODE_G5; 430 else if (arg != NULL && strcmp (arg, "esame") == 0) 431 current_cpu = S390_OPCODE_Z900; 432 else 433 as_bad ("invalid architecture -A%s", arg); 434 break; 435 436 /* -V: SVR4 argument to print version ID. */ 437 case 'V': 438 print_version_id (); 439 break; 440 441 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section 442 should be emitted or not. FIXME: Not implemented. */ 443 case 'Q': 444 break; 445 446 default: 447 return 0; 448 } 449 450 return 1; 451} 452 453void 454md_show_usage (stream) 455 FILE *stream; 456{ 457 fprintf (stream, _("\ 458 S390 options:\n\ 459 -mregnames Allow symbolic names for registers\n\ 460 -mwarn-areg-zero Warn about zero base/index registers\n\ 461 -mno-regnames Do not allow symbolic names for registers\n\ 462 -m31 Set file format to 31 bit format\n\ 463 -m64 Set file format to 64 bit format\n")); 464 fprintf (stream, _("\ 465 -V print assembler version number\n\ 466 -Qy, -Qn ignored\n")); 467} 468 469/* This function is called when the assembler starts up. It is called 470 after the options have been parsed and the output file has been 471 opened. */ 472 473void 474md_begin () 475{ 476 register const struct s390_opcode *op; 477 const struct s390_opcode *op_end; 478 bfd_boolean dup_insn = FALSE; 479 const char *retval; 480 481 /* Give a warning if the combination -m64-bit and -Aesa is used. */ 482 if (s390_arch_size == 64 && current_cpu < S390_OPCODE_Z900) 483 as_warn ("The 64 bit file format is used without esame instructions."); 484 485 s390_cie_data_alignment = -s390_arch_size / 8; 486 487 /* Set the ELF flags if desired. */ 488 if (s390_flags) 489 bfd_set_private_flags (stdoutput, s390_flags); 490 491 /* Insert the opcode formats into a hash table. */ 492 s390_opformat_hash = hash_new (); 493 494 op_end = s390_opformats + s390_num_opformats; 495 for (op = s390_opformats; op < op_end; op++) 496 { 497 retval = hash_insert (s390_opformat_hash, op->name, (PTR) op); 498 if (retval != (const char *) NULL) 499 { 500 as_bad (_("Internal assembler error for instruction format %s"), 501 op->name); 502 dup_insn = TRUE; 503 } 504 } 505 506 /* Insert the opcodes into a hash table. */ 507 s390_opcode_hash = hash_new (); 508 509 op_end = s390_opcodes + s390_num_opcodes; 510 for (op = s390_opcodes; op < op_end; op++) 511 if (op->min_cpu <= current_cpu) 512 { 513 retval = hash_insert (s390_opcode_hash, op->name, (PTR) op); 514 if (retval != (const char *) NULL) 515 { 516 as_bad (_("Internal assembler error for instruction %s"), 517 op->name); 518 dup_insn = TRUE; 519 } 520 while (op < op_end - 1 && strcmp (op->name, op[1].name) == 0) 521 op++; 522 } 523 524 if (dup_insn) 525 abort (); 526 527 record_alignment (text_section, 2); 528 record_alignment (data_section, 2); 529 record_alignment (bss_section, 2); 530 531} 532 533/* Called after all assembly has been done. */ 534void 535s390_md_end () 536{ 537 if (s390_arch_size == 64) 538 bfd_set_arch_mach (stdoutput, bfd_arch_s390, bfd_mach_s390_64); 539 else 540 bfd_set_arch_mach (stdoutput, bfd_arch_s390, bfd_mach_s390_31); 541} 542 543/* Insert an operand value into an instruction. */ 544 545static void 546s390_insert_operand (insn, operand, val, file, line) 547 unsigned char *insn; 548 const struct s390_operand *operand; 549 offsetT val; 550 char *file; 551 unsigned int line; 552{ 553 addressT uval; 554 int offset; 555 556 if (operand->flags & (S390_OPERAND_SIGNED|S390_OPERAND_PCREL)) 557 { 558 offsetT min, max; 559 560 max = ((offsetT) 1 << (operand->bits - 1)) - 1; 561 min = - ((offsetT) 1 << (operand->bits - 1)); 562 /* Halve PCREL operands. */ 563 if (operand->flags & S390_OPERAND_PCREL) 564 val >>= 1; 565 /* Check for underflow / overflow. */ 566 if (val < min || val > max) 567 { 568 const char *err = 569 "operand out of range (%s not between %ld and %ld)"; 570 char buf[100]; 571 572 if (operand->flags & S390_OPERAND_PCREL) 573 { 574 val <<= 1; 575 min <<= 1; 576 max <<= 1; 577 } 578 sprint_value (buf, val); 579 if (file == (char *) NULL) 580 as_bad (err, buf, (int) min, (int) max); 581 else 582 as_bad_where (file, line, err, buf, (int) min, (int) max); 583 return; 584 } 585 /* val is ok, now restrict it to operand->bits bits. */ 586 uval = (addressT) val & ((((addressT) 1 << (operand->bits-1)) << 1) - 1); 587 /* val is restrict, now check for special case. */ 588 if (operand->bits == 20 && operand->shift == 20) 589 uval = (uval >> 12) | ((uval & 0xfff) << 8); 590 } 591 else 592 { 593 addressT min, max; 594 595 max = (((addressT) 1 << (operand->bits - 1)) << 1) - 1; 596 min = (offsetT) 0; 597 uval = (addressT) val; 598 /* Length x in an instructions has real length x+1. */ 599 if (operand->flags & S390_OPERAND_LENGTH) 600 uval--; 601 /* Check for underflow / overflow. */ 602 if (uval < min || uval > max) 603 { 604 const char *err = 605 "operand out of range (%s not between %ld and %ld)"; 606 char buf[100]; 607 608 if (operand->flags & S390_OPERAND_LENGTH) 609 { 610 uval++; 611 min++; 612 max++; 613 } 614 sprint_value (buf, uval); 615 if (file == (char *) NULL) 616 as_bad (err, buf, (int) min, (int) max); 617 else 618 as_bad_where (file, line, err, buf, (int) min, (int) max); 619 return; 620 } 621 } 622 623 /* Insert fragments of the operand byte for byte. */ 624 offset = operand->shift + operand->bits; 625 uval <<= (-offset) & 7; 626 insn += (offset - 1) / 8; 627 while (uval != 0) 628 { 629 *insn-- |= uval; 630 uval >>= 8; 631 } 632} 633 634struct map_tls 635 { 636 char *string; 637 int length; 638 bfd_reloc_code_real_type reloc; 639 }; 640 641static bfd_reloc_code_real_type s390_tls_suffix 642 PARAMS ((char **, expressionS *)); 643 644/* Parse tls marker and return the desired relocation. */ 645static bfd_reloc_code_real_type 646s390_tls_suffix (str_p, exp_p) 647 char **str_p; 648 expressionS *exp_p; 649{ 650 static struct map_tls mapping[] = 651 { 652 { "tls_load", 8, BFD_RELOC_390_TLS_LOAD }, 653 { "tls_gdcall", 10, BFD_RELOC_390_TLS_GDCALL }, 654 { "tls_ldcall", 10, BFD_RELOC_390_TLS_LDCALL }, 655 { NULL, 0, BFD_RELOC_UNUSED } 656 }; 657 struct map_tls *ptr; 658 char *orig_line; 659 char *str; 660 char *ident; 661 int len; 662 663 str = *str_p; 664 if (*str++ != ':') 665 return BFD_RELOC_UNUSED; 666 667 ident = str; 668 while (ISIDNUM (*str)) 669 str++; 670 len = str - ident; 671 if (*str++ != ':') 672 return BFD_RELOC_UNUSED; 673 674 orig_line = input_line_pointer; 675 input_line_pointer = str; 676 expression (exp_p); 677 str = input_line_pointer; 678 if (&input_line_pointer != str_p) 679 input_line_pointer = orig_line; 680 681 if (exp_p->X_op != O_symbol) 682 return BFD_RELOC_UNUSED; 683 684 for (ptr = &mapping[0]; ptr->length > 0; ptr++) 685 if (len == ptr->length 686 && strncasecmp (ident, ptr->string, ptr->length) == 0) 687 { 688 /* Found a matching tls suffix. */ 689 *str_p = str; 690 return ptr->reloc; 691 } 692 return BFD_RELOC_UNUSED; 693} 694 695/* Structure used to hold suffixes. */ 696typedef enum 697 { 698 ELF_SUFFIX_NONE = 0, 699 ELF_SUFFIX_GOT, 700 ELF_SUFFIX_PLT, 701 ELF_SUFFIX_GOTENT, 702 ELF_SUFFIX_GOTOFF, 703 ELF_SUFFIX_GOTPLT, 704 ELF_SUFFIX_PLTOFF, 705 ELF_SUFFIX_TLS_GD, 706 ELF_SUFFIX_TLS_GOTIE, 707 ELF_SUFFIX_TLS_IE, 708 ELF_SUFFIX_TLS_LDM, 709 ELF_SUFFIX_TLS_LDO, 710 ELF_SUFFIX_TLS_LE 711 } 712elf_suffix_type; 713 714struct map_bfd 715 { 716 char *string; 717 int length; 718 elf_suffix_type suffix; 719 }; 720 721static elf_suffix_type s390_elf_suffix PARAMS ((char **, expressionS *)); 722static int s390_exp_compare PARAMS ((expressionS *exp1, expressionS *exp2)); 723static elf_suffix_type s390_lit_suffix 724 PARAMS ((char **, expressionS *, elf_suffix_type)); 725 726 727/* Parse @got/@plt/@gotoff. and return the desired relocation. */ 728static elf_suffix_type 729s390_elf_suffix (str_p, exp_p) 730 char **str_p; 731 expressionS *exp_p; 732{ 733 static struct map_bfd mapping[] = 734 { 735 { "got", 3, ELF_SUFFIX_GOT }, 736 { "got12", 5, ELF_SUFFIX_GOT }, 737 { "plt", 3, ELF_SUFFIX_PLT }, 738 { "gotent", 6, ELF_SUFFIX_GOTENT }, 739 { "gotoff", 6, ELF_SUFFIX_GOTOFF }, 740 { "gotplt", 6, ELF_SUFFIX_GOTPLT }, 741 { "pltoff", 6, ELF_SUFFIX_PLTOFF }, 742 { "tlsgd", 5, ELF_SUFFIX_TLS_GD }, 743 { "gotntpoff", 9, ELF_SUFFIX_TLS_GOTIE }, 744 { "indntpoff", 9, ELF_SUFFIX_TLS_IE }, 745 { "tlsldm", 6, ELF_SUFFIX_TLS_LDM }, 746 { "dtpoff", 6, ELF_SUFFIX_TLS_LDO }, 747 { "ntpoff", 6, ELF_SUFFIX_TLS_LE }, 748 { NULL, 0, ELF_SUFFIX_NONE } 749 }; 750 751 struct map_bfd *ptr; 752 char *str = *str_p; 753 char *ident; 754 int len; 755 756 if (*str++ != '@') 757 return ELF_SUFFIX_NONE; 758 759 ident = str; 760 while (ISALNUM (*str)) 761 str++; 762 len = str - ident; 763 764 for (ptr = &mapping[0]; ptr->length > 0; ptr++) 765 if (len == ptr->length 766 && strncasecmp (ident, ptr->string, ptr->length) == 0) 767 { 768 if (exp_p->X_add_number != 0) 769 as_warn (_("identifier+constant@%s means identifier@%s+constant"), 770 ptr->string, ptr->string); 771 /* Now check for identifier@suffix+constant. */ 772 if (*str == '-' || *str == '+') 773 { 774 char *orig_line = input_line_pointer; 775 expressionS new_exp; 776 777 input_line_pointer = str; 778 expression (&new_exp); 779 780 switch (new_exp.X_op) 781 { 782 case O_constant: /* X_add_number (a constant expression). */ 783 exp_p->X_add_number += new_exp.X_add_number; 784 str = input_line_pointer; 785 break; 786 case O_symbol: /* X_add_symbol + X_add_number. */ 787 /* this case is used for e.g. xyz@PLT+.Label. */ 788 exp_p->X_add_number += new_exp.X_add_number; 789 exp_p->X_op_symbol = new_exp.X_add_symbol; 790 exp_p->X_op = O_add; 791 str = input_line_pointer; 792 break; 793 case O_uminus: /* (- X_add_symbol) + X_add_number. */ 794 /* this case is used for e.g. xyz@PLT-.Label. */ 795 exp_p->X_add_number += new_exp.X_add_number; 796 exp_p->X_op_symbol = new_exp.X_add_symbol; 797 exp_p->X_op = O_subtract; 798 str = input_line_pointer; 799 break; 800 default: 801 break; 802 } 803 804 /* If s390_elf_suffix has not been called with 805 &input_line_pointer as first parameter, we have 806 clobbered the input_line_pointer. We have to 807 undo that. */ 808 if (&input_line_pointer != str_p) 809 input_line_pointer = orig_line; 810 } 811 *str_p = str; 812 return ptr->suffix; 813 } 814 815 return BFD_RELOC_UNUSED; 816} 817 818/* Structure used to hold a literal pool entry. */ 819struct s390_lpe 820 { 821 struct s390_lpe *next; 822 expressionS ex; 823 FLONUM_TYPE floatnum; /* used if X_op == O_big && X_add_number <= 0 */ 824 LITTLENUM_TYPE bignum[4]; /* used if X_op == O_big && X_add_number > 0 */ 825 int nbytes; 826 bfd_reloc_code_real_type reloc; 827 symbolS *sym; 828 }; 829 830static struct s390_lpe *lpe_free_list = NULL; 831static struct s390_lpe *lpe_list = NULL; 832static struct s390_lpe *lpe_list_tail = NULL; 833static symbolS *lp_sym = NULL; 834static int lp_count = 0; 835static int lpe_count = 0; 836 837static int 838s390_exp_compare (exp1, exp2) 839 expressionS *exp1; 840 expressionS *exp2; 841{ 842 if (exp1->X_op != exp2->X_op) 843 return 0; 844 845 switch (exp1->X_op) 846 { 847 case O_constant: /* X_add_number must be equal. */ 848 case O_register: 849 return exp1->X_add_number == exp2->X_add_number; 850 851 case O_big: 852 as_bad (_("Can't handle O_big in s390_exp_compare")); 853 854 case O_symbol: /* X_add_symbol & X_add_number must be equal. */ 855 case O_symbol_rva: 856 case O_uminus: 857 case O_bit_not: 858 case O_logical_not: 859 return (exp1->X_add_symbol == exp2->X_add_symbol) 860 && (exp1->X_add_number == exp2->X_add_number); 861 862 case O_multiply: /* X_add_symbol,X_op_symbol&X_add_number must be equal. */ 863 case O_divide: 864 case O_modulus: 865 case O_left_shift: 866 case O_right_shift: 867 case O_bit_inclusive_or: 868 case O_bit_or_not: 869 case O_bit_exclusive_or: 870 case O_bit_and: 871 case O_add: 872 case O_subtract: 873 case O_eq: 874 case O_ne: 875 case O_lt: 876 case O_le: 877 case O_ge: 878 case O_gt: 879 case O_logical_and: 880 case O_logical_or: 881 return (exp1->X_add_symbol == exp2->X_add_symbol) 882 && (exp1->X_op_symbol == exp2->X_op_symbol) 883 && (exp1->X_add_number == exp2->X_add_number); 884 default: 885 return 0; 886 } 887} 888 889/* Test for @lit and if its present make an entry in the literal pool and 890 modify the current expression to be an offset into the literal pool. */ 891static elf_suffix_type 892s390_lit_suffix (str_p, exp_p, suffix) 893 char **str_p; 894 expressionS *exp_p; 895 elf_suffix_type suffix; 896{ 897 bfd_reloc_code_real_type reloc; 898 char tmp_name[64]; 899 char *str = *str_p; 900 char *ident; 901 struct s390_lpe *lpe; 902 int nbytes, len; 903 904 if (*str++ != ':') 905 return suffix; /* No modification. */ 906 907 /* We look for a suffix of the form "@lit1", "@lit2", "@lit4" or "@lit8". */ 908 ident = str; 909 while (ISALNUM (*str)) 910 str++; 911 len = str - ident; 912 if (len != 4 || strncasecmp (ident, "lit", 3) != 0 913 || (ident[3]!='1' && ident[3]!='2' && ident[3]!='4' && ident[3]!='8')) 914 return suffix; /* no modification */ 915 nbytes = ident[3] - '0'; 916 917 reloc = BFD_RELOC_UNUSED; 918 if (suffix == ELF_SUFFIX_GOT) 919 { 920 if (nbytes == 2) 921 reloc = BFD_RELOC_390_GOT16; 922 else if (nbytes == 4) 923 reloc = BFD_RELOC_32_GOT_PCREL; 924 else if (nbytes == 8) 925 reloc = BFD_RELOC_390_GOT64; 926 } 927 else if (suffix == ELF_SUFFIX_PLT) 928 { 929 if (nbytes == 4) 930 reloc = BFD_RELOC_390_PLT32; 931 else if (nbytes == 8) 932 reloc = BFD_RELOC_390_PLT64; 933 } 934 935 if (suffix != ELF_SUFFIX_NONE && reloc == BFD_RELOC_UNUSED) 936 as_bad (_("Invalid suffix for literal pool entry")); 937 938 /* Search the pool if the new entry is a duplicate. */ 939 if (exp_p->X_op == O_big) 940 { 941 /* Special processing for big numbers. */ 942 for (lpe = lpe_list; lpe != NULL; lpe = lpe->next) 943 { 944 if (lpe->ex.X_op == O_big) 945 { 946 if (exp_p->X_add_number <= 0 && lpe->ex.X_add_number <= 0) 947 { 948 if (memcmp (&generic_floating_point_number, &lpe->floatnum, 949 sizeof (FLONUM_TYPE)) == 0) 950 break; 951 } 952 else if (exp_p->X_add_number == lpe->ex.X_add_number) 953 { 954 if (memcmp (generic_bignum, lpe->bignum, 955 sizeof (LITTLENUM_TYPE)*exp_p->X_add_number) == 0) 956 break; 957 } 958 } 959 } 960 } 961 else 962 { 963 /* Processing for 'normal' data types. */ 964 for (lpe = lpe_list; lpe != NULL; lpe = lpe->next) 965 if (lpe->nbytes == nbytes && lpe->reloc == reloc 966 && s390_exp_compare (exp_p, &lpe->ex) != 0) 967 break; 968 } 969 970 if (lpe == NULL) 971 { 972 /* A new literal. */ 973 if (lpe_free_list != NULL) 974 { 975 lpe = lpe_free_list; 976 lpe_free_list = lpe_free_list->next; 977 } 978 else 979 { 980 lpe = (struct s390_lpe *) xmalloc (sizeof (struct s390_lpe)); 981 } 982 983 lpe->ex = *exp_p; 984 985 if (exp_p->X_op == O_big) 986 { 987 if (exp_p->X_add_number <= 0) 988 lpe->floatnum = generic_floating_point_number; 989 else if (exp_p->X_add_number <= 4) 990 memcpy (lpe->bignum, generic_bignum, 991 exp_p->X_add_number * sizeof (LITTLENUM_TYPE)); 992 else 993 as_bad (_("Big number is too big")); 994 } 995 996 lpe->nbytes = nbytes; 997 lpe->reloc = reloc; 998 /* Literal pool name defined ? */ 999 if (lp_sym == NULL) 1000 { 1001 sprintf (tmp_name, ".L\001%i", lp_count); 1002 lp_sym = symbol_make (tmp_name); 1003 } 1004 1005 /* Make name for literal pool entry. */ 1006 sprintf (tmp_name, ".L\001%i\002%i", lp_count, lpe_count); 1007 lpe_count++; 1008 lpe->sym = symbol_make (tmp_name); 1009 1010 /* Add to literal pool list. */ 1011 lpe->next = NULL; 1012 if (lpe_list_tail != NULL) 1013 { 1014 lpe_list_tail->next = lpe; 1015 lpe_list_tail = lpe; 1016 } 1017 else 1018 lpe_list = lpe_list_tail = lpe; 1019 } 1020 1021 /* Now change exp_p to the offset into the literal pool. 1022 Thats the expression: .L^Ax^By-.L^Ax */ 1023 exp_p->X_add_symbol = lpe->sym; 1024 exp_p->X_op_symbol = lp_sym; 1025 exp_p->X_op = O_subtract; 1026 exp_p->X_add_number = 0; 1027 1028 *str_p = str; 1029 1030 /* We change the suffix type to ELF_SUFFIX_NONE, because 1031 the difference of two local labels is just a number. */ 1032 return ELF_SUFFIX_NONE; 1033} 1034 1035/* Like normal .long/.short/.word, except support @got, etc. 1036 clobbers input_line_pointer, checks end-of-line. */ 1037static void 1038s390_elf_cons (nbytes) 1039 register int nbytes; /* 1=.byte, 2=.word, 4=.long */ 1040{ 1041 expressionS exp; 1042 elf_suffix_type suffix; 1043 1044 if (is_it_end_of_statement ()) 1045 { 1046 demand_empty_rest_of_line (); 1047 return; 1048 } 1049 1050 do 1051 { 1052 expression (&exp); 1053 1054 if (exp.X_op == O_symbol 1055 && *input_line_pointer == '@' 1056 && (suffix = s390_elf_suffix (&input_line_pointer, &exp)) != ELF_SUFFIX_NONE) 1057 { 1058 bfd_reloc_code_real_type reloc; 1059 reloc_howto_type *reloc_howto; 1060 int size; 1061 char *where; 1062 1063 if (nbytes == 2) 1064 { 1065 static bfd_reloc_code_real_type tab2[] = 1066 { 1067 BFD_RELOC_UNUSED, /* ELF_SUFFIX_NONE */ 1068 BFD_RELOC_390_GOT16, /* ELF_SUFFIX_GOT */ 1069 BFD_RELOC_UNUSED, /* ELF_SUFFIX_PLT */ 1070 BFD_RELOC_UNUSED, /* ELF_SUFFIX_GOTENT */ 1071 BFD_RELOC_16_GOTOFF, /* ELF_SUFFIX_GOTOFF */ 1072 BFD_RELOC_UNUSED, /* ELF_SUFFIX_GOTPLT */ 1073 BFD_RELOC_390_PLTOFF16, /* ELF_SUFFIX_PLTOFF */ 1074 BFD_RELOC_UNUSED, /* ELF_SUFFIX_TLS_GD */ 1075 BFD_RELOC_UNUSED, /* ELF_SUFFIX_TLS_GOTIE */ 1076 BFD_RELOC_UNUSED, /* ELF_SUFFIX_TLS_IE */ 1077 BFD_RELOC_UNUSED, /* ELF_SUFFIX_TLS_LDM */ 1078 BFD_RELOC_UNUSED, /* ELF_SUFFIX_TLS_LDO */ 1079 BFD_RELOC_UNUSED /* ELF_SUFFIX_TLS_LE */ 1080 }; 1081 reloc = tab2[suffix]; 1082 } 1083 else if (nbytes == 4) 1084 { 1085 static bfd_reloc_code_real_type tab4[] = 1086 { 1087 BFD_RELOC_UNUSED, /* ELF_SUFFIX_NONE */ 1088 BFD_RELOC_32_GOT_PCREL, /* ELF_SUFFIX_GOT */ 1089 BFD_RELOC_390_PLT32, /* ELF_SUFFIX_PLT */ 1090 BFD_RELOC_UNUSED, /* ELF_SUFFIX_GOTENT */ 1091 BFD_RELOC_32_GOTOFF, /* ELF_SUFFIX_GOTOFF */ 1092 BFD_RELOC_390_GOTPLT32, /* ELF_SUFFIX_GOTPLT */ 1093 BFD_RELOC_390_PLTOFF32, /* ELF_SUFFIX_PLTOFF */ 1094 BFD_RELOC_390_TLS_GD32, /* ELF_SUFFIX_TLS_GD */ 1095 BFD_RELOC_390_TLS_GOTIE32, /* ELF_SUFFIX_TLS_GOTIE */ 1096 BFD_RELOC_390_TLS_IE32, /* ELF_SUFFIX_TLS_IE */ 1097 BFD_RELOC_390_TLS_LDM32, /* ELF_SUFFIX_TLS_LDM */ 1098 BFD_RELOC_390_TLS_LDO32, /* ELF_SUFFIX_TLS_LDO */ 1099 BFD_RELOC_390_TLS_LE32 /* ELF_SUFFIX_TLS_LE */ 1100 }; 1101 reloc = tab4[suffix]; 1102 } 1103 else if (nbytes == 8) 1104 { 1105 static bfd_reloc_code_real_type tab8[] = 1106 { 1107 BFD_RELOC_UNUSED, /* ELF_SUFFIX_NONE */ 1108 BFD_RELOC_390_GOT64, /* ELF_SUFFIX_GOT */ 1109 BFD_RELOC_390_PLT64, /* ELF_SUFFIX_PLT */ 1110 BFD_RELOC_UNUSED, /* ELF_SUFFIX_GOTENT */ 1111 BFD_RELOC_390_GOTOFF64, /* ELF_SUFFIX_GOTOFF */ 1112 BFD_RELOC_390_GOTPLT64, /* ELF_SUFFIX_GOTPLT */ 1113 BFD_RELOC_390_PLTOFF64, /* ELF_SUFFIX_PLTOFF */ 1114 BFD_RELOC_390_TLS_GD64, /* ELF_SUFFIX_TLS_GD */ 1115 BFD_RELOC_390_TLS_GOTIE64, /* ELF_SUFFIX_TLS_GOTIE */ 1116 BFD_RELOC_390_TLS_IE64, /* ELF_SUFFIX_TLS_IE */ 1117 BFD_RELOC_390_TLS_LDM64, /* ELF_SUFFIX_TLS_LDM */ 1118 BFD_RELOC_390_TLS_LDO64, /* ELF_SUFFIX_TLS_LDO */ 1119 BFD_RELOC_390_TLS_LE64 /* ELF_SUFFIX_TLS_LE */ 1120 }; 1121 reloc = tab8[suffix]; 1122 } 1123 else 1124 reloc = BFD_RELOC_UNUSED; 1125 1126 if (reloc != BFD_RELOC_UNUSED 1127 && (reloc_howto = bfd_reloc_type_lookup (stdoutput, reloc))) 1128 { 1129 size = bfd_get_reloc_size (reloc_howto); 1130 if (size > nbytes) 1131 as_bad (_("%s relocations do not fit in %d bytes"), 1132 reloc_howto->name, nbytes); 1133 where = frag_more (nbytes); 1134 md_number_to_chars (where, 0, size); 1135 /* To make fixup_segment do the pc relative conversion the 1136 pcrel parameter on the fix_new_exp call needs to be FALSE. */ 1137 fix_new_exp (frag_now, where - frag_now->fr_literal, 1138 size, &exp, FALSE, reloc); 1139 } 1140 else 1141 as_bad (_("relocation not applicable")); 1142 } 1143 else 1144 emit_expr (&exp, (unsigned int) nbytes); 1145 } 1146 while (*input_line_pointer++ == ','); 1147 1148 input_line_pointer--; /* Put terminator back into stream. */ 1149 demand_empty_rest_of_line (); 1150} 1151 1152/* We need to keep a list of fixups. We can't simply generate them as 1153 we go, because that would require us to first create the frag, and 1154 that would screw up references to ``.''. */ 1155 1156struct s390_fixup 1157 { 1158 expressionS exp; 1159 int opindex; 1160 bfd_reloc_code_real_type reloc; 1161 }; 1162 1163#define MAX_INSN_FIXUPS (4) 1164 1165/* This routine is called for each instruction to be assembled. */ 1166 1167static char * 1168md_gather_operands (str, insn, opcode) 1169 char *str; 1170 unsigned char *insn; 1171 const struct s390_opcode *opcode; 1172{ 1173 struct s390_fixup fixups[MAX_INSN_FIXUPS]; 1174 const struct s390_operand *operand; 1175 const unsigned char *opindex_ptr; 1176 expressionS ex; 1177 elf_suffix_type suffix; 1178 bfd_reloc_code_real_type reloc; 1179 int skip_optional; 1180 int parentheses; 1181 char *f; 1182 int fc, i; 1183 1184 while (ISSPACE (*str)) 1185 str++; 1186 1187 parentheses = 0; 1188 skip_optional = 0; 1189 1190 /* Gather the operands. */ 1191 fc = 0; 1192 for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++) 1193 { 1194 char *hold; 1195 1196 operand = s390_operands + *opindex_ptr; 1197 1198 if (skip_optional && (operand->flags & S390_OPERAND_INDEX)) 1199 { 1200 /* We do an early skip. For D(X,B) constructions the index 1201 register is skipped (X is optional). For D(L,B) the base 1202 register will be the skipped operand, because L is NOT 1203 optional. */ 1204 skip_optional = 0; 1205 continue; 1206 } 1207 1208 /* Gather the operand. */ 1209 hold = input_line_pointer; 1210 input_line_pointer = str; 1211 1212 /* Parse the operand. */ 1213 if (! register_name (&ex)) 1214 expression (&ex); 1215 1216 str = input_line_pointer; 1217 input_line_pointer = hold; 1218 1219 /* Write the operand to the insn. */ 1220 if (ex.X_op == O_illegal) 1221 as_bad (_("illegal operand")); 1222 else if (ex.X_op == O_absent) 1223 as_bad (_("missing operand")); 1224 else if (ex.X_op == O_register || ex.X_op == O_constant) 1225 { 1226 s390_lit_suffix (&str, &ex, ELF_SUFFIX_NONE); 1227 1228 if (ex.X_op != O_register && ex.X_op != O_constant) 1229 { 1230 /* We need to generate a fixup for the 1231 expression returned by s390_lit_suffix. */ 1232 if (fc >= MAX_INSN_FIXUPS) 1233 as_fatal (_("too many fixups")); 1234 fixups[fc].exp = ex; 1235 fixups[fc].opindex = *opindex_ptr; 1236 fixups[fc].reloc = BFD_RELOC_UNUSED; 1237 ++fc; 1238 } 1239 else 1240 { 1241 if ((operand->flags & S390_OPERAND_INDEX) 1242 && ex.X_add_number == 0 1243 && warn_areg_zero) 1244 as_warn ("index register specified but zero"); 1245 if ((operand->flags & S390_OPERAND_BASE) 1246 && ex.X_add_number == 0 1247 && warn_areg_zero) 1248 as_warn ("base register specified but zero"); 1249 s390_insert_operand (insn, operand, ex.X_add_number, NULL, 0); 1250 } 1251 } 1252 else 1253 { 1254 suffix = s390_elf_suffix (&str, &ex); 1255 suffix = s390_lit_suffix (&str, &ex, suffix); 1256 reloc = BFD_RELOC_UNUSED; 1257 1258 if (suffix == ELF_SUFFIX_GOT) 1259 { 1260 if ((operand->flags & S390_OPERAND_DISP) && 1261 (operand->bits == 12)) 1262 reloc = BFD_RELOC_390_GOT12; 1263 else if ((operand->flags & S390_OPERAND_DISP) && 1264 (operand->bits == 20)) 1265 reloc = BFD_RELOC_390_GOT20; 1266 else if ((operand->flags & S390_OPERAND_SIGNED) 1267 && (operand->bits == 16)) 1268 reloc = BFD_RELOC_390_GOT16; 1269 else if ((operand->flags & S390_OPERAND_PCREL) 1270 && (operand->bits == 32)) 1271 reloc = BFD_RELOC_390_GOTENT; 1272 } 1273 else if (suffix == ELF_SUFFIX_PLT) 1274 { 1275 if ((operand->flags & S390_OPERAND_PCREL) 1276 && (operand->bits == 16)) 1277 reloc = BFD_RELOC_390_PLT16DBL; 1278 else if ((operand->flags & S390_OPERAND_PCREL) 1279 && (operand->bits == 32)) 1280 reloc = BFD_RELOC_390_PLT32DBL; 1281 } 1282 else if (suffix == ELF_SUFFIX_GOTENT) 1283 { 1284 if ((operand->flags & S390_OPERAND_PCREL) 1285 && (operand->bits == 32)) 1286 reloc = BFD_RELOC_390_GOTENT; 1287 } 1288 else if (suffix == ELF_SUFFIX_GOTOFF) 1289 { 1290 if ((operand->flags & S390_OPERAND_SIGNED) 1291 && (operand->bits == 16)) 1292 reloc = BFD_RELOC_16_GOTOFF; 1293 } 1294 else if (suffix == ELF_SUFFIX_PLTOFF) 1295 { 1296 if ((operand->flags & S390_OPERAND_SIGNED) 1297 && (operand->bits == 16)) 1298 reloc = BFD_RELOC_390_PLTOFF16; 1299 } 1300 else if (suffix == ELF_SUFFIX_GOTPLT) 1301 { 1302 if ((operand->flags & S390_OPERAND_DISP) 1303 && (operand->bits == 12)) 1304 reloc = BFD_RELOC_390_GOTPLT12; 1305 else if ((operand->flags & S390_OPERAND_SIGNED) 1306 && (operand->bits == 16)) 1307 reloc = BFD_RELOC_390_GOTPLT16; 1308 else if ((operand->flags & S390_OPERAND_PCREL) 1309 && (operand->bits == 32)) 1310 reloc = BFD_RELOC_390_GOTPLTENT; 1311 } 1312 else if (suffix == ELF_SUFFIX_TLS_GOTIE) 1313 { 1314 if ((operand->flags & S390_OPERAND_DISP) 1315 && (operand->bits == 12)) 1316 reloc = BFD_RELOC_390_TLS_GOTIE12; 1317 else if ((operand->flags & S390_OPERAND_DISP) 1318 && (operand->bits == 20)) 1319 reloc = BFD_RELOC_390_TLS_GOTIE20; 1320 } 1321 else if (suffix == ELF_SUFFIX_TLS_IE) 1322 { 1323 if ((operand->flags & S390_OPERAND_PCREL) 1324 && (operand->bits == 32)) 1325 reloc = BFD_RELOC_390_TLS_IEENT; 1326 } 1327 1328 if (suffix != ELF_SUFFIX_NONE && reloc == BFD_RELOC_UNUSED) 1329 as_bad (_("invalid operand suffix")); 1330 /* We need to generate a fixup of type 'reloc' for this 1331 expression. */ 1332 if (fc >= MAX_INSN_FIXUPS) 1333 as_fatal (_("too many fixups")); 1334 fixups[fc].exp = ex; 1335 fixups[fc].opindex = *opindex_ptr; 1336 fixups[fc].reloc = reloc; 1337 ++fc; 1338 } 1339 1340 /* Check the next character. The call to expression has advanced 1341 str past any whitespace. */ 1342 if (operand->flags & S390_OPERAND_DISP) 1343 { 1344 /* After a displacement a block in parentheses can start. */ 1345 if (*str != '(') 1346 { 1347 /* Check if parenthesized block can be skipped. If the next 1348 operand is neiter an optional operand nor a base register 1349 then we have a syntax error. */ 1350 operand = s390_operands + *(++opindex_ptr); 1351 if (!(operand->flags & (S390_OPERAND_INDEX|S390_OPERAND_BASE))) 1352 as_bad (_("syntax error; missing '(' after displacement")); 1353 1354 /* Ok, skip all operands until S390_OPERAND_BASE. */ 1355 while (!(operand->flags & S390_OPERAND_BASE)) 1356 operand = s390_operands + *(++opindex_ptr); 1357 1358 /* If there is a next operand it must be separated by a comma. */ 1359 if (opindex_ptr[1] != '\0') 1360 { 1361 if (*str++ != ',') 1362 as_bad (_("syntax error; expected ,")); 1363 } 1364 } 1365 else 1366 { 1367 /* We found an opening parentheses. */ 1368 str++; 1369 for (f = str; *f != '\0'; f++) 1370 if (*f == ',' || *f == ')') 1371 break; 1372 /* If there is no comma until the closing parentheses OR 1373 there is a comma right after the opening parentheses, 1374 we have to skip optional operands. */ 1375 if (*f == ',' && f == str) 1376 { 1377 /* comma directly after '(' ? */ 1378 skip_optional = 1; 1379 str++; 1380 } 1381 else 1382 skip_optional = (*f != ','); 1383 } 1384 } 1385 else if (operand->flags & S390_OPERAND_BASE) 1386 { 1387 /* After the base register the parenthesed block ends. */ 1388 if (*str++ != ')') 1389 as_bad (_("syntax error; missing ')' after base register")); 1390 skip_optional = 0; 1391 /* If there is a next operand it must be separated by a comma. */ 1392 if (opindex_ptr[1] != '\0') 1393 { 1394 if (*str++ != ',') 1395 as_bad (_("syntax error; expected ,")); 1396 } 1397 } 1398 else 1399 { 1400 /* We can find an 'early' closing parentheses in e.g. D(L) instead 1401 of D(L,B). In this case the base register has to be skipped. */ 1402 if (*str == ')') 1403 { 1404 operand = s390_operands + *(++opindex_ptr); 1405 1406 if (!(operand->flags & S390_OPERAND_BASE)) 1407 as_bad (_("syntax error; ')' not allowed here")); 1408 str++; 1409 } 1410 /* If there is a next operand it must be separated by a comma. */ 1411 if (opindex_ptr[1] != '\0') 1412 { 1413 if (*str++ != ',') 1414 as_bad (_("syntax error; expected ,")); 1415 } 1416 } 1417 } 1418 1419 while (ISSPACE (*str)) 1420 ++str; 1421 1422 /* Check for tls instruction marker. */ 1423 reloc = s390_tls_suffix (&str, &ex); 1424 if (reloc != BFD_RELOC_UNUSED) 1425 { 1426 /* We need to generate a fixup of type 'reloc' for this 1427 instruction. */ 1428 if (fc >= MAX_INSN_FIXUPS) 1429 as_fatal (_("too many fixups")); 1430 fixups[fc].exp = ex; 1431 fixups[fc].opindex = -1; 1432 fixups[fc].reloc = reloc; 1433 ++fc; 1434 } 1435 1436 if (*str != '\0') 1437 { 1438 char *linefeed; 1439 1440 if ((linefeed = strchr (str, '\n')) != NULL) 1441 *linefeed = '\0'; 1442 as_bad (_("junk at end of line: `%s'"), str); 1443 if (linefeed != NULL) 1444 *linefeed = '\n'; 1445 } 1446 1447 /* Write out the instruction. */ 1448 f = frag_more (opcode->oplen); 1449 memcpy (f, insn, opcode->oplen); 1450 dwarf2_emit_insn (opcode->oplen); 1451 1452 /* Create any fixups. At this point we do not use a 1453 bfd_reloc_code_real_type, but instead just use the 1454 BFD_RELOC_UNUSED plus the operand index. This lets us easily 1455 handle fixups for any operand type, although that is admittedly 1456 not a very exciting feature. We pick a BFD reloc type in 1457 md_apply_fix3. */ 1458 for (i = 0; i < fc; i++) 1459 { 1460 1461 if (fixups[i].opindex < 0) 1462 { 1463 /* Create tls instruction marker relocation. */ 1464 fix_new_exp (frag_now, f - frag_now->fr_literal, opcode->oplen, 1465 &fixups[i].exp, 0, fixups[i].reloc); 1466 continue; 1467 } 1468 1469 operand = s390_operands + fixups[i].opindex; 1470 1471 if (fixups[i].reloc != BFD_RELOC_UNUSED) 1472 { 1473 reloc_howto_type *reloc_howto; 1474 fixS *fixP; 1475 int size; 1476 1477 reloc_howto = bfd_reloc_type_lookup (stdoutput, fixups[i].reloc); 1478 if (!reloc_howto) 1479 abort (); 1480 1481 size = bfd_get_reloc_size (reloc_howto); 1482 1483 if (size < 1 || size > 4) 1484 abort (); 1485 1486 fixP = fix_new_exp (frag_now, 1487 f - frag_now->fr_literal + (operand->shift/8), 1488 size, &fixups[i].exp, reloc_howto->pc_relative, 1489 fixups[i].reloc); 1490 /* Turn off overflow checking in fixup_segment. This is necessary 1491 because fixup_segment will signal an overflow for large 4 byte 1492 quantities for GOT12 relocations. */ 1493 if ( fixups[i].reloc == BFD_RELOC_390_GOT12 1494 || fixups[i].reloc == BFD_RELOC_390_GOT20 1495 || fixups[i].reloc == BFD_RELOC_390_GOT16) 1496 fixP->fx_no_overflow = 1; 1497 } 1498 else 1499 fix_new_exp (frag_now, f - frag_now->fr_literal, 4, &fixups[i].exp, 1500 (operand->flags & S390_OPERAND_PCREL) != 0, 1501 ((bfd_reloc_code_real_type) 1502 (fixups[i].opindex + (int) BFD_RELOC_UNUSED))); 1503 } 1504 return str; 1505} 1506 1507/* This routine is called for each instruction to be assembled. */ 1508 1509void 1510md_assemble (str) 1511 char *str; 1512{ 1513 const struct s390_opcode *opcode; 1514 unsigned char insn[6]; 1515 char *s; 1516 1517 /* Get the opcode. */ 1518 for (s = str; *s != '\0' && ! ISSPACE (*s); s++) 1519 ; 1520 if (*s != '\0') 1521 *s++ = '\0'; 1522 1523 /* Look up the opcode in the hash table. */ 1524 opcode = (struct s390_opcode *) hash_find (s390_opcode_hash, str); 1525 if (opcode == (const struct s390_opcode *) NULL) 1526 { 1527 as_bad (_("Unrecognized opcode: `%s'"), str); 1528 return; 1529 } 1530 else if (!(opcode->modes & current_mode_mask)) 1531 { 1532 as_bad ("Opcode %s not available in this mode", str); 1533 return; 1534 } 1535 memcpy (insn, opcode->opcode, sizeof (insn)); 1536 md_gather_operands (s, insn, opcode); 1537} 1538 1539#ifndef WORKING_DOT_WORD 1540/* Handle long and short jumps. We don't support these */ 1541void 1542md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol) 1543 char *ptr; 1544 addressT from_addr, to_addr; 1545 fragS *frag; 1546 symbolS *to_symbol; 1547{ 1548 abort (); 1549} 1550 1551void 1552md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol) 1553 char *ptr; 1554 addressT from_addr, to_addr; 1555 fragS *frag; 1556 symbolS *to_symbol; 1557{ 1558 abort (); 1559} 1560#endif 1561 1562void 1563s390_bss (ignore) 1564 int ignore ATTRIBUTE_UNUSED; 1565{ 1566 /* We don't support putting frags in the BSS segment, we fake it 1567 by marking in_bss, then looking at s_skip for clues. */ 1568 1569 subseg_set (bss_section, 0); 1570 demand_empty_rest_of_line (); 1571} 1572 1573/* Pseudo-op handling. */ 1574 1575void 1576s390_insn (ignore) 1577 int ignore ATTRIBUTE_UNUSED; 1578{ 1579 expressionS exp; 1580 const struct s390_opcode *opformat; 1581 unsigned char insn[6]; 1582 char *s; 1583 1584 /* Get the opcode format. */ 1585 s = input_line_pointer; 1586 while (*s != '\0' && *s != ',' && ! ISSPACE (*s)) 1587 s++; 1588 if (*s != ',') 1589 as_bad (_("Invalid .insn format\n")); 1590 *s++ = '\0'; 1591 1592 /* Look up the opcode in the hash table. */ 1593 opformat = (struct s390_opcode *) 1594 hash_find (s390_opformat_hash, input_line_pointer); 1595 if (opformat == (const struct s390_opcode *) NULL) 1596 { 1597 as_bad (_("Unrecognized opcode format: `%s'"), input_line_pointer); 1598 return; 1599 } 1600 input_line_pointer = s; 1601 expression (&exp); 1602 if (exp.X_op == O_constant) 1603 { 1604 if ( ( opformat->oplen == 6 1605 && exp.X_add_number >= 0 1606 && (addressT) exp.X_add_number < (1ULL << 48)) 1607 || ( opformat->oplen == 4 1608 && exp.X_add_number >= 0 1609 && (addressT) exp.X_add_number < (1ULL << 32)) 1610 || ( opformat->oplen == 2 1611 && exp.X_add_number >= 0 1612 && (addressT) exp.X_add_number < (1ULL << 16))) 1613 md_number_to_chars (insn, exp.X_add_number, opformat->oplen); 1614 else 1615 as_bad (_("Invalid .insn format\n")); 1616 } 1617 else if (exp.X_op == O_big) 1618 { 1619 if (exp.X_add_number > 0 1620 && opformat->oplen == 6 1621 && generic_bignum[3] == 0) 1622 { 1623 md_number_to_chars (insn, generic_bignum[2], 2); 1624 md_number_to_chars (&insn[2], generic_bignum[1], 2); 1625 md_number_to_chars (&insn[4], generic_bignum[0], 2); 1626 } 1627 else 1628 as_bad (_("Invalid .insn format\n")); 1629 } 1630 else 1631 as_bad (_("second operand of .insn not a constant\n")); 1632 1633 if (strcmp (opformat->name, "e") != 0 && *input_line_pointer++ != ',') 1634 as_bad (_("missing comma after insn constant\n")); 1635 1636 if ((s = strchr (input_line_pointer, '\n')) != NULL) 1637 *s = '\0'; 1638 input_line_pointer = md_gather_operands (input_line_pointer, insn, 1639 opformat); 1640 if (s != NULL) 1641 *s = '\n'; 1642 demand_empty_rest_of_line (); 1643} 1644 1645/* The .byte pseudo-op. This is similar to the normal .byte 1646 pseudo-op, but it can also take a single ASCII string. */ 1647 1648static void 1649s390_byte (ignore) 1650 int ignore ATTRIBUTE_UNUSED; 1651{ 1652 if (*input_line_pointer != '\"') 1653 { 1654 cons (1); 1655 return; 1656 } 1657 1658 /* Gather characters. A real double quote is doubled. Unusual 1659 characters are not permitted. */ 1660 ++input_line_pointer; 1661 while (1) 1662 { 1663 char c; 1664 1665 c = *input_line_pointer++; 1666 1667 if (c == '\"') 1668 { 1669 if (*input_line_pointer != '\"') 1670 break; 1671 ++input_line_pointer; 1672 } 1673 1674 FRAG_APPEND_1_CHAR (c); 1675 } 1676 1677 demand_empty_rest_of_line (); 1678} 1679 1680/* The .ltorg pseudo-op.This emits all literals defined since the last 1681 .ltorg or the invocation of gas. Literals are defined with the 1682 @lit suffix. */ 1683 1684static void 1685s390_literals (ignore) 1686 int ignore ATTRIBUTE_UNUSED; 1687{ 1688 struct s390_lpe *lpe; 1689 1690 if (lp_sym == NULL || lpe_count == 0) 1691 return; /* Nothing to be done. */ 1692 1693 /* Emit symbol for start of literal pool. */ 1694 S_SET_SEGMENT (lp_sym, now_seg); 1695 S_SET_VALUE (lp_sym, (valueT) frag_now_fix ()); 1696 lp_sym->sy_frag = frag_now; 1697 1698 while (lpe_list) 1699 { 1700 lpe = lpe_list; 1701 lpe_list = lpe_list->next; 1702 S_SET_SEGMENT (lpe->sym, now_seg); 1703 S_SET_VALUE (lpe->sym, (valueT) frag_now_fix ()); 1704 lpe->sym->sy_frag = frag_now; 1705 1706 /* Emit literal pool entry. */ 1707 if (lpe->reloc != BFD_RELOC_UNUSED) 1708 { 1709 reloc_howto_type *reloc_howto = 1710 bfd_reloc_type_lookup (stdoutput, lpe->reloc); 1711 int size = bfd_get_reloc_size (reloc_howto); 1712 char *where; 1713 1714 if (size > lpe->nbytes) 1715 as_bad (_("%s relocations do not fit in %d bytes"), 1716 reloc_howto->name, lpe->nbytes); 1717 where = frag_more (lpe->nbytes); 1718 md_number_to_chars (where, 0, size); 1719 fix_new_exp (frag_now, where - frag_now->fr_literal, 1720 size, &lpe->ex, reloc_howto->pc_relative, lpe->reloc); 1721 } 1722 else 1723 { 1724 if (lpe->ex.X_op == O_big) 1725 { 1726 if (lpe->ex.X_add_number <= 0) 1727 generic_floating_point_number = lpe->floatnum; 1728 else 1729 memcpy (generic_bignum, lpe->bignum, 1730 lpe->ex.X_add_number * sizeof (LITTLENUM_TYPE)); 1731 } 1732 emit_expr (&lpe->ex, lpe->nbytes); 1733 } 1734 1735 lpe->next = lpe_free_list; 1736 lpe_free_list = lpe; 1737 } 1738 lpe_list_tail = NULL; 1739 lp_sym = NULL; 1740 lp_count++; 1741 lpe_count = 0; 1742} 1743 1744/* Turn a string in input_line_pointer into a floating point constant 1745 of type type, and store the appropriate bytes in *litp. The number 1746 of LITTLENUMS emitted is stored in *sizep . An error message is 1747 returned, or NULL on OK. */ 1748 1749char * 1750md_atof (type, litp, sizep) 1751 int type; 1752 char *litp; 1753 int *sizep; 1754{ 1755 int prec; 1756 LITTLENUM_TYPE words[4]; 1757 char *t; 1758 int i; 1759 1760 switch (type) 1761 { 1762 case 'f': 1763 prec = 2; 1764 break; 1765 1766 case 'd': 1767 prec = 4; 1768 break; 1769 1770 default: 1771 *sizep = 0; 1772 return "bad call to md_atof"; 1773 } 1774 1775 t = atof_ieee (input_line_pointer, type, words); 1776 if (t) 1777 input_line_pointer = t; 1778 1779 *sizep = prec * 2; 1780 1781 for (i = 0; i < prec; i++) 1782 { 1783 md_number_to_chars (litp, (valueT) words[i], 2); 1784 litp += 2; 1785 } 1786 1787 return NULL; 1788} 1789 1790/* Align a section (I don't know why this is machine dependent). */ 1791 1792valueT 1793md_section_align (seg, addr) 1794 asection *seg; 1795 valueT addr; 1796{ 1797 int align = bfd_get_section_alignment (stdoutput, seg); 1798 1799 return ((addr + (1 << align) - 1) & (-1 << align)); 1800} 1801 1802/* We don't have any form of relaxing. */ 1803 1804int 1805md_estimate_size_before_relax (fragp, seg) 1806 fragS *fragp ATTRIBUTE_UNUSED; 1807 asection *seg ATTRIBUTE_UNUSED; 1808{ 1809 abort (); 1810 return 0; 1811} 1812 1813/* Convert a machine dependent frag. We never generate these. */ 1814 1815void 1816md_convert_frag (abfd, sec, fragp) 1817 bfd *abfd ATTRIBUTE_UNUSED; 1818 asection *sec ATTRIBUTE_UNUSED; 1819 fragS *fragp ATTRIBUTE_UNUSED; 1820{ 1821 abort (); 1822} 1823 1824symbolS * 1825md_undefined_symbol (name) 1826 char *name; 1827{ 1828 if (*name == '_' && *(name + 1) == 'G' 1829 && strcmp (name, "_GLOBAL_OFFSET_TABLE_") == 0) 1830 { 1831 if (!GOT_symbol) 1832 { 1833 if (symbol_find (name)) 1834 as_bad (_("GOT already in symbol table")); 1835 GOT_symbol = symbol_new (name, undefined_section, 1836 (valueT) 0, &zero_address_frag); 1837 } 1838 return GOT_symbol; 1839 } 1840 return 0; 1841} 1842 1843/* Functions concerning relocs. */ 1844 1845/* The location from which a PC relative jump should be calculated, 1846 given a PC relative reloc. */ 1847 1848long 1849md_pcrel_from_section (fixp, sec) 1850 fixS *fixp; 1851 segT sec ATTRIBUTE_UNUSED; 1852{ 1853 return fixp->fx_frag->fr_address + fixp->fx_where; 1854} 1855 1856/* Here we decide which fixups can be adjusted to make them relative to 1857 the beginning of the section instead of the symbol. Basically we need 1858 to make sure that the dynamic relocations are done correctly, so in 1859 some cases we force the original symbol to be used. */ 1860int 1861tc_s390_fix_adjustable (fixP) 1862 fixS *fixP; 1863{ 1864 /* Don't adjust references to merge sections. */ 1865 if ((S_GET_SEGMENT (fixP->fx_addsy)->flags & SEC_MERGE) != 0) 1866 return 0; 1867 /* adjust_reloc_syms doesn't know about the GOT. */ 1868 if ( fixP->fx_r_type == BFD_RELOC_16_GOTOFF 1869 || fixP->fx_r_type == BFD_RELOC_32_GOTOFF 1870 || fixP->fx_r_type == BFD_RELOC_390_GOTOFF64 1871 || fixP->fx_r_type == BFD_RELOC_390_PLTOFF16 1872 || fixP->fx_r_type == BFD_RELOC_390_PLTOFF32 1873 || fixP->fx_r_type == BFD_RELOC_390_PLTOFF64 1874 || fixP->fx_r_type == BFD_RELOC_390_PLT16DBL 1875 || fixP->fx_r_type == BFD_RELOC_390_PLT32 1876 || fixP->fx_r_type == BFD_RELOC_390_PLT32DBL 1877 || fixP->fx_r_type == BFD_RELOC_390_PLT64 1878 || fixP->fx_r_type == BFD_RELOC_390_GOT12 1879 || fixP->fx_r_type == BFD_RELOC_390_GOT20 1880 || fixP->fx_r_type == BFD_RELOC_390_GOT16 1881 || fixP->fx_r_type == BFD_RELOC_32_GOT_PCREL 1882 || fixP->fx_r_type == BFD_RELOC_390_GOT64 1883 || fixP->fx_r_type == BFD_RELOC_390_GOTENT 1884 || fixP->fx_r_type == BFD_RELOC_390_GOTPLT12 1885 || fixP->fx_r_type == BFD_RELOC_390_GOTPLT16 1886 || fixP->fx_r_type == BFD_RELOC_390_GOTPLT20 1887 || fixP->fx_r_type == BFD_RELOC_390_GOTPLT32 1888 || fixP->fx_r_type == BFD_RELOC_390_GOTPLT64 1889 || fixP->fx_r_type == BFD_RELOC_390_GOTPLTENT 1890 || fixP->fx_r_type == BFD_RELOC_390_TLS_LOAD 1891 || fixP->fx_r_type == BFD_RELOC_390_TLS_GDCALL 1892 || fixP->fx_r_type == BFD_RELOC_390_TLS_LDCALL 1893 || fixP->fx_r_type == BFD_RELOC_390_TLS_GD32 1894 || fixP->fx_r_type == BFD_RELOC_390_TLS_GD64 1895 || fixP->fx_r_type == BFD_RELOC_390_TLS_GOTIE12 1896 || fixP->fx_r_type == BFD_RELOC_390_TLS_GOTIE20 1897 || fixP->fx_r_type == BFD_RELOC_390_TLS_GOTIE32 1898 || fixP->fx_r_type == BFD_RELOC_390_TLS_GOTIE64 1899 || fixP->fx_r_type == BFD_RELOC_390_TLS_LDM32 1900 || fixP->fx_r_type == BFD_RELOC_390_TLS_LDM64 1901 || fixP->fx_r_type == BFD_RELOC_390_TLS_IE32 1902 || fixP->fx_r_type == BFD_RELOC_390_TLS_IE64 1903 || fixP->fx_r_type == BFD_RELOC_390_TLS_IEENT 1904 || fixP->fx_r_type == BFD_RELOC_390_TLS_LE32 1905 || fixP->fx_r_type == BFD_RELOC_390_TLS_LE64 1906 || fixP->fx_r_type == BFD_RELOC_390_TLS_LDO32 1907 || fixP->fx_r_type == BFD_RELOC_390_TLS_LDO64 1908 || fixP->fx_r_type == BFD_RELOC_390_TLS_DTPMOD 1909 || fixP->fx_r_type == BFD_RELOC_390_TLS_DTPOFF 1910 || fixP->fx_r_type == BFD_RELOC_390_TLS_TPOFF 1911 || fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT 1912 || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY) 1913 return 0; 1914 return 1; 1915} 1916 1917/* Return true if we must always emit a reloc for a type and false if 1918 there is some hope of resolving it at assembly time. */ 1919int 1920tc_s390_force_relocation (fixp) 1921 struct fix *fixp; 1922{ 1923 /* Ensure we emit a relocation for every reference to the global 1924 offset table or to the procedure link table. */ 1925 switch (fixp->fx_r_type) 1926 { 1927 case BFD_RELOC_390_GOT12: 1928 case BFD_RELOC_390_GOT20: 1929 case BFD_RELOC_32_GOT_PCREL: 1930 case BFD_RELOC_32_GOTOFF: 1931 case BFD_RELOC_390_GOTOFF64: 1932 case BFD_RELOC_390_PLTOFF16: 1933 case BFD_RELOC_390_PLTOFF32: 1934 case BFD_RELOC_390_PLTOFF64: 1935 case BFD_RELOC_390_GOTPC: 1936 case BFD_RELOC_390_GOT16: 1937 case BFD_RELOC_390_GOTPCDBL: 1938 case BFD_RELOC_390_GOT64: 1939 case BFD_RELOC_390_GOTENT: 1940 case BFD_RELOC_390_PLT32: 1941 case BFD_RELOC_390_PLT16DBL: 1942 case BFD_RELOC_390_PLT32DBL: 1943 case BFD_RELOC_390_PLT64: 1944 case BFD_RELOC_390_GOTPLT12: 1945 case BFD_RELOC_390_GOTPLT16: 1946 case BFD_RELOC_390_GOTPLT20: 1947 case BFD_RELOC_390_GOTPLT32: 1948 case BFD_RELOC_390_GOTPLT64: 1949 case BFD_RELOC_390_GOTPLTENT: 1950 return 1; 1951 default: 1952 break;; 1953 } 1954 1955 return generic_force_reloc (fixp); 1956} 1957 1958/* Apply a fixup to the object code. This is called for all the 1959 fixups we generated by the call to fix_new_exp, above. In the call 1960 above we used a reloc code which was the largest legal reloc code 1961 plus the operand index. Here we undo that to recover the operand 1962 index. At this point all symbol values should be fully resolved, 1963 and we attempt to completely resolve the reloc. If we can not do 1964 that, we determine the correct reloc code and put it back in the 1965 fixup. */ 1966 1967void 1968md_apply_fix3 (fixP, valP, seg) 1969 fixS *fixP; 1970 valueT *valP; 1971 segT seg ATTRIBUTE_UNUSED; 1972{ 1973 char *where; 1974 valueT value = *valP; 1975 1976 where = fixP->fx_frag->fr_literal + fixP->fx_where; 1977 1978 if (fixP->fx_subsy != NULL) 1979 as_bad_where (fixP->fx_file, fixP->fx_line, 1980 "cannot emit relocation %s against subsy symbol %s", 1981 bfd_get_reloc_code_name (fixP->fx_r_type), 1982 S_GET_NAME (fixP->fx_subsy)); 1983 1984 if (fixP->fx_addsy != NULL) 1985 { 1986 if (fixP->fx_pcrel) 1987 value += fixP->fx_frag->fr_address + fixP->fx_where; 1988 } 1989 else 1990 fixP->fx_done = 1; 1991 1992 if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED) 1993 { 1994 const struct s390_operand *operand; 1995 int opindex; 1996 1997 opindex = (int) fixP->fx_r_type - (int) BFD_RELOC_UNUSED; 1998 operand = &s390_operands[opindex]; 1999 2000 if (fixP->fx_done) 2001 { 2002 /* Insert the fully resolved operand value. */ 2003 s390_insert_operand (where, operand, (offsetT) value, 2004 fixP->fx_file, fixP->fx_line); 2005 return; 2006 } 2007 2008 /* Determine a BFD reloc value based on the operand information. 2009 We are only prepared to turn a few of the operands into 2010 relocs. */ 2011 fixP->fx_offset = value; 2012 if (operand->bits == 12 && operand->shift == 20) 2013 { 2014 fixP->fx_size = 2; 2015 fixP->fx_where += 2; 2016 fixP->fx_r_type = BFD_RELOC_390_12; 2017 } 2018 else if (operand->bits == 12 && operand->shift == 36) 2019 { 2020 fixP->fx_size = 2; 2021 fixP->fx_where += 4; 2022 fixP->fx_r_type = BFD_RELOC_390_12; 2023 } 2024 else if (operand->bits == 20 && operand->shift == 20) 2025 { 2026 fixP->fx_size = 2; 2027 fixP->fx_where += 2; 2028 fixP->fx_r_type = BFD_RELOC_390_20; 2029 } 2030 else if (operand->bits == 8 && operand->shift == 8) 2031 { 2032 fixP->fx_size = 1; 2033 fixP->fx_where += 1; 2034 fixP->fx_r_type = BFD_RELOC_8; 2035 } 2036 else if (operand->bits == 16 && operand->shift == 16) 2037 { 2038 fixP->fx_size = 2; 2039 fixP->fx_where += 2; 2040 if (operand->flags & S390_OPERAND_PCREL) 2041 { 2042 fixP->fx_r_type = BFD_RELOC_390_PC16DBL; 2043 fixP->fx_offset += 2; 2044 } 2045 else 2046 fixP->fx_r_type = BFD_RELOC_16; 2047 } 2048 else if (operand->bits == 32 && operand->shift == 16 2049 && (operand->flags & S390_OPERAND_PCREL)) 2050 { 2051 fixP->fx_size = 4; 2052 fixP->fx_where += 2; 2053 fixP->fx_offset += 2; 2054 fixP->fx_r_type = BFD_RELOC_390_PC32DBL; 2055 } 2056 else 2057 { 2058 char *sfile; 2059 unsigned int sline; 2060 2061 /* Use expr_symbol_where to see if this is an expression 2062 symbol. */ 2063 if (expr_symbol_where (fixP->fx_addsy, &sfile, &sline)) 2064 as_bad_where (fixP->fx_file, fixP->fx_line, 2065 _("unresolved expression that must be resolved")); 2066 else 2067 as_bad_where (fixP->fx_file, fixP->fx_line, 2068 _("unsupported relocation type")); 2069 fixP->fx_done = 1; 2070 return; 2071 } 2072 } 2073 else 2074 { 2075 switch (fixP->fx_r_type) 2076 { 2077 case BFD_RELOC_8: 2078 if (fixP->fx_pcrel) 2079 abort (); 2080 if (fixP->fx_done) 2081 md_number_to_chars (where, value, 1); 2082 break; 2083 case BFD_RELOC_390_12: 2084 case BFD_RELOC_390_GOT12: 2085 case BFD_RELOC_390_GOTPLT12: 2086 if (fixP->fx_done) 2087 { 2088 unsigned short mop; 2089 2090 mop = bfd_getb16 ((unsigned char *) where); 2091 mop |= (unsigned short) (value & 0xfff); 2092 bfd_putb16 ((bfd_vma) mop, (unsigned char *) where); 2093 } 2094 break; 2095 2096 case BFD_RELOC_390_20: 2097 case BFD_RELOC_390_GOT20: 2098 case BFD_RELOC_390_GOTPLT20: 2099 if (fixP->fx_done) 2100 { 2101 unsigned int mop; 2102 mop = bfd_getb32 ((unsigned char *) where); 2103 mop |= (unsigned int) ((value & 0xfff) << 8 | 2104 (value & 0xff000) >> 12); 2105 bfd_putb32 ((bfd_vma) mop, (unsigned char *) where); 2106 } 2107 break; 2108 2109 case BFD_RELOC_16: 2110 case BFD_RELOC_GPREL16: 2111 case BFD_RELOC_16_GOT_PCREL: 2112 case BFD_RELOC_16_GOTOFF: 2113 if (fixP->fx_pcrel) 2114 as_bad_where (fixP->fx_file, fixP->fx_line, 2115 "cannot emit PC relative %s relocation%s%s", 2116 bfd_get_reloc_code_name (fixP->fx_r_type), 2117 fixP->fx_addsy != NULL ? " against " : "", 2118 (fixP->fx_addsy != NULL 2119 ? S_GET_NAME (fixP->fx_addsy) 2120 : "")); 2121 if (fixP->fx_done) 2122 md_number_to_chars (where, value, 2); 2123 break; 2124 case BFD_RELOC_390_GOT16: 2125 case BFD_RELOC_390_PLTOFF16: 2126 case BFD_RELOC_390_GOTPLT16: 2127 if (fixP->fx_done) 2128 md_number_to_chars (where, value, 2); 2129 break; 2130 case BFD_RELOC_390_PC16DBL: 2131 case BFD_RELOC_390_PLT16DBL: 2132 value += 2; 2133 if (fixP->fx_done) 2134 md_number_to_chars (where, (offsetT) value >> 1, 2); 2135 break; 2136 2137 case BFD_RELOC_32: 2138 if (fixP->fx_pcrel) 2139 fixP->fx_r_type = BFD_RELOC_32_PCREL; 2140 else 2141 fixP->fx_r_type = BFD_RELOC_32; 2142 if (fixP->fx_done) 2143 md_number_to_chars (where, value, 4); 2144 break; 2145 case BFD_RELOC_32_PCREL: 2146 case BFD_RELOC_32_BASEREL: 2147 fixP->fx_r_type = BFD_RELOC_32_PCREL; 2148 if (fixP->fx_done) 2149 md_number_to_chars (where, value, 4); 2150 break; 2151 case BFD_RELOC_32_GOT_PCREL: 2152 case BFD_RELOC_390_PLTOFF32: 2153 case BFD_RELOC_390_PLT32: 2154 case BFD_RELOC_390_GOTPLT32: 2155 if (fixP->fx_done) 2156 md_number_to_chars (where, value, 4); 2157 break; 2158 case BFD_RELOC_390_PC32DBL: 2159 case BFD_RELOC_390_PLT32DBL: 2160 case BFD_RELOC_390_GOTPCDBL: 2161 case BFD_RELOC_390_GOTENT: 2162 case BFD_RELOC_390_GOTPLTENT: 2163 value += 2; 2164 if (fixP->fx_done) 2165 md_number_to_chars (where, (offsetT) value >> 1, 4); 2166 break; 2167 2168 case BFD_RELOC_32_GOTOFF: 2169 if (fixP->fx_done) 2170 md_number_to_chars (where, value, sizeof (int)); 2171 break; 2172 2173 case BFD_RELOC_390_GOTOFF64: 2174 if (fixP->fx_done) 2175 md_number_to_chars (where, value, 8); 2176 break; 2177 2178 case BFD_RELOC_390_GOT64: 2179 case BFD_RELOC_390_PLTOFF64: 2180 case BFD_RELOC_390_PLT64: 2181 case BFD_RELOC_390_GOTPLT64: 2182 if (fixP->fx_done) 2183 md_number_to_chars (where, value, 8); 2184 break; 2185 2186 case BFD_RELOC_64: 2187 if (fixP->fx_pcrel) 2188 fixP->fx_r_type = BFD_RELOC_64_PCREL; 2189 else 2190 fixP->fx_r_type = BFD_RELOC_64; 2191 if (fixP->fx_done) 2192 md_number_to_chars (where, value, 8); 2193 break; 2194 2195 case BFD_RELOC_64_PCREL: 2196 fixP->fx_r_type = BFD_RELOC_64_PCREL; 2197 if (fixP->fx_done) 2198 md_number_to_chars (where, value, 8); 2199 break; 2200 2201 case BFD_RELOC_VTABLE_INHERIT: 2202 case BFD_RELOC_VTABLE_ENTRY: 2203 fixP->fx_done = 0; 2204 return; 2205 2206 case BFD_RELOC_390_TLS_LOAD: 2207 case BFD_RELOC_390_TLS_GDCALL: 2208 case BFD_RELOC_390_TLS_LDCALL: 2209 case BFD_RELOC_390_TLS_GD32: 2210 case BFD_RELOC_390_TLS_GD64: 2211 case BFD_RELOC_390_TLS_GOTIE12: 2212 case BFD_RELOC_390_TLS_GOTIE20: 2213 case BFD_RELOC_390_TLS_GOTIE32: 2214 case BFD_RELOC_390_TLS_GOTIE64: 2215 case BFD_RELOC_390_TLS_LDM32: 2216 case BFD_RELOC_390_TLS_LDM64: 2217 case BFD_RELOC_390_TLS_IE32: 2218 case BFD_RELOC_390_TLS_IE64: 2219 case BFD_RELOC_390_TLS_LE32: 2220 case BFD_RELOC_390_TLS_LE64: 2221 case BFD_RELOC_390_TLS_LDO32: 2222 case BFD_RELOC_390_TLS_LDO64: 2223 case BFD_RELOC_390_TLS_DTPMOD: 2224 case BFD_RELOC_390_TLS_DTPOFF: 2225 case BFD_RELOC_390_TLS_TPOFF: 2226 /* Fully resolved at link time. */ 2227 break; 2228 case BFD_RELOC_390_TLS_IEENT: 2229 /* Fully resolved at link time. */ 2230 value += 2; 2231 break; 2232 2233 default: 2234 { 2235 const char *reloc_name = bfd_get_reloc_code_name (fixP->fx_r_type); 2236 2237 if (reloc_name != NULL) 2238 fprintf (stderr, "Gas failure, reloc type %s\n", reloc_name); 2239 else 2240 fprintf (stderr, "Gas failure, reloc type #%i\n", fixP->fx_r_type); 2241 fflush (stderr); 2242 abort (); 2243 } 2244 } 2245 2246 fixP->fx_offset = value; 2247 } 2248} 2249 2250/* Generate a reloc for a fixup. */ 2251 2252arelent * 2253tc_gen_reloc (seg, fixp) 2254 asection *seg ATTRIBUTE_UNUSED; 2255 fixS *fixp; 2256{ 2257 bfd_reloc_code_real_type code; 2258 arelent *reloc; 2259 2260 code = fixp->fx_r_type; 2261 if (GOT_symbol && fixp->fx_addsy == GOT_symbol) 2262 { 2263 if ( (s390_arch_size == 32 && code == BFD_RELOC_32_PCREL) 2264 || (s390_arch_size == 64 && code == BFD_RELOC_64_PCREL)) 2265 code = BFD_RELOC_390_GOTPC; 2266 if (code == BFD_RELOC_390_PC32DBL) 2267 code = BFD_RELOC_390_GOTPCDBL; 2268 } 2269 2270 reloc = (arelent *) xmalloc (sizeof (arelent)); 2271 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *)); 2272 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy); 2273 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where; 2274 reloc->howto = bfd_reloc_type_lookup (stdoutput, code); 2275 if (reloc->howto == NULL) 2276 { 2277 as_bad_where (fixp->fx_file, fixp->fx_line, 2278 _("cannot represent relocation type %s"), 2279 bfd_get_reloc_code_name (code)); 2280 /* Set howto to a garbage value so that we can keep going. */ 2281 reloc->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_32); 2282 assert (reloc->howto != NULL); 2283 } 2284 reloc->addend = fixp->fx_offset; 2285 2286 return reloc; 2287} 2288 2289void 2290s390_cfi_frame_initial_instructions () 2291{ 2292 cfi_add_CFA_def_cfa (15, s390_arch_size == 64 ? 160 : 96); 2293} 2294 2295int 2296tc_s390_regname_to_dw2regnum (const char *regname) 2297{ 2298 int regnum = -1; 2299 2300 if (regname[0] != 'c' && regname[0] != 'a') 2301 { 2302 regnum = reg_name_search (pre_defined_registers, REG_NAME_CNT, regname); 2303 if (regname[0] == 'f' && regnum != -1) 2304 regnum += 16; 2305 } 2306 else if (strcmp (regname, "ap") == 0) 2307 regnum = 32; 2308 else if (strcmp (regname, "cc") == 0) 2309 regnum = 33; 2310 return regnum; 2311} 2312