1 /* tc-s390.c -- Assemble for the S390
2 Copyright (C) 2000-2018 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 "dwarf2dbg.h"
26 #include "dw2gencfi.h"
28 #include "opcode/s390.h"
31 /* The default architecture. */
33 #define DEFAULT_ARCH "s390"
35 static const char *default_arch
= DEFAULT_ARCH
;
36 /* Either 32 or 64, selects file format. */
37 static int s390_arch_size
= 0;
39 /* If no -march option was given default to the highest available CPU.
40 Since with S/390 a newer CPU always supports everything from its
41 predecessors this will accept every valid asm input. */
42 static unsigned int current_cpu
= S390_OPCODE_MAXCPU
- 1;
43 /* All facilities are enabled by default. */
44 static unsigned int current_flags
= S390_INSTR_FLAG_FACILITY_MASK
;
45 /* The mode mask default is picked in init_default_arch depending on
47 static unsigned int current_mode_mask
= 0;
49 /* Set to TRUE if the highgprs flag in the ELF header needs to be set
50 for the output file. */
51 static bfd_boolean set_highgprs_p
= FALSE
;
53 /* Whether to use user friendly register names. Default is TRUE. */
54 #ifndef TARGET_REG_NAMES_P
55 #define TARGET_REG_NAMES_P TRUE
58 static bfd_boolean reg_names_p
= TARGET_REG_NAMES_P
;
60 /* Set to TRUE if we want to warn about zero base/index registers. */
61 static bfd_boolean warn_areg_zero
= FALSE
;
63 /* Generic assembler global variables which must be defined by all
66 const char comment_chars
[] = "#";
68 /* Characters which start a comment at the beginning of a line. */
69 const char line_comment_chars
[] = "#";
71 /* Characters which may be used to separate multiple commands on a
73 const char line_separator_chars
[] = ";";
75 /* Characters which are used to indicate an exponent in a floating
77 const char EXP_CHARS
[] = "eE";
79 /* Characters which mean that a number is a floating point constant,
81 const char FLT_CHARS
[] = "dD";
83 /* The dwarf2 data alignment, adjusted for 32 or 64 bit. */
84 int s390_cie_data_alignment
;
86 /* The target specific pseudo-ops which we support. */
88 /* Define the prototypes for the pseudo-ops */
89 static void s390_byte (int);
90 static void s390_elf_cons (int);
91 static void s390_bss (int);
92 static void s390_insn (int);
93 static void s390_literals (int);
94 static void s390_machine (int);
95 static void s390_machinemode (int);
97 const pseudo_typeS md_pseudo_table
[] =
99 { "align", s_align_bytes
, 0 },
100 /* Pseudo-ops which must be defined. */
101 { "bss", s390_bss
, 0 },
102 { "insn", s390_insn
, 0 },
103 /* Pseudo-ops which must be overridden. */
104 { "byte", s390_byte
, 0 },
105 { "short", s390_elf_cons
, 2 },
106 { "long", s390_elf_cons
, 4 },
107 { "quad", s390_elf_cons
, 8 },
108 { "ltorg", s390_literals
, 0 },
109 { "string", stringer
, 8 + 1 },
110 { "machine", s390_machine
, 0 },
111 { "machinemode", s390_machinemode
, 0 },
115 /* Given NAME, find the register number associated with that name, return
116 the integer value associated with the given name or -1 on failure. */
119 reg_name_search (const char *name
)
123 if (strcasecmp (name
, "lit") == 0)
126 if (strcasecmp (name
, "sp") == 0)
129 if (name
[0] != 'a' && name
[0] != 'c' && name
[0] != 'f'
130 && name
[0] != 'r' && name
[0] != 'v')
133 if (ISDIGIT (name
[1]))
136 if (ISDIGIT (name
[2]))
137 val
= val
* 10 + name
[2] - '0';
140 if ((name
[0] != 'v' && val
> 15) || val
> 31)
148 * Summary of register_name().
150 * in: Input_line_pointer points to 1st char of operand.
152 * out: A expressionS.
153 * The operand may have been a register: in this case, X_op == O_register,
154 * X_add_number is set to the register number, and truth is returned.
155 * Input_line_pointer->(next non-blank) char after operand, or is in its
160 register_name (expressionS
*expressionP
)
167 /* Find the spelling of the operand. */
168 start
= name
= input_line_pointer
;
169 if (name
[0] == '%' && ISALPHA (name
[1]))
170 name
= ++input_line_pointer
;
174 c
= get_symbol_name (&name
);
175 reg_number
= reg_name_search (name
);
177 /* Put back the delimiting char. */
178 (void) restore_line_pointer (c
);
180 /* Look to see if it's in the register table. */
183 expressionP
->X_op
= O_register
;
184 expressionP
->X_add_number
= reg_number
;
186 /* Make the rest nice. */
187 expressionP
->X_add_symbol
= NULL
;
188 expressionP
->X_op_symbol
= NULL
;
192 /* Reset the line as if we had not done anything. */
193 input_line_pointer
= start
;
197 /* Local variables. */
199 /* Opformat hash table. */
200 static struct hash_control
*s390_opformat_hash
;
202 /* Opcode hash table. */
203 static struct hash_control
*s390_opcode_hash
= NULL
;
205 /* Flags to set in the elf header */
206 static flagword s390_flags
= 0;
208 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE_" */
210 #ifndef WORKING_DOT_WORD
211 int md_short_jump_size
= 4;
212 int md_long_jump_size
= 4;
215 const char *md_shortopts
= "A:m:kVQ:";
216 struct option md_longopts
[] = {
217 {NULL
, no_argument
, NULL
, 0}
219 size_t md_longopts_size
= sizeof (md_longopts
);
221 /* Initialize the default opcode arch and word size from the default
222 architecture name if not specified by an option. */
224 init_default_arch (void)
226 if (strcmp (default_arch
, "s390") == 0)
228 if (s390_arch_size
== 0)
231 else if (strcmp (default_arch
, "s390x") == 0)
233 if (s390_arch_size
== 0)
237 as_fatal (_("Invalid default architecture, broken assembler."));
239 if (current_mode_mask
== 0)
241 /* Default to z/Architecture mode if the CPU supports it. */
242 if (current_cpu
< S390_OPCODE_Z900
)
243 current_mode_mask
= 1 << S390_OPCODE_ESA
;
245 current_mode_mask
= 1 << S390_OPCODE_ZARCH
;
249 /* Called by TARGET_FORMAT. */
251 s390_target_format (void)
253 /* We don't get a chance to initialize anything before we're called,
254 so handle that now. */
255 init_default_arch ();
257 return s390_arch_size
== 64 ? "elf64-s390" : "elf32-s390";
260 /* Map a cpu string ARG as given with -march= or .machine to the respective
261 enum s390_opcode_cpu_val value. If ALLOW_EXTENSIONS is TRUE, the cpu name
262 can be followed by a list of cpu facility flags each beginning with the
263 character '+'. The active cpu flags are returned through *RET_FLAGS.
264 In case of an error, S390_OPCODE_MAXCPU is returned. */
267 s390_parse_cpu (const char * arg
,
268 unsigned int * ret_flags
,
269 bfd_boolean allow_extensions
)
274 unsigned int name_len
;
275 const char * alt_name
;
276 unsigned int alt_name_len
;
278 } cpu_table
[S390_OPCODE_MAXCPU
] =
280 { STRING_COMMA_LEN ("g5"), STRING_COMMA_LEN ("arch3"), 0 },
281 { STRING_COMMA_LEN ("g6"), STRING_COMMA_LEN (""), 0 },
282 { STRING_COMMA_LEN ("z900"), STRING_COMMA_LEN ("arch5"), 0 },
283 { STRING_COMMA_LEN ("z990"), STRING_COMMA_LEN ("arch6"), 0 },
284 { STRING_COMMA_LEN ("z9-109"), STRING_COMMA_LEN (""), 0 },
285 { STRING_COMMA_LEN ("z9-ec"), STRING_COMMA_LEN ("arch7"), 0 },
286 { STRING_COMMA_LEN ("z10"), STRING_COMMA_LEN ("arch8"), 0 },
287 { STRING_COMMA_LEN ("z196"), STRING_COMMA_LEN ("arch9"), 0 },
288 { STRING_COMMA_LEN ("zEC12"), STRING_COMMA_LEN ("arch10"),
289 S390_INSTR_FLAG_HTM
},
290 { STRING_COMMA_LEN ("z13"), STRING_COMMA_LEN ("arch11"),
291 S390_INSTR_FLAG_HTM
| S390_INSTR_FLAG_VX
},
292 { STRING_COMMA_LEN ("z14"), STRING_COMMA_LEN ("arch12"),
293 S390_INSTR_FLAG_HTM
| S390_INSTR_FLAG_VX
}
302 { "htm", S390_INSTR_FLAG_HTM
, TRUE
},
303 { "nohtm", S390_INSTR_FLAG_HTM
, FALSE
},
304 { "vx", S390_INSTR_FLAG_VX
, TRUE
},
305 { "novx", S390_INSTR_FLAG_VX
, FALSE
}
310 icpu
= S390_OPCODE_MAXCPU
;
311 if (strncmp (arg
, "all", 3) == 0 && (arg
[3] == 0 || arg
[3] == '+'))
313 icpu
= S390_OPCODE_MAXCPU
- 1;
318 for (icpu
= 0; icpu
< S390_OPCODE_MAXCPU
; icpu
++)
320 unsigned int l
, l_alt
;
322 l
= cpu_table
[icpu
].name_len
;
324 if (strncmp (arg
, cpu_table
[icpu
].name
, l
) == 0
325 && (arg
[l
] == 0 || arg
[l
] == '+'))
331 l_alt
= cpu_table
[icpu
].alt_name_len
;
334 && strncmp (arg
, cpu_table
[icpu
].alt_name
, l_alt
) == 0
335 && (arg
[l_alt
] == 0 || arg
[l_alt
] == '+'))
343 if (icpu
== S390_OPCODE_MAXCPU
)
344 return S390_OPCODE_MAXCPU
;
346 ilp_bak
= input_line_pointer
;
347 if (icpu
!= S390_OPCODE_MAXCPU
)
349 input_line_pointer
= (char *) arg
;
350 *ret_flags
= (cpu_table
[icpu
].flags
& S390_INSTR_FLAG_FACILITY_MASK
);
352 while (*input_line_pointer
== '+' && allow_extensions
)
358 input_line_pointer
++;
359 c
= get_symbol_name (&sym
);
360 for (iflag
= 0; iflag
< ARRAY_SIZE (cpu_flags
); iflag
++)
362 if (strcmp (sym
, cpu_flags
[iflag
].name
) == 0)
364 if (cpu_flags
[iflag
].on
)
365 *ret_flags
|= cpu_flags
[iflag
].mask
;
367 *ret_flags
&= ~cpu_flags
[iflag
].mask
;
371 if (iflag
== ARRAY_SIZE (cpu_flags
))
372 as_bad (_("no such machine extension `%s'"), sym
- 1);
373 *input_line_pointer
= c
;
374 if (iflag
== ARRAY_SIZE (cpu_flags
))
381 if (*input_line_pointer
!= 0 && *input_line_pointer
!= '\n')
383 as_bad (_("junk at end of machine string, first unrecognized character"
384 " is `%c'"), *input_line_pointer
);
385 icpu
= S390_OPCODE_MAXCPU
;
387 input_line_pointer
= ilp_bak
;
393 md_parse_option (int c
, const char *arg
)
397 /* -k: Ignore for FreeBSD compatibility. */
401 if (arg
!= NULL
&& strcmp (arg
, "regnames") == 0)
404 else if (arg
!= NULL
&& strcmp (arg
, "no-regnames") == 0)
407 else if (arg
!= NULL
&& strcmp (arg
, "warn-areg-zero") == 0)
408 warn_areg_zero
= TRUE
;
410 else if (arg
!= NULL
&& strcmp (arg
, "31") == 0)
413 else if (arg
!= NULL
&& strcmp (arg
, "64") == 0)
416 else if (arg
!= NULL
&& strcmp (arg
, "esa") == 0)
417 current_mode_mask
= 1 << S390_OPCODE_ESA
;
419 else if (arg
!= NULL
&& strcmp (arg
, "zarch") == 0)
421 if (s390_arch_size
== 32)
422 set_highgprs_p
= TRUE
;
423 current_mode_mask
= 1 << S390_OPCODE_ZARCH
;
426 else if (arg
!= NULL
&& strncmp (arg
, "arch=", 5) == 0)
428 current_cpu
= s390_parse_cpu (arg
+ 5, ¤t_flags
, FALSE
);
429 if (current_cpu
== S390_OPCODE_MAXCPU
)
431 as_bad (_("invalid switch -m%s"), arg
);
438 as_bad (_("invalid switch -m%s"), arg
);
444 /* Option -A is deprecated. Still available for compatibility. */
445 if (arg
!= NULL
&& strcmp (arg
, "esa") == 0)
446 current_cpu
= S390_OPCODE_G5
;
447 else if (arg
!= NULL
&& strcmp (arg
, "esame") == 0)
448 current_cpu
= S390_OPCODE_Z900
;
450 as_bad (_("invalid architecture -A%s"), arg
);
453 /* -V: SVR4 argument to print version ID. */
458 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
459 should be emitted or not. FIXME: Not implemented. */
471 md_show_usage (FILE *stream
)
473 fprintf (stream
, _("\
475 -mregnames Allow symbolic names for registers\n\
476 -mwarn-areg-zero Warn about zero base/index registers\n\
477 -mno-regnames Do not allow symbolic names for registers\n\
478 -m31 Set file format to 31 bit format\n\
479 -m64 Set file format to 64 bit format\n"));
480 fprintf (stream
, _("\
481 -V print assembler version number\n\
482 -Qy, -Qn ignored\n"));
485 /* Generate the hash table mapping mnemonics to struct s390_opcode.
486 This table is built at startup and whenever the CPU level is
487 changed using .machine. */
490 s390_setup_opcodes (void)
492 const struct s390_opcode
*op
;
493 const struct s390_opcode
*op_end
;
494 bfd_boolean dup_insn
= FALSE
;
497 if (s390_opcode_hash
!= NULL
)
498 hash_die (s390_opcode_hash
);
500 /* Insert the opcodes into a hash table. */
501 s390_opcode_hash
= hash_new ();
503 op_end
= s390_opcodes
+ s390_num_opcodes
;
504 for (op
= s390_opcodes
; op
< op_end
; op
++)
508 while (op
< op_end
- 1 && strcmp(op
->name
, op
[1].name
) == 0)
510 if (op
->min_cpu
<= current_cpu
&& (op
->modes
& current_mode_mask
))
515 if ((op
->modes
& current_mode_mask
) == 0)
517 else if ((op
->flags
& S390_INSTR_FLAG_FACILITY_MASK
) == 0)
519 /* Opcodes that do not belong to a specific facility are enabled if
520 present in the selected cpu. */
521 use_opcode
= (op
->min_cpu
<= current_cpu
);
527 /* Opcodes of a specific facility are enabled if the facility is
528 enabled. Note: only some facilities are represented as flags. */
529 f
= (op
->flags
& S390_INSTR_FLAG_FACILITY_MASK
);
530 use_opcode
= ((f
& current_flags
) == f
);
534 retval
= hash_insert (s390_opcode_hash
, op
->name
, (void *) op
);
535 if (retval
!= (const char *) NULL
)
537 as_bad (_("Internal assembler error for instruction %s"),
543 while (op
< op_end
- 1 && strcmp (op
->name
, op
[1].name
) == 0)
551 /* This function is called when the assembler starts up. It is called
552 after the options have been parsed and the output file has been
558 const struct s390_opcode
*op
;
559 const struct s390_opcode
*op_end
;
562 /* Give a warning if the combination -m64-bit and -Aesa is used. */
563 if (s390_arch_size
== 64 && current_cpu
< S390_OPCODE_Z900
)
564 as_warn (_("The 64 bit file format is used without esame instructions."));
566 s390_cie_data_alignment
= -s390_arch_size
/ 8;
568 /* Set the ELF flags if desired. */
570 bfd_set_private_flags (stdoutput
, s390_flags
);
572 /* Insert the opcode formats into a hash table. */
573 s390_opformat_hash
= hash_new ();
575 op_end
= s390_opformats
+ s390_num_opformats
;
576 for (op
= s390_opformats
; op
< op_end
; op
++)
578 retval
= hash_insert (s390_opformat_hash
, op
->name
, (void *) op
);
579 if (retval
!= (const char *) NULL
)
580 as_bad (_("Internal assembler error for instruction format %s"),
584 s390_setup_opcodes ();
586 record_alignment (text_section
, 2);
587 record_alignment (data_section
, 2);
588 record_alignment (bss_section
, 2);
591 /* Called after all assembly has been done. */
595 if (s390_arch_size
== 64)
596 bfd_set_arch_mach (stdoutput
, bfd_arch_s390
, bfd_mach_s390_64
);
598 bfd_set_arch_mach (stdoutput
, bfd_arch_s390
, bfd_mach_s390_31
);
601 /* Insert an operand value into an instruction. */
604 s390_insert_operand (unsigned char *insn
,
605 const struct s390_operand
*operand
,
613 if (operand
->flags
& (S390_OPERAND_SIGNED
|S390_OPERAND_PCREL
))
617 max
= ((offsetT
) 1 << (operand
->bits
- 1)) - 1;
618 min
= - ((offsetT
) 1 << (operand
->bits
- 1));
619 /* Halve PCREL operands. */
620 if (operand
->flags
& S390_OPERAND_PCREL
)
622 /* Check for underflow / overflow. */
623 if (val
< min
|| val
> max
)
626 _("operand out of range (%s not between %ld and %ld)");
629 if (operand
->flags
& S390_OPERAND_PCREL
)
635 sprint_value (buf
, val
);
636 if (file
== (char *) NULL
)
637 as_bad (err
, buf
, (int) min
, (int) max
);
639 as_bad_where (file
, line
, err
, buf
, (int) min
, (int) max
);
642 /* val is ok, now restrict it to operand->bits bits. */
643 uval
= (addressT
) val
& ((((addressT
) 1 << (operand
->bits
-1)) << 1) - 1);
644 /* val is restrict, now check for special case. */
645 if (operand
->bits
== 20 && operand
->shift
== 20)
646 uval
= (uval
>> 12) | ((uval
& 0xfff) << 8);
652 max
= (((addressT
) 1 << (operand
->bits
- 1)) << 1) - 1;
654 uval
= (addressT
) val
;
656 /* Vector register operands have an additional bit in the RXB
658 if (operand
->flags
& S390_OPERAND_VR
)
659 max
= (max
<< 1) | 1;
661 /* Length x in an instructions has real length x+1. */
662 if (operand
->flags
& S390_OPERAND_LENGTH
)
664 /* Check for underflow / overflow. */
665 if (uval
< min
|| uval
> max
)
667 if (operand
->flags
& S390_OPERAND_LENGTH
)
674 as_bad_value_out_of_range (_("operand"), uval
, (offsetT
) min
, (offsetT
) max
, file
, line
);
680 if (operand
->flags
& S390_OPERAND_VR
)
682 /* Insert the extra bit into the RXB field. */
683 switch (operand
->shift
)
686 insn
[4] |= (uval
& 0x10) >> 1;
689 insn
[4] |= (uval
& 0x10) >> 2;
692 insn
[4] |= (uval
& 0x10) >> 3;
695 insn
[4] |= (uval
& 0x10) >> 4;
701 if (operand
->flags
& S390_OPERAND_OR1
)
703 if (operand
->flags
& S390_OPERAND_OR2
)
705 if (operand
->flags
& S390_OPERAND_OR8
)
708 /* Duplicate the operand at bit pos 12 to 16. */
709 if (operand
->flags
& S390_OPERAND_CP16
)
711 /* Copy VR operand at bit pos 12 to bit pos 16. */
712 insn
[2] |= uval
<< 4;
713 /* Copy the flag in the RXB field. */
714 insn
[4] |= (insn
[4] & 4) >> 1;
717 /* Insert fragments of the operand byte for byte. */
718 offset
= operand
->shift
+ operand
->bits
;
719 uval
<<= (-offset
) & 7;
720 insn
+= (offset
- 1) / 8;
732 bfd_reloc_code_real_type reloc
;
735 /* Parse tls marker and return the desired relocation. */
736 static bfd_reloc_code_real_type
737 s390_tls_suffix (char **str_p
, expressionS
*exp_p
)
739 static struct map_tls mapping
[] =
741 { "tls_load", 8, BFD_RELOC_390_TLS_LOAD
},
742 { "tls_gdcall", 10, BFD_RELOC_390_TLS_GDCALL
},
743 { "tls_ldcall", 10, BFD_RELOC_390_TLS_LDCALL
},
744 { NULL
, 0, BFD_RELOC_UNUSED
}
754 return BFD_RELOC_UNUSED
;
757 while (ISIDNUM (*str
))
761 return BFD_RELOC_UNUSED
;
763 orig_line
= input_line_pointer
;
764 input_line_pointer
= str
;
766 str
= input_line_pointer
;
767 if (&input_line_pointer
!= str_p
)
768 input_line_pointer
= orig_line
;
770 if (exp_p
->X_op
!= O_symbol
)
771 return BFD_RELOC_UNUSED
;
773 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
774 if (len
== ptr
->length
775 && strncasecmp (ident
, ptr
->string
, ptr
->length
) == 0)
777 /* Found a matching tls suffix. */
781 return BFD_RELOC_UNUSED
;
784 /* Structure used to hold suffixes. */
795 ELF_SUFFIX_TLS_GOTIE
,
807 elf_suffix_type suffix
;
811 /* Parse @got/@plt/@gotoff. and return the desired relocation. */
812 static elf_suffix_type
813 s390_elf_suffix (char **str_p
, expressionS
*exp_p
)
815 static struct map_bfd mapping
[] =
817 { "got", 3, ELF_SUFFIX_GOT
},
818 { "got12", 5, ELF_SUFFIX_GOT
},
819 { "plt", 3, ELF_SUFFIX_PLT
},
820 { "gotent", 6, ELF_SUFFIX_GOTENT
},
821 { "gotoff", 6, ELF_SUFFIX_GOTOFF
},
822 { "gotplt", 6, ELF_SUFFIX_GOTPLT
},
823 { "pltoff", 6, ELF_SUFFIX_PLTOFF
},
824 { "tlsgd", 5, ELF_SUFFIX_TLS_GD
},
825 { "gotntpoff", 9, ELF_SUFFIX_TLS_GOTIE
},
826 { "indntpoff", 9, ELF_SUFFIX_TLS_IE
},
827 { "tlsldm", 6, ELF_SUFFIX_TLS_LDM
},
828 { "dtpoff", 6, ELF_SUFFIX_TLS_LDO
},
829 { "ntpoff", 6, ELF_SUFFIX_TLS_LE
},
830 { NULL
, 0, ELF_SUFFIX_NONE
}
839 return ELF_SUFFIX_NONE
;
842 while (ISALNUM (*str
))
846 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
847 if (len
== ptr
->length
848 && strncasecmp (ident
, ptr
->string
, ptr
->length
) == 0)
850 if (exp_p
->X_add_number
!= 0)
851 as_warn (_("identifier+constant@%s means identifier@%s+constant"),
852 ptr
->string
, ptr
->string
);
853 /* Now check for identifier@suffix+constant. */
854 if (*str
== '-' || *str
== '+')
856 char *orig_line
= input_line_pointer
;
859 input_line_pointer
= str
;
860 expression (&new_exp
);
862 switch (new_exp
.X_op
)
864 case O_constant
: /* X_add_number (a constant expression). */
865 exp_p
->X_add_number
+= new_exp
.X_add_number
;
866 str
= input_line_pointer
;
868 case O_symbol
: /* X_add_symbol + X_add_number. */
869 /* this case is used for e.g. xyz@PLT+.Label. */
870 exp_p
->X_add_number
+= new_exp
.X_add_number
;
871 exp_p
->X_op_symbol
= new_exp
.X_add_symbol
;
873 str
= input_line_pointer
;
875 case O_uminus
: /* (- X_add_symbol) + X_add_number. */
876 /* this case is used for e.g. xyz@PLT-.Label. */
877 exp_p
->X_add_number
+= new_exp
.X_add_number
;
878 exp_p
->X_op_symbol
= new_exp
.X_add_symbol
;
879 exp_p
->X_op
= O_subtract
;
880 str
= input_line_pointer
;
886 /* If s390_elf_suffix has not been called with
887 &input_line_pointer as first parameter, we have
888 clobbered the input_line_pointer. We have to
890 if (&input_line_pointer
!= str_p
)
891 input_line_pointer
= orig_line
;
897 return BFD_RELOC_UNUSED
;
900 /* Structure used to hold a literal pool entry. */
903 struct s390_lpe
*next
;
905 FLONUM_TYPE floatnum
; /* used if X_op == O_big && X_add_number <= 0 */
906 LITTLENUM_TYPE bignum
[4]; /* used if X_op == O_big && X_add_number > 0 */
908 bfd_reloc_code_real_type reloc
;
912 static struct s390_lpe
*lpe_free_list
= NULL
;
913 static struct s390_lpe
*lpe_list
= NULL
;
914 static struct s390_lpe
*lpe_list_tail
= NULL
;
915 static symbolS
*lp_sym
= NULL
;
916 static int lp_count
= 0;
917 static int lpe_count
= 0;
920 s390_exp_compare (expressionS
*exp1
, expressionS
*exp2
)
922 if (exp1
->X_op
!= exp2
->X_op
)
927 case O_constant
: /* X_add_number must be equal. */
929 return exp1
->X_add_number
== exp2
->X_add_number
;
932 as_bad (_("Can't handle O_big in s390_exp_compare"));
935 case O_symbol
: /* X_add_symbol & X_add_number must be equal. */
940 return (exp1
->X_add_symbol
== exp2
->X_add_symbol
)
941 && (exp1
->X_add_number
== exp2
->X_add_number
);
943 case O_multiply
: /* X_add_symbol,X_op_symbol&X_add_number must be equal. */
948 case O_bit_inclusive_or
:
950 case O_bit_exclusive_or
:
962 return (exp1
->X_add_symbol
== exp2
->X_add_symbol
)
963 && (exp1
->X_op_symbol
== exp2
->X_op_symbol
)
964 && (exp1
->X_add_number
== exp2
->X_add_number
);
970 /* Test for @lit and if it's present make an entry in the literal pool and
971 modify the current expression to be an offset into the literal pool. */
972 static elf_suffix_type
973 s390_lit_suffix (char **str_p
, expressionS
*exp_p
, elf_suffix_type suffix
)
975 bfd_reloc_code_real_type reloc
;
979 struct s390_lpe
*lpe
;
983 return suffix
; /* No modification. */
985 /* We look for a suffix of the form "@lit1", "@lit2", "@lit4" or "@lit8". */
987 while (ISALNUM (*str
))
990 if (len
!= 4 || strncasecmp (ident
, "lit", 3) != 0
991 || (ident
[3]!='1' && ident
[3]!='2' && ident
[3]!='4' && ident
[3]!='8'))
992 return suffix
; /* no modification */
993 nbytes
= ident
[3] - '0';
995 reloc
= BFD_RELOC_UNUSED
;
996 if (suffix
== ELF_SUFFIX_GOT
)
999 reloc
= BFD_RELOC_390_GOT16
;
1000 else if (nbytes
== 4)
1001 reloc
= BFD_RELOC_32_GOT_PCREL
;
1002 else if (nbytes
== 8)
1003 reloc
= BFD_RELOC_390_GOT64
;
1005 else if (suffix
== ELF_SUFFIX_PLT
)
1008 reloc
= BFD_RELOC_390_PLT32
;
1009 else if (nbytes
== 8)
1010 reloc
= BFD_RELOC_390_PLT64
;
1013 if (suffix
!= ELF_SUFFIX_NONE
&& reloc
== BFD_RELOC_UNUSED
)
1014 as_bad (_("Invalid suffix for literal pool entry"));
1016 /* Search the pool if the new entry is a duplicate. */
1017 if (exp_p
->X_op
== O_big
)
1019 /* Special processing for big numbers. */
1020 for (lpe
= lpe_list
; lpe
!= NULL
; lpe
= lpe
->next
)
1022 if (lpe
->ex
.X_op
== O_big
)
1024 if (exp_p
->X_add_number
<= 0 && lpe
->ex
.X_add_number
<= 0)
1026 if (memcmp (&generic_floating_point_number
, &lpe
->floatnum
,
1027 sizeof (FLONUM_TYPE
)) == 0)
1030 else if (exp_p
->X_add_number
== lpe
->ex
.X_add_number
)
1032 if (memcmp (generic_bignum
, lpe
->bignum
,
1033 sizeof (LITTLENUM_TYPE
)*exp_p
->X_add_number
) == 0)
1041 /* Processing for 'normal' data types. */
1042 for (lpe
= lpe_list
; lpe
!= NULL
; lpe
= lpe
->next
)
1043 if (lpe
->nbytes
== nbytes
&& lpe
->reloc
== reloc
1044 && s390_exp_compare (exp_p
, &lpe
->ex
) != 0)
1050 /* A new literal. */
1051 if (lpe_free_list
!= NULL
)
1053 lpe
= lpe_free_list
;
1054 lpe_free_list
= lpe_free_list
->next
;
1058 lpe
= XNEW (struct s390_lpe
);
1063 if (exp_p
->X_op
== O_big
)
1065 if (exp_p
->X_add_number
<= 0)
1066 lpe
->floatnum
= generic_floating_point_number
;
1067 else if (exp_p
->X_add_number
<= 4)
1068 memcpy (lpe
->bignum
, generic_bignum
,
1069 exp_p
->X_add_number
* sizeof (LITTLENUM_TYPE
));
1071 as_bad (_("Big number is too big"));
1074 lpe
->nbytes
= nbytes
;
1076 /* Literal pool name defined ? */
1079 sprintf (tmp_name
, ".L\001%i", lp_count
);
1080 lp_sym
= symbol_make (tmp_name
);
1083 /* Make name for literal pool entry. */
1084 sprintf (tmp_name
, ".L\001%i\002%i", lp_count
, lpe_count
);
1086 lpe
->sym
= symbol_make (tmp_name
);
1088 /* Add to literal pool list. */
1090 if (lpe_list_tail
!= NULL
)
1092 lpe_list_tail
->next
= lpe
;
1093 lpe_list_tail
= lpe
;
1096 lpe_list
= lpe_list_tail
= lpe
;
1099 /* Now change exp_p to the offset into the literal pool.
1100 That's the expression: .L^Ax^By-.L^Ax */
1101 exp_p
->X_add_symbol
= lpe
->sym
;
1102 exp_p
->X_op_symbol
= lp_sym
;
1103 exp_p
->X_op
= O_subtract
;
1104 exp_p
->X_add_number
= 0;
1108 /* We change the suffix type to ELF_SUFFIX_NONE, because
1109 the difference of two local labels is just a number. */
1110 return ELF_SUFFIX_NONE
;
1113 /* Like normal .long/.short/.word, except support @got, etc.
1114 clobbers input_line_pointer, checks end-of-line. */
1116 s390_elf_cons (int nbytes
/* 1=.byte, 2=.word, 4=.long */)
1119 elf_suffix_type suffix
;
1121 if (is_it_end_of_statement ())
1123 demand_empty_rest_of_line ();
1131 if (exp
.X_op
== O_symbol
1132 && *input_line_pointer
== '@'
1133 && (suffix
= s390_elf_suffix (&input_line_pointer
, &exp
)) != ELF_SUFFIX_NONE
)
1135 bfd_reloc_code_real_type reloc
;
1136 reloc_howto_type
*reloc_howto
;
1142 static bfd_reloc_code_real_type tab2
[] =
1144 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_NONE */
1145 BFD_RELOC_390_GOT16
, /* ELF_SUFFIX_GOT */
1146 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_PLT */
1147 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTENT */
1148 BFD_RELOC_16_GOTOFF
, /* ELF_SUFFIX_GOTOFF */
1149 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTPLT */
1150 BFD_RELOC_390_PLTOFF16
, /* ELF_SUFFIX_PLTOFF */
1151 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_GD */
1152 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_GOTIE */
1153 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_IE */
1154 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_LDM */
1155 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_LDO */
1156 BFD_RELOC_UNUSED
/* ELF_SUFFIX_TLS_LE */
1158 reloc
= tab2
[suffix
];
1160 else if (nbytes
== 4)
1162 static bfd_reloc_code_real_type tab4
[] =
1164 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_NONE */
1165 BFD_RELOC_32_GOT_PCREL
, /* ELF_SUFFIX_GOT */
1166 BFD_RELOC_390_PLT32
, /* ELF_SUFFIX_PLT */
1167 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTENT */
1168 BFD_RELOC_32_GOTOFF
, /* ELF_SUFFIX_GOTOFF */
1169 BFD_RELOC_390_GOTPLT32
, /* ELF_SUFFIX_GOTPLT */
1170 BFD_RELOC_390_PLTOFF32
, /* ELF_SUFFIX_PLTOFF */
1171 BFD_RELOC_390_TLS_GD32
, /* ELF_SUFFIX_TLS_GD */
1172 BFD_RELOC_390_TLS_GOTIE32
, /* ELF_SUFFIX_TLS_GOTIE */
1173 BFD_RELOC_390_TLS_IE32
, /* ELF_SUFFIX_TLS_IE */
1174 BFD_RELOC_390_TLS_LDM32
, /* ELF_SUFFIX_TLS_LDM */
1175 BFD_RELOC_390_TLS_LDO32
, /* ELF_SUFFIX_TLS_LDO */
1176 BFD_RELOC_390_TLS_LE32
/* ELF_SUFFIX_TLS_LE */
1178 reloc
= tab4
[suffix
];
1180 else if (nbytes
== 8)
1182 static bfd_reloc_code_real_type tab8
[] =
1184 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_NONE */
1185 BFD_RELOC_390_GOT64
, /* ELF_SUFFIX_GOT */
1186 BFD_RELOC_390_PLT64
, /* ELF_SUFFIX_PLT */
1187 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTENT */
1188 BFD_RELOC_390_GOTOFF64
, /* ELF_SUFFIX_GOTOFF */
1189 BFD_RELOC_390_GOTPLT64
, /* ELF_SUFFIX_GOTPLT */
1190 BFD_RELOC_390_PLTOFF64
, /* ELF_SUFFIX_PLTOFF */
1191 BFD_RELOC_390_TLS_GD64
, /* ELF_SUFFIX_TLS_GD */
1192 BFD_RELOC_390_TLS_GOTIE64
, /* ELF_SUFFIX_TLS_GOTIE */
1193 BFD_RELOC_390_TLS_IE64
, /* ELF_SUFFIX_TLS_IE */
1194 BFD_RELOC_390_TLS_LDM64
, /* ELF_SUFFIX_TLS_LDM */
1195 BFD_RELOC_390_TLS_LDO64
, /* ELF_SUFFIX_TLS_LDO */
1196 BFD_RELOC_390_TLS_LE64
/* ELF_SUFFIX_TLS_LE */
1198 reloc
= tab8
[suffix
];
1201 reloc
= BFD_RELOC_UNUSED
;
1203 if (reloc
!= BFD_RELOC_UNUSED
1204 && (reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
)))
1206 size
= bfd_get_reloc_size (reloc_howto
);
1208 as_bad (ngettext ("%s relocations do not fit in %d byte",
1209 "%s relocations do not fit in %d bytes",
1211 reloc_howto
->name
, nbytes
);
1212 where
= frag_more (nbytes
);
1213 md_number_to_chars (where
, 0, size
);
1214 /* To make fixup_segment do the pc relative conversion the
1215 pcrel parameter on the fix_new_exp call needs to be FALSE. */
1216 fix_new_exp (frag_now
, where
- frag_now
->fr_literal
,
1217 size
, &exp
, FALSE
, reloc
);
1220 as_bad (_("relocation not applicable"));
1223 emit_expr (&exp
, (unsigned int) nbytes
);
1225 while (*input_line_pointer
++ == ',');
1227 input_line_pointer
--; /* Put terminator back into stream. */
1228 demand_empty_rest_of_line ();
1231 /* Return true if all remaining operands in the opcode with
1232 OPCODE_FLAGS can be skipped. */
1234 skip_optargs_p (unsigned int opcode_flags
, const unsigned char *opindex_ptr
)
1236 if ((opcode_flags
& (S390_INSTR_FLAG_OPTPARM
| S390_INSTR_FLAG_OPTPARM2
))
1237 && opindex_ptr
[0] != '\0'
1238 && opindex_ptr
[1] == '\0')
1241 if ((opcode_flags
& S390_INSTR_FLAG_OPTPARM2
)
1242 && opindex_ptr
[0] != '\0'
1243 && opindex_ptr
[1] != '\0'
1244 && opindex_ptr
[2] == '\0')
1249 /* We need to keep a list of fixups. We can't simply generate them as
1250 we go, because that would require us to first create the frag, and
1251 that would screw up references to ``.''. */
1257 bfd_reloc_code_real_type reloc
;
1260 #define MAX_INSN_FIXUPS (4)
1262 /* This routine is called for each instruction to be assembled. */
1265 md_gather_operands (char *str
,
1266 unsigned char *insn
,
1267 const struct s390_opcode
*opcode
)
1269 struct s390_fixup fixups
[MAX_INSN_FIXUPS
];
1270 const struct s390_operand
*operand
;
1271 const unsigned char *opindex_ptr
;
1273 elf_suffix_type suffix
;
1274 bfd_reloc_code_real_type reloc
;
1279 while (ISSPACE (*str
))
1284 /* Gather the operands. */
1286 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
1290 operand
= s390_operands
+ *opindex_ptr
;
1292 if ((opcode
->flags
& (S390_INSTR_FLAG_OPTPARM
| S390_INSTR_FLAG_OPTPARM2
))
1295 /* Optional parameters might need to be ORed with a
1296 value so calling s390_insert_operand is needed. */
1297 s390_insert_operand (insn
, operand
, 0, NULL
, 0);
1301 if (skip_optional
&& (operand
->flags
& S390_OPERAND_INDEX
))
1303 /* We do an early skip. For D(X,B) constructions the index
1304 register is skipped (X is optional). For D(L,B) the base
1305 register will be the skipped operand, because L is NOT
1311 /* Gather the operand. */
1312 hold
= input_line_pointer
;
1313 input_line_pointer
= str
;
1315 /* Parse the operand. */
1316 if (! register_name (&ex
))
1319 str
= input_line_pointer
;
1320 input_line_pointer
= hold
;
1322 /* Write the operand to the insn. */
1323 if (ex
.X_op
== O_illegal
)
1324 as_bad (_("illegal operand"));
1325 else if (ex
.X_op
== O_absent
)
1327 if (opindex_ptr
[0] == '\0')
1329 as_bad (_("missing operand"));
1331 else if (ex
.X_op
== O_register
|| ex
.X_op
== O_constant
)
1333 s390_lit_suffix (&str
, &ex
, ELF_SUFFIX_NONE
);
1335 if (ex
.X_op
!= O_register
&& ex
.X_op
!= O_constant
)
1337 /* We need to generate a fixup for the
1338 expression returned by s390_lit_suffix. */
1339 if (fc
>= MAX_INSN_FIXUPS
)
1340 as_fatal (_("too many fixups"));
1341 fixups
[fc
].exp
= ex
;
1342 fixups
[fc
].opindex
= *opindex_ptr
;
1343 fixups
[fc
].reloc
= BFD_RELOC_UNUSED
;
1348 if ((operand
->flags
& S390_OPERAND_LENGTH
)
1349 && ex
.X_op
!= O_constant
)
1350 as_fatal (_("invalid length field specified"));
1351 if ((operand
->flags
& S390_OPERAND_INDEX
)
1352 && ex
.X_add_number
== 0
1354 as_warn (_("index register specified but zero"));
1355 if ((operand
->flags
& S390_OPERAND_BASE
)
1356 && ex
.X_add_number
== 0
1358 as_warn (_("base register specified but zero"));
1359 if ((operand
->flags
& S390_OPERAND_GPR
)
1360 && (operand
->flags
& S390_OPERAND_REG_PAIR
)
1361 && (ex
.X_add_number
& 1))
1362 as_fatal (_("odd numbered general purpose register specified as "
1364 if ((operand
->flags
& S390_OPERAND_FPR
)
1365 && (operand
->flags
& S390_OPERAND_REG_PAIR
)
1366 && ex
.X_add_number
!= 0 && ex
.X_add_number
!= 1
1367 && ex
.X_add_number
!= 4 && ex
.X_add_number
!= 5
1368 && ex
.X_add_number
!= 8 && ex
.X_add_number
!= 9
1369 && ex
.X_add_number
!= 12 && ex
.X_add_number
!= 13)
1370 as_fatal (_("invalid floating point register pair. Valid fp "
1371 "register pair operands are 0, 1, 4, 5, 8, 9, "
1373 s390_insert_operand (insn
, operand
, ex
.X_add_number
, NULL
, 0);
1378 suffix
= s390_elf_suffix (&str
, &ex
);
1379 suffix
= s390_lit_suffix (&str
, &ex
, suffix
);
1380 reloc
= BFD_RELOC_UNUSED
;
1382 if (suffix
== ELF_SUFFIX_GOT
)
1384 if ((operand
->flags
& S390_OPERAND_DISP
) &&
1385 (operand
->bits
== 12))
1386 reloc
= BFD_RELOC_390_GOT12
;
1387 else if ((operand
->flags
& S390_OPERAND_DISP
) &&
1388 (operand
->bits
== 20))
1389 reloc
= BFD_RELOC_390_GOT20
;
1390 else if ((operand
->flags
& S390_OPERAND_SIGNED
)
1391 && (operand
->bits
== 16))
1392 reloc
= BFD_RELOC_390_GOT16
;
1393 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1394 && (operand
->bits
== 32))
1395 reloc
= BFD_RELOC_390_GOTENT
;
1397 else if (suffix
== ELF_SUFFIX_PLT
)
1399 if ((operand
->flags
& S390_OPERAND_PCREL
)
1400 && (operand
->bits
== 12))
1401 reloc
= BFD_RELOC_390_PLT12DBL
;
1402 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1403 && (operand
->bits
== 16))
1404 reloc
= BFD_RELOC_390_PLT16DBL
;
1405 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1406 && (operand
->bits
== 24))
1407 reloc
= BFD_RELOC_390_PLT24DBL
;
1408 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1409 && (operand
->bits
== 32))
1410 reloc
= BFD_RELOC_390_PLT32DBL
;
1412 else if (suffix
== ELF_SUFFIX_GOTENT
)
1414 if ((operand
->flags
& S390_OPERAND_PCREL
)
1415 && (operand
->bits
== 32))
1416 reloc
= BFD_RELOC_390_GOTENT
;
1418 else if (suffix
== ELF_SUFFIX_GOTOFF
)
1420 if ((operand
->flags
& S390_OPERAND_SIGNED
)
1421 && (operand
->bits
== 16))
1422 reloc
= BFD_RELOC_16_GOTOFF
;
1424 else if (suffix
== ELF_SUFFIX_PLTOFF
)
1426 if ((operand
->flags
& S390_OPERAND_SIGNED
)
1427 && (operand
->bits
== 16))
1428 reloc
= BFD_RELOC_390_PLTOFF16
;
1430 else if (suffix
== ELF_SUFFIX_GOTPLT
)
1432 if ((operand
->flags
& S390_OPERAND_DISP
)
1433 && (operand
->bits
== 12))
1434 reloc
= BFD_RELOC_390_GOTPLT12
;
1435 else if ((operand
->flags
& S390_OPERAND_SIGNED
)
1436 && (operand
->bits
== 16))
1437 reloc
= BFD_RELOC_390_GOTPLT16
;
1438 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1439 && (operand
->bits
== 32))
1440 reloc
= BFD_RELOC_390_GOTPLTENT
;
1442 else if (suffix
== ELF_SUFFIX_TLS_GOTIE
)
1444 if ((operand
->flags
& S390_OPERAND_DISP
)
1445 && (operand
->bits
== 12))
1446 reloc
= BFD_RELOC_390_TLS_GOTIE12
;
1447 else if ((operand
->flags
& S390_OPERAND_DISP
)
1448 && (operand
->bits
== 20))
1449 reloc
= BFD_RELOC_390_TLS_GOTIE20
;
1451 else if (suffix
== ELF_SUFFIX_TLS_IE
)
1453 if ((operand
->flags
& S390_OPERAND_PCREL
)
1454 && (operand
->bits
== 32))
1455 reloc
= BFD_RELOC_390_TLS_IEENT
;
1458 if (suffix
!= ELF_SUFFIX_NONE
&& reloc
== BFD_RELOC_UNUSED
)
1459 as_bad (_("invalid operand suffix"));
1460 /* We need to generate a fixup of type 'reloc' for this
1462 if (fc
>= MAX_INSN_FIXUPS
)
1463 as_fatal (_("too many fixups"));
1464 fixups
[fc
].exp
= ex
;
1465 fixups
[fc
].opindex
= *opindex_ptr
;
1466 fixups
[fc
].reloc
= reloc
;
1470 /* Check the next character. The call to expression has advanced
1471 str past any whitespace. */
1472 if (operand
->flags
& S390_OPERAND_DISP
)
1474 /* After a displacement a block in parentheses can start. */
1477 /* Check if parenthesized block can be skipped. If the next
1478 operand is neither an optional operand nor a base register
1479 then we have a syntax error. */
1480 operand
= s390_operands
+ *(++opindex_ptr
);
1481 if (!(operand
->flags
& (S390_OPERAND_INDEX
|S390_OPERAND_BASE
)))
1482 as_bad (_("syntax error; missing '(' after displacement"));
1484 /* Ok, skip all operands until S390_OPERAND_BASE. */
1485 while (!(operand
->flags
& S390_OPERAND_BASE
))
1486 operand
= s390_operands
+ *(++opindex_ptr
);
1488 if (*str
== '\0' && skip_optargs_p (opcode
->flags
, &opindex_ptr
[1]))
1491 /* If there is a next operand it must be separated by a comma. */
1492 if (opindex_ptr
[1] != '\0')
1496 while (opindex_ptr
[1] != '\0')
1498 operand
= s390_operands
+ *(++opindex_ptr
);
1499 as_bad (_("syntax error; expected ','"));
1509 /* We found an opening parentheses. */
1511 for (f
= str
; *f
!= '\0'; f
++)
1512 if (*f
== ',' || *f
== ')')
1514 /* If there is no comma until the closing parentheses OR
1515 there is a comma right after the opening parentheses,
1516 we have to skip optional operands. */
1517 if (*f
== ',' && f
== str
)
1519 /* comma directly after '(' ? */
1524 skip_optional
= (*f
!= ',');
1527 else if (operand
->flags
& S390_OPERAND_BASE
)
1529 /* After the base register the parenthesised block ends. */
1531 as_bad (_("syntax error; missing ')' after base register"));
1534 if (*str
== '\0' && skip_optargs_p (opcode
->flags
, &opindex_ptr
[1]))
1537 /* If there is a next operand it must be separated by a comma. */
1538 if (opindex_ptr
[1] != '\0')
1542 while (opindex_ptr
[1] != '\0')
1544 operand
= s390_operands
+ *(++opindex_ptr
);
1545 as_bad (_("syntax error; expected ','"));
1555 /* We can find an 'early' closing parentheses in e.g. D(L) instead
1556 of D(L,B). In this case the base register has to be skipped. */
1559 operand
= s390_operands
+ *(++opindex_ptr
);
1561 if (!(operand
->flags
& S390_OPERAND_BASE
))
1562 as_bad (_("syntax error; ')' not allowed here"));
1566 if (*str
== '\0' && skip_optargs_p (opcode
->flags
, &opindex_ptr
[1]))
1569 /* If there is a next operand it must be separated by a comma. */
1570 if (opindex_ptr
[1] != '\0')
1574 while (opindex_ptr
[1] != '\0')
1576 operand
= s390_operands
+ *(++opindex_ptr
);
1577 as_bad (_("syntax error; expected ','"));
1587 while (ISSPACE (*str
))
1590 /* Check for tls instruction marker. */
1591 reloc
= s390_tls_suffix (&str
, &ex
);
1592 if (reloc
!= BFD_RELOC_UNUSED
)
1594 /* We need to generate a fixup of type 'reloc' for this
1596 if (fc
>= MAX_INSN_FIXUPS
)
1597 as_fatal (_("too many fixups"));
1598 fixups
[fc
].exp
= ex
;
1599 fixups
[fc
].opindex
= -1;
1600 fixups
[fc
].reloc
= reloc
;
1608 if ((linefeed
= strchr (str
, '\n')) != NULL
)
1610 as_bad (_("junk at end of line: `%s'"), str
);
1611 if (linefeed
!= NULL
)
1615 /* Write out the instruction. */
1616 f
= frag_more (opcode
->oplen
);
1617 memcpy (f
, insn
, opcode
->oplen
);
1618 dwarf2_emit_insn (opcode
->oplen
);
1620 /* Create any fixups. At this point we do not use a
1621 bfd_reloc_code_real_type, but instead just use the
1622 BFD_RELOC_UNUSED plus the operand index. This lets us easily
1623 handle fixups for any operand type, although that is admittedly
1624 not a very exciting feature. We pick a BFD reloc type in
1626 for (i
= 0; i
< fc
; i
++)
1629 if (fixups
[i
].opindex
< 0)
1631 /* Create tls instruction marker relocation. */
1632 fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, opcode
->oplen
,
1633 &fixups
[i
].exp
, 0, fixups
[i
].reloc
);
1637 operand
= s390_operands
+ fixups
[i
].opindex
;
1639 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
1641 reloc_howto_type
*reloc_howto
;
1645 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
1649 size
= ((reloc_howto
->bitsize
- 1) / 8) + 1;
1651 if (size
< 1 || size
> 4)
1654 fixP
= fix_new_exp (frag_now
,
1655 f
- frag_now
->fr_literal
+ (operand
->shift
/8),
1656 size
, &fixups
[i
].exp
, reloc_howto
->pc_relative
,
1658 /* Turn off overflow checking in fixup_segment. This is necessary
1659 because fixup_segment will signal an overflow for large 4 byte
1660 quantities for GOT12 relocations. */
1661 if ( fixups
[i
].reloc
== BFD_RELOC_390_GOT12
1662 || fixups
[i
].reloc
== BFD_RELOC_390_GOT20
1663 || fixups
[i
].reloc
== BFD_RELOC_390_GOT16
)
1664 fixP
->fx_no_overflow
= 1;
1666 if (operand
->flags
& S390_OPERAND_PCREL
)
1667 fixP
->fx_pcrel_adjust
= operand
->shift
/ 8;
1670 fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, 4, &fixups
[i
].exp
,
1671 (operand
->flags
& S390_OPERAND_PCREL
) != 0,
1672 ((bfd_reloc_code_real_type
)
1673 (fixups
[i
].opindex
+ (int) BFD_RELOC_UNUSED
)));
1678 /* This routine is called for each instruction to be assembled. */
1681 md_assemble (char *str
)
1683 const struct s390_opcode
*opcode
;
1684 unsigned char insn
[6];
1687 /* Get the opcode. */
1688 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
1693 /* Look up the opcode in the hash table. */
1694 opcode
= (struct s390_opcode
*) hash_find (s390_opcode_hash
, str
);
1695 if (opcode
== (const struct s390_opcode
*) NULL
)
1697 as_bad (_("Unrecognized opcode: `%s'"), str
);
1700 else if (!(opcode
->modes
& current_mode_mask
))
1702 as_bad (_("Opcode %s not available in this mode"), str
);
1705 memcpy (insn
, opcode
->opcode
, sizeof (insn
));
1706 md_gather_operands (s
, insn
, opcode
);
1709 #ifndef WORKING_DOT_WORD
1710 /* Handle long and short jumps. We don't support these */
1712 md_create_short_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
1714 addressT from_addr
, to_addr
;
1722 md_create_long_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
1724 addressT from_addr
, to_addr
;
1733 s390_bss (int ignore ATTRIBUTE_UNUSED
)
1735 /* We don't support putting frags in the BSS segment, we fake it
1736 by marking in_bss, then looking at s_skip for clues. */
1738 subseg_set (bss_section
, 0);
1739 demand_empty_rest_of_line ();
1742 /* Pseudo-op handling. */
1745 s390_insn (int ignore ATTRIBUTE_UNUSED
)
1748 const struct s390_opcode
*opformat
;
1749 unsigned char insn
[6];
1752 /* Get the opcode format. */
1753 s
= input_line_pointer
;
1754 while (*s
!= '\0' && *s
!= ',' && ! ISSPACE (*s
))
1757 as_bad (_("Invalid .insn format\n"));
1760 /* Look up the opcode in the hash table. */
1761 opformat
= (struct s390_opcode
*)
1762 hash_find (s390_opformat_hash
, input_line_pointer
);
1763 if (opformat
== (const struct s390_opcode
*) NULL
)
1765 as_bad (_("Unrecognized opcode format: `%s'"), input_line_pointer
);
1768 input_line_pointer
= s
;
1770 if (exp
.X_op
== O_constant
)
1772 if ( ( opformat
->oplen
== 6
1773 && (addressT
) exp
.X_add_number
< (1ULL << 48))
1774 || ( opformat
->oplen
== 4
1775 && (addressT
) exp
.X_add_number
< (1ULL << 32))
1776 || ( opformat
->oplen
== 2
1777 && (addressT
) exp
.X_add_number
< (1ULL << 16)))
1778 md_number_to_chars ((char *) insn
, exp
.X_add_number
, opformat
->oplen
);
1780 as_bad (_("Invalid .insn format\n"));
1782 else if (exp
.X_op
== O_big
)
1784 if (exp
.X_add_number
> 0
1785 && opformat
->oplen
== 6
1786 && generic_bignum
[3] == 0)
1788 md_number_to_chars ((char *) insn
, generic_bignum
[2], 2);
1789 md_number_to_chars ((char *) &insn
[2], generic_bignum
[1], 2);
1790 md_number_to_chars ((char *) &insn
[4], generic_bignum
[0], 2);
1793 as_bad (_("Invalid .insn format\n"));
1796 as_bad (_("second operand of .insn not a constant\n"));
1798 if (strcmp (opformat
->name
, "e") != 0 && *input_line_pointer
++ != ',')
1799 as_bad (_("missing comma after insn constant\n"));
1801 if ((s
= strchr (input_line_pointer
, '\n')) != NULL
)
1803 input_line_pointer
= md_gather_operands (input_line_pointer
, insn
,
1807 demand_empty_rest_of_line ();
1810 /* The .byte pseudo-op. This is similar to the normal .byte
1811 pseudo-op, but it can also take a single ASCII string. */
1814 s390_byte (int ignore ATTRIBUTE_UNUSED
)
1816 if (*input_line_pointer
!= '\"')
1822 /* Gather characters. A real double quote is doubled. Unusual
1823 characters are not permitted. */
1824 ++input_line_pointer
;
1829 c
= *input_line_pointer
++;
1833 if (*input_line_pointer
!= '\"')
1835 ++input_line_pointer
;
1838 FRAG_APPEND_1_CHAR (c
);
1841 demand_empty_rest_of_line ();
1844 /* The .ltorg pseudo-op.This emits all literals defined since the last
1845 .ltorg or the invocation of gas. Literals are defined with the
1849 s390_literals (int ignore ATTRIBUTE_UNUSED
)
1851 struct s390_lpe
*lpe
;
1853 if (lp_sym
== NULL
|| lpe_count
== 0)
1854 return; /* Nothing to be done. */
1856 /* Emit symbol for start of literal pool. */
1857 S_SET_SEGMENT (lp_sym
, now_seg
);
1858 S_SET_VALUE (lp_sym
, (valueT
) frag_now_fix ());
1859 symbol_set_frag (lp_sym
, frag_now
);
1864 lpe_list
= lpe_list
->next
;
1865 S_SET_SEGMENT (lpe
->sym
, now_seg
);
1866 S_SET_VALUE (lpe
->sym
, (valueT
) frag_now_fix ());
1867 symbol_set_frag (lpe
->sym
, frag_now
);
1869 /* Emit literal pool entry. */
1870 if (lpe
->reloc
!= BFD_RELOC_UNUSED
)
1872 reloc_howto_type
*reloc_howto
=
1873 bfd_reloc_type_lookup (stdoutput
, lpe
->reloc
);
1874 int size
= bfd_get_reloc_size (reloc_howto
);
1877 if (size
> lpe
->nbytes
)
1878 as_bad (ngettext ("%s relocations do not fit in %d byte",
1879 "%s relocations do not fit in %d bytes",
1881 reloc_howto
->name
, lpe
->nbytes
);
1882 where
= frag_more (lpe
->nbytes
);
1883 md_number_to_chars (where
, 0, size
);
1884 fix_new_exp (frag_now
, where
- frag_now
->fr_literal
,
1885 size
, &lpe
->ex
, reloc_howto
->pc_relative
, lpe
->reloc
);
1889 if (lpe
->ex
.X_op
== O_big
)
1891 if (lpe
->ex
.X_add_number
<= 0)
1892 generic_floating_point_number
= lpe
->floatnum
;
1894 memcpy (generic_bignum
, lpe
->bignum
,
1895 lpe
->ex
.X_add_number
* sizeof (LITTLENUM_TYPE
));
1897 emit_expr (&lpe
->ex
, lpe
->nbytes
);
1900 lpe
->next
= lpe_free_list
;
1901 lpe_free_list
= lpe
;
1903 lpe_list_tail
= NULL
;
1909 #define MAX_HISTORY 100
1911 /* The .machine pseudo op allows to switch to a different CPU level in
1912 the asm listing. The current CPU setting can be stored on a stack
1913 with .machine push and restored with .machine pop. */
1916 s390_machine (int ignore ATTRIBUTE_UNUSED
)
1919 static struct cpu_history
1924 static int curr_hist
;
1928 if (*input_line_pointer
== '"')
1931 cpu_string
= demand_copy_C_string (&len
);
1937 cpu_string
= input_line_pointer
;
1942 c
= get_symbol_name (&str
);
1943 c
= restore_line_pointer (c
);
1945 ++ input_line_pointer
;
1949 c
= *input_line_pointer
;
1950 *input_line_pointer
= 0;
1951 cpu_string
= xstrdup (cpu_string
);
1952 (void) restore_line_pointer (c
);
1955 if (cpu_string
!= NULL
)
1957 unsigned int new_cpu
= current_cpu
;
1958 unsigned int new_flags
= current_flags
;
1960 if (strcmp (cpu_string
, "push") == 0)
1962 if (cpu_history
== NULL
)
1963 cpu_history
= XNEWVEC (struct cpu_history
, MAX_HISTORY
);
1965 if (curr_hist
>= MAX_HISTORY
)
1966 as_bad (_(".machine stack overflow"));
1969 cpu_history
[curr_hist
].cpu
= current_cpu
;
1970 cpu_history
[curr_hist
].flags
= current_flags
;
1974 else if (strcmp (cpu_string
, "pop") == 0)
1977 as_bad (_(".machine stack underflow"));
1981 new_cpu
= cpu_history
[curr_hist
].cpu
;
1982 new_flags
= cpu_history
[curr_hist
].flags
;
1986 new_cpu
= s390_parse_cpu (cpu_string
, &new_flags
, TRUE
);
1988 if (new_cpu
== S390_OPCODE_MAXCPU
)
1989 as_bad (_("invalid machine `%s'"), cpu_string
);
1991 if (new_cpu
!= current_cpu
|| new_flags
!= current_flags
)
1993 current_cpu
= new_cpu
;
1994 current_flags
= new_flags
;
1995 s390_setup_opcodes ();
1999 demand_empty_rest_of_line ();
2002 /* The .machinemode pseudo op allows to switch to a different
2003 architecture mode in the asm listing. The current architecture
2004 mode setting can be stored on a stack with .machinemode push and
2005 restored with .machinemode pop. */
2008 s390_machinemode (int ignore ATTRIBUTE_UNUSED
)
2011 static unsigned int *mode_history
;
2012 static int curr_hist
;
2019 c
= get_symbol_name (&mode_string
);
2020 mode_string
= xstrdup (mode_string
);
2021 (void) restore_line_pointer (c
);
2024 if (mode_string
!= NULL
)
2026 unsigned int old_mode_mask
= current_mode_mask
;
2029 for (p
= mode_string
; *p
!= 0; p
++)
2032 if (strcmp (mode_string
, "push") == 0)
2034 if (mode_history
== NULL
)
2035 mode_history
= XNEWVEC (unsigned int, MAX_HISTORY
);
2037 if (curr_hist
>= MAX_HISTORY
)
2038 as_bad (_(".machinemode stack overflow"));
2040 mode_history
[curr_hist
++] = current_mode_mask
;
2042 else if (strcmp (mode_string
, "pop") == 0)
2045 as_bad (_(".machinemode stack underflow"));
2047 current_mode_mask
= mode_history
[--curr_hist
];
2051 if (strcmp (mode_string
, "esa") == 0)
2052 current_mode_mask
= 1 << S390_OPCODE_ESA
;
2053 else if (strcmp (mode_string
, "zarch") == 0)
2055 if (s390_arch_size
== 32)
2056 set_highgprs_p
= TRUE
;
2057 current_mode_mask
= 1 << S390_OPCODE_ZARCH
;
2059 else if (strcmp (mode_string
, "zarch_nohighgprs") == 0)
2060 current_mode_mask
= 1 << S390_OPCODE_ZARCH
;
2062 as_bad (_("invalid machine mode `%s'"), mode_string
);
2065 if (current_mode_mask
!= old_mode_mask
)
2066 s390_setup_opcodes ();
2069 demand_empty_rest_of_line ();
2075 md_atof (int type
, char *litp
, int *sizep
)
2077 return ieee_md_atof (type
, litp
, sizep
, TRUE
);
2080 /* Align a section (I don't know why this is machine dependent). */
2083 md_section_align (asection
*seg
, valueT addr
)
2085 int align
= bfd_get_section_alignment (stdoutput
, seg
);
2087 return ((addr
+ (1 << align
) - 1) & -(1 << align
));
2090 /* We don't have any form of relaxing. */
2093 md_estimate_size_before_relax (fragS
*fragp ATTRIBUTE_UNUSED
,
2094 asection
*seg ATTRIBUTE_UNUSED
)
2100 /* Convert a machine dependent frag. We never generate these. */
2103 md_convert_frag (bfd
*abfd ATTRIBUTE_UNUSED
,
2104 asection
*sec ATTRIBUTE_UNUSED
,
2105 fragS
*fragp ATTRIBUTE_UNUSED
)
2111 md_undefined_symbol (char *name
)
2113 if (*name
== '_' && *(name
+ 1) == 'G'
2114 && strcmp (name
, "_GLOBAL_OFFSET_TABLE_") == 0)
2118 if (symbol_find (name
))
2119 as_bad (_("GOT already in symbol table"));
2120 GOT_symbol
= symbol_new (name
, undefined_section
,
2121 (valueT
) 0, &zero_address_frag
);
2128 /* Functions concerning relocs. */
2130 /* The location from which a PC relative jump should be calculated,
2131 given a PC relative reloc. */
2134 md_pcrel_from_section (fixS
*fixp
, segT sec ATTRIBUTE_UNUSED
)
2136 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
2139 /* Here we decide which fixups can be adjusted to make them relative to
2140 the beginning of the section instead of the symbol. Basically we need
2141 to make sure that the dynamic relocations are done correctly, so in
2142 some cases we force the original symbol to be used. */
2144 tc_s390_fix_adjustable (fixS
*fixP
)
2146 /* Don't adjust pc-relative references to merge sections. */
2148 && (S_GET_SEGMENT (fixP
->fx_addsy
)->flags
& SEC_MERGE
) != 0)
2151 /* adjust_reloc_syms doesn't know about the GOT. */
2152 if ( fixP
->fx_r_type
== BFD_RELOC_16_GOTOFF
2153 || fixP
->fx_r_type
== BFD_RELOC_32_GOTOFF
2154 || fixP
->fx_r_type
== BFD_RELOC_390_GOTOFF64
2155 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF16
2156 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF32
2157 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF64
2158 || fixP
->fx_r_type
== BFD_RELOC_390_PLT12DBL
2159 || fixP
->fx_r_type
== BFD_RELOC_390_PLT16DBL
2160 || fixP
->fx_r_type
== BFD_RELOC_390_PLT24DBL
2161 || fixP
->fx_r_type
== BFD_RELOC_390_PLT32
2162 || fixP
->fx_r_type
== BFD_RELOC_390_PLT32DBL
2163 || fixP
->fx_r_type
== BFD_RELOC_390_PLT64
2164 || fixP
->fx_r_type
== BFD_RELOC_390_GOT12
2165 || fixP
->fx_r_type
== BFD_RELOC_390_GOT20
2166 || fixP
->fx_r_type
== BFD_RELOC_390_GOT16
2167 || fixP
->fx_r_type
== BFD_RELOC_32_GOT_PCREL
2168 || fixP
->fx_r_type
== BFD_RELOC_390_GOT64
2169 || fixP
->fx_r_type
== BFD_RELOC_390_GOTENT
2170 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT12
2171 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT16
2172 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT20
2173 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT32
2174 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT64
2175 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLTENT
2176 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LOAD
2177 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GDCALL
2178 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDCALL
2179 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GD32
2180 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GD64
2181 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE12
2182 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE20
2183 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE32
2184 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE64
2185 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDM32
2186 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDM64
2187 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IE32
2188 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IE64
2189 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IEENT
2190 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LE32
2191 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LE64
2192 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDO32
2193 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDO64
2194 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_DTPMOD
2195 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_DTPOFF
2196 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_TPOFF
2197 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
2198 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
2203 /* Return true if we must always emit a reloc for a type and false if
2204 there is some hope of resolving it at assembly time. */
2206 tc_s390_force_relocation (struct fix
*fixp
)
2208 /* Ensure we emit a relocation for every reference to the global
2209 offset table or to the procedure link table. */
2210 switch (fixp
->fx_r_type
)
2212 case BFD_RELOC_390_GOT12
:
2213 case BFD_RELOC_390_GOT20
:
2214 case BFD_RELOC_32_GOT_PCREL
:
2215 case BFD_RELOC_32_GOTOFF
:
2216 case BFD_RELOC_390_GOTOFF64
:
2217 case BFD_RELOC_390_PLTOFF16
:
2218 case BFD_RELOC_390_PLTOFF32
:
2219 case BFD_RELOC_390_PLTOFF64
:
2220 case BFD_RELOC_390_GOTPC
:
2221 case BFD_RELOC_390_GOT16
:
2222 case BFD_RELOC_390_GOTPCDBL
:
2223 case BFD_RELOC_390_GOT64
:
2224 case BFD_RELOC_390_GOTENT
:
2225 case BFD_RELOC_390_PLT32
:
2226 case BFD_RELOC_390_PLT12DBL
:
2227 case BFD_RELOC_390_PLT16DBL
:
2228 case BFD_RELOC_390_PLT24DBL
:
2229 case BFD_RELOC_390_PLT32DBL
:
2230 case BFD_RELOC_390_PLT64
:
2231 case BFD_RELOC_390_GOTPLT12
:
2232 case BFD_RELOC_390_GOTPLT16
:
2233 case BFD_RELOC_390_GOTPLT20
:
2234 case BFD_RELOC_390_GOTPLT32
:
2235 case BFD_RELOC_390_GOTPLT64
:
2236 case BFD_RELOC_390_GOTPLTENT
:
2242 return generic_force_reloc (fixp
);
2245 /* Apply a fixup to the object code. This is called for all the
2246 fixups we generated by the call to fix_new_exp, above. In the call
2247 above we used a reloc code which was the largest legal reloc code
2248 plus the operand index. Here we undo that to recover the operand
2249 index. At this point all symbol values should be fully resolved,
2250 and we attempt to completely resolve the reloc. If we can not do
2251 that, we determine the correct reloc code and put it back in the
2255 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg ATTRIBUTE_UNUSED
)
2258 valueT value
= *valP
;
2260 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
2262 if (fixP
->fx_subsy
!= NULL
)
2263 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2264 _("cannot emit relocation %s against subsy symbol %s"),
2265 bfd_get_reloc_code_name (fixP
->fx_r_type
),
2266 S_GET_NAME (fixP
->fx_subsy
));
2268 if (fixP
->fx_addsy
!= NULL
)
2271 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
2276 if ((int) fixP
->fx_r_type
>= (int) BFD_RELOC_UNUSED
)
2278 const struct s390_operand
*operand
;
2281 opindex
= (int) fixP
->fx_r_type
- (int) BFD_RELOC_UNUSED
;
2282 operand
= &s390_operands
[opindex
];
2286 /* Insert the fully resolved operand value. */
2287 s390_insert_operand ((unsigned char *) where
, operand
,
2288 (offsetT
) value
, fixP
->fx_file
, fixP
->fx_line
);
2292 /* Determine a BFD reloc value based on the operand information.
2293 We are only prepared to turn a few of the operands into
2295 fixP
->fx_offset
= value
;
2296 if (operand
->bits
== 12 && operand
->shift
== 20)
2299 fixP
->fx_where
+= 2;
2300 fixP
->fx_r_type
= BFD_RELOC_390_12
;
2302 else if (operand
->bits
== 12 && operand
->shift
== 36)
2305 fixP
->fx_where
+= 4;
2306 fixP
->fx_r_type
= BFD_RELOC_390_12
;
2308 else if (operand
->bits
== 20 && operand
->shift
== 20)
2311 fixP
->fx_where
+= 2;
2312 fixP
->fx_r_type
= BFD_RELOC_390_20
;
2314 else if (operand
->bits
== 8 && operand
->shift
== 8)
2317 fixP
->fx_where
+= 1;
2318 fixP
->fx_r_type
= BFD_RELOC_8
;
2320 else if (operand
->bits
== 12 && operand
->shift
== 12
2321 && (operand
->flags
& S390_OPERAND_PCREL
))
2324 fixP
->fx_where
+= 1;
2325 fixP
->fx_offset
+= 1;
2326 fixP
->fx_pcrel_adjust
= 1;
2327 fixP
->fx_r_type
= BFD_RELOC_390_PC12DBL
;
2329 else if (operand
->bits
== 16 && operand
->shift
== 16)
2332 fixP
->fx_where
+= 2;
2333 if (operand
->flags
& S390_OPERAND_PCREL
)
2335 fixP
->fx_r_type
= BFD_RELOC_390_PC16DBL
;
2336 fixP
->fx_offset
+= 2;
2337 fixP
->fx_pcrel_adjust
= 2;
2340 fixP
->fx_r_type
= BFD_RELOC_16
;
2342 else if (operand
->bits
== 16 && operand
->shift
== 32
2343 && (operand
->flags
& S390_OPERAND_PCREL
))
2346 fixP
->fx_where
+= 4;
2347 fixP
->fx_offset
+= 4;
2348 fixP
->fx_pcrel_adjust
= 4;
2349 fixP
->fx_r_type
= BFD_RELOC_390_PC16DBL
;
2351 else if (operand
->bits
== 24 && operand
->shift
== 24
2352 && (operand
->flags
& S390_OPERAND_PCREL
))
2355 fixP
->fx_where
+= 3;
2356 fixP
->fx_offset
+= 3;
2357 fixP
->fx_pcrel_adjust
= 3;
2358 fixP
->fx_r_type
= BFD_RELOC_390_PC24DBL
;
2360 else if (operand
->bits
== 32 && operand
->shift
== 16
2361 && (operand
->flags
& S390_OPERAND_PCREL
))
2364 fixP
->fx_where
+= 2;
2365 fixP
->fx_offset
+= 2;
2366 fixP
->fx_pcrel_adjust
= 2;
2367 fixP
->fx_r_type
= BFD_RELOC_390_PC32DBL
;
2374 /* Use expr_symbol_where to see if this is an expression
2376 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
2377 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2378 _("unresolved expression that must be resolved"));
2380 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2381 _("unsupported relocation type"));
2388 switch (fixP
->fx_r_type
)
2394 md_number_to_chars (where
, value
, 1);
2396 case BFD_RELOC_390_12
:
2397 case BFD_RELOC_390_GOT12
:
2398 case BFD_RELOC_390_GOTPLT12
:
2399 case BFD_RELOC_390_PC12DBL
:
2400 case BFD_RELOC_390_PLT12DBL
:
2402 value
+= fixP
->fx_pcrel_adjust
;
2411 mop
= bfd_getb16 ((unsigned char *) where
);
2412 mop
|= (unsigned short) (value
& 0xfff);
2413 bfd_putb16 ((bfd_vma
) mop
, (unsigned char *) where
);
2417 case BFD_RELOC_390_20
:
2418 case BFD_RELOC_390_GOT20
:
2419 case BFD_RELOC_390_GOTPLT20
:
2423 mop
= bfd_getb32 ((unsigned char *) where
);
2424 mop
|= (unsigned int) ((value
& 0xfff) << 8 |
2425 (value
& 0xff000) >> 12);
2426 bfd_putb32 ((bfd_vma
) mop
, (unsigned char *) where
);
2431 case BFD_RELOC_GPREL16
:
2432 case BFD_RELOC_16_GOT_PCREL
:
2433 case BFD_RELOC_16_GOTOFF
:
2435 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2436 _("cannot emit PC relative %s relocation%s%s"),
2437 bfd_get_reloc_code_name (fixP
->fx_r_type
),
2438 fixP
->fx_addsy
!= NULL
? " against " : "",
2439 (fixP
->fx_addsy
!= NULL
2440 ? S_GET_NAME (fixP
->fx_addsy
)
2443 md_number_to_chars (where
, value
, 2);
2445 case BFD_RELOC_390_GOT16
:
2446 case BFD_RELOC_390_PLTOFF16
:
2447 case BFD_RELOC_390_GOTPLT16
:
2449 md_number_to_chars (where
, value
, 2);
2451 case BFD_RELOC_390_PC16DBL
:
2452 case BFD_RELOC_390_PLT16DBL
:
2453 value
+= fixP
->fx_pcrel_adjust
;
2455 md_number_to_chars (where
, (offsetT
) value
>> 1, 2);
2458 case BFD_RELOC_390_PC24DBL
:
2459 case BFD_RELOC_390_PLT24DBL
:
2460 value
+= fixP
->fx_pcrel_adjust
;
2466 mop
= bfd_getb32 ((unsigned char *) where
- 1);
2467 mop
|= (unsigned int) (value
& 0xffffff);
2468 bfd_putb32 ((bfd_vma
) mop
, (unsigned char *) where
- 1);
2474 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
2476 fixP
->fx_r_type
= BFD_RELOC_32
;
2478 md_number_to_chars (where
, value
, 4);
2480 case BFD_RELOC_32_PCREL
:
2481 case BFD_RELOC_32_BASEREL
:
2482 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
2484 md_number_to_chars (where
, value
, 4);
2486 case BFD_RELOC_32_GOT_PCREL
:
2487 case BFD_RELOC_390_PLTOFF32
:
2488 case BFD_RELOC_390_PLT32
:
2489 case BFD_RELOC_390_GOTPLT32
:
2491 md_number_to_chars (where
, value
, 4);
2493 case BFD_RELOC_390_PC32DBL
:
2494 case BFD_RELOC_390_PLT32DBL
:
2495 case BFD_RELOC_390_GOTPCDBL
:
2496 case BFD_RELOC_390_GOTENT
:
2497 case BFD_RELOC_390_GOTPLTENT
:
2498 value
+= fixP
->fx_pcrel_adjust
;
2500 md_number_to_chars (where
, (offsetT
) value
>> 1, 4);
2503 case BFD_RELOC_32_GOTOFF
:
2505 md_number_to_chars (where
, value
, sizeof (int));
2508 case BFD_RELOC_390_GOTOFF64
:
2510 md_number_to_chars (where
, value
, 8);
2513 case BFD_RELOC_390_GOT64
:
2514 case BFD_RELOC_390_PLTOFF64
:
2515 case BFD_RELOC_390_PLT64
:
2516 case BFD_RELOC_390_GOTPLT64
:
2518 md_number_to_chars (where
, value
, 8);
2523 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
2525 fixP
->fx_r_type
= BFD_RELOC_64
;
2527 md_number_to_chars (where
, value
, 8);
2530 case BFD_RELOC_64_PCREL
:
2531 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
2533 md_number_to_chars (where
, value
, 8);
2536 case BFD_RELOC_VTABLE_INHERIT
:
2537 case BFD_RELOC_VTABLE_ENTRY
:
2541 case BFD_RELOC_390_TLS_LOAD
:
2542 case BFD_RELOC_390_TLS_GDCALL
:
2543 case BFD_RELOC_390_TLS_LDCALL
:
2544 case BFD_RELOC_390_TLS_GD32
:
2545 case BFD_RELOC_390_TLS_GD64
:
2546 case BFD_RELOC_390_TLS_GOTIE12
:
2547 case BFD_RELOC_390_TLS_GOTIE20
:
2548 case BFD_RELOC_390_TLS_GOTIE32
:
2549 case BFD_RELOC_390_TLS_GOTIE64
:
2550 case BFD_RELOC_390_TLS_LDM32
:
2551 case BFD_RELOC_390_TLS_LDM64
:
2552 case BFD_RELOC_390_TLS_IE32
:
2553 case BFD_RELOC_390_TLS_IE64
:
2554 case BFD_RELOC_390_TLS_LE32
:
2555 case BFD_RELOC_390_TLS_LE64
:
2556 case BFD_RELOC_390_TLS_LDO32
:
2557 case BFD_RELOC_390_TLS_LDO64
:
2558 case BFD_RELOC_390_TLS_DTPMOD
:
2559 case BFD_RELOC_390_TLS_DTPOFF
:
2560 case BFD_RELOC_390_TLS_TPOFF
:
2561 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
2562 /* Fully resolved at link time. */
2564 case BFD_RELOC_390_TLS_IEENT
:
2565 /* Fully resolved at link time. */
2566 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
2572 const char *reloc_name
= bfd_get_reloc_code_name (fixP
->fx_r_type
);
2574 if (reloc_name
!= NULL
)
2575 as_fatal (_("Gas failure, reloc type %s\n"), reloc_name
);
2577 as_fatal (_("Gas failure, reloc type #%i\n"), fixP
->fx_r_type
);
2581 fixP
->fx_offset
= value
;
2585 /* Generate a reloc for a fixup. */
2588 tc_gen_reloc (asection
*seg ATTRIBUTE_UNUSED
, fixS
*fixp
)
2590 bfd_reloc_code_real_type code
;
2593 code
= fixp
->fx_r_type
;
2594 if (GOT_symbol
&& fixp
->fx_addsy
== GOT_symbol
)
2596 if ( (s390_arch_size
== 32 && code
== BFD_RELOC_32_PCREL
)
2597 || (s390_arch_size
== 64 && code
== BFD_RELOC_64_PCREL
))
2598 code
= BFD_RELOC_390_GOTPC
;
2599 if (code
== BFD_RELOC_390_PC32DBL
)
2600 code
= BFD_RELOC_390_GOTPCDBL
;
2603 reloc
= XNEW (arelent
);
2604 reloc
->sym_ptr_ptr
= XNEW (asymbol
*);
2605 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
2606 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
2607 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
2608 if (reloc
->howto
== NULL
)
2610 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2611 _("cannot represent relocation type %s"),
2612 bfd_get_reloc_code_name (code
));
2613 /* Set howto to a garbage value so that we can keep going. */
2614 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, BFD_RELOC_32
);
2615 gas_assert (reloc
->howto
!= NULL
);
2617 reloc
->addend
= fixp
->fx_offset
;
2623 s390_cfi_frame_initial_instructions (void)
2625 cfi_add_CFA_def_cfa (15, s390_arch_size
== 64 ? 160 : 96);
2629 tc_s390_regname_to_dw2regnum (char *regname
)
2633 if (regname
[0] != 'c' && regname
[0] != 'a')
2635 regnum
= reg_name_search (regname
);
2636 if (regname
[0] == 'f' && regnum
!= -1)
2639 else if (strcmp (regname
, "ap") == 0)
2641 else if (strcmp (regname
, "cc") == 0)
2647 s390_elf_final_processing (void)
2650 elf_elfheader (stdoutput
)->e_flags
|= EF_S390_HIGH_GPRS
;