1 /* tc-s390.c -- Assemble for the S390
2 Copyright (C) 2000-2017 Free Software Foundation, Inc.
3 Contributed by Martin Schwidefsky (schwidefsky@de.ibm.com).
5 This file is part of GAS, the GNU Assembler.
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 3, or (at your option)
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.
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, 51 Franklin Street - Fifth Floor, Boston, MA
23 #include "safe-ctype.h"
25 #include "struc-symbol.h"
26 #include "dwarf2dbg.h"
27 #include "dw2gencfi.h"
29 #include "opcode/s390.h"
32 /* The default architecture. */
34 #define DEFAULT_ARCH "s390"
36 static const char *default_arch = DEFAULT_ARCH;
37 /* Either 32 or 64, selects file format. */
38 static int s390_arch_size = 0;
40 /* If no -march option was given default to the highest available CPU.
41 Since with S/390 a newer CPU always supports everything from its
42 predecessors this will accept every valid asm input. */
43 static unsigned int current_cpu = S390_OPCODE_MAXCPU - 1;
44 /* All facilities are enabled by default. */
45 static unsigned int current_flags = S390_INSTR_FLAG_FACILITY_MASK;
46 /* The mode mask default is picked in init_default_arch depending on
48 static unsigned int current_mode_mask = 0;
50 /* Set to TRUE if the highgprs flag in the ELF header needs to be set
51 for the output file. */
52 static bfd_boolean set_highgprs_p = FALSE;
54 /* Whether to use user friendly register names. Default is TRUE. */
55 #ifndef TARGET_REG_NAMES_P
56 #define TARGET_REG_NAMES_P TRUE
59 static bfd_boolean reg_names_p = TARGET_REG_NAMES_P;
61 /* Set to TRUE if we want to warn about zero base/index registers. */
62 static bfd_boolean warn_areg_zero = FALSE;
64 /* Generic assembler global variables which must be defined by all
67 const char comment_chars[] = "#";
69 /* Characters which start a comment at the beginning of a line. */
70 const char line_comment_chars[] = "#";
72 /* Characters which may be used to separate multiple commands on a
74 const char line_separator_chars[] = ";";
76 /* Characters which are used to indicate an exponent in a floating
78 const char EXP_CHARS[] = "eE";
80 /* Characters which mean that a number is a floating point constant,
82 const char FLT_CHARS[] = "dD";
84 /* The dwarf2 data alignment, adjusted for 32 or 64 bit. */
85 int s390_cie_data_alignment;
87 /* The target specific pseudo-ops which we support. */
89 /* Define the prototypes for the pseudo-ops */
90 static void s390_byte (int);
91 static void s390_elf_cons (int);
92 static void s390_bss (int);
93 static void s390_insn (int);
94 static void s390_literals (int);
95 static void s390_machine (int);
96 static void s390_machinemode (int);
98 const pseudo_typeS md_pseudo_table[] =
100 { "align", s_align_bytes, 0 },
101 /* Pseudo-ops which must be defined. */
102 { "bss", s390_bss, 0 },
103 { "insn", s390_insn, 0 },
104 /* Pseudo-ops which must be overridden. */
105 { "byte", s390_byte, 0 },
106 { "short", s390_elf_cons, 2 },
107 { "long", s390_elf_cons, 4 },
108 { "quad", s390_elf_cons, 8 },
109 { "ltorg", s390_literals, 0 },
110 { "string", stringer, 8 + 1 },
111 { "machine", s390_machine, 0 },
112 { "machinemode", s390_machinemode, 0 },
116 /* Given NAME, find the register number associated with that name, return
117 the integer value associated with the given name or -1 on failure. */
120 reg_name_search (const char *name)
124 if (strcasecmp (name, "lit") == 0)
127 if (strcasecmp (name, "sp") == 0)
130 if (name[0] != 'a' && name[0] != 'c' && name[0] != 'f'
131 && name[0] != 'r' && name[0] != 'v')
134 if (ISDIGIT (name[1]))
137 if (ISDIGIT (name[2]))
138 val = val * 10 + name[2] - '0';
141 if ((name[0] != 'v' && val > 15) || val > 31)
149 * Summary of register_name().
151 * in: Input_line_pointer points to 1st char of operand.
153 * out: A expressionS.
154 * The operand may have been a register: in this case, X_op == O_register,
155 * X_add_number is set to the register number, and truth is returned.
156 * Input_line_pointer->(next non-blank) char after operand, or is in its
161 register_name (expressionS *expressionP)
168 /* Find the spelling of the operand. */
169 start = name = input_line_pointer;
170 if (name[0] == '%' && ISALPHA (name[1]))
171 name = ++input_line_pointer;
175 c = get_symbol_name (&name);
176 reg_number = reg_name_search (name);
178 /* Put back the delimiting char. */
179 (void) restore_line_pointer (c);
181 /* Look to see if it's in the register table. */
184 expressionP->X_op = O_register;
185 expressionP->X_add_number = reg_number;
187 /* Make the rest nice. */
188 expressionP->X_add_symbol = NULL;
189 expressionP->X_op_symbol = NULL;
193 /* Reset the line as if we had not done anything. */
194 input_line_pointer = start;
198 /* Local variables. */
200 /* Opformat hash table. */
201 static struct hash_control *s390_opformat_hash;
203 /* Opcode hash table. */
204 static struct hash_control *s390_opcode_hash = NULL;
206 /* Flags to set in the elf header */
207 static flagword s390_flags = 0;
209 symbolS *GOT_symbol; /* Pre-defined "_GLOBAL_OFFSET_TABLE_" */
211 #ifndef WORKING_DOT_WORD
212 int md_short_jump_size = 4;
213 int md_long_jump_size = 4;
216 const char *md_shortopts = "A:m:kVQ:";
217 struct option md_longopts[] = {
218 {NULL, no_argument, NULL, 0}
220 size_t md_longopts_size = sizeof (md_longopts);
222 /* Initialize the default opcode arch and word size from the default
223 architecture name if not specified by an option. */
225 init_default_arch (void)
227 if (strcmp (default_arch, "s390") == 0)
229 if (s390_arch_size == 0)
232 else if (strcmp (default_arch, "s390x") == 0)
234 if (s390_arch_size == 0)
238 as_fatal (_("Invalid default architecture, broken assembler."));
240 if (current_mode_mask == 0)
242 /* Default to z/Architecture mode if the CPU supports it. */
243 if (current_cpu < S390_OPCODE_Z900)
244 current_mode_mask = 1 << S390_OPCODE_ESA;
246 current_mode_mask = 1 << S390_OPCODE_ZARCH;
250 /* Called by TARGET_FORMAT. */
252 s390_target_format (void)
254 /* We don't get a chance to initialize anything before we're called,
255 so handle that now. */
256 init_default_arch ();
258 return s390_arch_size == 64 ? "elf64-s390" : "elf32-s390";
261 /* Map a cpu string ARG as given with -march= or .machine to the respective
262 enum s390_opcode_cpu_val value. If ALLOW_EXTENSIONS is TRUE, the cpu name
263 can be followed by a list of cpu facility flags each beginning with the
264 character '+'. The active cpu flags are returned through *RET_FLAGS.
265 In case of an error, S390_OPCODE_MAXCPU is returned. */
268 s390_parse_cpu (const char * arg,
269 unsigned int * ret_flags,
270 bfd_boolean allow_extensions)
275 unsigned int name_len;
276 const char * alt_name;
277 unsigned int alt_name_len;
279 } cpu_table[S390_OPCODE_MAXCPU] =
281 { STRING_COMMA_LEN ("g5"), STRING_COMMA_LEN ("arch3"), 0 },
282 { STRING_COMMA_LEN ("g6"), STRING_COMMA_LEN (""), 0 },
283 { STRING_COMMA_LEN ("z900"), STRING_COMMA_LEN ("arch5"), 0 },
284 { STRING_COMMA_LEN ("z990"), STRING_COMMA_LEN ("arch6"), 0 },
285 { STRING_COMMA_LEN ("z9-109"), STRING_COMMA_LEN (""), 0 },
286 { STRING_COMMA_LEN ("z9-ec"), STRING_COMMA_LEN ("arch7"), 0 },
287 { STRING_COMMA_LEN ("z10"), STRING_COMMA_LEN ("arch8"), 0 },
288 { STRING_COMMA_LEN ("z196"), STRING_COMMA_LEN ("arch9"), 0 },
289 { STRING_COMMA_LEN ("zEC12"), STRING_COMMA_LEN ("arch10"),
290 S390_INSTR_FLAG_HTM },
291 { STRING_COMMA_LEN ("z13"), STRING_COMMA_LEN ("arch11"),
292 S390_INSTR_FLAG_HTM | S390_INSTR_FLAG_VX },
293 { STRING_COMMA_LEN ("arch12"), STRING_COMMA_LEN (""),
294 S390_INSTR_FLAG_HTM | S390_INSTR_FLAG_VX | S390_INSTR_FLAG_VX2 }
303 { "htm", S390_INSTR_FLAG_HTM, TRUE },
304 { "nohtm", S390_INSTR_FLAG_HTM, FALSE },
305 { "vx", S390_INSTR_FLAG_VX, TRUE },
306 { "novx", S390_INSTR_FLAG_VX, FALSE },
307 { "vx2", S390_INSTR_FLAG_VX2, TRUE },
308 { "novx2", S390_INSTR_FLAG_VX2, FALSE }
313 icpu = S390_OPCODE_MAXCPU;
314 if (strncmp (arg, "all", 3) == 0 && (arg[3] == 0 || arg[3] == '+'))
316 icpu = S390_OPCODE_MAXCPU - 1;
321 for (icpu = 0; icpu < S390_OPCODE_MAXCPU; icpu++)
323 unsigned int l, l_alt;
325 l = cpu_table[icpu].name_len;
327 if (strncmp (arg, cpu_table[icpu].name, l) == 0
328 && (arg[l] == 0 || arg[l] == '+'))
334 l_alt = cpu_table[icpu].alt_name_len;
337 && strncmp (arg, cpu_table[icpu].alt_name, l_alt) == 0
338 && (arg[l_alt] == 0 || arg[l_alt] == '+'))
346 if (icpu == S390_OPCODE_MAXCPU)
347 return S390_OPCODE_MAXCPU;
349 ilp_bak = input_line_pointer;
350 if (icpu != S390_OPCODE_MAXCPU)
352 input_line_pointer = (char *) arg;
353 *ret_flags = (cpu_table[icpu].flags & S390_INSTR_FLAG_FACILITY_MASK);
355 while (*input_line_pointer == '+' && allow_extensions)
361 input_line_pointer++;
362 c = get_symbol_name (&sym);
363 for (iflag = 0; iflag < ARRAY_SIZE (cpu_flags); iflag++)
365 if (strcmp (sym, cpu_flags[iflag].name) == 0)
367 if (cpu_flags[iflag].on)
368 *ret_flags |= cpu_flags[iflag].mask;
370 *ret_flags &= ~cpu_flags[iflag].mask;
374 if (iflag == ARRAY_SIZE (cpu_flags))
375 as_bad (_("no such machine extension `%s'"), sym - 1);
376 *input_line_pointer = c;
377 if (iflag == ARRAY_SIZE (cpu_flags))
384 if (*input_line_pointer != 0 && *input_line_pointer != '\n')
386 as_bad (_("junk at end of machine string, first unrecognized character"
387 " is `%c'"), *input_line_pointer);
388 icpu = S390_OPCODE_MAXCPU;
390 input_line_pointer = ilp_bak;
396 md_parse_option (int c, const char *arg)
400 /* -k: Ignore for FreeBSD compatibility. */
404 if (arg != NULL && strcmp (arg, "regnames") == 0)
407 else if (arg != NULL && strcmp (arg, "no-regnames") == 0)
410 else if (arg != NULL && strcmp (arg, "warn-areg-zero") == 0)
411 warn_areg_zero = TRUE;
413 else if (arg != NULL && strcmp (arg, "31") == 0)
416 else if (arg != NULL && strcmp (arg, "64") == 0)
419 else if (arg != NULL && strcmp (arg, "esa") == 0)
420 current_mode_mask = 1 << S390_OPCODE_ESA;
422 else if (arg != NULL && strcmp (arg, "zarch") == 0)
424 if (s390_arch_size == 32)
425 set_highgprs_p = TRUE;
426 current_mode_mask = 1 << S390_OPCODE_ZARCH;
429 else if (arg != NULL && strncmp (arg, "arch=", 5) == 0)
431 current_cpu = s390_parse_cpu (arg + 5, ¤t_flags, FALSE);
432 if (current_cpu == S390_OPCODE_MAXCPU)
434 as_bad (_("invalid switch -m%s"), arg);
441 as_bad (_("invalid switch -m%s"), arg);
447 /* Option -A is deprecated. Still available for compatibility. */
448 if (arg != NULL && strcmp (arg, "esa") == 0)
449 current_cpu = S390_OPCODE_G5;
450 else if (arg != NULL && strcmp (arg, "esame") == 0)
451 current_cpu = S390_OPCODE_Z900;
453 as_bad (_("invalid architecture -A%s"), arg);
456 /* -V: SVR4 argument to print version ID. */
461 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
462 should be emitted or not. FIXME: Not implemented. */
474 md_show_usage (FILE *stream)
476 fprintf (stream, _("\
478 -mregnames Allow symbolic names for registers\n\
479 -mwarn-areg-zero Warn about zero base/index registers\n\
480 -mno-regnames Do not allow symbolic names for registers\n\
481 -m31 Set file format to 31 bit format\n\
482 -m64 Set file format to 64 bit format\n"));
483 fprintf (stream, _("\
484 -V print assembler version number\n\
485 -Qy, -Qn ignored\n"));
488 /* Generate the hash table mapping mnemonics to struct s390_opcode.
489 This table is built at startup and whenever the CPU level is
490 changed using .machine. */
493 s390_setup_opcodes (void)
495 const struct s390_opcode *op;
496 const struct s390_opcode *op_end;
497 bfd_boolean dup_insn = FALSE;
500 if (s390_opcode_hash != NULL)
501 hash_die (s390_opcode_hash);
503 /* Insert the opcodes into a hash table. */
504 s390_opcode_hash = hash_new ();
506 op_end = s390_opcodes + s390_num_opcodes;
507 for (op = s390_opcodes; op < op_end; op++)
511 while (op < op_end - 1 && strcmp(op->name, op[1].name) == 0)
513 if (op->min_cpu <= current_cpu && (op->modes & current_mode_mask))
518 if ((op->modes & current_mode_mask) == 0)
520 else if ((op->flags & S390_INSTR_FLAG_FACILITY_MASK) == 0)
522 /* Opcodes that do not belong to a specific facility are enabled if
523 present in the selected cpu. */
524 use_opcode = (op->min_cpu <= current_cpu);
530 /* Opcodes of a specific facility are enabled if the facility is
531 enabled. Note: only some facilities are represented as flags. */
532 f = (op->flags & S390_INSTR_FLAG_FACILITY_MASK);
533 use_opcode = ((f & current_flags) == f);
537 retval = hash_insert (s390_opcode_hash, op->name, (void *) op);
538 if (retval != (const char *) NULL)
540 as_bad (_("Internal assembler error for instruction %s"),
546 while (op < op_end - 1 && strcmp (op->name, op[1].name) == 0)
554 /* This function is called when the assembler starts up. It is called
555 after the options have been parsed and the output file has been
561 const struct s390_opcode *op;
562 const struct s390_opcode *op_end;
565 /* Give a warning if the combination -m64-bit and -Aesa is used. */
566 if (s390_arch_size == 64 && current_cpu < S390_OPCODE_Z900)
567 as_warn (_("The 64 bit file format is used without esame instructions."));
569 s390_cie_data_alignment = -s390_arch_size / 8;
571 /* Set the ELF flags if desired. */
573 bfd_set_private_flags (stdoutput, s390_flags);
575 /* Insert the opcode formats into a hash table. */
576 s390_opformat_hash = hash_new ();
578 op_end = s390_opformats + s390_num_opformats;
579 for (op = s390_opformats; op < op_end; op++)
581 retval = hash_insert (s390_opformat_hash, op->name, (void *) op);
582 if (retval != (const char *) NULL)
583 as_bad (_("Internal assembler error for instruction format %s"),
587 s390_setup_opcodes ();
589 record_alignment (text_section, 2);
590 record_alignment (data_section, 2);
591 record_alignment (bss_section, 2);
594 /* Called after all assembly has been done. */
598 if (s390_arch_size == 64)
599 bfd_set_arch_mach (stdoutput, bfd_arch_s390, bfd_mach_s390_64);
601 bfd_set_arch_mach (stdoutput, bfd_arch_s390, bfd_mach_s390_31);
604 /* Insert an operand value into an instruction. */
607 s390_insert_operand (unsigned char *insn,
608 const struct s390_operand *operand,
616 if (operand->flags & (S390_OPERAND_SIGNED|S390_OPERAND_PCREL))
620 max = ((offsetT) 1 << (operand->bits - 1)) - 1;
621 min = - ((offsetT) 1 << (operand->bits - 1));
622 /* Halve PCREL operands. */
623 if (operand->flags & S390_OPERAND_PCREL)
625 /* Check for underflow / overflow. */
626 if (val < min || val > max)
629 _("operand out of range (%s not between %ld and %ld)");
632 if (operand->flags & S390_OPERAND_PCREL)
638 sprint_value (buf, val);
639 if (file == (char *) NULL)
640 as_bad (err, buf, (int) min, (int) max);
642 as_bad_where (file, line, err, buf, (int) min, (int) max);
645 /* val is ok, now restrict it to operand->bits bits. */
646 uval = (addressT) val & ((((addressT) 1 << (operand->bits-1)) << 1) - 1);
647 /* val is restrict, now check for special case. */
648 if (operand->bits == 20 && operand->shift == 20)
649 uval = (uval >> 12) | ((uval & 0xfff) << 8);
655 max = (((addressT) 1 << (operand->bits - 1)) << 1) - 1;
657 uval = (addressT) val;
659 /* Vector register operands have an additional bit in the RXB
661 if (operand->flags & S390_OPERAND_VR)
662 max = (max << 1) | 1;
664 /* Length x in an instructions has real length x+1. */
665 if (operand->flags & S390_OPERAND_LENGTH)
667 /* Check for underflow / overflow. */
668 if (uval < min || uval > max)
670 if (operand->flags & S390_OPERAND_LENGTH)
677 as_bad_value_out_of_range (_("operand"), uval, (offsetT) min, (offsetT) max, file, line);
683 if (operand->flags & S390_OPERAND_VR)
685 /* Insert the extra bit into the RXB field. */
686 switch (operand->shift)
689 insn[4] |= (uval & 0x10) >> 1;
692 insn[4] |= (uval & 0x10) >> 2;
695 insn[4] |= (uval & 0x10) >> 3;
698 insn[4] |= (uval & 0x10) >> 4;
704 if (operand->flags & S390_OPERAND_OR1)
706 if (operand->flags & S390_OPERAND_OR2)
708 if (operand->flags & S390_OPERAND_OR8)
711 /* Duplicate the operand at bit pos 12 to 16. */
712 if (operand->flags & S390_OPERAND_CP16)
714 /* Copy VR operand at bit pos 12 to bit pos 16. */
715 insn[2] |= uval << 4;
716 /* Copy the flag in the RXB field. */
717 insn[4] |= (insn[4] & 4) >> 1;
720 /* Insert fragments of the operand byte for byte. */
721 offset = operand->shift + operand->bits;
722 uval <<= (-offset) & 7;
723 insn += (offset - 1) / 8;
735 bfd_reloc_code_real_type reloc;
738 /* Parse tls marker and return the desired relocation. */
739 static bfd_reloc_code_real_type
740 s390_tls_suffix (char **str_p, expressionS *exp_p)
742 static struct map_tls mapping[] =
744 { "tls_load", 8, BFD_RELOC_390_TLS_LOAD },
745 { "tls_gdcall", 10, BFD_RELOC_390_TLS_GDCALL },
746 { "tls_ldcall", 10, BFD_RELOC_390_TLS_LDCALL },
747 { NULL, 0, BFD_RELOC_UNUSED }
757 return BFD_RELOC_UNUSED;
760 while (ISIDNUM (*str))
764 return BFD_RELOC_UNUSED;
766 orig_line = input_line_pointer;
767 input_line_pointer = str;
769 str = input_line_pointer;
770 if (&input_line_pointer != str_p)
771 input_line_pointer = orig_line;
773 if (exp_p->X_op != O_symbol)
774 return BFD_RELOC_UNUSED;
776 for (ptr = &mapping[0]; ptr->length > 0; ptr++)
777 if (len == ptr->length
778 && strncasecmp (ident, ptr->string, ptr->length) == 0)
780 /* Found a matching tls suffix. */
784 return BFD_RELOC_UNUSED;
787 /* Structure used to hold suffixes. */
798 ELF_SUFFIX_TLS_GOTIE,
810 elf_suffix_type suffix;
814 /* Parse @got/@plt/@gotoff. and return the desired relocation. */
815 static elf_suffix_type
816 s390_elf_suffix (char **str_p, expressionS *exp_p)
818 static struct map_bfd mapping[] =
820 { "got", 3, ELF_SUFFIX_GOT },
821 { "got12", 5, ELF_SUFFIX_GOT },
822 { "plt", 3, ELF_SUFFIX_PLT },
823 { "gotent", 6, ELF_SUFFIX_GOTENT },
824 { "gotoff", 6, ELF_SUFFIX_GOTOFF },
825 { "gotplt", 6, ELF_SUFFIX_GOTPLT },
826 { "pltoff", 6, ELF_SUFFIX_PLTOFF },
827 { "tlsgd", 5, ELF_SUFFIX_TLS_GD },
828 { "gotntpoff", 9, ELF_SUFFIX_TLS_GOTIE },
829 { "indntpoff", 9, ELF_SUFFIX_TLS_IE },
830 { "tlsldm", 6, ELF_SUFFIX_TLS_LDM },
831 { "dtpoff", 6, ELF_SUFFIX_TLS_LDO },
832 { "ntpoff", 6, ELF_SUFFIX_TLS_LE },
833 { NULL, 0, ELF_SUFFIX_NONE }
842 return ELF_SUFFIX_NONE;
845 while (ISALNUM (*str))
849 for (ptr = &mapping[0]; ptr->length > 0; ptr++)
850 if (len == ptr->length
851 && strncasecmp (ident, ptr->string, ptr->length) == 0)
853 if (exp_p->X_add_number != 0)
854 as_warn (_("identifier+constant@%s means identifier@%s+constant"),
855 ptr->string, ptr->string);
856 /* Now check for identifier@suffix+constant. */
857 if (*str == '-' || *str == '+')
859 char *orig_line = input_line_pointer;
862 input_line_pointer = str;
863 expression (&new_exp);
865 switch (new_exp.X_op)
867 case O_constant: /* X_add_number (a constant expression). */
868 exp_p->X_add_number += new_exp.X_add_number;
869 str = input_line_pointer;
871 case O_symbol: /* X_add_symbol + X_add_number. */
872 /* this case is used for e.g. xyz@PLT+.Label. */
873 exp_p->X_add_number += new_exp.X_add_number;
874 exp_p->X_op_symbol = new_exp.X_add_symbol;
876 str = input_line_pointer;
878 case O_uminus: /* (- X_add_symbol) + X_add_number. */
879 /* this case is used for e.g. xyz@PLT-.Label. */
880 exp_p->X_add_number += new_exp.X_add_number;
881 exp_p->X_op_symbol = new_exp.X_add_symbol;
882 exp_p->X_op = O_subtract;
883 str = input_line_pointer;
889 /* If s390_elf_suffix has not been called with
890 &input_line_pointer as first parameter, we have
891 clobbered the input_line_pointer. We have to
893 if (&input_line_pointer != str_p)
894 input_line_pointer = orig_line;
900 return BFD_RELOC_UNUSED;
903 /* Structure used to hold a literal pool entry. */
906 struct s390_lpe *next;
908 FLONUM_TYPE floatnum; /* used if X_op == O_big && X_add_number <= 0 */
909 LITTLENUM_TYPE bignum[4]; /* used if X_op == O_big && X_add_number > 0 */
911 bfd_reloc_code_real_type reloc;
915 static struct s390_lpe *lpe_free_list = NULL;
916 static struct s390_lpe *lpe_list = NULL;
917 static struct s390_lpe *lpe_list_tail = NULL;
918 static symbolS *lp_sym = NULL;
919 static int lp_count = 0;
920 static int lpe_count = 0;
923 s390_exp_compare (expressionS *exp1, expressionS *exp2)
925 if (exp1->X_op != exp2->X_op)
930 case O_constant: /* X_add_number must be equal. */
932 return exp1->X_add_number == exp2->X_add_number;
935 as_bad (_("Can't handle O_big in s390_exp_compare"));
938 case O_symbol: /* X_add_symbol & X_add_number must be equal. */
943 return (exp1->X_add_symbol == exp2->X_add_symbol)
944 && (exp1->X_add_number == exp2->X_add_number);
946 case O_multiply: /* X_add_symbol,X_op_symbol&X_add_number must be equal. */
951 case O_bit_inclusive_or:
953 case O_bit_exclusive_or:
965 return (exp1->X_add_symbol == exp2->X_add_symbol)
966 && (exp1->X_op_symbol == exp2->X_op_symbol)
967 && (exp1->X_add_number == exp2->X_add_number);
973 /* Test for @lit and if it's present make an entry in the literal pool and
974 modify the current expression to be an offset into the literal pool. */
975 static elf_suffix_type
976 s390_lit_suffix (char **str_p, expressionS *exp_p, elf_suffix_type suffix)
978 bfd_reloc_code_real_type reloc;
982 struct s390_lpe *lpe;
986 return suffix; /* No modification. */
988 /* We look for a suffix of the form "@lit1", "@lit2", "@lit4" or "@lit8". */
990 while (ISALNUM (*str))
993 if (len != 4 || strncasecmp (ident, "lit", 3) != 0
994 || (ident[3]!='1' && ident[3]!='2' && ident[3]!='4' && ident[3]!='8'))
995 return suffix; /* no modification */
996 nbytes = ident[3] - '0';
998 reloc = BFD_RELOC_UNUSED;
999 if (suffix == ELF_SUFFIX_GOT)
1002 reloc = BFD_RELOC_390_GOT16;
1003 else if (nbytes == 4)
1004 reloc = BFD_RELOC_32_GOT_PCREL;
1005 else if (nbytes == 8)
1006 reloc = BFD_RELOC_390_GOT64;
1008 else if (suffix == ELF_SUFFIX_PLT)
1011 reloc = BFD_RELOC_390_PLT32;
1012 else if (nbytes == 8)
1013 reloc = BFD_RELOC_390_PLT64;
1016 if (suffix != ELF_SUFFIX_NONE && reloc == BFD_RELOC_UNUSED)
1017 as_bad (_("Invalid suffix for literal pool entry"));
1019 /* Search the pool if the new entry is a duplicate. */
1020 if (exp_p->X_op == O_big)
1022 /* Special processing for big numbers. */
1023 for (lpe = lpe_list; lpe != NULL; lpe = lpe->next)
1025 if (lpe->ex.X_op == O_big)
1027 if (exp_p->X_add_number <= 0 && lpe->ex.X_add_number <= 0)
1029 if (memcmp (&generic_floating_point_number, &lpe->floatnum,
1030 sizeof (FLONUM_TYPE)) == 0)
1033 else if (exp_p->X_add_number == lpe->ex.X_add_number)
1035 if (memcmp (generic_bignum, lpe->bignum,
1036 sizeof (LITTLENUM_TYPE)*exp_p->X_add_number) == 0)
1044 /* Processing for 'normal' data types. */
1045 for (lpe = lpe_list; lpe != NULL; lpe = lpe->next)
1046 if (lpe->nbytes == nbytes && lpe->reloc == reloc
1047 && s390_exp_compare (exp_p, &lpe->ex) != 0)
1053 /* A new literal. */
1054 if (lpe_free_list != NULL)
1056 lpe = lpe_free_list;
1057 lpe_free_list = lpe_free_list->next;
1061 lpe = XNEW (struct s390_lpe);
1066 if (exp_p->X_op == O_big)
1068 if (exp_p->X_add_number <= 0)
1069 lpe->floatnum = generic_floating_point_number;
1070 else if (exp_p->X_add_number <= 4)
1071 memcpy (lpe->bignum, generic_bignum,
1072 exp_p->X_add_number * sizeof (LITTLENUM_TYPE));
1074 as_bad (_("Big number is too big"));
1077 lpe->nbytes = nbytes;
1079 /* Literal pool name defined ? */
1082 sprintf (tmp_name, ".L\001%i", lp_count);
1083 lp_sym = symbol_make (tmp_name);
1086 /* Make name for literal pool entry. */
1087 sprintf (tmp_name, ".L\001%i\002%i", lp_count, lpe_count);
1089 lpe->sym = symbol_make (tmp_name);
1091 /* Add to literal pool list. */
1093 if (lpe_list_tail != NULL)
1095 lpe_list_tail->next = lpe;
1096 lpe_list_tail = lpe;
1099 lpe_list = lpe_list_tail = lpe;
1102 /* Now change exp_p to the offset into the literal pool.
1103 That's the expression: .L^Ax^By-.L^Ax */
1104 exp_p->X_add_symbol = lpe->sym;
1105 exp_p->X_op_symbol = lp_sym;
1106 exp_p->X_op = O_subtract;
1107 exp_p->X_add_number = 0;
1111 /* We change the suffix type to ELF_SUFFIX_NONE, because
1112 the difference of two local labels is just a number. */
1113 return ELF_SUFFIX_NONE;
1116 /* Like normal .long/.short/.word, except support @got, etc.
1117 clobbers input_line_pointer, checks end-of-line. */
1119 s390_elf_cons (int nbytes /* 1=.byte, 2=.word, 4=.long */)
1122 elf_suffix_type suffix;
1124 if (is_it_end_of_statement ())
1126 demand_empty_rest_of_line ();
1134 if (exp.X_op == O_symbol
1135 && *input_line_pointer == '@'
1136 && (suffix = s390_elf_suffix (&input_line_pointer, &exp)) != ELF_SUFFIX_NONE)
1138 bfd_reloc_code_real_type reloc;
1139 reloc_howto_type *reloc_howto;
1145 static bfd_reloc_code_real_type tab2[] =
1147 BFD_RELOC_UNUSED, /* ELF_SUFFIX_NONE */
1148 BFD_RELOC_390_GOT16, /* ELF_SUFFIX_GOT */
1149 BFD_RELOC_UNUSED, /* ELF_SUFFIX_PLT */
1150 BFD_RELOC_UNUSED, /* ELF_SUFFIX_GOTENT */
1151 BFD_RELOC_16_GOTOFF, /* ELF_SUFFIX_GOTOFF */
1152 BFD_RELOC_UNUSED, /* ELF_SUFFIX_GOTPLT */
1153 BFD_RELOC_390_PLTOFF16, /* ELF_SUFFIX_PLTOFF */
1154 BFD_RELOC_UNUSED, /* ELF_SUFFIX_TLS_GD */
1155 BFD_RELOC_UNUSED, /* ELF_SUFFIX_TLS_GOTIE */
1156 BFD_RELOC_UNUSED, /* ELF_SUFFIX_TLS_IE */
1157 BFD_RELOC_UNUSED, /* ELF_SUFFIX_TLS_LDM */
1158 BFD_RELOC_UNUSED, /* ELF_SUFFIX_TLS_LDO */
1159 BFD_RELOC_UNUSED /* ELF_SUFFIX_TLS_LE */
1161 reloc = tab2[suffix];
1163 else if (nbytes == 4)
1165 static bfd_reloc_code_real_type tab4[] =
1167 BFD_RELOC_UNUSED, /* ELF_SUFFIX_NONE */
1168 BFD_RELOC_32_GOT_PCREL, /* ELF_SUFFIX_GOT */
1169 BFD_RELOC_390_PLT32, /* ELF_SUFFIX_PLT */
1170 BFD_RELOC_UNUSED, /* ELF_SUFFIX_GOTENT */
1171 BFD_RELOC_32_GOTOFF, /* ELF_SUFFIX_GOTOFF */
1172 BFD_RELOC_390_GOTPLT32, /* ELF_SUFFIX_GOTPLT */
1173 BFD_RELOC_390_PLTOFF32, /* ELF_SUFFIX_PLTOFF */
1174 BFD_RELOC_390_TLS_GD32, /* ELF_SUFFIX_TLS_GD */
1175 BFD_RELOC_390_TLS_GOTIE32, /* ELF_SUFFIX_TLS_GOTIE */
1176 BFD_RELOC_390_TLS_IE32, /* ELF_SUFFIX_TLS_IE */
1177 BFD_RELOC_390_TLS_LDM32, /* ELF_SUFFIX_TLS_LDM */
1178 BFD_RELOC_390_TLS_LDO32, /* ELF_SUFFIX_TLS_LDO */
1179 BFD_RELOC_390_TLS_LE32 /* ELF_SUFFIX_TLS_LE */
1181 reloc = tab4[suffix];
1183 else if (nbytes == 8)
1185 static bfd_reloc_code_real_type tab8[] =
1187 BFD_RELOC_UNUSED, /* ELF_SUFFIX_NONE */
1188 BFD_RELOC_390_GOT64, /* ELF_SUFFIX_GOT */
1189 BFD_RELOC_390_PLT64, /* ELF_SUFFIX_PLT */
1190 BFD_RELOC_UNUSED, /* ELF_SUFFIX_GOTENT */
1191 BFD_RELOC_390_GOTOFF64, /* ELF_SUFFIX_GOTOFF */
1192 BFD_RELOC_390_GOTPLT64, /* ELF_SUFFIX_GOTPLT */
1193 BFD_RELOC_390_PLTOFF64, /* ELF_SUFFIX_PLTOFF */
1194 BFD_RELOC_390_TLS_GD64, /* ELF_SUFFIX_TLS_GD */
1195 BFD_RELOC_390_TLS_GOTIE64, /* ELF_SUFFIX_TLS_GOTIE */
1196 BFD_RELOC_390_TLS_IE64, /* ELF_SUFFIX_TLS_IE */
1197 BFD_RELOC_390_TLS_LDM64, /* ELF_SUFFIX_TLS_LDM */
1198 BFD_RELOC_390_TLS_LDO64, /* ELF_SUFFIX_TLS_LDO */
1199 BFD_RELOC_390_TLS_LE64 /* ELF_SUFFIX_TLS_LE */
1201 reloc = tab8[suffix];
1204 reloc = BFD_RELOC_UNUSED;
1206 if (reloc != BFD_RELOC_UNUSED
1207 && (reloc_howto = bfd_reloc_type_lookup (stdoutput, reloc)))
1209 size = bfd_get_reloc_size (reloc_howto);
1211 as_bad (_("%s relocations do not fit in %d bytes"),
1212 reloc_howto->name, nbytes);
1213 where = frag_more (nbytes);
1214 md_number_to_chars (where, 0, size);
1215 /* To make fixup_segment do the pc relative conversion the
1216 pcrel parameter on the fix_new_exp call needs to be FALSE. */
1217 fix_new_exp (frag_now, where - frag_now->fr_literal,
1218 size, &exp, FALSE, reloc);
1221 as_bad (_("relocation not applicable"));
1224 emit_expr (&exp, (unsigned int) nbytes);
1226 while (*input_line_pointer++ == ',');
1228 input_line_pointer--; /* Put terminator back into stream. */
1229 demand_empty_rest_of_line ();
1232 /* We need to keep a list of fixups. We can't simply generate them as
1233 we go, because that would require us to first create the frag, and
1234 that would screw up references to ``.''. */
1240 bfd_reloc_code_real_type reloc;
1243 #define MAX_INSN_FIXUPS (4)
1245 /* This routine is called for each instruction to be assembled. */
1248 md_gather_operands (char *str,
1249 unsigned char *insn,
1250 const struct s390_opcode *opcode)
1252 struct s390_fixup fixups[MAX_INSN_FIXUPS];
1253 const struct s390_operand *operand;
1254 const unsigned char *opindex_ptr;
1256 elf_suffix_type suffix;
1257 bfd_reloc_code_real_type reloc;
1262 while (ISSPACE (*str))
1267 /* Gather the operands. */
1269 for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
1273 operand = s390_operands + *opindex_ptr;
1275 if ((opcode->flags & S390_INSTR_FLAG_OPTPARM) && *str == '\0')
1277 /* Optional parameters might need to be ORed with a
1278 value so calling s390_insert_operand is needed. */
1279 s390_insert_operand (insn, operand, 0, NULL, 0);
1283 if (skip_optional && (operand->flags & S390_OPERAND_INDEX))
1285 /* We do an early skip. For D(X,B) constructions the index
1286 register is skipped (X is optional). For D(L,B) the base
1287 register will be the skipped operand, because L is NOT
1293 /* Gather the operand. */
1294 hold = input_line_pointer;
1295 input_line_pointer = str;
1297 /* Parse the operand. */
1298 if (! register_name (&ex))
1301 str = input_line_pointer;
1302 input_line_pointer = hold;
1304 /* Write the operand to the insn. */
1305 if (ex.X_op == O_illegal)
1306 as_bad (_("illegal operand"));
1307 else if (ex.X_op == O_absent)
1309 /* No operands, check if all operands can be skipped. */
1310 while (*opindex_ptr != 0 && operand->flags & S390_OPERAND_OPTIONAL)
1312 if (operand->flags & S390_OPERAND_DISP)
1314 /* An optional displacement makes the whole D(X,B)
1315 D(L,B) or D(B) block optional. */
1317 operand = s390_operands + *(++opindex_ptr);
1318 } while (!(operand->flags & S390_OPERAND_BASE));
1320 operand = s390_operands + *(++opindex_ptr);
1322 if (opindex_ptr[0] == '\0')
1324 as_bad (_("missing operand"));
1326 else if (ex.X_op == O_register || ex.X_op == O_constant)
1328 s390_lit_suffix (&str, &ex, ELF_SUFFIX_NONE);
1330 if (ex.X_op != O_register && ex.X_op != O_constant)
1332 /* We need to generate a fixup for the
1333 expression returned by s390_lit_suffix. */
1334 if (fc >= MAX_INSN_FIXUPS)
1335 as_fatal (_("too many fixups"));
1336 fixups[fc].exp = ex;
1337 fixups[fc].opindex = *opindex_ptr;
1338 fixups[fc].reloc = BFD_RELOC_UNUSED;
1343 if ((operand->flags & S390_OPERAND_LENGTH)
1344 && ex.X_op != O_constant)
1345 as_fatal (_("invalid length field specified"));
1346 if ((operand->flags & S390_OPERAND_INDEX)
1347 && ex.X_add_number == 0
1349 as_warn (_("index register specified but zero"));
1350 if ((operand->flags & S390_OPERAND_BASE)
1351 && ex.X_add_number == 0
1353 as_warn (_("base register specified but zero"));
1354 if ((operand->flags & S390_OPERAND_GPR)
1355 && (operand->flags & S390_OPERAND_REG_PAIR)
1356 && (ex.X_add_number & 1))
1357 as_fatal (_("odd numbered general purpose register specified as "
1359 if ((operand->flags & S390_OPERAND_FPR)
1360 && (operand->flags & S390_OPERAND_REG_PAIR)
1361 && ex.X_add_number != 0 && ex.X_add_number != 1
1362 && ex.X_add_number != 4 && ex.X_add_number != 5
1363 && ex.X_add_number != 8 && ex.X_add_number != 9
1364 && ex.X_add_number != 12 && ex.X_add_number != 13)
1365 as_fatal (_("invalid floating point register pair. Valid fp "
1366 "register pair operands are 0, 1, 4, 5, 8, 9, "
1368 s390_insert_operand (insn, operand, ex.X_add_number, NULL, 0);
1373 suffix = s390_elf_suffix (&str, &ex);
1374 suffix = s390_lit_suffix (&str, &ex, suffix);
1375 reloc = BFD_RELOC_UNUSED;
1377 if (suffix == ELF_SUFFIX_GOT)
1379 if ((operand->flags & S390_OPERAND_DISP) &&
1380 (operand->bits == 12))
1381 reloc = BFD_RELOC_390_GOT12;
1382 else if ((operand->flags & S390_OPERAND_DISP) &&
1383 (operand->bits == 20))
1384 reloc = BFD_RELOC_390_GOT20;
1385 else if ((operand->flags & S390_OPERAND_SIGNED)
1386 && (operand->bits == 16))
1387 reloc = BFD_RELOC_390_GOT16;
1388 else if ((operand->flags & S390_OPERAND_PCREL)
1389 && (operand->bits == 32))
1390 reloc = BFD_RELOC_390_GOTENT;
1392 else if (suffix == ELF_SUFFIX_PLT)
1394 if ((operand->flags & S390_OPERAND_PCREL)
1395 && (operand->bits == 12))
1396 reloc = BFD_RELOC_390_PLT12DBL;
1397 else if ((operand->flags & S390_OPERAND_PCREL)
1398 && (operand->bits == 16))
1399 reloc = BFD_RELOC_390_PLT16DBL;
1400 else if ((operand->flags & S390_OPERAND_PCREL)
1401 && (operand->bits == 24))
1402 reloc = BFD_RELOC_390_PLT24DBL;
1403 else if ((operand->flags & S390_OPERAND_PCREL)
1404 && (operand->bits == 32))
1405 reloc = BFD_RELOC_390_PLT32DBL;
1407 else if (suffix == ELF_SUFFIX_GOTENT)
1409 if ((operand->flags & S390_OPERAND_PCREL)
1410 && (operand->bits == 32))
1411 reloc = BFD_RELOC_390_GOTENT;
1413 else if (suffix == ELF_SUFFIX_GOTOFF)
1415 if ((operand->flags & S390_OPERAND_SIGNED)
1416 && (operand->bits == 16))
1417 reloc = BFD_RELOC_16_GOTOFF;
1419 else if (suffix == ELF_SUFFIX_PLTOFF)
1421 if ((operand->flags & S390_OPERAND_SIGNED)
1422 && (operand->bits == 16))
1423 reloc = BFD_RELOC_390_PLTOFF16;
1425 else if (suffix == ELF_SUFFIX_GOTPLT)
1427 if ((operand->flags & S390_OPERAND_DISP)
1428 && (operand->bits == 12))
1429 reloc = BFD_RELOC_390_GOTPLT12;
1430 else if ((operand->flags & S390_OPERAND_SIGNED)
1431 && (operand->bits == 16))
1432 reloc = BFD_RELOC_390_GOTPLT16;
1433 else if ((operand->flags & S390_OPERAND_PCREL)
1434 && (operand->bits == 32))
1435 reloc = BFD_RELOC_390_GOTPLTENT;
1437 else if (suffix == ELF_SUFFIX_TLS_GOTIE)
1439 if ((operand->flags & S390_OPERAND_DISP)
1440 && (operand->bits == 12))
1441 reloc = BFD_RELOC_390_TLS_GOTIE12;
1442 else if ((operand->flags & S390_OPERAND_DISP)
1443 && (operand->bits == 20))
1444 reloc = BFD_RELOC_390_TLS_GOTIE20;
1446 else if (suffix == ELF_SUFFIX_TLS_IE)
1448 if ((operand->flags & S390_OPERAND_PCREL)
1449 && (operand->bits == 32))
1450 reloc = BFD_RELOC_390_TLS_IEENT;
1453 if (suffix != ELF_SUFFIX_NONE && reloc == BFD_RELOC_UNUSED)
1454 as_bad (_("invalid operand suffix"));
1455 /* We need to generate a fixup of type 'reloc' for this
1457 if (fc >= MAX_INSN_FIXUPS)
1458 as_fatal (_("too many fixups"));
1459 fixups[fc].exp = ex;
1460 fixups[fc].opindex = *opindex_ptr;
1461 fixups[fc].reloc = reloc;
1465 /* Check the next character. The call to expression has advanced
1466 str past any whitespace. */
1467 if (operand->flags & S390_OPERAND_DISP)
1469 /* After a displacement a block in parentheses can start. */
1472 /* Check if parenthesized block can be skipped. If the next
1473 operand is neither an optional operand nor a base register
1474 then we have a syntax error. */
1475 operand = s390_operands + *(++opindex_ptr);
1476 if (!(operand->flags & (S390_OPERAND_INDEX|S390_OPERAND_BASE)))
1477 as_bad (_("syntax error; missing '(' after displacement"));
1479 /* Ok, skip all operands until S390_OPERAND_BASE. */
1480 while (!(operand->flags & S390_OPERAND_BASE))
1481 operand = s390_operands + *(++opindex_ptr);
1483 /* If there is a next operand it must be separated by a comma. */
1484 if (opindex_ptr[1] != '\0')
1488 while (opindex_ptr[1] != '\0')
1490 operand = s390_operands + *(++opindex_ptr);
1491 if (operand->flags & S390_OPERAND_OPTIONAL)
1493 as_bad (_("syntax error; expected ','"));
1503 /* We found an opening parentheses. */
1505 for (f = str; *f != '\0'; f++)
1506 if (*f == ',' || *f == ')')
1508 /* If there is no comma until the closing parentheses OR
1509 there is a comma right after the opening parentheses,
1510 we have to skip optional operands. */
1511 if (*f == ',' && f == str)
1513 /* comma directly after '(' ? */
1518 skip_optional = (*f != ',');
1521 else if (operand->flags & S390_OPERAND_BASE)
1523 /* After the base register the parenthesised block ends. */
1525 as_bad (_("syntax error; missing ')' after base register"));
1527 /* If there is a next operand it must be separated by a comma. */
1528 if (opindex_ptr[1] != '\0')
1532 while (opindex_ptr[1] != '\0')
1534 operand = s390_operands + *(++opindex_ptr);
1535 if (operand->flags & S390_OPERAND_OPTIONAL)
1537 as_bad (_("syntax error; expected ','"));
1547 /* We can find an 'early' closing parentheses in e.g. D(L) instead
1548 of D(L,B). In this case the base register has to be skipped. */
1551 operand = s390_operands + *(++opindex_ptr);
1553 if (!(operand->flags & S390_OPERAND_BASE))
1554 as_bad (_("syntax error; ')' not allowed here"));
1558 if ((opcode->flags & S390_INSTR_FLAG_OPTPARM) && *str == '\0')
1561 /* If there is a next operand it must be separated by a comma. */
1562 if (opindex_ptr[1] != '\0')
1566 while (opindex_ptr[1] != '\0')
1568 operand = s390_operands + *(++opindex_ptr);
1569 if (operand->flags & S390_OPERAND_OPTIONAL)
1571 as_bad (_("syntax error; expected ','"));
1581 while (ISSPACE (*str))
1584 /* Check for tls instruction marker. */
1585 reloc = s390_tls_suffix (&str, &ex);
1586 if (reloc != BFD_RELOC_UNUSED)
1588 /* We need to generate a fixup of type 'reloc' for this
1590 if (fc >= MAX_INSN_FIXUPS)
1591 as_fatal (_("too many fixups"));
1592 fixups[fc].exp = ex;
1593 fixups[fc].opindex = -1;
1594 fixups[fc].reloc = reloc;
1602 if ((linefeed = strchr (str, '\n')) != NULL)
1604 as_bad (_("junk at end of line: `%s'"), str);
1605 if (linefeed != NULL)
1609 /* Write out the instruction. */
1610 f = frag_more (opcode->oplen);
1611 memcpy (f, insn, opcode->oplen);
1612 dwarf2_emit_insn (opcode->oplen);
1614 /* Create any fixups. At this point we do not use a
1615 bfd_reloc_code_real_type, but instead just use the
1616 BFD_RELOC_UNUSED plus the operand index. This lets us easily
1617 handle fixups for any operand type, although that is admittedly
1618 not a very exciting feature. We pick a BFD reloc type in
1620 for (i = 0; i < fc; i++)
1623 if (fixups[i].opindex < 0)
1625 /* Create tls instruction marker relocation. */
1626 fix_new_exp (frag_now, f - frag_now->fr_literal, opcode->oplen,
1627 &fixups[i].exp, 0, fixups[i].reloc);
1631 operand = s390_operands + fixups[i].opindex;
1633 if (fixups[i].reloc != BFD_RELOC_UNUSED)
1635 reloc_howto_type *reloc_howto;
1639 reloc_howto = bfd_reloc_type_lookup (stdoutput, fixups[i].reloc);
1643 size = ((reloc_howto->bitsize - 1) / 8) + 1;
1645 if (size < 1 || size > 4)
1648 fixP = fix_new_exp (frag_now,
1649 f - frag_now->fr_literal + (operand->shift/8),
1650 size, &fixups[i].exp, reloc_howto->pc_relative,
1652 /* Turn off overflow checking in fixup_segment. This is necessary
1653 because fixup_segment will signal an overflow for large 4 byte
1654 quantities for GOT12 relocations. */
1655 if ( fixups[i].reloc == BFD_RELOC_390_GOT12
1656 || fixups[i].reloc == BFD_RELOC_390_GOT20
1657 || fixups[i].reloc == BFD_RELOC_390_GOT16)
1658 fixP->fx_no_overflow = 1;
1660 if (operand->flags & S390_OPERAND_PCREL)
1661 fixP->fx_pcrel_adjust = operand->shift / 8;
1664 fix_new_exp (frag_now, f - frag_now->fr_literal, 4, &fixups[i].exp,
1665 (operand->flags & S390_OPERAND_PCREL) != 0,
1666 ((bfd_reloc_code_real_type)
1667 (fixups[i].opindex + (int) BFD_RELOC_UNUSED)));
1672 /* This routine is called for each instruction to be assembled. */
1675 md_assemble (char *str)
1677 const struct s390_opcode *opcode;
1678 unsigned char insn[6];
1681 /* Get the opcode. */
1682 for (s = str; *s != '\0' && ! ISSPACE (*s); s++)
1687 /* Look up the opcode in the hash table. */
1688 opcode = (struct s390_opcode *) hash_find (s390_opcode_hash, str);
1689 if (opcode == (const struct s390_opcode *) NULL)
1691 as_bad (_("Unrecognized opcode: `%s'"), str);
1694 else if (!(opcode->modes & current_mode_mask))
1696 as_bad (_("Opcode %s not available in this mode"), str);
1699 memcpy (insn, opcode->opcode, sizeof (insn));
1700 md_gather_operands (s, insn, opcode);
1703 #ifndef WORKING_DOT_WORD
1704 /* Handle long and short jumps. We don't support these */
1706 md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
1708 addressT from_addr, to_addr;
1716 md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
1718 addressT from_addr, to_addr;
1727 s390_bss (int ignore ATTRIBUTE_UNUSED)
1729 /* We don't support putting frags in the BSS segment, we fake it
1730 by marking in_bss, then looking at s_skip for clues. */
1732 subseg_set (bss_section, 0);
1733 demand_empty_rest_of_line ();
1736 /* Pseudo-op handling. */
1739 s390_insn (int ignore ATTRIBUTE_UNUSED)
1742 const struct s390_opcode *opformat;
1743 unsigned char insn[6];
1746 /* Get the opcode format. */
1747 s = input_line_pointer;
1748 while (*s != '\0' && *s != ',' && ! ISSPACE (*s))
1751 as_bad (_("Invalid .insn format\n"));
1754 /* Look up the opcode in the hash table. */
1755 opformat = (struct s390_opcode *)
1756 hash_find (s390_opformat_hash, input_line_pointer);
1757 if (opformat == (const struct s390_opcode *) NULL)
1759 as_bad (_("Unrecognized opcode format: `%s'"), input_line_pointer);
1762 input_line_pointer = s;
1764 if (exp.X_op == O_constant)
1766 if ( ( opformat->oplen == 6
1767 && (addressT) exp.X_add_number < (1ULL << 48))
1768 || ( opformat->oplen == 4
1769 && (addressT) exp.X_add_number < (1ULL << 32))
1770 || ( opformat->oplen == 2
1771 && (addressT) exp.X_add_number < (1ULL << 16)))
1772 md_number_to_chars ((char *) insn, exp.X_add_number, opformat->oplen);
1774 as_bad (_("Invalid .insn format\n"));
1776 else if (exp.X_op == O_big)
1778 if (exp.X_add_number > 0
1779 && opformat->oplen == 6
1780 && generic_bignum[3] == 0)
1782 md_number_to_chars ((char *) insn, generic_bignum[2], 2);
1783 md_number_to_chars ((char *) &insn[2], generic_bignum[1], 2);
1784 md_number_to_chars ((char *) &insn[4], generic_bignum[0], 2);
1787 as_bad (_("Invalid .insn format\n"));
1790 as_bad (_("second operand of .insn not a constant\n"));
1792 if (strcmp (opformat->name, "e") != 0 && *input_line_pointer++ != ',')
1793 as_bad (_("missing comma after insn constant\n"));
1795 if ((s = strchr (input_line_pointer, '\n')) != NULL)
1797 input_line_pointer = md_gather_operands (input_line_pointer, insn,
1801 demand_empty_rest_of_line ();
1804 /* The .byte pseudo-op. This is similar to the normal .byte
1805 pseudo-op, but it can also take a single ASCII string. */
1808 s390_byte (int ignore ATTRIBUTE_UNUSED)
1810 if (*input_line_pointer != '\"')
1816 /* Gather characters. A real double quote is doubled. Unusual
1817 characters are not permitted. */
1818 ++input_line_pointer;
1823 c = *input_line_pointer++;
1827 if (*input_line_pointer != '\"')
1829 ++input_line_pointer;
1832 FRAG_APPEND_1_CHAR (c);
1835 demand_empty_rest_of_line ();
1838 /* The .ltorg pseudo-op.This emits all literals defined since the last
1839 .ltorg or the invocation of gas. Literals are defined with the
1843 s390_literals (int ignore ATTRIBUTE_UNUSED)
1845 struct s390_lpe *lpe;
1847 if (lp_sym == NULL || lpe_count == 0)
1848 return; /* Nothing to be done. */
1850 /* Emit symbol for start of literal pool. */
1851 S_SET_SEGMENT (lp_sym, now_seg);
1852 S_SET_VALUE (lp_sym, (valueT) frag_now_fix ());
1853 lp_sym->sy_frag = frag_now;
1858 lpe_list = lpe_list->next;
1859 S_SET_SEGMENT (lpe->sym, now_seg);
1860 S_SET_VALUE (lpe->sym, (valueT) frag_now_fix ());
1861 lpe->sym->sy_frag = frag_now;
1863 /* Emit literal pool entry. */
1864 if (lpe->reloc != BFD_RELOC_UNUSED)
1866 reloc_howto_type *reloc_howto =
1867 bfd_reloc_type_lookup (stdoutput, lpe->reloc);
1868 int size = bfd_get_reloc_size (reloc_howto);
1871 if (size > lpe->nbytes)
1872 as_bad (_("%s relocations do not fit in %d bytes"),
1873 reloc_howto->name, lpe->nbytes);
1874 where = frag_more (lpe->nbytes);
1875 md_number_to_chars (where, 0, size);
1876 fix_new_exp (frag_now, where - frag_now->fr_literal,
1877 size, &lpe->ex, reloc_howto->pc_relative, lpe->reloc);
1881 if (lpe->ex.X_op == O_big)
1883 if (lpe->ex.X_add_number <= 0)
1884 generic_floating_point_number = lpe->floatnum;
1886 memcpy (generic_bignum, lpe->bignum,
1887 lpe->ex.X_add_number * sizeof (LITTLENUM_TYPE));
1889 emit_expr (&lpe->ex, lpe->nbytes);
1892 lpe->next = lpe_free_list;
1893 lpe_free_list = lpe;
1895 lpe_list_tail = NULL;
1901 #define MAX_HISTORY 100
1903 /* The .machine pseudo op allows to switch to a different CPU level in
1904 the asm listing. The current CPU setting can be stored on a stack
1905 with .machine push and restored with .machine pop. */
1908 s390_machine (int ignore ATTRIBUTE_UNUSED)
1911 static struct cpu_history
1916 static int curr_hist;
1920 if (*input_line_pointer == '"')
1923 cpu_string = demand_copy_C_string (&len);
1929 cpu_string = input_line_pointer;
1934 c = get_symbol_name (&str);
1935 c = restore_line_pointer (c);
1937 ++ input_line_pointer;
1941 c = *input_line_pointer;
1942 *input_line_pointer = 0;
1943 cpu_string = xstrdup (cpu_string);
1944 (void) restore_line_pointer (c);
1947 if (cpu_string != NULL)
1949 unsigned int new_cpu = current_cpu;
1950 unsigned int new_flags = current_flags;
1952 if (strcmp (cpu_string, "push") == 0)
1954 if (cpu_history == NULL)
1955 cpu_history = XNEWVEC (struct cpu_history, MAX_HISTORY);
1957 if (curr_hist >= MAX_HISTORY)
1958 as_bad (_(".machine stack overflow"));
1961 cpu_history[curr_hist].cpu = current_cpu;
1962 cpu_history[curr_hist].flags = current_flags;
1966 else if (strcmp (cpu_string, "pop") == 0)
1969 as_bad (_(".machine stack underflow"));
1973 new_cpu = cpu_history[curr_hist].cpu;
1974 new_flags = cpu_history[curr_hist].flags;
1978 new_cpu = s390_parse_cpu (cpu_string, &new_flags, TRUE);
1980 if (new_cpu == S390_OPCODE_MAXCPU)
1981 as_bad (_("invalid machine `%s'"), cpu_string);
1983 if (new_cpu != current_cpu || new_flags != current_flags)
1985 current_cpu = new_cpu;
1986 current_flags = new_flags;
1987 s390_setup_opcodes ();
1991 demand_empty_rest_of_line ();
1994 /* The .machinemode pseudo op allows to switch to a different
1995 architecture mode in the asm listing. The current architecture
1996 mode setting can be stored on a stack with .machinemode push and
1997 restored with .machinemode pop. */
2000 s390_machinemode (int ignore ATTRIBUTE_UNUSED)
2003 static unsigned int *mode_history;
2004 static int curr_hist;
2011 c = get_symbol_name (&mode_string);
2012 mode_string = xstrdup (mode_string);
2013 (void) restore_line_pointer (c);
2016 if (mode_string != NULL)
2018 unsigned int old_mode_mask = current_mode_mask;
2021 for (p = mode_string; *p != 0; p++)
2024 if (strcmp (mode_string, "push") == 0)
2026 if (mode_history == NULL)
2027 mode_history = XNEWVEC (unsigned int, MAX_HISTORY);
2029 if (curr_hist >= MAX_HISTORY)
2030 as_bad (_(".machinemode stack overflow"));
2032 mode_history[curr_hist++] = current_mode_mask;
2034 else if (strcmp (mode_string, "pop") == 0)
2037 as_bad (_(".machinemode stack underflow"));
2039 current_mode_mask = mode_history[--curr_hist];
2043 if (strcmp (mode_string, "esa") == 0)
2044 current_mode_mask = 1 << S390_OPCODE_ESA;
2045 else if (strcmp (mode_string, "zarch") == 0)
2047 if (s390_arch_size == 32)
2048 set_highgprs_p = TRUE;
2049 current_mode_mask = 1 << S390_OPCODE_ZARCH;
2051 else if (strcmp (mode_string, "zarch_nohighgprs") == 0)
2052 current_mode_mask = 1 << S390_OPCODE_ZARCH;
2054 as_bad (_("invalid machine mode `%s'"), mode_string);
2057 if (current_mode_mask != old_mode_mask)
2058 s390_setup_opcodes ();
2061 demand_empty_rest_of_line ();
2067 md_atof (int type, char *litp, int *sizep)
2069 return ieee_md_atof (type, litp, sizep, TRUE);
2072 /* Align a section (I don't know why this is machine dependent). */
2075 md_section_align (asection *seg, valueT addr)
2077 int align = bfd_get_section_alignment (stdoutput, seg);
2079 return ((addr + (1 << align) - 1) & -(1 << align));
2082 /* We don't have any form of relaxing. */
2085 md_estimate_size_before_relax (fragS *fragp ATTRIBUTE_UNUSED,
2086 asection *seg ATTRIBUTE_UNUSED)
2092 /* Convert a machine dependent frag. We never generate these. */
2095 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED,
2096 asection *sec ATTRIBUTE_UNUSED,
2097 fragS *fragp ATTRIBUTE_UNUSED)
2103 md_undefined_symbol (char *name)
2105 if (*name == '_' && *(name + 1) == 'G'
2106 && strcmp (name, "_GLOBAL_OFFSET_TABLE_") == 0)
2110 if (symbol_find (name))
2111 as_bad (_("GOT already in symbol table"));
2112 GOT_symbol = symbol_new (name, undefined_section,
2113 (valueT) 0, &zero_address_frag);
2120 /* Functions concerning relocs. */
2122 /* The location from which a PC relative jump should be calculated,
2123 given a PC relative reloc. */
2126 md_pcrel_from_section (fixS *fixp, segT sec ATTRIBUTE_UNUSED)
2128 return fixp->fx_frag->fr_address + fixp->fx_where;
2131 /* Here we decide which fixups can be adjusted to make them relative to
2132 the beginning of the section instead of the symbol. Basically we need
2133 to make sure that the dynamic relocations are done correctly, so in
2134 some cases we force the original symbol to be used. */
2136 tc_s390_fix_adjustable (fixS *fixP)
2138 /* Don't adjust references to merge sections. */
2139 if ((S_GET_SEGMENT (fixP->fx_addsy)->flags & SEC_MERGE) != 0)
2141 /* adjust_reloc_syms doesn't know about the GOT. */
2142 if ( fixP->fx_r_type == BFD_RELOC_16_GOTOFF
2143 || fixP->fx_r_type == BFD_RELOC_32_GOTOFF
2144 || fixP->fx_r_type == BFD_RELOC_390_GOTOFF64
2145 || fixP->fx_r_type == BFD_RELOC_390_PLTOFF16
2146 || fixP->fx_r_type == BFD_RELOC_390_PLTOFF32
2147 || fixP->fx_r_type == BFD_RELOC_390_PLTOFF64
2148 || fixP->fx_r_type == BFD_RELOC_390_PLT12DBL
2149 || fixP->fx_r_type == BFD_RELOC_390_PLT16DBL
2150 || fixP->fx_r_type == BFD_RELOC_390_PLT24DBL
2151 || fixP->fx_r_type == BFD_RELOC_390_PLT32
2152 || fixP->fx_r_type == BFD_RELOC_390_PLT32DBL
2153 || fixP->fx_r_type == BFD_RELOC_390_PLT64
2154 || fixP->fx_r_type == BFD_RELOC_390_GOT12
2155 || fixP->fx_r_type == BFD_RELOC_390_GOT20
2156 || fixP->fx_r_type == BFD_RELOC_390_GOT16
2157 || fixP->fx_r_type == BFD_RELOC_32_GOT_PCREL
2158 || fixP->fx_r_type == BFD_RELOC_390_GOT64
2159 || fixP->fx_r_type == BFD_RELOC_390_GOTENT
2160 || fixP->fx_r_type == BFD_RELOC_390_GOTPLT12
2161 || fixP->fx_r_type == BFD_RELOC_390_GOTPLT16
2162 || fixP->fx_r_type == BFD_RELOC_390_GOTPLT20
2163 || fixP->fx_r_type == BFD_RELOC_390_GOTPLT32
2164 || fixP->fx_r_type == BFD_RELOC_390_GOTPLT64
2165 || fixP->fx_r_type == BFD_RELOC_390_GOTPLTENT
2166 || fixP->fx_r_type == BFD_RELOC_390_TLS_LOAD
2167 || fixP->fx_r_type == BFD_RELOC_390_TLS_GDCALL
2168 || fixP->fx_r_type == BFD_RELOC_390_TLS_LDCALL
2169 || fixP->fx_r_type == BFD_RELOC_390_TLS_GD32
2170 || fixP->fx_r_type == BFD_RELOC_390_TLS_GD64
2171 || fixP->fx_r_type == BFD_RELOC_390_TLS_GOTIE12
2172 || fixP->fx_r_type == BFD_RELOC_390_TLS_GOTIE20
2173 || fixP->fx_r_type == BFD_RELOC_390_TLS_GOTIE32
2174 || fixP->fx_r_type == BFD_RELOC_390_TLS_GOTIE64
2175 || fixP->fx_r_type == BFD_RELOC_390_TLS_LDM32
2176 || fixP->fx_r_type == BFD_RELOC_390_TLS_LDM64
2177 || fixP->fx_r_type == BFD_RELOC_390_TLS_IE32
2178 || fixP->fx_r_type == BFD_RELOC_390_TLS_IE64
2179 || fixP->fx_r_type == BFD_RELOC_390_TLS_IEENT
2180 || fixP->fx_r_type == BFD_RELOC_390_TLS_LE32
2181 || fixP->fx_r_type == BFD_RELOC_390_TLS_LE64
2182 || fixP->fx_r_type == BFD_RELOC_390_TLS_LDO32
2183 || fixP->fx_r_type == BFD_RELOC_390_TLS_LDO64
2184 || fixP->fx_r_type == BFD_RELOC_390_TLS_DTPMOD
2185 || fixP->fx_r_type == BFD_RELOC_390_TLS_DTPOFF
2186 || fixP->fx_r_type == BFD_RELOC_390_TLS_TPOFF
2187 || fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
2188 || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
2193 /* Return true if we must always emit a reloc for a type and false if
2194 there is some hope of resolving it at assembly time. */
2196 tc_s390_force_relocation (struct fix *fixp)
2198 /* Ensure we emit a relocation for every reference to the global
2199 offset table or to the procedure link table. */
2200 switch (fixp->fx_r_type)
2202 case BFD_RELOC_390_GOT12:
2203 case BFD_RELOC_390_GOT20:
2204 case BFD_RELOC_32_GOT_PCREL:
2205 case BFD_RELOC_32_GOTOFF:
2206 case BFD_RELOC_390_GOTOFF64:
2207 case BFD_RELOC_390_PLTOFF16:
2208 case BFD_RELOC_390_PLTOFF32:
2209 case BFD_RELOC_390_PLTOFF64:
2210 case BFD_RELOC_390_GOTPC:
2211 case BFD_RELOC_390_GOT16:
2212 case BFD_RELOC_390_GOTPCDBL:
2213 case BFD_RELOC_390_GOT64:
2214 case BFD_RELOC_390_GOTENT:
2215 case BFD_RELOC_390_PLT32:
2216 case BFD_RELOC_390_PLT12DBL:
2217 case BFD_RELOC_390_PLT16DBL:
2218 case BFD_RELOC_390_PLT24DBL:
2219 case BFD_RELOC_390_PLT32DBL:
2220 case BFD_RELOC_390_PLT64:
2221 case BFD_RELOC_390_GOTPLT12:
2222 case BFD_RELOC_390_GOTPLT16:
2223 case BFD_RELOC_390_GOTPLT20:
2224 case BFD_RELOC_390_GOTPLT32:
2225 case BFD_RELOC_390_GOTPLT64:
2226 case BFD_RELOC_390_GOTPLTENT:
2232 return generic_force_reloc (fixp);
2235 /* Apply a fixup to the object code. This is called for all the
2236 fixups we generated by the call to fix_new_exp, above. In the call
2237 above we used a reloc code which was the largest legal reloc code
2238 plus the operand index. Here we undo that to recover the operand
2239 index. At this point all symbol values should be fully resolved,
2240 and we attempt to completely resolve the reloc. If we can not do
2241 that, we determine the correct reloc code and put it back in the
2245 md_apply_fix (fixS *fixP, valueT *valP, segT seg ATTRIBUTE_UNUSED)
2248 valueT value = *valP;
2250 where = fixP->fx_frag->fr_literal + fixP->fx_where;
2252 if (fixP->fx_subsy != NULL)
2253 as_bad_where (fixP->fx_file, fixP->fx_line,
2254 _("cannot emit relocation %s against subsy symbol %s"),
2255 bfd_get_reloc_code_name (fixP->fx_r_type),
2256 S_GET_NAME (fixP->fx_subsy));
2258 if (fixP->fx_addsy != NULL)
2261 value += fixP->fx_frag->fr_address + fixP->fx_where;
2266 if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED)
2268 const struct s390_operand *operand;
2271 opindex = (int) fixP->fx_r_type - (int) BFD_RELOC_UNUSED;
2272 operand = &s390_operands[opindex];
2276 /* Insert the fully resolved operand value. */
2277 s390_insert_operand ((unsigned char *) where, operand,
2278 (offsetT) value, fixP->fx_file, fixP->fx_line);
2282 /* Determine a BFD reloc value based on the operand information.
2283 We are only prepared to turn a few of the operands into
2285 fixP->fx_offset = value;
2286 if (operand->bits == 12 && operand->shift == 20)
2289 fixP->fx_where += 2;
2290 fixP->fx_r_type = BFD_RELOC_390_12;
2292 else if (operand->bits == 12 && operand->shift == 36)
2295 fixP->fx_where += 4;
2296 fixP->fx_r_type = BFD_RELOC_390_12;
2298 else if (operand->bits == 20 && operand->shift == 20)
2301 fixP->fx_where += 2;
2302 fixP->fx_r_type = BFD_RELOC_390_20;
2304 else if (operand->bits == 8 && operand->shift == 8)
2307 fixP->fx_where += 1;
2308 fixP->fx_r_type = BFD_RELOC_8;
2310 else if (operand->bits == 12 && operand->shift == 12
2311 && (operand->flags & S390_OPERAND_PCREL))
2314 fixP->fx_where += 1;
2315 fixP->fx_offset += 1;
2316 fixP->fx_pcrel_adjust = 1;
2317 fixP->fx_r_type = BFD_RELOC_390_PC12DBL;
2319 else if (operand->bits == 16 && operand->shift == 16)
2322 fixP->fx_where += 2;
2323 if (operand->flags & S390_OPERAND_PCREL)
2325 fixP->fx_r_type = BFD_RELOC_390_PC16DBL;
2326 fixP->fx_offset += 2;
2327 fixP->fx_pcrel_adjust = 2;
2330 fixP->fx_r_type = BFD_RELOC_16;
2332 else if (operand->bits == 16 && operand->shift == 32
2333 && (operand->flags & S390_OPERAND_PCREL))
2336 fixP->fx_where += 4;
2337 fixP->fx_offset += 4;
2338 fixP->fx_pcrel_adjust = 4;
2339 fixP->fx_r_type = BFD_RELOC_390_PC16DBL;
2341 else if (operand->bits == 24 && operand->shift == 24
2342 && (operand->flags & S390_OPERAND_PCREL))
2345 fixP->fx_where += 3;
2346 fixP->fx_offset += 3;
2347 fixP->fx_pcrel_adjust = 3;
2348 fixP->fx_r_type = BFD_RELOC_390_PC24DBL;
2350 else if (operand->bits == 32 && operand->shift == 16
2351 && (operand->flags & S390_OPERAND_PCREL))
2354 fixP->fx_where += 2;
2355 fixP->fx_offset += 2;
2356 fixP->fx_pcrel_adjust = 2;
2357 fixP->fx_r_type = BFD_RELOC_390_PC32DBL;
2364 /* Use expr_symbol_where to see if this is an expression
2366 if (expr_symbol_where (fixP->fx_addsy, &sfile, &sline))
2367 as_bad_where (fixP->fx_file, fixP->fx_line,
2368 _("unresolved expression that must be resolved"));
2370 as_bad_where (fixP->fx_file, fixP->fx_line,
2371 _("unsupported relocation type"));
2378 switch (fixP->fx_r_type)
2384 md_number_to_chars (where, value, 1);
2386 case BFD_RELOC_390_12:
2387 case BFD_RELOC_390_GOT12:
2388 case BFD_RELOC_390_GOTPLT12:
2389 case BFD_RELOC_390_PC12DBL:
2390 case BFD_RELOC_390_PLT12DBL:
2392 value += fixP->fx_pcrel_adjust;
2401 mop = bfd_getb16 ((unsigned char *) where);
2402 mop |= (unsigned short) (value & 0xfff);
2403 bfd_putb16 ((bfd_vma) mop, (unsigned char *) where);
2407 case BFD_RELOC_390_20:
2408 case BFD_RELOC_390_GOT20:
2409 case BFD_RELOC_390_GOTPLT20:
2413 mop = bfd_getb32 ((unsigned char *) where);
2414 mop |= (unsigned int) ((value & 0xfff) << 8 |
2415 (value & 0xff000) >> 12);
2416 bfd_putb32 ((bfd_vma) mop, (unsigned char *) where);
2421 case BFD_RELOC_GPREL16:
2422 case BFD_RELOC_16_GOT_PCREL:
2423 case BFD_RELOC_16_GOTOFF:
2425 as_bad_where (fixP->fx_file, fixP->fx_line,
2426 _("cannot emit PC relative %s relocation%s%s"),
2427 bfd_get_reloc_code_name (fixP->fx_r_type),
2428 fixP->fx_addsy != NULL ? " against " : "",
2429 (fixP->fx_addsy != NULL
2430 ? S_GET_NAME (fixP->fx_addsy)
2433 md_number_to_chars (where, value, 2);
2435 case BFD_RELOC_390_GOT16:
2436 case BFD_RELOC_390_PLTOFF16:
2437 case BFD_RELOC_390_GOTPLT16:
2439 md_number_to_chars (where, value, 2);
2441 case BFD_RELOC_390_PC16DBL:
2442 case BFD_RELOC_390_PLT16DBL:
2443 value += fixP->fx_pcrel_adjust;
2445 md_number_to_chars (where, (offsetT) value >> 1, 2);
2448 case BFD_RELOC_390_PC24DBL:
2449 case BFD_RELOC_390_PLT24DBL:
2450 value += fixP->fx_pcrel_adjust;
2456 mop = bfd_getb32 ((unsigned char *) where - 1);
2457 mop |= (unsigned int) (value & 0xffffff);
2458 bfd_putb32 ((bfd_vma) mop, (unsigned char *) where - 1);
2464 fixP->fx_r_type = BFD_RELOC_32_PCREL;
2466 fixP->fx_r_type = BFD_RELOC_32;
2468 md_number_to_chars (where, value, 4);
2470 case BFD_RELOC_32_PCREL:
2471 case BFD_RELOC_32_BASEREL:
2472 fixP->fx_r_type = BFD_RELOC_32_PCREL;
2474 md_number_to_chars (where, value, 4);
2476 case BFD_RELOC_32_GOT_PCREL:
2477 case BFD_RELOC_390_PLTOFF32:
2478 case BFD_RELOC_390_PLT32:
2479 case BFD_RELOC_390_GOTPLT32:
2481 md_number_to_chars (where, value, 4);
2483 case BFD_RELOC_390_PC32DBL:
2484 case BFD_RELOC_390_PLT32DBL:
2485 case BFD_RELOC_390_GOTPCDBL:
2486 case BFD_RELOC_390_GOTENT:
2487 case BFD_RELOC_390_GOTPLTENT:
2488 value += fixP->fx_pcrel_adjust;
2490 md_number_to_chars (where, (offsetT) value >> 1, 4);
2493 case BFD_RELOC_32_GOTOFF:
2495 md_number_to_chars (where, value, sizeof (int));
2498 case BFD_RELOC_390_GOTOFF64:
2500 md_number_to_chars (where, value, 8);
2503 case BFD_RELOC_390_GOT64:
2504 case BFD_RELOC_390_PLTOFF64:
2505 case BFD_RELOC_390_PLT64:
2506 case BFD_RELOC_390_GOTPLT64:
2508 md_number_to_chars (where, value, 8);
2513 fixP->fx_r_type = BFD_RELOC_64_PCREL;
2515 fixP->fx_r_type = BFD_RELOC_64;
2517 md_number_to_chars (where, value, 8);
2520 case BFD_RELOC_64_PCREL:
2521 fixP->fx_r_type = BFD_RELOC_64_PCREL;
2523 md_number_to_chars (where, value, 8);
2526 case BFD_RELOC_VTABLE_INHERIT:
2527 case BFD_RELOC_VTABLE_ENTRY:
2531 case BFD_RELOC_390_TLS_LOAD:
2532 case BFD_RELOC_390_TLS_GDCALL:
2533 case BFD_RELOC_390_TLS_LDCALL:
2534 case BFD_RELOC_390_TLS_GD32:
2535 case BFD_RELOC_390_TLS_GD64:
2536 case BFD_RELOC_390_TLS_GOTIE12:
2537 case BFD_RELOC_390_TLS_GOTIE20:
2538 case BFD_RELOC_390_TLS_GOTIE32:
2539 case BFD_RELOC_390_TLS_GOTIE64:
2540 case BFD_RELOC_390_TLS_LDM32:
2541 case BFD_RELOC_390_TLS_LDM64:
2542 case BFD_RELOC_390_TLS_IE32:
2543 case BFD_RELOC_390_TLS_IE64:
2544 case BFD_RELOC_390_TLS_LE32:
2545 case BFD_RELOC_390_TLS_LE64:
2546 case BFD_RELOC_390_TLS_LDO32:
2547 case BFD_RELOC_390_TLS_LDO64:
2548 case BFD_RELOC_390_TLS_DTPMOD:
2549 case BFD_RELOC_390_TLS_DTPOFF:
2550 case BFD_RELOC_390_TLS_TPOFF:
2551 S_SET_THREAD_LOCAL (fixP->fx_addsy);
2552 /* Fully resolved at link time. */
2554 case BFD_RELOC_390_TLS_IEENT:
2555 /* Fully resolved at link time. */
2556 S_SET_THREAD_LOCAL (fixP->fx_addsy);
2562 const char *reloc_name = bfd_get_reloc_code_name (fixP->fx_r_type);
2564 if (reloc_name != NULL)
2565 as_fatal (_("Gas failure, reloc type %s\n"), reloc_name);
2567 as_fatal (_("Gas failure, reloc type #%i\n"), fixP->fx_r_type);
2571 fixP->fx_offset = value;
2575 /* Generate a reloc for a fixup. */
2578 tc_gen_reloc (asection *seg ATTRIBUTE_UNUSED, fixS *fixp)
2580 bfd_reloc_code_real_type code;
2583 code = fixp->fx_r_type;
2584 if (GOT_symbol && fixp->fx_addsy == GOT_symbol)
2586 if ( (s390_arch_size == 32 && code == BFD_RELOC_32_PCREL)
2587 || (s390_arch_size == 64 && code == BFD_RELOC_64_PCREL))
2588 code = BFD_RELOC_390_GOTPC;
2589 if (code == BFD_RELOC_390_PC32DBL)
2590 code = BFD_RELOC_390_GOTPCDBL;
2593 reloc = XNEW (arelent);
2594 reloc->sym_ptr_ptr = XNEW (asymbol *);
2595 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
2596 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
2597 reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
2598 if (reloc->howto == NULL)
2600 as_bad_where (fixp->fx_file, fixp->fx_line,
2601 _("cannot represent relocation type %s"),
2602 bfd_get_reloc_code_name (code));
2603 /* Set howto to a garbage value so that we can keep going. */
2604 reloc->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_32);
2605 gas_assert (reloc->howto != NULL);
2607 reloc->addend = fixp->fx_offset;
2613 s390_cfi_frame_initial_instructions (void)
2615 cfi_add_CFA_def_cfa (15, s390_arch_size == 64 ? 160 : 96);
2619 tc_s390_regname_to_dw2regnum (char *regname)
2623 if (regname[0] != 'c' && regname[0] != 'a')
2625 regnum = reg_name_search (regname);
2626 if (regname[0] == 'f' && regnum != -1)
2629 else if (strcmp (regname, "ap") == 0)
2631 else if (strcmp (regname, "cc") == 0)
2637 s390_elf_final_processing (void)
2640 elf_elfheader (stdoutput)->e_flags |= EF_S390_HIGH_GPRS;