1 /* tc-s390.c -- Assemble for the S390
2 Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
3 2009, 2010 Free Software Foundation, Inc.
4 Contributed by Martin Schwidefsky (schwidefsky@de.ibm.com).
6 This file is part of GAS, the GNU Assembler.
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GAS is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
24 #include "safe-ctype.h"
26 #include "struc-symbol.h"
27 #include "dwarf2dbg.h"
28 #include "dw2gencfi.h"
30 #include "opcode/s390.h"
33 /* The default architecture. */
35 #define DEFAULT_ARCH "s390"
37 static char *default_arch
= DEFAULT_ARCH
;
38 /* Either 32 or 64, selects file format. */
39 static int s390_arch_size
= 0;
41 /* If no -march option was given default to the highest available CPU.
42 Since with S/390 a newer CPU always supports everything from its
43 predecessors this will accept every valid asm input. */
44 static unsigned int current_cpu
= S390_OPCODE_MAXCPU
- 1;
45 static unsigned int current_mode_mask
= 0;
47 /* Set to TRUE if the highgprs flag in the ELF header needs to be set
48 for the output file. */
49 static bfd_boolean set_highgprs_p
= FALSE
;
51 /* Whether to use user friendly register names. Default is TRUE. */
52 #ifndef TARGET_REG_NAMES_P
53 #define TARGET_REG_NAMES_P TRUE
56 static bfd_boolean reg_names_p
= TARGET_REG_NAMES_P
;
58 /* Set to TRUE if we want to warn about zero base/index registers. */
59 static bfd_boolean warn_areg_zero
= FALSE
;
61 /* Generic assembler global variables which must be defined by all
64 const char comment_chars
[] = "#";
66 /* Characters which start a comment at the beginning of a line. */
67 const char line_comment_chars
[] = "#";
69 /* Characters which may be used to separate multiple commands on a
71 const char line_separator_chars
[] = ";";
73 /* Characters which are used to indicate an exponent in a floating
75 const char EXP_CHARS
[] = "eE";
77 /* Characters which mean that a number is a floating point constant,
79 const char FLT_CHARS
[] = "dD";
81 /* The dwarf2 data alignment, adjusted for 32 or 64 bit. */
82 int s390_cie_data_alignment
;
84 /* The target specific pseudo-ops which we support. */
86 /* Define the prototypes for the pseudo-ops */
87 static void s390_byte (int);
88 static void s390_elf_cons (int);
89 static void s390_bss (int);
90 static void s390_insn (int);
91 static void s390_literals (int);
92 static void s390_machine (int);
93 static void s390_machinemode (int);
95 const pseudo_typeS md_pseudo_table
[] =
97 { "align", s_align_bytes
, 0 },
98 /* Pseudo-ops which must be defined. */
99 { "bss", s390_bss
, 0 },
100 { "insn", s390_insn
, 0 },
101 /* Pseudo-ops which must be overridden. */
102 { "byte", s390_byte
, 0 },
103 { "short", s390_elf_cons
, 2 },
104 { "long", s390_elf_cons
, 4 },
105 { "quad", s390_elf_cons
, 8 },
106 { "ltorg", s390_literals
, 0 },
107 { "string", stringer
, 8 + 1 },
108 { "machine", s390_machine
, 0 },
109 { "machinemode", s390_machinemode
, 0 },
114 /* Structure to hold information about predefined registers. */
121 /* List of registers that are pre-defined:
123 Each access register has a predefined name of the form:
124 a<reg_num> which has the value <reg_num>.
126 Each control register has a predefined name of the form:
127 c<reg_num> which has the value <reg_num>.
129 Each general register has a predefined name of the form:
130 r<reg_num> which has the value <reg_num>.
132 Each floating point register a has predefined name of the form:
133 f<reg_num> which has the value <reg_num>.
135 There are individual registers as well:
139 The table is sorted. Suitable for searching by a binary search. */
141 static const struct pd_reg pre_defined_registers
[] =
143 { "a0", 0 }, /* Access registers */
160 { "c0", 0 }, /* Control registers */
177 { "f0", 0 }, /* Floating point registers */
194 { "lit", 13 }, /* Pointer to literal pool */
196 { "r0", 0 }, /* General purpose registers */
213 { "sp", 15 }, /* Stack pointer */
217 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
219 /* Given NAME, find the register number associated with that name, return
220 the integer value associated with the given name or -1 on failure. */
223 reg_name_search (const struct pd_reg
*regs
, int regcount
, const char *name
)
225 int middle
, low
, high
;
233 middle
= (low
+ high
) / 2;
234 cmp
= strcasecmp (name
, regs
[middle
].name
);
240 return regs
[middle
].value
;
249 * Summary of register_name().
251 * in: Input_line_pointer points to 1st char of operand.
253 * out: A expressionS.
254 * The operand may have been a register: in this case, X_op == O_register,
255 * X_add_number is set to the register number, and truth is returned.
256 * Input_line_pointer->(next non-blank) char after operand, or is in its
261 register_name (expressionS
*expressionP
)
268 /* Find the spelling of the operand. */
269 start
= name
= input_line_pointer
;
270 if (name
[0] == '%' && ISALPHA (name
[1]))
271 name
= ++input_line_pointer
;
275 c
= get_symbol_end ();
276 reg_number
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
, name
);
278 /* Put back the delimiting char. */
279 *input_line_pointer
= c
;
281 /* Look to see if it's in the register table. */
284 expressionP
->X_op
= O_register
;
285 expressionP
->X_add_number
= reg_number
;
287 /* Make the rest nice. */
288 expressionP
->X_add_symbol
= NULL
;
289 expressionP
->X_op_symbol
= NULL
;
293 /* Reset the line as if we had not done anything. */
294 input_line_pointer
= start
;
298 /* Local variables. */
300 /* Opformat hash table. */
301 static struct hash_control
*s390_opformat_hash
;
303 /* Opcode hash table. */
304 static struct hash_control
*s390_opcode_hash
= NULL
;
306 /* Flags to set in the elf header */
307 static flagword s390_flags
= 0;
309 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE_" */
311 #ifndef WORKING_DOT_WORD
312 int md_short_jump_size
= 4;
313 int md_long_jump_size
= 4;
316 const char *md_shortopts
= "A:m:kVQ:";
317 struct option md_longopts
[] = {
318 {NULL
, no_argument
, NULL
, 0}
320 size_t md_longopts_size
= sizeof (md_longopts
);
322 /* Initialize the default opcode arch and word size from the default
323 architecture name if not specified by an option. */
325 init_default_arch (void)
327 if (strcmp (default_arch
, "s390") == 0)
329 if (s390_arch_size
== 0)
332 else if (strcmp (default_arch
, "s390x") == 0)
334 if (s390_arch_size
== 0)
338 as_fatal (_("Invalid default architecture, broken assembler."));
340 if (current_mode_mask
== 0)
342 /* Default to z/Architecture mode if the CPU supports it. */
343 if (current_cpu
< S390_OPCODE_Z900
)
344 current_mode_mask
= 1 << S390_OPCODE_ESA
;
346 current_mode_mask
= 1 << S390_OPCODE_ZARCH
;
350 /* Called by TARGET_FORMAT. */
352 s390_target_format (void)
354 /* We don't get a chance to initialize anything before we're called,
355 so handle that now. */
356 init_default_arch ();
358 return s390_arch_size
== 64 ? "elf64-s390" : "elf32-s390";
361 /* Map a CPU string as given with -march= or .machine to the
362 respective enum s390_opcode_cpu_val value. 0xffffffff is returned
363 in case of an error. */
366 s390_parse_cpu (char *arg
)
368 if (strcmp (arg
, "g5") == 0)
369 return S390_OPCODE_G5
;
370 else if (strcmp (arg
, "g6") == 0)
371 return S390_OPCODE_G6
;
372 else if (strcmp (arg
, "z900") == 0)
373 return S390_OPCODE_Z900
;
374 else if (strcmp (arg
, "z990") == 0)
375 return S390_OPCODE_Z990
;
376 else if (strcmp (arg
, "z9-109") == 0)
377 return S390_OPCODE_Z9_109
;
378 else if (strcmp (arg
, "z9-ec") == 0)
379 return S390_OPCODE_Z9_EC
;
380 else if (strcmp (arg
, "z10") == 0)
381 return S390_OPCODE_Z10
;
382 else if (strcmp (arg
, "z196") == 0)
383 return S390_OPCODE_Z196
;
384 else if (strcmp (arg
, "zEC12") == 0)
385 return S390_OPCODE_ZEC12
;
386 else if (strcmp (arg
, "all") == 0)
387 return S390_OPCODE_MAXCPU
- 1;
393 md_parse_option (int c
, 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);
430 if (current_cpu
== (unsigned int)-1)
432 as_bad (_("invalid switch -m%s"), arg
);
439 as_bad (_("invalid switch -m%s"), arg
);
445 /* Option -A is deprecated. Still available for compatibility. */
446 if (arg
!= NULL
&& strcmp (arg
, "esa") == 0)
447 current_cpu
= S390_OPCODE_G5
;
448 else if (arg
!= NULL
&& strcmp (arg
, "esame") == 0)
449 current_cpu
= S390_OPCODE_Z900
;
451 as_bad (_("invalid architecture -A%s"), arg
);
454 /* -V: SVR4 argument to print version ID. */
459 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
460 should be emitted or not. FIXME: Not implemented. */
472 md_show_usage (FILE *stream
)
474 fprintf (stream
, _("\
476 -mregnames Allow symbolic names for registers\n\
477 -mwarn-areg-zero Warn about zero base/index registers\n\
478 -mno-regnames Do not allow symbolic names for registers\n\
479 -m31 Set file format to 31 bit format\n\
480 -m64 Set file format to 64 bit format\n"));
481 fprintf (stream
, _("\
482 -V print assembler version number\n\
483 -Qy, -Qn ignored\n"));
486 /* Generate the hash table mapping mnemonics to struct s390_opcode.
487 This table is built at startup and whenever the CPU level is
488 changed using .machine. */
491 s390_setup_opcodes (void)
493 register const struct s390_opcode
*op
;
494 const struct s390_opcode
*op_end
;
495 bfd_boolean dup_insn
= FALSE
;
498 if (s390_opcode_hash
!= NULL
)
499 hash_die (s390_opcode_hash
);
501 /* Insert the opcodes into a hash table. */
502 s390_opcode_hash
= hash_new ();
504 op_end
= s390_opcodes
+ s390_num_opcodes
;
505 for (op
= s390_opcodes
; op
< op_end
; op
++)
507 while (op
< op_end
- 1 && strcmp(op
->name
, op
[1].name
) == 0)
509 if (op
->min_cpu
<= current_cpu
&& (op
->modes
& current_mode_mask
))
514 if (op
->min_cpu
<= current_cpu
&& (op
->modes
& current_mode_mask
))
516 retval
= hash_insert (s390_opcode_hash
, op
->name
, (void *) op
);
517 if (retval
!= (const char *) NULL
)
519 as_bad (_("Internal assembler error for instruction %s"),
525 while (op
< op_end
- 1 && strcmp (op
->name
, op
[1].name
) == 0)
533 /* This function is called when the assembler starts up. It is called
534 after the options have been parsed and the output file has been
540 register const struct s390_opcode
*op
;
541 const struct s390_opcode
*op_end
;
544 /* Give a warning if the combination -m64-bit and -Aesa is used. */
545 if (s390_arch_size
== 64 && current_cpu
< S390_OPCODE_Z900
)
546 as_warn (_("The 64 bit file format is used without esame instructions."));
548 s390_cie_data_alignment
= -s390_arch_size
/ 8;
550 /* Set the ELF flags if desired. */
552 bfd_set_private_flags (stdoutput
, s390_flags
);
554 /* Insert the opcode formats into a hash table. */
555 s390_opformat_hash
= hash_new ();
557 op_end
= s390_opformats
+ s390_num_opformats
;
558 for (op
= s390_opformats
; op
< op_end
; op
++)
560 retval
= hash_insert (s390_opformat_hash
, op
->name
, (void *) op
);
561 if (retval
!= (const char *) NULL
)
562 as_bad (_("Internal assembler error for instruction format %s"),
566 s390_setup_opcodes ();
568 record_alignment (text_section
, 2);
569 record_alignment (data_section
, 2);
570 record_alignment (bss_section
, 2);
573 /* Called after all assembly has been done. */
577 if (s390_arch_size
== 64)
578 bfd_set_arch_mach (stdoutput
, bfd_arch_s390
, bfd_mach_s390_64
);
580 bfd_set_arch_mach (stdoutput
, bfd_arch_s390
, bfd_mach_s390_31
);
583 /* Insert an operand value into an instruction. */
586 s390_insert_operand (unsigned char *insn
,
587 const struct s390_operand
*operand
,
595 if (operand
->flags
& (S390_OPERAND_SIGNED
|S390_OPERAND_PCREL
))
599 max
= ((offsetT
) 1 << (operand
->bits
- 1)) - 1;
600 min
= - ((offsetT
) 1 << (operand
->bits
- 1));
601 /* Halve PCREL operands. */
602 if (operand
->flags
& S390_OPERAND_PCREL
)
604 /* Check for underflow / overflow. */
605 if (val
< min
|| val
> max
)
608 _("operand out of range (%s not between %ld and %ld)");
611 if (operand
->flags
& S390_OPERAND_PCREL
)
617 sprint_value (buf
, val
);
618 if (file
== (char *) NULL
)
619 as_bad (err
, buf
, (int) min
, (int) max
);
621 as_bad_where (file
, line
, err
, buf
, (int) min
, (int) max
);
624 /* val is ok, now restrict it to operand->bits bits. */
625 uval
= (addressT
) val
& ((((addressT
) 1 << (operand
->bits
-1)) << 1) - 1);
626 /* val is restrict, now check for special case. */
627 if (operand
->bits
== 20 && operand
->shift
== 20)
628 uval
= (uval
>> 12) | ((uval
& 0xfff) << 8);
634 max
= (((addressT
) 1 << (operand
->bits
- 1)) << 1) - 1;
636 uval
= (addressT
) val
;
637 /* Length x in an instructions has real length x+1. */
638 if (operand
->flags
& S390_OPERAND_LENGTH
)
640 /* Check for underflow / overflow. */
641 if (uval
< min
|| uval
> max
)
643 if (operand
->flags
& S390_OPERAND_LENGTH
)
650 as_bad_value_out_of_range (_("operand"), uval
, (offsetT
) min
, (offsetT
) max
, file
, line
);
656 /* Insert fragments of the operand byte for byte. */
657 offset
= operand
->shift
+ operand
->bits
;
658 uval
<<= (-offset
) & 7;
659 insn
+= (offset
- 1) / 8;
671 bfd_reloc_code_real_type reloc
;
674 /* Parse tls marker and return the desired relocation. */
675 static bfd_reloc_code_real_type
676 s390_tls_suffix (char **str_p
, expressionS
*exp_p
)
678 static struct map_tls mapping
[] =
680 { "tls_load", 8, BFD_RELOC_390_TLS_LOAD
},
681 { "tls_gdcall", 10, BFD_RELOC_390_TLS_GDCALL
},
682 { "tls_ldcall", 10, BFD_RELOC_390_TLS_LDCALL
},
683 { NULL
, 0, BFD_RELOC_UNUSED
}
693 return BFD_RELOC_UNUSED
;
696 while (ISIDNUM (*str
))
700 return BFD_RELOC_UNUSED
;
702 orig_line
= input_line_pointer
;
703 input_line_pointer
= str
;
705 str
= input_line_pointer
;
706 if (&input_line_pointer
!= str_p
)
707 input_line_pointer
= orig_line
;
709 if (exp_p
->X_op
!= O_symbol
)
710 return BFD_RELOC_UNUSED
;
712 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
713 if (len
== ptr
->length
714 && strncasecmp (ident
, ptr
->string
, ptr
->length
) == 0)
716 /* Found a matching tls suffix. */
720 return BFD_RELOC_UNUSED
;
723 /* Structure used to hold suffixes. */
734 ELF_SUFFIX_TLS_GOTIE
,
746 elf_suffix_type suffix
;
750 /* Parse @got/@plt/@gotoff. and return the desired relocation. */
751 static elf_suffix_type
752 s390_elf_suffix (char **str_p
, expressionS
*exp_p
)
754 static struct map_bfd mapping
[] =
756 { "got", 3, ELF_SUFFIX_GOT
},
757 { "got12", 5, ELF_SUFFIX_GOT
},
758 { "plt", 3, ELF_SUFFIX_PLT
},
759 { "gotent", 6, ELF_SUFFIX_GOTENT
},
760 { "gotoff", 6, ELF_SUFFIX_GOTOFF
},
761 { "gotplt", 6, ELF_SUFFIX_GOTPLT
},
762 { "pltoff", 6, ELF_SUFFIX_PLTOFF
},
763 { "tlsgd", 5, ELF_SUFFIX_TLS_GD
},
764 { "gotntpoff", 9, ELF_SUFFIX_TLS_GOTIE
},
765 { "indntpoff", 9, ELF_SUFFIX_TLS_IE
},
766 { "tlsldm", 6, ELF_SUFFIX_TLS_LDM
},
767 { "dtpoff", 6, ELF_SUFFIX_TLS_LDO
},
768 { "ntpoff", 6, ELF_SUFFIX_TLS_LE
},
769 { NULL
, 0, ELF_SUFFIX_NONE
}
778 return ELF_SUFFIX_NONE
;
781 while (ISALNUM (*str
))
785 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
786 if (len
== ptr
->length
787 && strncasecmp (ident
, ptr
->string
, ptr
->length
) == 0)
789 if (exp_p
->X_add_number
!= 0)
790 as_warn (_("identifier+constant@%s means identifier@%s+constant"),
791 ptr
->string
, ptr
->string
);
792 /* Now check for identifier@suffix+constant. */
793 if (*str
== '-' || *str
== '+')
795 char *orig_line
= input_line_pointer
;
798 input_line_pointer
= str
;
799 expression (&new_exp
);
801 switch (new_exp
.X_op
)
803 case O_constant
: /* X_add_number (a constant expression). */
804 exp_p
->X_add_number
+= new_exp
.X_add_number
;
805 str
= input_line_pointer
;
807 case O_symbol
: /* X_add_symbol + X_add_number. */
808 /* this case is used for e.g. xyz@PLT+.Label. */
809 exp_p
->X_add_number
+= new_exp
.X_add_number
;
810 exp_p
->X_op_symbol
= new_exp
.X_add_symbol
;
812 str
= input_line_pointer
;
814 case O_uminus
: /* (- X_add_symbol) + X_add_number. */
815 /* this case is used for e.g. xyz@PLT-.Label. */
816 exp_p
->X_add_number
+= new_exp
.X_add_number
;
817 exp_p
->X_op_symbol
= new_exp
.X_add_symbol
;
818 exp_p
->X_op
= O_subtract
;
819 str
= input_line_pointer
;
825 /* If s390_elf_suffix has not been called with
826 &input_line_pointer as first parameter, we have
827 clobbered the input_line_pointer. We have to
829 if (&input_line_pointer
!= str_p
)
830 input_line_pointer
= orig_line
;
836 return BFD_RELOC_UNUSED
;
839 /* Structure used to hold a literal pool entry. */
842 struct s390_lpe
*next
;
844 FLONUM_TYPE floatnum
; /* used if X_op == O_big && X_add_number <= 0 */
845 LITTLENUM_TYPE bignum
[4]; /* used if X_op == O_big && X_add_number > 0 */
847 bfd_reloc_code_real_type reloc
;
851 static struct s390_lpe
*lpe_free_list
= NULL
;
852 static struct s390_lpe
*lpe_list
= NULL
;
853 static struct s390_lpe
*lpe_list_tail
= NULL
;
854 static symbolS
*lp_sym
= NULL
;
855 static int lp_count
= 0;
856 static int lpe_count
= 0;
859 s390_exp_compare (expressionS
*exp1
, expressionS
*exp2
)
861 if (exp1
->X_op
!= exp2
->X_op
)
866 case O_constant
: /* X_add_number must be equal. */
868 return exp1
->X_add_number
== exp2
->X_add_number
;
871 as_bad (_("Can't handle O_big in s390_exp_compare"));
873 case O_symbol
: /* X_add_symbol & X_add_number must be equal. */
878 return (exp1
->X_add_symbol
== exp2
->X_add_symbol
)
879 && (exp1
->X_add_number
== exp2
->X_add_number
);
881 case O_multiply
: /* X_add_symbol,X_op_symbol&X_add_number must be equal. */
886 case O_bit_inclusive_or
:
888 case O_bit_exclusive_or
:
900 return (exp1
->X_add_symbol
== exp2
->X_add_symbol
)
901 && (exp1
->X_op_symbol
== exp2
->X_op_symbol
)
902 && (exp1
->X_add_number
== exp2
->X_add_number
);
908 /* Test for @lit and if its present make an entry in the literal pool and
909 modify the current expression to be an offset into the literal pool. */
910 static elf_suffix_type
911 s390_lit_suffix (char **str_p
, expressionS
*exp_p
, elf_suffix_type suffix
)
913 bfd_reloc_code_real_type reloc
;
917 struct s390_lpe
*lpe
;
921 return suffix
; /* No modification. */
923 /* We look for a suffix of the form "@lit1", "@lit2", "@lit4" or "@lit8". */
925 while (ISALNUM (*str
))
928 if (len
!= 4 || strncasecmp (ident
, "lit", 3) != 0
929 || (ident
[3]!='1' && ident
[3]!='2' && ident
[3]!='4' && ident
[3]!='8'))
930 return suffix
; /* no modification */
931 nbytes
= ident
[3] - '0';
933 reloc
= BFD_RELOC_UNUSED
;
934 if (suffix
== ELF_SUFFIX_GOT
)
937 reloc
= BFD_RELOC_390_GOT16
;
938 else if (nbytes
== 4)
939 reloc
= BFD_RELOC_32_GOT_PCREL
;
940 else if (nbytes
== 8)
941 reloc
= BFD_RELOC_390_GOT64
;
943 else if (suffix
== ELF_SUFFIX_PLT
)
946 reloc
= BFD_RELOC_390_PLT32
;
947 else if (nbytes
== 8)
948 reloc
= BFD_RELOC_390_PLT64
;
951 if (suffix
!= ELF_SUFFIX_NONE
&& reloc
== BFD_RELOC_UNUSED
)
952 as_bad (_("Invalid suffix for literal pool entry"));
954 /* Search the pool if the new entry is a duplicate. */
955 if (exp_p
->X_op
== O_big
)
957 /* Special processing for big numbers. */
958 for (lpe
= lpe_list
; lpe
!= NULL
; lpe
= lpe
->next
)
960 if (lpe
->ex
.X_op
== O_big
)
962 if (exp_p
->X_add_number
<= 0 && lpe
->ex
.X_add_number
<= 0)
964 if (memcmp (&generic_floating_point_number
, &lpe
->floatnum
,
965 sizeof (FLONUM_TYPE
)) == 0)
968 else if (exp_p
->X_add_number
== lpe
->ex
.X_add_number
)
970 if (memcmp (generic_bignum
, lpe
->bignum
,
971 sizeof (LITTLENUM_TYPE
)*exp_p
->X_add_number
) == 0)
979 /* Processing for 'normal' data types. */
980 for (lpe
= lpe_list
; lpe
!= NULL
; lpe
= lpe
->next
)
981 if (lpe
->nbytes
== nbytes
&& lpe
->reloc
== reloc
982 && s390_exp_compare (exp_p
, &lpe
->ex
) != 0)
989 if (lpe_free_list
!= NULL
)
992 lpe_free_list
= lpe_free_list
->next
;
996 lpe
= (struct s390_lpe
*) xmalloc (sizeof (struct s390_lpe
));
1001 if (exp_p
->X_op
== O_big
)
1003 if (exp_p
->X_add_number
<= 0)
1004 lpe
->floatnum
= generic_floating_point_number
;
1005 else if (exp_p
->X_add_number
<= 4)
1006 memcpy (lpe
->bignum
, generic_bignum
,
1007 exp_p
->X_add_number
* sizeof (LITTLENUM_TYPE
));
1009 as_bad (_("Big number is too big"));
1012 lpe
->nbytes
= nbytes
;
1014 /* Literal pool name defined ? */
1017 sprintf (tmp_name
, ".L\001%i", lp_count
);
1018 lp_sym
= symbol_make (tmp_name
);
1021 /* Make name for literal pool entry. */
1022 sprintf (tmp_name
, ".L\001%i\002%i", lp_count
, lpe_count
);
1024 lpe
->sym
= symbol_make (tmp_name
);
1026 /* Add to literal pool list. */
1028 if (lpe_list_tail
!= NULL
)
1030 lpe_list_tail
->next
= lpe
;
1031 lpe_list_tail
= lpe
;
1034 lpe_list
= lpe_list_tail
= lpe
;
1037 /* Now change exp_p to the offset into the literal pool.
1038 Thats the expression: .L^Ax^By-.L^Ax */
1039 exp_p
->X_add_symbol
= lpe
->sym
;
1040 exp_p
->X_op_symbol
= lp_sym
;
1041 exp_p
->X_op
= O_subtract
;
1042 exp_p
->X_add_number
= 0;
1046 /* We change the suffix type to ELF_SUFFIX_NONE, because
1047 the difference of two local labels is just a number. */
1048 return ELF_SUFFIX_NONE
;
1051 /* Like normal .long/.short/.word, except support @got, etc.
1052 clobbers input_line_pointer, checks end-of-line. */
1054 s390_elf_cons (int nbytes
/* 1=.byte, 2=.word, 4=.long */)
1057 elf_suffix_type suffix
;
1059 if (is_it_end_of_statement ())
1061 demand_empty_rest_of_line ();
1069 if (exp
.X_op
== O_symbol
1070 && *input_line_pointer
== '@'
1071 && (suffix
= s390_elf_suffix (&input_line_pointer
, &exp
)) != ELF_SUFFIX_NONE
)
1073 bfd_reloc_code_real_type reloc
;
1074 reloc_howto_type
*reloc_howto
;
1080 static bfd_reloc_code_real_type tab2
[] =
1082 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_NONE */
1083 BFD_RELOC_390_GOT16
, /* ELF_SUFFIX_GOT */
1084 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_PLT */
1085 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTENT */
1086 BFD_RELOC_16_GOTOFF
, /* ELF_SUFFIX_GOTOFF */
1087 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTPLT */
1088 BFD_RELOC_390_PLTOFF16
, /* ELF_SUFFIX_PLTOFF */
1089 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_GD */
1090 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_GOTIE */
1091 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_IE */
1092 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_LDM */
1093 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_LDO */
1094 BFD_RELOC_UNUSED
/* ELF_SUFFIX_TLS_LE */
1096 reloc
= tab2
[suffix
];
1098 else if (nbytes
== 4)
1100 static bfd_reloc_code_real_type tab4
[] =
1102 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_NONE */
1103 BFD_RELOC_32_GOT_PCREL
, /* ELF_SUFFIX_GOT */
1104 BFD_RELOC_390_PLT32
, /* ELF_SUFFIX_PLT */
1105 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTENT */
1106 BFD_RELOC_32_GOTOFF
, /* ELF_SUFFIX_GOTOFF */
1107 BFD_RELOC_390_GOTPLT32
, /* ELF_SUFFIX_GOTPLT */
1108 BFD_RELOC_390_PLTOFF32
, /* ELF_SUFFIX_PLTOFF */
1109 BFD_RELOC_390_TLS_GD32
, /* ELF_SUFFIX_TLS_GD */
1110 BFD_RELOC_390_TLS_GOTIE32
, /* ELF_SUFFIX_TLS_GOTIE */
1111 BFD_RELOC_390_TLS_IE32
, /* ELF_SUFFIX_TLS_IE */
1112 BFD_RELOC_390_TLS_LDM32
, /* ELF_SUFFIX_TLS_LDM */
1113 BFD_RELOC_390_TLS_LDO32
, /* ELF_SUFFIX_TLS_LDO */
1114 BFD_RELOC_390_TLS_LE32
/* ELF_SUFFIX_TLS_LE */
1116 reloc
= tab4
[suffix
];
1118 else if (nbytes
== 8)
1120 static bfd_reloc_code_real_type tab8
[] =
1122 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_NONE */
1123 BFD_RELOC_390_GOT64
, /* ELF_SUFFIX_GOT */
1124 BFD_RELOC_390_PLT64
, /* ELF_SUFFIX_PLT */
1125 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTENT */
1126 BFD_RELOC_390_GOTOFF64
, /* ELF_SUFFIX_GOTOFF */
1127 BFD_RELOC_390_GOTPLT64
, /* ELF_SUFFIX_GOTPLT */
1128 BFD_RELOC_390_PLTOFF64
, /* ELF_SUFFIX_PLTOFF */
1129 BFD_RELOC_390_TLS_GD64
, /* ELF_SUFFIX_TLS_GD */
1130 BFD_RELOC_390_TLS_GOTIE64
, /* ELF_SUFFIX_TLS_GOTIE */
1131 BFD_RELOC_390_TLS_IE64
, /* ELF_SUFFIX_TLS_IE */
1132 BFD_RELOC_390_TLS_LDM64
, /* ELF_SUFFIX_TLS_LDM */
1133 BFD_RELOC_390_TLS_LDO64
, /* ELF_SUFFIX_TLS_LDO */
1134 BFD_RELOC_390_TLS_LE64
/* ELF_SUFFIX_TLS_LE */
1136 reloc
= tab8
[suffix
];
1139 reloc
= BFD_RELOC_UNUSED
;
1141 if (reloc
!= BFD_RELOC_UNUSED
1142 && (reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
)))
1144 size
= bfd_get_reloc_size (reloc_howto
);
1146 as_bad (_("%s relocations do not fit in %d bytes"),
1147 reloc_howto
->name
, nbytes
);
1148 where
= frag_more (nbytes
);
1149 md_number_to_chars (where
, 0, size
);
1150 /* To make fixup_segment do the pc relative conversion the
1151 pcrel parameter on the fix_new_exp call needs to be FALSE. */
1152 fix_new_exp (frag_now
, where
- frag_now
->fr_literal
,
1153 size
, &exp
, FALSE
, reloc
);
1156 as_bad (_("relocation not applicable"));
1159 emit_expr (&exp
, (unsigned int) nbytes
);
1161 while (*input_line_pointer
++ == ',');
1163 input_line_pointer
--; /* Put terminator back into stream. */
1164 demand_empty_rest_of_line ();
1167 /* We need to keep a list of fixups. We can't simply generate them as
1168 we go, because that would require us to first create the frag, and
1169 that would screw up references to ``.''. */
1175 bfd_reloc_code_real_type reloc
;
1178 #define MAX_INSN_FIXUPS (4)
1180 /* This routine is called for each instruction to be assembled. */
1183 md_gather_operands (char *str
,
1184 unsigned char *insn
,
1185 const struct s390_opcode
*opcode
)
1187 struct s390_fixup fixups
[MAX_INSN_FIXUPS
];
1188 const struct s390_operand
*operand
;
1189 const unsigned char *opindex_ptr
;
1191 elf_suffix_type suffix
;
1192 bfd_reloc_code_real_type reloc
;
1197 while (ISSPACE (*str
))
1202 /* Gather the operands. */
1204 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
1208 operand
= s390_operands
+ *opindex_ptr
;
1210 if (skip_optional
&& (operand
->flags
& S390_OPERAND_INDEX
))
1212 /* We do an early skip. For D(X,B) constructions the index
1213 register is skipped (X is optional). For D(L,B) the base
1214 register will be the skipped operand, because L is NOT
1220 /* Gather the operand. */
1221 hold
= input_line_pointer
;
1222 input_line_pointer
= str
;
1224 /* Parse the operand. */
1225 if (! register_name (&ex
))
1228 str
= input_line_pointer
;
1229 input_line_pointer
= hold
;
1231 /* Write the operand to the insn. */
1232 if (ex
.X_op
== O_illegal
)
1233 as_bad (_("illegal operand"));
1234 else if (ex
.X_op
== O_absent
)
1236 /* No operands, check if all operands can be skipped. */
1237 while (*opindex_ptr
!= 0 && operand
->flags
& S390_OPERAND_OPTIONAL
)
1239 if (operand
->flags
& S390_OPERAND_DISP
)
1241 /* An optional displacement makes the whole D(X,B)
1242 D(L,B) or D(B) block optional. */
1244 operand
= s390_operands
+ *(++opindex_ptr
);
1245 } while (!(operand
->flags
& S390_OPERAND_BASE
));
1247 operand
= s390_operands
+ *(++opindex_ptr
);
1249 if (opindex_ptr
[0] == '\0')
1251 as_bad (_("missing operand"));
1253 else if (ex
.X_op
== O_register
|| ex
.X_op
== O_constant
)
1255 s390_lit_suffix (&str
, &ex
, ELF_SUFFIX_NONE
);
1257 if (ex
.X_op
!= O_register
&& ex
.X_op
!= O_constant
)
1259 /* We need to generate a fixup for the
1260 expression returned by s390_lit_suffix. */
1261 if (fc
>= MAX_INSN_FIXUPS
)
1262 as_fatal (_("too many fixups"));
1263 fixups
[fc
].exp
= ex
;
1264 fixups
[fc
].opindex
= *opindex_ptr
;
1265 fixups
[fc
].reloc
= BFD_RELOC_UNUSED
;
1270 if ((operand
->flags
& S390_OPERAND_INDEX
)
1271 && ex
.X_add_number
== 0
1273 as_warn (_("index register specified but zero"));
1274 if ((operand
->flags
& S390_OPERAND_BASE
)
1275 && ex
.X_add_number
== 0
1277 as_warn (_("base register specified but zero"));
1278 if ((operand
->flags
& S390_OPERAND_GPR
)
1279 && (operand
->flags
& S390_OPERAND_REG_PAIR
)
1280 && (ex
.X_add_number
& 1))
1281 as_fatal (_("odd numbered general purpose register specified as "
1283 if ((operand
->flags
& S390_OPERAND_FPR
)
1284 && (operand
->flags
& S390_OPERAND_REG_PAIR
)
1285 && ex
.X_add_number
!= 0 && ex
.X_add_number
!= 1
1286 && ex
.X_add_number
!= 4 && ex
.X_add_number
!= 5
1287 && ex
.X_add_number
!= 8 && ex
.X_add_number
!= 9
1288 && ex
.X_add_number
!= 12 && ex
.X_add_number
!= 13)
1289 as_fatal (_("invalid floating point register pair. Valid fp "
1290 "register pair operands are 0, 1, 4, 5, 8, 9, "
1292 s390_insert_operand (insn
, operand
, ex
.X_add_number
, NULL
, 0);
1297 suffix
= s390_elf_suffix (&str
, &ex
);
1298 suffix
= s390_lit_suffix (&str
, &ex
, suffix
);
1299 reloc
= BFD_RELOC_UNUSED
;
1301 if (suffix
== ELF_SUFFIX_GOT
)
1303 if ((operand
->flags
& S390_OPERAND_DISP
) &&
1304 (operand
->bits
== 12))
1305 reloc
= BFD_RELOC_390_GOT12
;
1306 else if ((operand
->flags
& S390_OPERAND_DISP
) &&
1307 (operand
->bits
== 20))
1308 reloc
= BFD_RELOC_390_GOT20
;
1309 else if ((operand
->flags
& S390_OPERAND_SIGNED
)
1310 && (operand
->bits
== 16))
1311 reloc
= BFD_RELOC_390_GOT16
;
1312 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1313 && (operand
->bits
== 32))
1314 reloc
= BFD_RELOC_390_GOTENT
;
1316 else if (suffix
== ELF_SUFFIX_PLT
)
1318 if ((operand
->flags
& S390_OPERAND_PCREL
)
1319 && (operand
->bits
== 12))
1320 reloc
= BFD_RELOC_390_PLT12DBL
;
1321 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1322 && (operand
->bits
== 16))
1323 reloc
= BFD_RELOC_390_PLT16DBL
;
1324 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1325 && (operand
->bits
== 24))
1326 reloc
= BFD_RELOC_390_PLT24DBL
;
1327 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1328 && (operand
->bits
== 32))
1329 reloc
= BFD_RELOC_390_PLT32DBL
;
1331 else if (suffix
== ELF_SUFFIX_GOTENT
)
1333 if ((operand
->flags
& S390_OPERAND_PCREL
)
1334 && (operand
->bits
== 32))
1335 reloc
= BFD_RELOC_390_GOTENT
;
1337 else if (suffix
== ELF_SUFFIX_GOTOFF
)
1339 if ((operand
->flags
& S390_OPERAND_SIGNED
)
1340 && (operand
->bits
== 16))
1341 reloc
= BFD_RELOC_16_GOTOFF
;
1343 else if (suffix
== ELF_SUFFIX_PLTOFF
)
1345 if ((operand
->flags
& S390_OPERAND_SIGNED
)
1346 && (operand
->bits
== 16))
1347 reloc
= BFD_RELOC_390_PLTOFF16
;
1349 else if (suffix
== ELF_SUFFIX_GOTPLT
)
1351 if ((operand
->flags
& S390_OPERAND_DISP
)
1352 && (operand
->bits
== 12))
1353 reloc
= BFD_RELOC_390_GOTPLT12
;
1354 else if ((operand
->flags
& S390_OPERAND_SIGNED
)
1355 && (operand
->bits
== 16))
1356 reloc
= BFD_RELOC_390_GOTPLT16
;
1357 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1358 && (operand
->bits
== 32))
1359 reloc
= BFD_RELOC_390_GOTPLTENT
;
1361 else if (suffix
== ELF_SUFFIX_TLS_GOTIE
)
1363 if ((operand
->flags
& S390_OPERAND_DISP
)
1364 && (operand
->bits
== 12))
1365 reloc
= BFD_RELOC_390_TLS_GOTIE12
;
1366 else if ((operand
->flags
& S390_OPERAND_DISP
)
1367 && (operand
->bits
== 20))
1368 reloc
= BFD_RELOC_390_TLS_GOTIE20
;
1370 else if (suffix
== ELF_SUFFIX_TLS_IE
)
1372 if ((operand
->flags
& S390_OPERAND_PCREL
)
1373 && (operand
->bits
== 32))
1374 reloc
= BFD_RELOC_390_TLS_IEENT
;
1377 if (suffix
!= ELF_SUFFIX_NONE
&& reloc
== BFD_RELOC_UNUSED
)
1378 as_bad (_("invalid operand suffix"));
1379 /* We need to generate a fixup of type 'reloc' for this
1381 if (fc
>= MAX_INSN_FIXUPS
)
1382 as_fatal (_("too many fixups"));
1383 fixups
[fc
].exp
= ex
;
1384 fixups
[fc
].opindex
= *opindex_ptr
;
1385 fixups
[fc
].reloc
= reloc
;
1389 /* Check the next character. The call to expression has advanced
1390 str past any whitespace. */
1391 if (operand
->flags
& S390_OPERAND_DISP
)
1393 /* After a displacement a block in parentheses can start. */
1396 /* Check if parenthesized block can be skipped. If the next
1397 operand is neiter an optional operand nor a base register
1398 then we have a syntax error. */
1399 operand
= s390_operands
+ *(++opindex_ptr
);
1400 if (!(operand
->flags
& (S390_OPERAND_INDEX
|S390_OPERAND_BASE
)))
1401 as_bad (_("syntax error; missing '(' after displacement"));
1403 /* Ok, skip all operands until S390_OPERAND_BASE. */
1404 while (!(operand
->flags
& S390_OPERAND_BASE
))
1405 operand
= s390_operands
+ *(++opindex_ptr
);
1407 /* If there is a next operand it must be separated by a comma. */
1408 if (opindex_ptr
[1] != '\0')
1412 while (opindex_ptr
[1] != '\0')
1414 operand
= s390_operands
+ *(++opindex_ptr
);
1415 if (operand
->flags
& S390_OPERAND_OPTIONAL
)
1417 as_bad (_("syntax error; expected ,"));
1427 /* We found an opening parentheses. */
1429 for (f
= str
; *f
!= '\0'; f
++)
1430 if (*f
== ',' || *f
== ')')
1432 /* If there is no comma until the closing parentheses OR
1433 there is a comma right after the opening parentheses,
1434 we have to skip optional operands. */
1435 if (*f
== ',' && f
== str
)
1437 /* comma directly after '(' ? */
1442 skip_optional
= (*f
!= ',');
1445 else if (operand
->flags
& S390_OPERAND_BASE
)
1447 /* After the base register the parenthesed block ends. */
1449 as_bad (_("syntax error; missing ')' after base register"));
1451 /* If there is a next operand it must be separated by a comma. */
1452 if (opindex_ptr
[1] != '\0')
1456 while (opindex_ptr
[1] != '\0')
1458 operand
= s390_operands
+ *(++opindex_ptr
);
1459 if (operand
->flags
& S390_OPERAND_OPTIONAL
)
1461 as_bad (_("syntax error; expected ,"));
1471 /* We can find an 'early' closing parentheses in e.g. D(L) instead
1472 of D(L,B). In this case the base register has to be skipped. */
1475 operand
= s390_operands
+ *(++opindex_ptr
);
1477 if (!(operand
->flags
& S390_OPERAND_BASE
))
1478 as_bad (_("syntax error; ')' not allowed here"));
1481 /* If there is a next operand it must be separated by a comma. */
1482 if (opindex_ptr
[1] != '\0')
1486 while (opindex_ptr
[1] != '\0')
1488 operand
= s390_operands
+ *(++opindex_ptr
);
1489 if (operand
->flags
& S390_OPERAND_OPTIONAL
)
1491 as_bad (_("syntax error; expected ,"));
1501 while (ISSPACE (*str
))
1504 /* Check for tls instruction marker. */
1505 reloc
= s390_tls_suffix (&str
, &ex
);
1506 if (reloc
!= BFD_RELOC_UNUSED
)
1508 /* We need to generate a fixup of type 'reloc' for this
1510 if (fc
>= MAX_INSN_FIXUPS
)
1511 as_fatal (_("too many fixups"));
1512 fixups
[fc
].exp
= ex
;
1513 fixups
[fc
].opindex
= -1;
1514 fixups
[fc
].reloc
= reloc
;
1522 if ((linefeed
= strchr (str
, '\n')) != NULL
)
1524 as_bad (_("junk at end of line: `%s'"), str
);
1525 if (linefeed
!= NULL
)
1529 /* Write out the instruction. */
1530 f
= frag_more (opcode
->oplen
);
1531 memcpy (f
, insn
, opcode
->oplen
);
1532 dwarf2_emit_insn (opcode
->oplen
);
1534 /* Create any fixups. At this point we do not use a
1535 bfd_reloc_code_real_type, but instead just use the
1536 BFD_RELOC_UNUSED plus the operand index. This lets us easily
1537 handle fixups for any operand type, although that is admittedly
1538 not a very exciting feature. We pick a BFD reloc type in
1540 for (i
= 0; i
< fc
; i
++)
1543 if (fixups
[i
].opindex
< 0)
1545 /* Create tls instruction marker relocation. */
1546 fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, opcode
->oplen
,
1547 &fixups
[i
].exp
, 0, fixups
[i
].reloc
);
1551 operand
= s390_operands
+ fixups
[i
].opindex
;
1553 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
1555 reloc_howto_type
*reloc_howto
;
1559 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
1563 size
= ((reloc_howto
->bitsize
- 1) / 8) + 1;
1565 if (size
< 1 || size
> 4)
1568 fixP
= fix_new_exp (frag_now
,
1569 f
- frag_now
->fr_literal
+ (operand
->shift
/8),
1570 size
, &fixups
[i
].exp
, reloc_howto
->pc_relative
,
1572 /* Turn off overflow checking in fixup_segment. This is necessary
1573 because fixup_segment will signal an overflow for large 4 byte
1574 quantities for GOT12 relocations. */
1575 if ( fixups
[i
].reloc
== BFD_RELOC_390_GOT12
1576 || fixups
[i
].reloc
== BFD_RELOC_390_GOT20
1577 || fixups
[i
].reloc
== BFD_RELOC_390_GOT16
)
1578 fixP
->fx_no_overflow
= 1;
1581 fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, 4, &fixups
[i
].exp
,
1582 (operand
->flags
& S390_OPERAND_PCREL
) != 0,
1583 ((bfd_reloc_code_real_type
)
1584 (fixups
[i
].opindex
+ (int) BFD_RELOC_UNUSED
)));
1589 /* This routine is called for each instruction to be assembled. */
1592 md_assemble (char *str
)
1594 const struct s390_opcode
*opcode
;
1595 unsigned char insn
[6];
1598 /* Get the opcode. */
1599 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
1604 /* Look up the opcode in the hash table. */
1605 opcode
= (struct s390_opcode
*) hash_find (s390_opcode_hash
, str
);
1606 if (opcode
== (const struct s390_opcode
*) NULL
)
1608 as_bad (_("Unrecognized opcode: `%s'"), str
);
1611 else if (!(opcode
->modes
& current_mode_mask
))
1613 as_bad (_("Opcode %s not available in this mode"), str
);
1616 memcpy (insn
, opcode
->opcode
, sizeof (insn
));
1617 md_gather_operands (s
, insn
, opcode
);
1620 #ifndef WORKING_DOT_WORD
1621 /* Handle long and short jumps. We don't support these */
1623 md_create_short_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
1625 addressT from_addr
, to_addr
;
1633 md_create_long_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
1635 addressT from_addr
, to_addr
;
1644 s390_bss (int ignore ATTRIBUTE_UNUSED
)
1646 /* We don't support putting frags in the BSS segment, we fake it
1647 by marking in_bss, then looking at s_skip for clues. */
1649 subseg_set (bss_section
, 0);
1650 demand_empty_rest_of_line ();
1653 /* Pseudo-op handling. */
1656 s390_insn (int ignore ATTRIBUTE_UNUSED
)
1659 const struct s390_opcode
*opformat
;
1660 unsigned char insn
[6];
1663 /* Get the opcode format. */
1664 s
= input_line_pointer
;
1665 while (*s
!= '\0' && *s
!= ',' && ! ISSPACE (*s
))
1668 as_bad (_("Invalid .insn format\n"));
1671 /* Look up the opcode in the hash table. */
1672 opformat
= (struct s390_opcode
*)
1673 hash_find (s390_opformat_hash
, input_line_pointer
);
1674 if (opformat
== (const struct s390_opcode
*) NULL
)
1676 as_bad (_("Unrecognized opcode format: `%s'"), input_line_pointer
);
1679 input_line_pointer
= s
;
1681 if (exp
.X_op
== O_constant
)
1683 if ( ( opformat
->oplen
== 6
1684 && (addressT
) exp
.X_add_number
< (1ULL << 48))
1685 || ( opformat
->oplen
== 4
1686 && (addressT
) exp
.X_add_number
< (1ULL << 32))
1687 || ( opformat
->oplen
== 2
1688 && (addressT
) exp
.X_add_number
< (1ULL << 16)))
1689 md_number_to_chars ((char *) insn
, exp
.X_add_number
, opformat
->oplen
);
1691 as_bad (_("Invalid .insn format\n"));
1693 else if (exp
.X_op
== O_big
)
1695 if (exp
.X_add_number
> 0
1696 && opformat
->oplen
== 6
1697 && generic_bignum
[3] == 0)
1699 md_number_to_chars ((char *) insn
, generic_bignum
[2], 2);
1700 md_number_to_chars ((char *) &insn
[2], generic_bignum
[1], 2);
1701 md_number_to_chars ((char *) &insn
[4], generic_bignum
[0], 2);
1704 as_bad (_("Invalid .insn format\n"));
1707 as_bad (_("second operand of .insn not a constant\n"));
1709 if (strcmp (opformat
->name
, "e") != 0 && *input_line_pointer
++ != ',')
1710 as_bad (_("missing comma after insn constant\n"));
1712 if ((s
= strchr (input_line_pointer
, '\n')) != NULL
)
1714 input_line_pointer
= md_gather_operands (input_line_pointer
, insn
,
1718 demand_empty_rest_of_line ();
1721 /* The .byte pseudo-op. This is similar to the normal .byte
1722 pseudo-op, but it can also take a single ASCII string. */
1725 s390_byte (int ignore ATTRIBUTE_UNUSED
)
1727 if (*input_line_pointer
!= '\"')
1733 /* Gather characters. A real double quote is doubled. Unusual
1734 characters are not permitted. */
1735 ++input_line_pointer
;
1740 c
= *input_line_pointer
++;
1744 if (*input_line_pointer
!= '\"')
1746 ++input_line_pointer
;
1749 FRAG_APPEND_1_CHAR (c
);
1752 demand_empty_rest_of_line ();
1755 /* The .ltorg pseudo-op.This emits all literals defined since the last
1756 .ltorg or the invocation of gas. Literals are defined with the
1760 s390_literals (int ignore ATTRIBUTE_UNUSED
)
1762 struct s390_lpe
*lpe
;
1764 if (lp_sym
== NULL
|| lpe_count
== 0)
1765 return; /* Nothing to be done. */
1767 /* Emit symbol for start of literal pool. */
1768 S_SET_SEGMENT (lp_sym
, now_seg
);
1769 S_SET_VALUE (lp_sym
, (valueT
) frag_now_fix ());
1770 lp_sym
->sy_frag
= frag_now
;
1775 lpe_list
= lpe_list
->next
;
1776 S_SET_SEGMENT (lpe
->sym
, now_seg
);
1777 S_SET_VALUE (lpe
->sym
, (valueT
) frag_now_fix ());
1778 lpe
->sym
->sy_frag
= frag_now
;
1780 /* Emit literal pool entry. */
1781 if (lpe
->reloc
!= BFD_RELOC_UNUSED
)
1783 reloc_howto_type
*reloc_howto
=
1784 bfd_reloc_type_lookup (stdoutput
, lpe
->reloc
);
1785 int size
= bfd_get_reloc_size (reloc_howto
);
1788 if (size
> lpe
->nbytes
)
1789 as_bad (_("%s relocations do not fit in %d bytes"),
1790 reloc_howto
->name
, lpe
->nbytes
);
1791 where
= frag_more (lpe
->nbytes
);
1792 md_number_to_chars (where
, 0, size
);
1793 fix_new_exp (frag_now
, where
- frag_now
->fr_literal
,
1794 size
, &lpe
->ex
, reloc_howto
->pc_relative
, lpe
->reloc
);
1798 if (lpe
->ex
.X_op
== O_big
)
1800 if (lpe
->ex
.X_add_number
<= 0)
1801 generic_floating_point_number
= lpe
->floatnum
;
1803 memcpy (generic_bignum
, lpe
->bignum
,
1804 lpe
->ex
.X_add_number
* sizeof (LITTLENUM_TYPE
));
1806 emit_expr (&lpe
->ex
, lpe
->nbytes
);
1809 lpe
->next
= lpe_free_list
;
1810 lpe_free_list
= lpe
;
1812 lpe_list_tail
= NULL
;
1818 /* The .machine pseudo op allows to switch to a different CPU level in
1819 the asm listing. The current CPU setting can be stored on a stack
1820 with .machine push and restored with .machine pop. */
1823 s390_machine (int ignore ATTRIBUTE_UNUSED
)
1826 #define MAX_HISTORY 100
1827 static unsigned int *cpu_history
;
1828 static int curr_hist
;
1832 if (*input_line_pointer
== '"')
1835 cpu_string
= demand_copy_C_string (&len
);
1840 cpu_string
= input_line_pointer
;
1841 c
= get_symbol_end ();
1842 cpu_string
= xstrdup (cpu_string
);
1843 *input_line_pointer
= c
;
1846 if (cpu_string
!= NULL
)
1848 unsigned int old_cpu
= current_cpu
;
1849 unsigned int new_cpu
;
1852 for (p
= cpu_string
; *p
!= 0; p
++)
1855 if (strcmp (cpu_string
, "push") == 0)
1857 if (cpu_history
== NULL
)
1858 cpu_history
= xmalloc (MAX_HISTORY
* sizeof (*cpu_history
));
1860 if (curr_hist
>= MAX_HISTORY
)
1861 as_bad (_(".machine stack overflow"));
1863 cpu_history
[curr_hist
++] = current_cpu
;
1865 else if (strcmp (cpu_string
, "pop") == 0)
1868 as_bad (_(".machine stack underflow"));
1870 current_cpu
= cpu_history
[--curr_hist
];
1872 else if ((new_cpu
= s390_parse_cpu (cpu_string
)) != (unsigned int)-1)
1873 current_cpu
= new_cpu
;
1875 as_bad (_("invalid machine `%s'"), cpu_string
);
1877 if (current_cpu
!= old_cpu
)
1878 s390_setup_opcodes ();
1881 demand_empty_rest_of_line ();
1884 /* The .machinemode pseudo op allows to switch to a different
1885 architecture mode in the asm listing. The current architecture
1886 mode setting can be stored on a stack with .machinemode push and
1887 restored with .machinemode pop. */
1890 s390_machinemode (int ignore ATTRIBUTE_UNUSED
)
1893 #define MAX_HISTORY 100
1894 static unsigned int *mode_history
;
1895 static int curr_hist
;
1899 if (*input_line_pointer
== '"')
1902 mode_string
= demand_copy_C_string (&len
);
1907 mode_string
= input_line_pointer
;
1908 c
= get_symbol_end ();
1909 mode_string
= xstrdup (mode_string
);
1910 *input_line_pointer
= c
;
1913 if (mode_string
!= NULL
)
1915 unsigned int old_mode_mask
= current_mode_mask
;
1918 for (p
= mode_string
; *p
!= 0; p
++)
1921 if (strcmp (mode_string
, "push") == 0)
1923 if (mode_history
== NULL
)
1924 mode_history
= xmalloc (MAX_HISTORY
* sizeof (*mode_history
));
1926 if (curr_hist
>= MAX_HISTORY
)
1927 as_bad (_(".machinemode stack overflow"));
1929 mode_history
[curr_hist
++] = current_mode_mask
;
1931 else if (strcmp (mode_string
, "pop") == 0)
1934 as_bad (_(".machinemode stack underflow"));
1936 current_mode_mask
= mode_history
[--curr_hist
];
1940 if (strcmp (mode_string
, "esa") == 0)
1941 current_mode_mask
= 1 << S390_OPCODE_ESA
;
1942 else if (strcmp (mode_string
, "zarch") == 0)
1944 if (s390_arch_size
== 32)
1945 set_highgprs_p
= TRUE
;
1946 current_mode_mask
= 1 << S390_OPCODE_ZARCH
;
1948 else if (strcmp (mode_string
, "zarch_nohighgprs") == 0)
1949 current_mode_mask
= 1 << S390_OPCODE_ZARCH
;
1951 as_bad (_("invalid machine `%s'"), mode_string
);
1954 if (current_mode_mask
!= old_mode_mask
)
1955 s390_setup_opcodes ();
1958 demand_empty_rest_of_line ();
1962 md_atof (int type
, char *litp
, int *sizep
)
1964 return ieee_md_atof (type
, litp
, sizep
, TRUE
);
1967 /* Align a section (I don't know why this is machine dependent). */
1970 md_section_align (asection
*seg
, valueT addr
)
1972 int align
= bfd_get_section_alignment (stdoutput
, seg
);
1974 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
1977 /* We don't have any form of relaxing. */
1980 md_estimate_size_before_relax (fragS
*fragp ATTRIBUTE_UNUSED
,
1981 asection
*seg ATTRIBUTE_UNUSED
)
1987 /* Convert a machine dependent frag. We never generate these. */
1990 md_convert_frag (bfd
*abfd ATTRIBUTE_UNUSED
,
1991 asection
*sec ATTRIBUTE_UNUSED
,
1992 fragS
*fragp ATTRIBUTE_UNUSED
)
1998 md_undefined_symbol (char *name
)
2000 if (*name
== '_' && *(name
+ 1) == 'G'
2001 && strcmp (name
, "_GLOBAL_OFFSET_TABLE_") == 0)
2005 if (symbol_find (name
))
2006 as_bad (_("GOT already in symbol table"));
2007 GOT_symbol
= symbol_new (name
, undefined_section
,
2008 (valueT
) 0, &zero_address_frag
);
2015 /* Functions concerning relocs. */
2017 /* The location from which a PC relative jump should be calculated,
2018 given a PC relative reloc. */
2021 md_pcrel_from_section (fixS
*fixp
, segT sec ATTRIBUTE_UNUSED
)
2023 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
2026 /* Here we decide which fixups can be adjusted to make them relative to
2027 the beginning of the section instead of the symbol. Basically we need
2028 to make sure that the dynamic relocations are done correctly, so in
2029 some cases we force the original symbol to be used. */
2031 tc_s390_fix_adjustable (fixS
*fixP
)
2033 /* Don't adjust references to merge sections. */
2034 if ((S_GET_SEGMENT (fixP
->fx_addsy
)->flags
& SEC_MERGE
) != 0)
2036 /* adjust_reloc_syms doesn't know about the GOT. */
2037 if ( fixP
->fx_r_type
== BFD_RELOC_16_GOTOFF
2038 || fixP
->fx_r_type
== BFD_RELOC_32_GOTOFF
2039 || fixP
->fx_r_type
== BFD_RELOC_390_GOTOFF64
2040 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF16
2041 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF32
2042 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF64
2043 || fixP
->fx_r_type
== BFD_RELOC_390_PLT12DBL
2044 || fixP
->fx_r_type
== BFD_RELOC_390_PLT16DBL
2045 || fixP
->fx_r_type
== BFD_RELOC_390_PLT24DBL
2046 || fixP
->fx_r_type
== BFD_RELOC_390_PLT32
2047 || fixP
->fx_r_type
== BFD_RELOC_390_PLT32DBL
2048 || fixP
->fx_r_type
== BFD_RELOC_390_PLT64
2049 || fixP
->fx_r_type
== BFD_RELOC_390_GOT12
2050 || fixP
->fx_r_type
== BFD_RELOC_390_GOT20
2051 || fixP
->fx_r_type
== BFD_RELOC_390_GOT16
2052 || fixP
->fx_r_type
== BFD_RELOC_32_GOT_PCREL
2053 || fixP
->fx_r_type
== BFD_RELOC_390_GOT64
2054 || fixP
->fx_r_type
== BFD_RELOC_390_GOTENT
2055 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT12
2056 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT16
2057 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT20
2058 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT32
2059 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT64
2060 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLTENT
2061 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LOAD
2062 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GDCALL
2063 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDCALL
2064 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GD32
2065 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GD64
2066 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE12
2067 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE20
2068 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE32
2069 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE64
2070 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDM32
2071 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDM64
2072 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IE32
2073 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IE64
2074 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IEENT
2075 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LE32
2076 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LE64
2077 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDO32
2078 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDO64
2079 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_DTPMOD
2080 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_DTPOFF
2081 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_TPOFF
2082 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
2083 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
2088 /* Return true if we must always emit a reloc for a type and false if
2089 there is some hope of resolving it at assembly time. */
2091 tc_s390_force_relocation (struct fix
*fixp
)
2093 /* Ensure we emit a relocation for every reference to the global
2094 offset table or to the procedure link table. */
2095 switch (fixp
->fx_r_type
)
2097 case BFD_RELOC_390_GOT12
:
2098 case BFD_RELOC_390_GOT20
:
2099 case BFD_RELOC_32_GOT_PCREL
:
2100 case BFD_RELOC_32_GOTOFF
:
2101 case BFD_RELOC_390_GOTOFF64
:
2102 case BFD_RELOC_390_PLTOFF16
:
2103 case BFD_RELOC_390_PLTOFF32
:
2104 case BFD_RELOC_390_PLTOFF64
:
2105 case BFD_RELOC_390_GOTPC
:
2106 case BFD_RELOC_390_GOT16
:
2107 case BFD_RELOC_390_GOTPCDBL
:
2108 case BFD_RELOC_390_GOT64
:
2109 case BFD_RELOC_390_GOTENT
:
2110 case BFD_RELOC_390_PLT32
:
2111 case BFD_RELOC_390_PLT12DBL
:
2112 case BFD_RELOC_390_PLT16DBL
:
2113 case BFD_RELOC_390_PLT24DBL
:
2114 case BFD_RELOC_390_PLT32DBL
:
2115 case BFD_RELOC_390_PLT64
:
2116 case BFD_RELOC_390_GOTPLT12
:
2117 case BFD_RELOC_390_GOTPLT16
:
2118 case BFD_RELOC_390_GOTPLT20
:
2119 case BFD_RELOC_390_GOTPLT32
:
2120 case BFD_RELOC_390_GOTPLT64
:
2121 case BFD_RELOC_390_GOTPLTENT
:
2127 return generic_force_reloc (fixp
);
2130 /* Apply a fixup to the object code. This is called for all the
2131 fixups we generated by the call to fix_new_exp, above. In the call
2132 above we used a reloc code which was the largest legal reloc code
2133 plus the operand index. Here we undo that to recover the operand
2134 index. At this point all symbol values should be fully resolved,
2135 and we attempt to completely resolve the reloc. If we can not do
2136 that, we determine the correct reloc code and put it back in the
2140 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg ATTRIBUTE_UNUSED
)
2143 valueT value
= *valP
;
2145 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
2147 if (fixP
->fx_subsy
!= NULL
)
2148 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2149 _("cannot emit relocation %s against subsy symbol %s"),
2150 bfd_get_reloc_code_name (fixP
->fx_r_type
),
2151 S_GET_NAME (fixP
->fx_subsy
));
2153 if (fixP
->fx_addsy
!= NULL
)
2156 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
2161 if ((int) fixP
->fx_r_type
>= (int) BFD_RELOC_UNUSED
)
2163 const struct s390_operand
*operand
;
2166 opindex
= (int) fixP
->fx_r_type
- (int) BFD_RELOC_UNUSED
;
2167 operand
= &s390_operands
[opindex
];
2171 /* Insert the fully resolved operand value. */
2172 s390_insert_operand ((unsigned char *) where
, operand
,
2173 (offsetT
) value
, fixP
->fx_file
, fixP
->fx_line
);
2177 /* Determine a BFD reloc value based on the operand information.
2178 We are only prepared to turn a few of the operands into
2180 fixP
->fx_offset
= value
;
2181 if (operand
->bits
== 12 && operand
->shift
== 20)
2184 fixP
->fx_where
+= 2;
2185 fixP
->fx_r_type
= BFD_RELOC_390_12
;
2187 else if (operand
->bits
== 12 && operand
->shift
== 36)
2190 fixP
->fx_where
+= 4;
2191 fixP
->fx_r_type
= BFD_RELOC_390_12
;
2193 else if (operand
->bits
== 20 && operand
->shift
== 20)
2196 fixP
->fx_where
+= 2;
2197 fixP
->fx_r_type
= BFD_RELOC_390_20
;
2199 else if (operand
->bits
== 8 && operand
->shift
== 8)
2202 fixP
->fx_where
+= 1;
2203 fixP
->fx_r_type
= BFD_RELOC_8
;
2205 else if (operand
->bits
== 12 && operand
->shift
== 12
2206 && (operand
->flags
& S390_OPERAND_PCREL
))
2209 fixP
->fx_where
+= 1;
2210 fixP
->fx_offset
+= 1;
2211 fixP
->fx_r_type
= BFD_RELOC_390_PC12DBL
;
2213 else if (operand
->bits
== 16 && operand
->shift
== 16)
2216 fixP
->fx_where
+= 2;
2217 if (operand
->flags
& S390_OPERAND_PCREL
)
2219 fixP
->fx_r_type
= BFD_RELOC_390_PC16DBL
;
2220 fixP
->fx_offset
+= 2;
2223 fixP
->fx_r_type
= BFD_RELOC_16
;
2225 else if (operand
->bits
== 24 && operand
->shift
== 24
2226 && (operand
->flags
& S390_OPERAND_PCREL
))
2229 fixP
->fx_where
+= 3;
2230 fixP
->fx_offset
+= 3;
2231 fixP
->fx_r_type
= BFD_RELOC_390_PC24DBL
;
2233 else if (operand
->bits
== 32 && operand
->shift
== 16
2234 && (operand
->flags
& S390_OPERAND_PCREL
))
2237 fixP
->fx_where
+= 2;
2238 fixP
->fx_offset
+= 2;
2239 fixP
->fx_r_type
= BFD_RELOC_390_PC32DBL
;
2246 /* Use expr_symbol_where to see if this is an expression
2248 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
2249 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2250 _("unresolved expression that must be resolved"));
2252 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2253 _("unsupported relocation type"));
2260 switch (fixP
->fx_r_type
)
2266 md_number_to_chars (where
, value
, 1);
2268 case BFD_RELOC_390_12
:
2269 case BFD_RELOC_390_GOT12
:
2270 case BFD_RELOC_390_GOTPLT12
:
2271 case BFD_RELOC_390_PC12DBL
:
2272 case BFD_RELOC_390_PLT12DBL
:
2283 mop
= bfd_getb16 ((unsigned char *) where
);
2284 mop
|= (unsigned short) (value
& 0xfff);
2285 bfd_putb16 ((bfd_vma
) mop
, (unsigned char *) where
);
2289 case BFD_RELOC_390_20
:
2290 case BFD_RELOC_390_GOT20
:
2291 case BFD_RELOC_390_GOTPLT20
:
2295 mop
= bfd_getb32 ((unsigned char *) where
);
2296 mop
|= (unsigned int) ((value
& 0xfff) << 8 |
2297 (value
& 0xff000) >> 12);
2298 bfd_putb32 ((bfd_vma
) mop
, (unsigned char *) where
);
2303 case BFD_RELOC_GPREL16
:
2304 case BFD_RELOC_16_GOT_PCREL
:
2305 case BFD_RELOC_16_GOTOFF
:
2307 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2308 _("cannot emit PC relative %s relocation%s%s"),
2309 bfd_get_reloc_code_name (fixP
->fx_r_type
),
2310 fixP
->fx_addsy
!= NULL
? " against " : "",
2311 (fixP
->fx_addsy
!= NULL
2312 ? S_GET_NAME (fixP
->fx_addsy
)
2315 md_number_to_chars (where
, value
, 2);
2317 case BFD_RELOC_390_GOT16
:
2318 case BFD_RELOC_390_PLTOFF16
:
2319 case BFD_RELOC_390_GOTPLT16
:
2321 md_number_to_chars (where
, value
, 2);
2323 case BFD_RELOC_390_PC16DBL
:
2324 case BFD_RELOC_390_PLT16DBL
:
2327 md_number_to_chars (where
, (offsetT
) value
>> 1, 2);
2330 case BFD_RELOC_390_PC24DBL
:
2331 case BFD_RELOC_390_PLT24DBL
:
2338 mop
= bfd_getb32 ((unsigned char *) where
- 1);
2339 mop
|= (unsigned int) (value
& 0xffffff);
2340 bfd_putb32 ((bfd_vma
) mop
, (unsigned char *) where
- 1);
2346 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
2348 fixP
->fx_r_type
= BFD_RELOC_32
;
2350 md_number_to_chars (where
, value
, 4);
2352 case BFD_RELOC_32_PCREL
:
2353 case BFD_RELOC_32_BASEREL
:
2354 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
2356 md_number_to_chars (where
, value
, 4);
2358 case BFD_RELOC_32_GOT_PCREL
:
2359 case BFD_RELOC_390_PLTOFF32
:
2360 case BFD_RELOC_390_PLT32
:
2361 case BFD_RELOC_390_GOTPLT32
:
2363 md_number_to_chars (where
, value
, 4);
2365 case BFD_RELOC_390_PC32DBL
:
2366 case BFD_RELOC_390_PLT32DBL
:
2367 case BFD_RELOC_390_GOTPCDBL
:
2368 case BFD_RELOC_390_GOTENT
:
2369 case BFD_RELOC_390_GOTPLTENT
:
2372 md_number_to_chars (where
, (offsetT
) value
>> 1, 4);
2375 case BFD_RELOC_32_GOTOFF
:
2377 md_number_to_chars (where
, value
, sizeof (int));
2380 case BFD_RELOC_390_GOTOFF64
:
2382 md_number_to_chars (where
, value
, 8);
2385 case BFD_RELOC_390_GOT64
:
2386 case BFD_RELOC_390_PLTOFF64
:
2387 case BFD_RELOC_390_PLT64
:
2388 case BFD_RELOC_390_GOTPLT64
:
2390 md_number_to_chars (where
, value
, 8);
2395 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
2397 fixP
->fx_r_type
= BFD_RELOC_64
;
2399 md_number_to_chars (where
, value
, 8);
2402 case BFD_RELOC_64_PCREL
:
2403 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
2405 md_number_to_chars (where
, value
, 8);
2408 case BFD_RELOC_VTABLE_INHERIT
:
2409 case BFD_RELOC_VTABLE_ENTRY
:
2413 case BFD_RELOC_390_TLS_LOAD
:
2414 case BFD_RELOC_390_TLS_GDCALL
:
2415 case BFD_RELOC_390_TLS_LDCALL
:
2416 case BFD_RELOC_390_TLS_GD32
:
2417 case BFD_RELOC_390_TLS_GD64
:
2418 case BFD_RELOC_390_TLS_GOTIE12
:
2419 case BFD_RELOC_390_TLS_GOTIE20
:
2420 case BFD_RELOC_390_TLS_GOTIE32
:
2421 case BFD_RELOC_390_TLS_GOTIE64
:
2422 case BFD_RELOC_390_TLS_LDM32
:
2423 case BFD_RELOC_390_TLS_LDM64
:
2424 case BFD_RELOC_390_TLS_IE32
:
2425 case BFD_RELOC_390_TLS_IE64
:
2426 case BFD_RELOC_390_TLS_LE32
:
2427 case BFD_RELOC_390_TLS_LE64
:
2428 case BFD_RELOC_390_TLS_LDO32
:
2429 case BFD_RELOC_390_TLS_LDO64
:
2430 case BFD_RELOC_390_TLS_DTPMOD
:
2431 case BFD_RELOC_390_TLS_DTPOFF
:
2432 case BFD_RELOC_390_TLS_TPOFF
:
2433 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
2434 /* Fully resolved at link time. */
2436 case BFD_RELOC_390_TLS_IEENT
:
2437 /* Fully resolved at link time. */
2438 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
2444 const char *reloc_name
= bfd_get_reloc_code_name (fixP
->fx_r_type
);
2446 if (reloc_name
!= NULL
)
2447 as_fatal (_("Gas failure, reloc type %s\n"), reloc_name
);
2449 as_fatal (_("Gas failure, reloc type #%i\n"), fixP
->fx_r_type
);
2453 fixP
->fx_offset
= value
;
2457 /* Generate a reloc for a fixup. */
2460 tc_gen_reloc (asection
*seg ATTRIBUTE_UNUSED
, fixS
*fixp
)
2462 bfd_reloc_code_real_type code
;
2465 code
= fixp
->fx_r_type
;
2466 if (GOT_symbol
&& fixp
->fx_addsy
== GOT_symbol
)
2468 if ( (s390_arch_size
== 32 && code
== BFD_RELOC_32_PCREL
)
2469 || (s390_arch_size
== 64 && code
== BFD_RELOC_64_PCREL
))
2470 code
= BFD_RELOC_390_GOTPC
;
2471 if (code
== BFD_RELOC_390_PC32DBL
)
2472 code
= BFD_RELOC_390_GOTPCDBL
;
2475 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
2476 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
2477 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
2478 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
2479 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
2480 if (reloc
->howto
== NULL
)
2482 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2483 _("cannot represent relocation type %s"),
2484 bfd_get_reloc_code_name (code
));
2485 /* Set howto to a garbage value so that we can keep going. */
2486 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, BFD_RELOC_32
);
2487 gas_assert (reloc
->howto
!= NULL
);
2489 reloc
->addend
= fixp
->fx_offset
;
2495 s390_cfi_frame_initial_instructions (void)
2497 cfi_add_CFA_def_cfa (15, s390_arch_size
== 64 ? 160 : 96);
2501 tc_s390_regname_to_dw2regnum (char *regname
)
2505 if (regname
[0] != 'c' && regname
[0] != 'a')
2507 regnum
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
, regname
);
2508 if (regname
[0] == 'f' && regnum
!= -1)
2511 else if (strcmp (regname
, "ap") == 0)
2513 else if (strcmp (regname
, "cc") == 0)
2519 s390_elf_final_processing (void)
2522 elf_elfheader (stdoutput
)->e_flags
|= EF_S390_HIGH_GPRS
;