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 static unsigned int current_mode_mask
= 0;
42 static unsigned int current_cpu
= -1U;
44 /* Whether to use user friendly register names. Default is TRUE. */
45 #ifndef TARGET_REG_NAMES_P
46 #define TARGET_REG_NAMES_P TRUE
49 static bfd_boolean reg_names_p
= TARGET_REG_NAMES_P
;
51 /* Set to TRUE if we want to warn about zero base/index registers. */
52 static bfd_boolean warn_areg_zero
= FALSE
;
54 /* Generic assembler global variables which must be defined by all
57 const char comment_chars
[] = "#";
59 /* Characters which start a comment at the beginning of a line. */
60 const char line_comment_chars
[] = "#";
62 /* Characters which may be used to separate multiple commands on a
64 const char line_separator_chars
[] = ";";
66 /* Characters which are used to indicate an exponent in a floating
68 const char EXP_CHARS
[] = "eE";
70 /* Characters which mean that a number is a floating point constant,
72 const char FLT_CHARS
[] = "dD";
74 /* The dwarf2 data alignment, adjusted for 32 or 64 bit. */
75 int s390_cie_data_alignment
;
77 /* The target specific pseudo-ops which we support. */
79 /* Define the prototypes for the pseudo-ops */
80 static void s390_byte (int);
81 static void s390_elf_cons (int);
82 static void s390_bss (int);
83 static void s390_insn (int);
84 static void s390_literals (int);
86 const pseudo_typeS md_pseudo_table
[] =
88 { "align", s_align_bytes
, 0 },
89 /* Pseudo-ops which must be defined. */
90 { "bss", s390_bss
, 0 },
91 { "insn", s390_insn
, 0 },
92 /* Pseudo-ops which must be overridden. */
93 { "byte", s390_byte
, 0 },
94 { "short", s390_elf_cons
, 2 },
95 { "long", s390_elf_cons
, 4 },
96 { "quad", s390_elf_cons
, 8 },
97 { "ltorg", s390_literals
, 0 },
98 { "string", stringer
, 8 + 1 },
103 /* Structure to hold information about predefined registers. */
110 /* List of registers that are pre-defined:
112 Each access register has a predefined name of the form:
113 a<reg_num> which has the value <reg_num>.
115 Each control register has a predefined name of the form:
116 c<reg_num> which has the value <reg_num>.
118 Each general register has a predefined name of the form:
119 r<reg_num> which has the value <reg_num>.
121 Each floating point register a has predefined name of the form:
122 f<reg_num> which has the value <reg_num>.
124 There are individual registers as well:
128 The table is sorted. Suitable for searching by a binary search. */
130 static const struct pd_reg pre_defined_registers
[] =
132 { "a0", 0 }, /* Access registers */
149 { "c0", 0 }, /* Control registers */
166 { "f0", 0 }, /* Floating point registers */
183 { "lit", 13 }, /* Pointer to literal pool */
185 { "r0", 0 }, /* General purpose registers */
202 { "sp", 15 }, /* Stack pointer */
206 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
208 /* Given NAME, find the register number associated with that name, return
209 the integer value associated with the given name or -1 on failure. */
212 reg_name_search (const struct pd_reg
*regs
, int regcount
, const char *name
)
214 int middle
, low
, high
;
222 middle
= (low
+ high
) / 2;
223 cmp
= strcasecmp (name
, regs
[middle
].name
);
229 return regs
[middle
].value
;
238 * Summary of register_name().
240 * in: Input_line_pointer points to 1st char of operand.
242 * out: A expressionS.
243 * The operand may have been a register: in this case, X_op == O_register,
244 * X_add_number is set to the register number, and truth is returned.
245 * Input_line_pointer->(next non-blank) char after operand, or is in its
250 register_name (expressionS
*expressionP
)
257 /* Find the spelling of the operand. */
258 start
= name
= input_line_pointer
;
259 if (name
[0] == '%' && ISALPHA (name
[1]))
260 name
= ++input_line_pointer
;
264 c
= get_symbol_end ();
265 reg_number
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
, name
);
267 /* Put back the delimiting char. */
268 *input_line_pointer
= c
;
270 /* Look to see if it's in the register table. */
273 expressionP
->X_op
= O_register
;
274 expressionP
->X_add_number
= reg_number
;
276 /* Make the rest nice. */
277 expressionP
->X_add_symbol
= NULL
;
278 expressionP
->X_op_symbol
= NULL
;
282 /* Reset the line as if we had not done anything. */
283 input_line_pointer
= start
;
287 /* Local variables. */
289 /* Opformat hash table. */
290 static struct hash_control
*s390_opformat_hash
;
292 /* Opcode hash table. */
293 static struct hash_control
*s390_opcode_hash
;
295 /* Flags to set in the elf header */
296 static flagword s390_flags
= 0;
298 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE_" */
300 #ifndef WORKING_DOT_WORD
301 int md_short_jump_size
= 4;
302 int md_long_jump_size
= 4;
305 const char *md_shortopts
= "A:m:kVQ:";
306 struct option md_longopts
[] = {
307 {NULL
, no_argument
, NULL
, 0}
309 size_t md_longopts_size
= sizeof (md_longopts
);
311 /* Initialize the default opcode arch and word size from the default
312 architecture name if not specified by an option. */
314 init_default_arch (void)
316 if (strcmp (default_arch
, "s390") == 0)
318 if (s390_arch_size
== 0)
321 else if (strcmp (default_arch
, "s390x") == 0)
323 if (s390_arch_size
== 0)
327 as_fatal (_("Invalid default architecture, broken assembler."));
329 if (current_mode_mask
== 0)
331 if (s390_arch_size
== 32)
332 current_mode_mask
= 1 << S390_OPCODE_ESA
;
334 current_mode_mask
= 1 << S390_OPCODE_ZARCH
;
336 if (current_cpu
== -1U)
338 if (current_mode_mask
== (1 << S390_OPCODE_ESA
))
339 current_cpu
= S390_OPCODE_G5
;
341 current_cpu
= S390_OPCODE_Z900
;
345 /* Called by TARGET_FORMAT. */
347 s390_target_format (void)
349 /* We don't get a chance to initialize anything before we're called,
350 so handle that now. */
351 init_default_arch ();
353 return s390_arch_size
== 64 ? "elf64-s390" : "elf32-s390";
357 md_parse_option (int c
, char *arg
)
361 /* -k: Ignore for FreeBSD compatibility. */
365 if (arg
!= NULL
&& strcmp (arg
, "regnames") == 0)
368 else if (arg
!= NULL
&& strcmp (arg
, "no-regnames") == 0)
371 else if (arg
!= NULL
&& strcmp (arg
, "warn-areg-zero") == 0)
372 warn_areg_zero
= TRUE
;
374 else if (arg
!= NULL
&& strcmp (arg
, "31") == 0)
377 else if (arg
!= NULL
&& strcmp (arg
, "64") == 0)
380 else if (arg
!= NULL
&& strcmp (arg
, "esa") == 0)
381 current_mode_mask
= 1 << S390_OPCODE_ESA
;
383 else if (arg
!= NULL
&& strcmp (arg
, "zarch") == 0)
384 current_mode_mask
= 1 << S390_OPCODE_ZARCH
;
386 else if (arg
!= NULL
&& strncmp (arg
, "arch=", 5) == 0)
388 if (strcmp (arg
+ 5, "g5") == 0)
389 current_cpu
= S390_OPCODE_G5
;
390 else if (strcmp (arg
+ 5, "g6") == 0)
391 current_cpu
= S390_OPCODE_G6
;
392 else if (strcmp (arg
+ 5, "z900") == 0)
393 current_cpu
= S390_OPCODE_Z900
;
394 else if (strcmp (arg
+ 5, "z990") == 0)
395 current_cpu
= S390_OPCODE_Z990
;
396 else if (strcmp (arg
+ 5, "z9-109") == 0)
397 current_cpu
= S390_OPCODE_Z9_109
;
398 else if (strcmp (arg
+ 5, "z9-ec") == 0)
399 current_cpu
= S390_OPCODE_Z9_EC
;
400 else if (strcmp (arg
+ 5, "z10") == 0)
401 current_cpu
= S390_OPCODE_Z10
;
402 else if (strcmp (arg
+ 5, "z196") == 0)
403 current_cpu
= S390_OPCODE_Z196
;
406 as_bad (_("invalid switch -m%s"), arg
);
413 as_bad (_("invalid switch -m%s"), arg
);
419 /* Option -A is deprecated. Still available for compatibility. */
420 if (arg
!= NULL
&& strcmp (arg
, "esa") == 0)
421 current_cpu
= S390_OPCODE_G5
;
422 else if (arg
!= NULL
&& strcmp (arg
, "esame") == 0)
423 current_cpu
= S390_OPCODE_Z900
;
425 as_bad (_("invalid architecture -A%s"), arg
);
428 /* -V: SVR4 argument to print version ID. */
433 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
434 should be emitted or not. FIXME: Not implemented. */
446 md_show_usage (FILE *stream
)
448 fprintf (stream
, _("\
450 -mregnames Allow symbolic names for registers\n\
451 -mwarn-areg-zero Warn about zero base/index registers\n\
452 -mno-regnames Do not allow symbolic names for registers\n\
453 -m31 Set file format to 31 bit format\n\
454 -m64 Set file format to 64 bit format\n"));
455 fprintf (stream
, _("\
456 -V print assembler version number\n\
457 -Qy, -Qn ignored\n"));
460 /* This function is called when the assembler starts up. It is called
461 after the options have been parsed and the output file has been
467 register const struct s390_opcode
*op
;
468 const struct s390_opcode
*op_end
;
469 bfd_boolean dup_insn
= FALSE
;
472 /* Give a warning if the combination -m64-bit and -Aesa is used. */
473 if (s390_arch_size
== 64 && current_cpu
< S390_OPCODE_Z900
)
474 as_warn (_("The 64 bit file format is used without esame instructions."));
476 s390_cie_data_alignment
= -s390_arch_size
/ 8;
478 /* Set the ELF flags if desired. */
480 bfd_set_private_flags (stdoutput
, s390_flags
);
482 /* Insert the opcode formats into a hash table. */
483 s390_opformat_hash
= hash_new ();
485 op_end
= s390_opformats
+ s390_num_opformats
;
486 for (op
= s390_opformats
; op
< op_end
; op
++)
488 retval
= hash_insert (s390_opformat_hash
, op
->name
, (void *) op
);
489 if (retval
!= (const char *) NULL
)
491 as_bad (_("Internal assembler error for instruction format %s"),
497 /* Insert the opcodes into a hash table. */
498 s390_opcode_hash
= hash_new ();
500 op_end
= s390_opcodes
+ s390_num_opcodes
;
501 for (op
= s390_opcodes
; op
< op_end
; op
++)
503 while (op
< op_end
- 1 && strcmp(op
->name
, op
[1].name
) == 0)
505 if (op
->min_cpu
<= current_cpu
&& (op
->modes
& current_mode_mask
))
510 if (op
->min_cpu
<= current_cpu
&& (op
->modes
& current_mode_mask
))
512 retval
= hash_insert (s390_opcode_hash
, op
->name
, (void *) op
);
513 if (retval
!= (const char *) NULL
)
515 as_bad (_("Internal assembler error for instruction %s"),
521 while (op
< op_end
- 1 && strcmp (op
->name
, op
[1].name
) == 0)
528 record_alignment (text_section
, 2);
529 record_alignment (data_section
, 2);
530 record_alignment (bss_section
, 2);
534 /* Called after all assembly has been done. */
538 if (s390_arch_size
== 64)
539 bfd_set_arch_mach (stdoutput
, bfd_arch_s390
, bfd_mach_s390_64
);
541 bfd_set_arch_mach (stdoutput
, bfd_arch_s390
, bfd_mach_s390_31
);
544 /* Insert an operand value into an instruction. */
547 s390_insert_operand (unsigned char *insn
,
548 const struct s390_operand
*operand
,
556 if (operand
->flags
& (S390_OPERAND_SIGNED
|S390_OPERAND_PCREL
))
560 max
= ((offsetT
) 1 << (operand
->bits
- 1)) - 1;
561 min
= - ((offsetT
) 1 << (operand
->bits
- 1));
562 /* Halve PCREL operands. */
563 if (operand
->flags
& S390_OPERAND_PCREL
)
565 /* Check for underflow / overflow. */
566 if (val
< min
|| val
> max
)
569 _("operand out of range (%s not between %ld and %ld)");
572 if (operand
->flags
& S390_OPERAND_PCREL
)
578 sprint_value (buf
, val
);
579 if (file
== (char *) NULL
)
580 as_bad (err
, buf
, (int) min
, (int) max
);
582 as_bad_where (file
, line
, err
, buf
, (int) min
, (int) max
);
585 /* val is ok, now restrict it to operand->bits bits. */
586 uval
= (addressT
) val
& ((((addressT
) 1 << (operand
->bits
-1)) << 1) - 1);
587 /* val is restrict, now check for special case. */
588 if (operand
->bits
== 20 && operand
->shift
== 20)
589 uval
= (uval
>> 12) | ((uval
& 0xfff) << 8);
595 max
= (((addressT
) 1 << (operand
->bits
- 1)) << 1) - 1;
597 uval
= (addressT
) val
;
598 /* Length x in an instructions has real length x+1. */
599 if (operand
->flags
& S390_OPERAND_LENGTH
)
601 /* Check for underflow / overflow. */
602 if (uval
< min
|| uval
> max
)
604 if (operand
->flags
& S390_OPERAND_LENGTH
)
611 as_bad_value_out_of_range (_("operand"), uval
, (offsetT
) min
, (offsetT
) max
, file
, line
);
617 /* Insert fragments of the operand byte for byte. */
618 offset
= operand
->shift
+ operand
->bits
;
619 uval
<<= (-offset
) & 7;
620 insn
+= (offset
- 1) / 8;
632 bfd_reloc_code_real_type reloc
;
635 /* Parse tls marker and return the desired relocation. */
636 static bfd_reloc_code_real_type
637 s390_tls_suffix (char **str_p
, expressionS
*exp_p
)
639 static struct map_tls mapping
[] =
641 { "tls_load", 8, BFD_RELOC_390_TLS_LOAD
},
642 { "tls_gdcall", 10, BFD_RELOC_390_TLS_GDCALL
},
643 { "tls_ldcall", 10, BFD_RELOC_390_TLS_LDCALL
},
644 { NULL
, 0, BFD_RELOC_UNUSED
}
654 return BFD_RELOC_UNUSED
;
657 while (ISIDNUM (*str
))
661 return BFD_RELOC_UNUSED
;
663 orig_line
= input_line_pointer
;
664 input_line_pointer
= str
;
666 str
= input_line_pointer
;
667 if (&input_line_pointer
!= str_p
)
668 input_line_pointer
= orig_line
;
670 if (exp_p
->X_op
!= O_symbol
)
671 return BFD_RELOC_UNUSED
;
673 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
674 if (len
== ptr
->length
675 && strncasecmp (ident
, ptr
->string
, ptr
->length
) == 0)
677 /* Found a matching tls suffix. */
681 return BFD_RELOC_UNUSED
;
684 /* Structure used to hold suffixes. */
695 ELF_SUFFIX_TLS_GOTIE
,
707 elf_suffix_type suffix
;
711 /* Parse @got/@plt/@gotoff. and return the desired relocation. */
712 static elf_suffix_type
713 s390_elf_suffix (char **str_p
, expressionS
*exp_p
)
715 static struct map_bfd mapping
[] =
717 { "got", 3, ELF_SUFFIX_GOT
},
718 { "got12", 5, ELF_SUFFIX_GOT
},
719 { "plt", 3, ELF_SUFFIX_PLT
},
720 { "gotent", 6, ELF_SUFFIX_GOTENT
},
721 { "gotoff", 6, ELF_SUFFIX_GOTOFF
},
722 { "gotplt", 6, ELF_SUFFIX_GOTPLT
},
723 { "pltoff", 6, ELF_SUFFIX_PLTOFF
},
724 { "tlsgd", 5, ELF_SUFFIX_TLS_GD
},
725 { "gotntpoff", 9, ELF_SUFFIX_TLS_GOTIE
},
726 { "indntpoff", 9, ELF_SUFFIX_TLS_IE
},
727 { "tlsldm", 6, ELF_SUFFIX_TLS_LDM
},
728 { "dtpoff", 6, ELF_SUFFIX_TLS_LDO
},
729 { "ntpoff", 6, ELF_SUFFIX_TLS_LE
},
730 { NULL
, 0, ELF_SUFFIX_NONE
}
739 return ELF_SUFFIX_NONE
;
742 while (ISALNUM (*str
))
746 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
747 if (len
== ptr
->length
748 && strncasecmp (ident
, ptr
->string
, ptr
->length
) == 0)
750 if (exp_p
->X_add_number
!= 0)
751 as_warn (_("identifier+constant@%s means identifier@%s+constant"),
752 ptr
->string
, ptr
->string
);
753 /* Now check for identifier@suffix+constant. */
754 if (*str
== '-' || *str
== '+')
756 char *orig_line
= input_line_pointer
;
759 input_line_pointer
= str
;
760 expression (&new_exp
);
762 switch (new_exp
.X_op
)
764 case O_constant
: /* X_add_number (a constant expression). */
765 exp_p
->X_add_number
+= new_exp
.X_add_number
;
766 str
= input_line_pointer
;
768 case O_symbol
: /* X_add_symbol + X_add_number. */
769 /* this case is used for e.g. xyz@PLT+.Label. */
770 exp_p
->X_add_number
+= new_exp
.X_add_number
;
771 exp_p
->X_op_symbol
= new_exp
.X_add_symbol
;
773 str
= input_line_pointer
;
775 case O_uminus
: /* (- X_add_symbol) + X_add_number. */
776 /* this case is used for e.g. xyz@PLT-.Label. */
777 exp_p
->X_add_number
+= new_exp
.X_add_number
;
778 exp_p
->X_op_symbol
= new_exp
.X_add_symbol
;
779 exp_p
->X_op
= O_subtract
;
780 str
= input_line_pointer
;
786 /* If s390_elf_suffix has not been called with
787 &input_line_pointer as first parameter, we have
788 clobbered the input_line_pointer. We have to
790 if (&input_line_pointer
!= str_p
)
791 input_line_pointer
= orig_line
;
797 return BFD_RELOC_UNUSED
;
800 /* Structure used to hold a literal pool entry. */
803 struct s390_lpe
*next
;
805 FLONUM_TYPE floatnum
; /* used if X_op == O_big && X_add_number <= 0 */
806 LITTLENUM_TYPE bignum
[4]; /* used if X_op == O_big && X_add_number > 0 */
808 bfd_reloc_code_real_type reloc
;
812 static struct s390_lpe
*lpe_free_list
= NULL
;
813 static struct s390_lpe
*lpe_list
= NULL
;
814 static struct s390_lpe
*lpe_list_tail
= NULL
;
815 static symbolS
*lp_sym
= NULL
;
816 static int lp_count
= 0;
817 static int lpe_count
= 0;
820 s390_exp_compare (expressionS
*exp1
, expressionS
*exp2
)
822 if (exp1
->X_op
!= exp2
->X_op
)
827 case O_constant
: /* X_add_number must be equal. */
829 return exp1
->X_add_number
== exp2
->X_add_number
;
832 as_bad (_("Can't handle O_big in s390_exp_compare"));
834 case O_symbol
: /* X_add_symbol & X_add_number must be equal. */
839 return (exp1
->X_add_symbol
== exp2
->X_add_symbol
)
840 && (exp1
->X_add_number
== exp2
->X_add_number
);
842 case O_multiply
: /* X_add_symbol,X_op_symbol&X_add_number must be equal. */
847 case O_bit_inclusive_or
:
849 case O_bit_exclusive_or
:
861 return (exp1
->X_add_symbol
== exp2
->X_add_symbol
)
862 && (exp1
->X_op_symbol
== exp2
->X_op_symbol
)
863 && (exp1
->X_add_number
== exp2
->X_add_number
);
869 /* Test for @lit and if its present make an entry in the literal pool and
870 modify the current expression to be an offset into the literal pool. */
871 static elf_suffix_type
872 s390_lit_suffix (char **str_p
, expressionS
*exp_p
, elf_suffix_type suffix
)
874 bfd_reloc_code_real_type reloc
;
878 struct s390_lpe
*lpe
;
882 return suffix
; /* No modification. */
884 /* We look for a suffix of the form "@lit1", "@lit2", "@lit4" or "@lit8". */
886 while (ISALNUM (*str
))
889 if (len
!= 4 || strncasecmp (ident
, "lit", 3) != 0
890 || (ident
[3]!='1' && ident
[3]!='2' && ident
[3]!='4' && ident
[3]!='8'))
891 return suffix
; /* no modification */
892 nbytes
= ident
[3] - '0';
894 reloc
= BFD_RELOC_UNUSED
;
895 if (suffix
== ELF_SUFFIX_GOT
)
898 reloc
= BFD_RELOC_390_GOT16
;
899 else if (nbytes
== 4)
900 reloc
= BFD_RELOC_32_GOT_PCREL
;
901 else if (nbytes
== 8)
902 reloc
= BFD_RELOC_390_GOT64
;
904 else if (suffix
== ELF_SUFFIX_PLT
)
907 reloc
= BFD_RELOC_390_PLT32
;
908 else if (nbytes
== 8)
909 reloc
= BFD_RELOC_390_PLT64
;
912 if (suffix
!= ELF_SUFFIX_NONE
&& reloc
== BFD_RELOC_UNUSED
)
913 as_bad (_("Invalid suffix for literal pool entry"));
915 /* Search the pool if the new entry is a duplicate. */
916 if (exp_p
->X_op
== O_big
)
918 /* Special processing for big numbers. */
919 for (lpe
= lpe_list
; lpe
!= NULL
; lpe
= lpe
->next
)
921 if (lpe
->ex
.X_op
== O_big
)
923 if (exp_p
->X_add_number
<= 0 && lpe
->ex
.X_add_number
<= 0)
925 if (memcmp (&generic_floating_point_number
, &lpe
->floatnum
,
926 sizeof (FLONUM_TYPE
)) == 0)
929 else if (exp_p
->X_add_number
== lpe
->ex
.X_add_number
)
931 if (memcmp (generic_bignum
, lpe
->bignum
,
932 sizeof (LITTLENUM_TYPE
)*exp_p
->X_add_number
) == 0)
940 /* Processing for 'normal' data types. */
941 for (lpe
= lpe_list
; lpe
!= NULL
; lpe
= lpe
->next
)
942 if (lpe
->nbytes
== nbytes
&& lpe
->reloc
== reloc
943 && s390_exp_compare (exp_p
, &lpe
->ex
) != 0)
950 if (lpe_free_list
!= NULL
)
953 lpe_free_list
= lpe_free_list
->next
;
957 lpe
= (struct s390_lpe
*) xmalloc (sizeof (struct s390_lpe
));
962 if (exp_p
->X_op
== O_big
)
964 if (exp_p
->X_add_number
<= 0)
965 lpe
->floatnum
= generic_floating_point_number
;
966 else if (exp_p
->X_add_number
<= 4)
967 memcpy (lpe
->bignum
, generic_bignum
,
968 exp_p
->X_add_number
* sizeof (LITTLENUM_TYPE
));
970 as_bad (_("Big number is too big"));
973 lpe
->nbytes
= nbytes
;
975 /* Literal pool name defined ? */
978 sprintf (tmp_name
, ".L\001%i", lp_count
);
979 lp_sym
= symbol_make (tmp_name
);
982 /* Make name for literal pool entry. */
983 sprintf (tmp_name
, ".L\001%i\002%i", lp_count
, lpe_count
);
985 lpe
->sym
= symbol_make (tmp_name
);
987 /* Add to literal pool list. */
989 if (lpe_list_tail
!= NULL
)
991 lpe_list_tail
->next
= lpe
;
995 lpe_list
= lpe_list_tail
= lpe
;
998 /* Now change exp_p to the offset into the literal pool.
999 Thats the expression: .L^Ax^By-.L^Ax */
1000 exp_p
->X_add_symbol
= lpe
->sym
;
1001 exp_p
->X_op_symbol
= lp_sym
;
1002 exp_p
->X_op
= O_subtract
;
1003 exp_p
->X_add_number
= 0;
1007 /* We change the suffix type to ELF_SUFFIX_NONE, because
1008 the difference of two local labels is just a number. */
1009 return ELF_SUFFIX_NONE
;
1012 /* Like normal .long/.short/.word, except support @got, etc.
1013 clobbers input_line_pointer, checks end-of-line. */
1015 s390_elf_cons (int nbytes
/* 1=.byte, 2=.word, 4=.long */)
1018 elf_suffix_type suffix
;
1020 if (is_it_end_of_statement ())
1022 demand_empty_rest_of_line ();
1030 if (exp
.X_op
== O_symbol
1031 && *input_line_pointer
== '@'
1032 && (suffix
= s390_elf_suffix (&input_line_pointer
, &exp
)) != ELF_SUFFIX_NONE
)
1034 bfd_reloc_code_real_type reloc
;
1035 reloc_howto_type
*reloc_howto
;
1041 static bfd_reloc_code_real_type tab2
[] =
1043 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_NONE */
1044 BFD_RELOC_390_GOT16
, /* ELF_SUFFIX_GOT */
1045 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_PLT */
1046 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTENT */
1047 BFD_RELOC_16_GOTOFF
, /* ELF_SUFFIX_GOTOFF */
1048 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTPLT */
1049 BFD_RELOC_390_PLTOFF16
, /* ELF_SUFFIX_PLTOFF */
1050 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_GD */
1051 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_GOTIE */
1052 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_IE */
1053 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_LDM */
1054 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_LDO */
1055 BFD_RELOC_UNUSED
/* ELF_SUFFIX_TLS_LE */
1057 reloc
= tab2
[suffix
];
1059 else if (nbytes
== 4)
1061 static bfd_reloc_code_real_type tab4
[] =
1063 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_NONE */
1064 BFD_RELOC_32_GOT_PCREL
, /* ELF_SUFFIX_GOT */
1065 BFD_RELOC_390_PLT32
, /* ELF_SUFFIX_PLT */
1066 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTENT */
1067 BFD_RELOC_32_GOTOFF
, /* ELF_SUFFIX_GOTOFF */
1068 BFD_RELOC_390_GOTPLT32
, /* ELF_SUFFIX_GOTPLT */
1069 BFD_RELOC_390_PLTOFF32
, /* ELF_SUFFIX_PLTOFF */
1070 BFD_RELOC_390_TLS_GD32
, /* ELF_SUFFIX_TLS_GD */
1071 BFD_RELOC_390_TLS_GOTIE32
, /* ELF_SUFFIX_TLS_GOTIE */
1072 BFD_RELOC_390_TLS_IE32
, /* ELF_SUFFIX_TLS_IE */
1073 BFD_RELOC_390_TLS_LDM32
, /* ELF_SUFFIX_TLS_LDM */
1074 BFD_RELOC_390_TLS_LDO32
, /* ELF_SUFFIX_TLS_LDO */
1075 BFD_RELOC_390_TLS_LE32
/* ELF_SUFFIX_TLS_LE */
1077 reloc
= tab4
[suffix
];
1079 else if (nbytes
== 8)
1081 static bfd_reloc_code_real_type tab8
[] =
1083 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_NONE */
1084 BFD_RELOC_390_GOT64
, /* ELF_SUFFIX_GOT */
1085 BFD_RELOC_390_PLT64
, /* ELF_SUFFIX_PLT */
1086 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTENT */
1087 BFD_RELOC_390_GOTOFF64
, /* ELF_SUFFIX_GOTOFF */
1088 BFD_RELOC_390_GOTPLT64
, /* ELF_SUFFIX_GOTPLT */
1089 BFD_RELOC_390_PLTOFF64
, /* ELF_SUFFIX_PLTOFF */
1090 BFD_RELOC_390_TLS_GD64
, /* ELF_SUFFIX_TLS_GD */
1091 BFD_RELOC_390_TLS_GOTIE64
, /* ELF_SUFFIX_TLS_GOTIE */
1092 BFD_RELOC_390_TLS_IE64
, /* ELF_SUFFIX_TLS_IE */
1093 BFD_RELOC_390_TLS_LDM64
, /* ELF_SUFFIX_TLS_LDM */
1094 BFD_RELOC_390_TLS_LDO64
, /* ELF_SUFFIX_TLS_LDO */
1095 BFD_RELOC_390_TLS_LE64
/* ELF_SUFFIX_TLS_LE */
1097 reloc
= tab8
[suffix
];
1100 reloc
= BFD_RELOC_UNUSED
;
1102 if (reloc
!= BFD_RELOC_UNUSED
1103 && (reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
)))
1105 size
= bfd_get_reloc_size (reloc_howto
);
1107 as_bad (_("%s relocations do not fit in %d bytes"),
1108 reloc_howto
->name
, nbytes
);
1109 where
= frag_more (nbytes
);
1110 md_number_to_chars (where
, 0, size
);
1111 /* To make fixup_segment do the pc relative conversion the
1112 pcrel parameter on the fix_new_exp call needs to be FALSE. */
1113 fix_new_exp (frag_now
, where
- frag_now
->fr_literal
,
1114 size
, &exp
, FALSE
, reloc
);
1117 as_bad (_("relocation not applicable"));
1120 emit_expr (&exp
, (unsigned int) nbytes
);
1122 while (*input_line_pointer
++ == ',');
1124 input_line_pointer
--; /* Put terminator back into stream. */
1125 demand_empty_rest_of_line ();
1128 /* We need to keep a list of fixups. We can't simply generate them as
1129 we go, because that would require us to first create the frag, and
1130 that would screw up references to ``.''. */
1136 bfd_reloc_code_real_type reloc
;
1139 #define MAX_INSN_FIXUPS (4)
1141 /* This routine is called for each instruction to be assembled. */
1144 md_gather_operands (char *str
,
1145 unsigned char *insn
,
1146 const struct s390_opcode
*opcode
)
1148 struct s390_fixup fixups
[MAX_INSN_FIXUPS
];
1149 const struct s390_operand
*operand
;
1150 const unsigned char *opindex_ptr
;
1152 elf_suffix_type suffix
;
1153 bfd_reloc_code_real_type reloc
;
1158 while (ISSPACE (*str
))
1163 /* Gather the operands. */
1165 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
1169 operand
= s390_operands
+ *opindex_ptr
;
1171 if (skip_optional
&& (operand
->flags
& S390_OPERAND_INDEX
))
1173 /* We do an early skip. For D(X,B) constructions the index
1174 register is skipped (X is optional). For D(L,B) the base
1175 register will be the skipped operand, because L is NOT
1181 /* Gather the operand. */
1182 hold
= input_line_pointer
;
1183 input_line_pointer
= str
;
1185 /* Parse the operand. */
1186 if (! register_name (&ex
))
1189 str
= input_line_pointer
;
1190 input_line_pointer
= hold
;
1192 /* Write the operand to the insn. */
1193 if (ex
.X_op
== O_illegal
)
1194 as_bad (_("illegal operand"));
1195 else if (ex
.X_op
== O_absent
)
1197 /* No operands, check if all operands can be skipped. */
1198 while (*opindex_ptr
!= 0 && operand
->flags
& S390_OPERAND_OPTIONAL
)
1200 if (operand
->flags
& S390_OPERAND_DISP
)
1202 /* An optional displacement makes the whole D(X,B)
1203 D(L,B) or D(B) block optional. */
1205 operand
= s390_operands
+ *(++opindex_ptr
);
1206 } while (!(operand
->flags
& S390_OPERAND_BASE
));
1208 operand
= s390_operands
+ *(++opindex_ptr
);
1210 if (opindex_ptr
[0] == '\0')
1212 as_bad (_("missing operand"));
1214 else if (ex
.X_op
== O_register
|| ex
.X_op
== O_constant
)
1216 s390_lit_suffix (&str
, &ex
, ELF_SUFFIX_NONE
);
1218 if (ex
.X_op
!= O_register
&& ex
.X_op
!= O_constant
)
1220 /* We need to generate a fixup for the
1221 expression returned by s390_lit_suffix. */
1222 if (fc
>= MAX_INSN_FIXUPS
)
1223 as_fatal (_("too many fixups"));
1224 fixups
[fc
].exp
= ex
;
1225 fixups
[fc
].opindex
= *opindex_ptr
;
1226 fixups
[fc
].reloc
= BFD_RELOC_UNUSED
;
1231 if ((operand
->flags
& S390_OPERAND_INDEX
)
1232 && ex
.X_add_number
== 0
1234 as_warn (_("index register specified but zero"));
1235 if ((operand
->flags
& S390_OPERAND_BASE
)
1236 && ex
.X_add_number
== 0
1238 as_warn (_("base register specified but zero"));
1239 s390_insert_operand (insn
, operand
, ex
.X_add_number
, NULL
, 0);
1244 suffix
= s390_elf_suffix (&str
, &ex
);
1245 suffix
= s390_lit_suffix (&str
, &ex
, suffix
);
1246 reloc
= BFD_RELOC_UNUSED
;
1248 if (suffix
== ELF_SUFFIX_GOT
)
1250 if ((operand
->flags
& S390_OPERAND_DISP
) &&
1251 (operand
->bits
== 12))
1252 reloc
= BFD_RELOC_390_GOT12
;
1253 else if ((operand
->flags
& S390_OPERAND_DISP
) &&
1254 (operand
->bits
== 20))
1255 reloc
= BFD_RELOC_390_GOT20
;
1256 else if ((operand
->flags
& S390_OPERAND_SIGNED
)
1257 && (operand
->bits
== 16))
1258 reloc
= BFD_RELOC_390_GOT16
;
1259 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1260 && (operand
->bits
== 32))
1261 reloc
= BFD_RELOC_390_GOTENT
;
1263 else if (suffix
== ELF_SUFFIX_PLT
)
1265 if ((operand
->flags
& S390_OPERAND_PCREL
)
1266 && (operand
->bits
== 16))
1267 reloc
= BFD_RELOC_390_PLT16DBL
;
1268 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1269 && (operand
->bits
== 32))
1270 reloc
= BFD_RELOC_390_PLT32DBL
;
1272 else if (suffix
== ELF_SUFFIX_GOTENT
)
1274 if ((operand
->flags
& S390_OPERAND_PCREL
)
1275 && (operand
->bits
== 32))
1276 reloc
= BFD_RELOC_390_GOTENT
;
1278 else if (suffix
== ELF_SUFFIX_GOTOFF
)
1280 if ((operand
->flags
& S390_OPERAND_SIGNED
)
1281 && (operand
->bits
== 16))
1282 reloc
= BFD_RELOC_16_GOTOFF
;
1284 else if (suffix
== ELF_SUFFIX_PLTOFF
)
1286 if ((operand
->flags
& S390_OPERAND_SIGNED
)
1287 && (operand
->bits
== 16))
1288 reloc
= BFD_RELOC_390_PLTOFF16
;
1290 else if (suffix
== ELF_SUFFIX_GOTPLT
)
1292 if ((operand
->flags
& S390_OPERAND_DISP
)
1293 && (operand
->bits
== 12))
1294 reloc
= BFD_RELOC_390_GOTPLT12
;
1295 else if ((operand
->flags
& S390_OPERAND_SIGNED
)
1296 && (operand
->bits
== 16))
1297 reloc
= BFD_RELOC_390_GOTPLT16
;
1298 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1299 && (operand
->bits
== 32))
1300 reloc
= BFD_RELOC_390_GOTPLTENT
;
1302 else if (suffix
== ELF_SUFFIX_TLS_GOTIE
)
1304 if ((operand
->flags
& S390_OPERAND_DISP
)
1305 && (operand
->bits
== 12))
1306 reloc
= BFD_RELOC_390_TLS_GOTIE12
;
1307 else if ((operand
->flags
& S390_OPERAND_DISP
)
1308 && (operand
->bits
== 20))
1309 reloc
= BFD_RELOC_390_TLS_GOTIE20
;
1311 else if (suffix
== ELF_SUFFIX_TLS_IE
)
1313 if ((operand
->flags
& S390_OPERAND_PCREL
)
1314 && (operand
->bits
== 32))
1315 reloc
= BFD_RELOC_390_TLS_IEENT
;
1318 if (suffix
!= ELF_SUFFIX_NONE
&& reloc
== BFD_RELOC_UNUSED
)
1319 as_bad (_("invalid operand suffix"));
1320 /* We need to generate a fixup of type 'reloc' for this
1322 if (fc
>= MAX_INSN_FIXUPS
)
1323 as_fatal (_("too many fixups"));
1324 fixups
[fc
].exp
= ex
;
1325 fixups
[fc
].opindex
= *opindex_ptr
;
1326 fixups
[fc
].reloc
= reloc
;
1330 /* Check the next character. The call to expression has advanced
1331 str past any whitespace. */
1332 if (operand
->flags
& S390_OPERAND_DISP
)
1334 /* After a displacement a block in parentheses can start. */
1337 /* Check if parenthesized block can be skipped. If the next
1338 operand is neiter an optional operand nor a base register
1339 then we have a syntax error. */
1340 operand
= s390_operands
+ *(++opindex_ptr
);
1341 if (!(operand
->flags
& (S390_OPERAND_INDEX
|S390_OPERAND_BASE
)))
1342 as_bad (_("syntax error; missing '(' after displacement"));
1344 /* Ok, skip all operands until S390_OPERAND_BASE. */
1345 while (!(operand
->flags
& S390_OPERAND_BASE
))
1346 operand
= s390_operands
+ *(++opindex_ptr
);
1348 /* If there is a next operand it must be separated by a comma. */
1349 if (opindex_ptr
[1] != '\0')
1353 while (opindex_ptr
[1] != '\0')
1355 operand
= s390_operands
+ *(++opindex_ptr
);
1356 if (operand
->flags
& S390_OPERAND_OPTIONAL
)
1358 as_bad (_("syntax error; expected ,"));
1368 /* We found an opening parentheses. */
1370 for (f
= str
; *f
!= '\0'; f
++)
1371 if (*f
== ',' || *f
== ')')
1373 /* If there is no comma until the closing parentheses OR
1374 there is a comma right after the opening parentheses,
1375 we have to skip optional operands. */
1376 if (*f
== ',' && f
== str
)
1378 /* comma directly after '(' ? */
1383 skip_optional
= (*f
!= ',');
1386 else if (operand
->flags
& S390_OPERAND_BASE
)
1388 /* After the base register the parenthesed block ends. */
1390 as_bad (_("syntax error; missing ')' after base register"));
1392 /* If there is a next operand it must be separated by a comma. */
1393 if (opindex_ptr
[1] != '\0')
1397 while (opindex_ptr
[1] != '\0')
1399 operand
= s390_operands
+ *(++opindex_ptr
);
1400 if (operand
->flags
& S390_OPERAND_OPTIONAL
)
1402 as_bad (_("syntax error; expected ,"));
1412 /* We can find an 'early' closing parentheses in e.g. D(L) instead
1413 of D(L,B). In this case the base register has to be skipped. */
1416 operand
= s390_operands
+ *(++opindex_ptr
);
1418 if (!(operand
->flags
& S390_OPERAND_BASE
))
1419 as_bad (_("syntax error; ')' not allowed here"));
1422 /* If there is a next operand it must be separated by a comma. */
1423 if (opindex_ptr
[1] != '\0')
1427 while (opindex_ptr
[1] != '\0')
1429 operand
= s390_operands
+ *(++opindex_ptr
);
1430 if (operand
->flags
& S390_OPERAND_OPTIONAL
)
1432 as_bad (_("syntax error; expected ,"));
1442 while (ISSPACE (*str
))
1445 /* Check for tls instruction marker. */
1446 reloc
= s390_tls_suffix (&str
, &ex
);
1447 if (reloc
!= BFD_RELOC_UNUSED
)
1449 /* We need to generate a fixup of type 'reloc' for this
1451 if (fc
>= MAX_INSN_FIXUPS
)
1452 as_fatal (_("too many fixups"));
1453 fixups
[fc
].exp
= ex
;
1454 fixups
[fc
].opindex
= -1;
1455 fixups
[fc
].reloc
= reloc
;
1463 if ((linefeed
= strchr (str
, '\n')) != NULL
)
1465 as_bad (_("junk at end of line: `%s'"), str
);
1466 if (linefeed
!= NULL
)
1470 /* Write out the instruction. */
1471 f
= frag_more (opcode
->oplen
);
1472 memcpy (f
, insn
, opcode
->oplen
);
1473 dwarf2_emit_insn (opcode
->oplen
);
1475 /* Create any fixups. At this point we do not use a
1476 bfd_reloc_code_real_type, but instead just use the
1477 BFD_RELOC_UNUSED plus the operand index. This lets us easily
1478 handle fixups for any operand type, although that is admittedly
1479 not a very exciting feature. We pick a BFD reloc type in
1481 for (i
= 0; i
< fc
; i
++)
1484 if (fixups
[i
].opindex
< 0)
1486 /* Create tls instruction marker relocation. */
1487 fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, opcode
->oplen
,
1488 &fixups
[i
].exp
, 0, fixups
[i
].reloc
);
1492 operand
= s390_operands
+ fixups
[i
].opindex
;
1494 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
1496 reloc_howto_type
*reloc_howto
;
1500 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
1504 size
= bfd_get_reloc_size (reloc_howto
);
1506 if (size
< 1 || size
> 4)
1509 fixP
= fix_new_exp (frag_now
,
1510 f
- frag_now
->fr_literal
+ (operand
->shift
/8),
1511 size
, &fixups
[i
].exp
, reloc_howto
->pc_relative
,
1513 /* Turn off overflow checking in fixup_segment. This is necessary
1514 because fixup_segment will signal an overflow for large 4 byte
1515 quantities for GOT12 relocations. */
1516 if ( fixups
[i
].reloc
== BFD_RELOC_390_GOT12
1517 || fixups
[i
].reloc
== BFD_RELOC_390_GOT20
1518 || fixups
[i
].reloc
== BFD_RELOC_390_GOT16
)
1519 fixP
->fx_no_overflow
= 1;
1522 fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, 4, &fixups
[i
].exp
,
1523 (operand
->flags
& S390_OPERAND_PCREL
) != 0,
1524 ((bfd_reloc_code_real_type
)
1525 (fixups
[i
].opindex
+ (int) BFD_RELOC_UNUSED
)));
1530 /* This routine is called for each instruction to be assembled. */
1533 md_assemble (char *str
)
1535 const struct s390_opcode
*opcode
;
1536 unsigned char insn
[6];
1539 /* Get the opcode. */
1540 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
1545 /* Look up the opcode in the hash table. */
1546 opcode
= (struct s390_opcode
*) hash_find (s390_opcode_hash
, str
);
1547 if (opcode
== (const struct s390_opcode
*) NULL
)
1549 as_bad (_("Unrecognized opcode: `%s'"), str
);
1552 else if (!(opcode
->modes
& current_mode_mask
))
1554 as_bad (_("Opcode %s not available in this mode"), str
);
1557 memcpy (insn
, opcode
->opcode
, sizeof (insn
));
1558 md_gather_operands (s
, insn
, opcode
);
1561 #ifndef WORKING_DOT_WORD
1562 /* Handle long and short jumps. We don't support these */
1564 md_create_short_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
1566 addressT from_addr
, to_addr
;
1574 md_create_long_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
1576 addressT from_addr
, to_addr
;
1585 s390_bss (int ignore ATTRIBUTE_UNUSED
)
1587 /* We don't support putting frags in the BSS segment, we fake it
1588 by marking in_bss, then looking at s_skip for clues. */
1590 subseg_set (bss_section
, 0);
1591 demand_empty_rest_of_line ();
1594 /* Pseudo-op handling. */
1597 s390_insn (int ignore ATTRIBUTE_UNUSED
)
1600 const struct s390_opcode
*opformat
;
1601 unsigned char insn
[6];
1604 /* Get the opcode format. */
1605 s
= input_line_pointer
;
1606 while (*s
!= '\0' && *s
!= ',' && ! ISSPACE (*s
))
1609 as_bad (_("Invalid .insn format\n"));
1612 /* Look up the opcode in the hash table. */
1613 opformat
= (struct s390_opcode
*)
1614 hash_find (s390_opformat_hash
, input_line_pointer
);
1615 if (opformat
== (const struct s390_opcode
*) NULL
)
1617 as_bad (_("Unrecognized opcode format: `%s'"), input_line_pointer
);
1620 input_line_pointer
= s
;
1622 if (exp
.X_op
== O_constant
)
1624 if ( ( opformat
->oplen
== 6
1625 && (addressT
) exp
.X_add_number
< (1ULL << 48))
1626 || ( opformat
->oplen
== 4
1627 && (addressT
) exp
.X_add_number
< (1ULL << 32))
1628 || ( opformat
->oplen
== 2
1629 && (addressT
) exp
.X_add_number
< (1ULL << 16)))
1630 md_number_to_chars ((char *) insn
, exp
.X_add_number
, opformat
->oplen
);
1632 as_bad (_("Invalid .insn format\n"));
1634 else if (exp
.X_op
== O_big
)
1636 if (exp
.X_add_number
> 0
1637 && opformat
->oplen
== 6
1638 && generic_bignum
[3] == 0)
1640 md_number_to_chars ((char *) insn
, generic_bignum
[2], 2);
1641 md_number_to_chars ((char *) &insn
[2], generic_bignum
[1], 2);
1642 md_number_to_chars ((char *) &insn
[4], generic_bignum
[0], 2);
1645 as_bad (_("Invalid .insn format\n"));
1648 as_bad (_("second operand of .insn not a constant\n"));
1650 if (strcmp (opformat
->name
, "e") != 0 && *input_line_pointer
++ != ',')
1651 as_bad (_("missing comma after insn constant\n"));
1653 if ((s
= strchr (input_line_pointer
, '\n')) != NULL
)
1655 input_line_pointer
= md_gather_operands (input_line_pointer
, insn
,
1659 demand_empty_rest_of_line ();
1662 /* The .byte pseudo-op. This is similar to the normal .byte
1663 pseudo-op, but it can also take a single ASCII string. */
1666 s390_byte (int ignore ATTRIBUTE_UNUSED
)
1668 if (*input_line_pointer
!= '\"')
1674 /* Gather characters. A real double quote is doubled. Unusual
1675 characters are not permitted. */
1676 ++input_line_pointer
;
1681 c
= *input_line_pointer
++;
1685 if (*input_line_pointer
!= '\"')
1687 ++input_line_pointer
;
1690 FRAG_APPEND_1_CHAR (c
);
1693 demand_empty_rest_of_line ();
1696 /* The .ltorg pseudo-op.This emits all literals defined since the last
1697 .ltorg or the invocation of gas. Literals are defined with the
1701 s390_literals (int ignore ATTRIBUTE_UNUSED
)
1703 struct s390_lpe
*lpe
;
1705 if (lp_sym
== NULL
|| lpe_count
== 0)
1706 return; /* Nothing to be done. */
1708 /* Emit symbol for start of literal pool. */
1709 S_SET_SEGMENT (lp_sym
, now_seg
);
1710 S_SET_VALUE (lp_sym
, (valueT
) frag_now_fix ());
1711 lp_sym
->sy_frag
= frag_now
;
1716 lpe_list
= lpe_list
->next
;
1717 S_SET_SEGMENT (lpe
->sym
, now_seg
);
1718 S_SET_VALUE (lpe
->sym
, (valueT
) frag_now_fix ());
1719 lpe
->sym
->sy_frag
= frag_now
;
1721 /* Emit literal pool entry. */
1722 if (lpe
->reloc
!= BFD_RELOC_UNUSED
)
1724 reloc_howto_type
*reloc_howto
=
1725 bfd_reloc_type_lookup (stdoutput
, lpe
->reloc
);
1726 int size
= bfd_get_reloc_size (reloc_howto
);
1729 if (size
> lpe
->nbytes
)
1730 as_bad (_("%s relocations do not fit in %d bytes"),
1731 reloc_howto
->name
, lpe
->nbytes
);
1732 where
= frag_more (lpe
->nbytes
);
1733 md_number_to_chars (where
, 0, size
);
1734 fix_new_exp (frag_now
, where
- frag_now
->fr_literal
,
1735 size
, &lpe
->ex
, reloc_howto
->pc_relative
, lpe
->reloc
);
1739 if (lpe
->ex
.X_op
== O_big
)
1741 if (lpe
->ex
.X_add_number
<= 0)
1742 generic_floating_point_number
= lpe
->floatnum
;
1744 memcpy (generic_bignum
, lpe
->bignum
,
1745 lpe
->ex
.X_add_number
* sizeof (LITTLENUM_TYPE
));
1747 emit_expr (&lpe
->ex
, lpe
->nbytes
);
1750 lpe
->next
= lpe_free_list
;
1751 lpe_free_list
= lpe
;
1753 lpe_list_tail
= NULL
;
1760 md_atof (int type
, char *litp
, int *sizep
)
1762 return ieee_md_atof (type
, litp
, sizep
, TRUE
);
1765 /* Align a section (I don't know why this is machine dependent). */
1768 md_section_align (asection
*seg
, valueT addr
)
1770 int align
= bfd_get_section_alignment (stdoutput
, seg
);
1772 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
1775 /* We don't have any form of relaxing. */
1778 md_estimate_size_before_relax (fragS
*fragp ATTRIBUTE_UNUSED
,
1779 asection
*seg ATTRIBUTE_UNUSED
)
1785 /* Convert a machine dependent frag. We never generate these. */
1788 md_convert_frag (bfd
*abfd ATTRIBUTE_UNUSED
,
1789 asection
*sec ATTRIBUTE_UNUSED
,
1790 fragS
*fragp ATTRIBUTE_UNUSED
)
1796 md_undefined_symbol (char *name
)
1798 if (*name
== '_' && *(name
+ 1) == 'G'
1799 && strcmp (name
, "_GLOBAL_OFFSET_TABLE_") == 0)
1803 if (symbol_find (name
))
1804 as_bad (_("GOT already in symbol table"));
1805 GOT_symbol
= symbol_new (name
, undefined_section
,
1806 (valueT
) 0, &zero_address_frag
);
1813 /* Functions concerning relocs. */
1815 /* The location from which a PC relative jump should be calculated,
1816 given a PC relative reloc. */
1819 md_pcrel_from_section (fixS
*fixp
, segT sec ATTRIBUTE_UNUSED
)
1821 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
1824 /* Here we decide which fixups can be adjusted to make them relative to
1825 the beginning of the section instead of the symbol. Basically we need
1826 to make sure that the dynamic relocations are done correctly, so in
1827 some cases we force the original symbol to be used. */
1829 tc_s390_fix_adjustable (fixS
*fixP
)
1831 /* Don't adjust references to merge sections. */
1832 if ((S_GET_SEGMENT (fixP
->fx_addsy
)->flags
& SEC_MERGE
) != 0)
1834 /* adjust_reloc_syms doesn't know about the GOT. */
1835 if ( fixP
->fx_r_type
== BFD_RELOC_16_GOTOFF
1836 || fixP
->fx_r_type
== BFD_RELOC_32_GOTOFF
1837 || fixP
->fx_r_type
== BFD_RELOC_390_GOTOFF64
1838 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF16
1839 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF32
1840 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF64
1841 || fixP
->fx_r_type
== BFD_RELOC_390_PLT16DBL
1842 || fixP
->fx_r_type
== BFD_RELOC_390_PLT32
1843 || fixP
->fx_r_type
== BFD_RELOC_390_PLT32DBL
1844 || fixP
->fx_r_type
== BFD_RELOC_390_PLT64
1845 || fixP
->fx_r_type
== BFD_RELOC_390_GOT12
1846 || fixP
->fx_r_type
== BFD_RELOC_390_GOT20
1847 || fixP
->fx_r_type
== BFD_RELOC_390_GOT16
1848 || fixP
->fx_r_type
== BFD_RELOC_32_GOT_PCREL
1849 || fixP
->fx_r_type
== BFD_RELOC_390_GOT64
1850 || fixP
->fx_r_type
== BFD_RELOC_390_GOTENT
1851 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT12
1852 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT16
1853 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT20
1854 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT32
1855 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT64
1856 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLTENT
1857 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LOAD
1858 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GDCALL
1859 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDCALL
1860 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GD32
1861 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GD64
1862 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE12
1863 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE20
1864 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE32
1865 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE64
1866 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDM32
1867 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDM64
1868 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IE32
1869 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IE64
1870 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IEENT
1871 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LE32
1872 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LE64
1873 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDO32
1874 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDO64
1875 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_DTPMOD
1876 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_DTPOFF
1877 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_TPOFF
1878 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
1879 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
1884 /* Return true if we must always emit a reloc for a type and false if
1885 there is some hope of resolving it at assembly time. */
1887 tc_s390_force_relocation (struct fix
*fixp
)
1889 /* Ensure we emit a relocation for every reference to the global
1890 offset table or to the procedure link table. */
1891 switch (fixp
->fx_r_type
)
1893 case BFD_RELOC_390_GOT12
:
1894 case BFD_RELOC_390_GOT20
:
1895 case BFD_RELOC_32_GOT_PCREL
:
1896 case BFD_RELOC_32_GOTOFF
:
1897 case BFD_RELOC_390_GOTOFF64
:
1898 case BFD_RELOC_390_PLTOFF16
:
1899 case BFD_RELOC_390_PLTOFF32
:
1900 case BFD_RELOC_390_PLTOFF64
:
1901 case BFD_RELOC_390_GOTPC
:
1902 case BFD_RELOC_390_GOT16
:
1903 case BFD_RELOC_390_GOTPCDBL
:
1904 case BFD_RELOC_390_GOT64
:
1905 case BFD_RELOC_390_GOTENT
:
1906 case BFD_RELOC_390_PLT32
:
1907 case BFD_RELOC_390_PLT16DBL
:
1908 case BFD_RELOC_390_PLT32DBL
:
1909 case BFD_RELOC_390_PLT64
:
1910 case BFD_RELOC_390_GOTPLT12
:
1911 case BFD_RELOC_390_GOTPLT16
:
1912 case BFD_RELOC_390_GOTPLT20
:
1913 case BFD_RELOC_390_GOTPLT32
:
1914 case BFD_RELOC_390_GOTPLT64
:
1915 case BFD_RELOC_390_GOTPLTENT
:
1921 return generic_force_reloc (fixp
);
1924 /* Apply a fixup to the object code. This is called for all the
1925 fixups we generated by the call to fix_new_exp, above. In the call
1926 above we used a reloc code which was the largest legal reloc code
1927 plus the operand index. Here we undo that to recover the operand
1928 index. At this point all symbol values should be fully resolved,
1929 and we attempt to completely resolve the reloc. If we can not do
1930 that, we determine the correct reloc code and put it back in the
1934 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg ATTRIBUTE_UNUSED
)
1937 valueT value
= *valP
;
1939 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
1941 if (fixP
->fx_subsy
!= NULL
)
1942 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1943 _("cannot emit relocation %s against subsy symbol %s"),
1944 bfd_get_reloc_code_name (fixP
->fx_r_type
),
1945 S_GET_NAME (fixP
->fx_subsy
));
1947 if (fixP
->fx_addsy
!= NULL
)
1950 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
1955 if ((int) fixP
->fx_r_type
>= (int) BFD_RELOC_UNUSED
)
1957 const struct s390_operand
*operand
;
1960 opindex
= (int) fixP
->fx_r_type
- (int) BFD_RELOC_UNUSED
;
1961 operand
= &s390_operands
[opindex
];
1965 /* Insert the fully resolved operand value. */
1966 s390_insert_operand ((unsigned char *) where
, operand
,
1967 (offsetT
) value
, fixP
->fx_file
, fixP
->fx_line
);
1971 /* Determine a BFD reloc value based on the operand information.
1972 We are only prepared to turn a few of the operands into
1974 fixP
->fx_offset
= value
;
1975 if (operand
->bits
== 12 && operand
->shift
== 20)
1978 fixP
->fx_where
+= 2;
1979 fixP
->fx_r_type
= BFD_RELOC_390_12
;
1981 else if (operand
->bits
== 12 && operand
->shift
== 36)
1984 fixP
->fx_where
+= 4;
1985 fixP
->fx_r_type
= BFD_RELOC_390_12
;
1987 else if (operand
->bits
== 20 && operand
->shift
== 20)
1990 fixP
->fx_where
+= 2;
1991 fixP
->fx_r_type
= BFD_RELOC_390_20
;
1993 else if (operand
->bits
== 8 && operand
->shift
== 8)
1996 fixP
->fx_where
+= 1;
1997 fixP
->fx_r_type
= BFD_RELOC_8
;
1999 else if (operand
->bits
== 16 && operand
->shift
== 16)
2002 fixP
->fx_where
+= 2;
2003 if (operand
->flags
& S390_OPERAND_PCREL
)
2005 fixP
->fx_r_type
= BFD_RELOC_390_PC16DBL
;
2006 fixP
->fx_offset
+= 2;
2009 fixP
->fx_r_type
= BFD_RELOC_16
;
2011 else if (operand
->bits
== 32 && operand
->shift
== 16
2012 && (operand
->flags
& S390_OPERAND_PCREL
))
2015 fixP
->fx_where
+= 2;
2016 fixP
->fx_offset
+= 2;
2017 fixP
->fx_r_type
= BFD_RELOC_390_PC32DBL
;
2024 /* Use expr_symbol_where to see if this is an expression
2026 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
2027 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2028 _("unresolved expression that must be resolved"));
2030 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2031 _("unsupported relocation type"));
2038 switch (fixP
->fx_r_type
)
2044 md_number_to_chars (where
, value
, 1);
2046 case BFD_RELOC_390_12
:
2047 case BFD_RELOC_390_GOT12
:
2048 case BFD_RELOC_390_GOTPLT12
:
2053 mop
= bfd_getb16 ((unsigned char *) where
);
2054 mop
|= (unsigned short) (value
& 0xfff);
2055 bfd_putb16 ((bfd_vma
) mop
, (unsigned char *) where
);
2059 case BFD_RELOC_390_20
:
2060 case BFD_RELOC_390_GOT20
:
2061 case BFD_RELOC_390_GOTPLT20
:
2065 mop
= bfd_getb32 ((unsigned char *) where
);
2066 mop
|= (unsigned int) ((value
& 0xfff) << 8 |
2067 (value
& 0xff000) >> 12);
2068 bfd_putb32 ((bfd_vma
) mop
, (unsigned char *) where
);
2073 case BFD_RELOC_GPREL16
:
2074 case BFD_RELOC_16_GOT_PCREL
:
2075 case BFD_RELOC_16_GOTOFF
:
2077 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2078 _("cannot emit PC relative %s relocation%s%s"),
2079 bfd_get_reloc_code_name (fixP
->fx_r_type
),
2080 fixP
->fx_addsy
!= NULL
? " against " : "",
2081 (fixP
->fx_addsy
!= NULL
2082 ? S_GET_NAME (fixP
->fx_addsy
)
2085 md_number_to_chars (where
, value
, 2);
2087 case BFD_RELOC_390_GOT16
:
2088 case BFD_RELOC_390_PLTOFF16
:
2089 case BFD_RELOC_390_GOTPLT16
:
2091 md_number_to_chars (where
, value
, 2);
2093 case BFD_RELOC_390_PC16DBL
:
2094 case BFD_RELOC_390_PLT16DBL
:
2097 md_number_to_chars (where
, (offsetT
) value
>> 1, 2);
2102 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
2104 fixP
->fx_r_type
= BFD_RELOC_32
;
2106 md_number_to_chars (where
, value
, 4);
2108 case BFD_RELOC_32_PCREL
:
2109 case BFD_RELOC_32_BASEREL
:
2110 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
2112 md_number_to_chars (where
, value
, 4);
2114 case BFD_RELOC_32_GOT_PCREL
:
2115 case BFD_RELOC_390_PLTOFF32
:
2116 case BFD_RELOC_390_PLT32
:
2117 case BFD_RELOC_390_GOTPLT32
:
2119 md_number_to_chars (where
, value
, 4);
2121 case BFD_RELOC_390_PC32DBL
:
2122 case BFD_RELOC_390_PLT32DBL
:
2123 case BFD_RELOC_390_GOTPCDBL
:
2124 case BFD_RELOC_390_GOTENT
:
2125 case BFD_RELOC_390_GOTPLTENT
:
2128 md_number_to_chars (where
, (offsetT
) value
>> 1, 4);
2131 case BFD_RELOC_32_GOTOFF
:
2133 md_number_to_chars (where
, value
, sizeof (int));
2136 case BFD_RELOC_390_GOTOFF64
:
2138 md_number_to_chars (where
, value
, 8);
2141 case BFD_RELOC_390_GOT64
:
2142 case BFD_RELOC_390_PLTOFF64
:
2143 case BFD_RELOC_390_PLT64
:
2144 case BFD_RELOC_390_GOTPLT64
:
2146 md_number_to_chars (where
, value
, 8);
2151 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
2153 fixP
->fx_r_type
= BFD_RELOC_64
;
2155 md_number_to_chars (where
, value
, 8);
2158 case BFD_RELOC_64_PCREL
:
2159 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
2161 md_number_to_chars (where
, value
, 8);
2164 case BFD_RELOC_VTABLE_INHERIT
:
2165 case BFD_RELOC_VTABLE_ENTRY
:
2169 case BFD_RELOC_390_TLS_LOAD
:
2170 case BFD_RELOC_390_TLS_GDCALL
:
2171 case BFD_RELOC_390_TLS_LDCALL
:
2172 case BFD_RELOC_390_TLS_GD32
:
2173 case BFD_RELOC_390_TLS_GD64
:
2174 case BFD_RELOC_390_TLS_GOTIE12
:
2175 case BFD_RELOC_390_TLS_GOTIE20
:
2176 case BFD_RELOC_390_TLS_GOTIE32
:
2177 case BFD_RELOC_390_TLS_GOTIE64
:
2178 case BFD_RELOC_390_TLS_LDM32
:
2179 case BFD_RELOC_390_TLS_LDM64
:
2180 case BFD_RELOC_390_TLS_IE32
:
2181 case BFD_RELOC_390_TLS_IE64
:
2182 case BFD_RELOC_390_TLS_LE32
:
2183 case BFD_RELOC_390_TLS_LE64
:
2184 case BFD_RELOC_390_TLS_LDO32
:
2185 case BFD_RELOC_390_TLS_LDO64
:
2186 case BFD_RELOC_390_TLS_DTPMOD
:
2187 case BFD_RELOC_390_TLS_DTPOFF
:
2188 case BFD_RELOC_390_TLS_TPOFF
:
2189 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
2190 /* Fully resolved at link time. */
2192 case BFD_RELOC_390_TLS_IEENT
:
2193 /* Fully resolved at link time. */
2194 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
2200 const char *reloc_name
= bfd_get_reloc_code_name (fixP
->fx_r_type
);
2202 if (reloc_name
!= NULL
)
2203 as_fatal (_("Gas failure, reloc type %s\n"), reloc_name
);
2205 as_fatal (_("Gas failure, reloc type #%i\n"), fixP
->fx_r_type
);
2209 fixP
->fx_offset
= value
;
2213 /* Generate a reloc for a fixup. */
2216 tc_gen_reloc (asection
*seg ATTRIBUTE_UNUSED
, fixS
*fixp
)
2218 bfd_reloc_code_real_type code
;
2221 code
= fixp
->fx_r_type
;
2222 if (GOT_symbol
&& fixp
->fx_addsy
== GOT_symbol
)
2224 if ( (s390_arch_size
== 32 && code
== BFD_RELOC_32_PCREL
)
2225 || (s390_arch_size
== 64 && code
== BFD_RELOC_64_PCREL
))
2226 code
= BFD_RELOC_390_GOTPC
;
2227 if (code
== BFD_RELOC_390_PC32DBL
)
2228 code
= BFD_RELOC_390_GOTPCDBL
;
2231 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
2232 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
2233 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
2234 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
2235 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
2236 if (reloc
->howto
== NULL
)
2238 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2239 _("cannot represent relocation type %s"),
2240 bfd_get_reloc_code_name (code
));
2241 /* Set howto to a garbage value so that we can keep going. */
2242 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, BFD_RELOC_32
);
2243 gas_assert (reloc
->howto
!= NULL
);
2245 reloc
->addend
= fixp
->fx_offset
;
2251 s390_cfi_frame_initial_instructions (void)
2253 cfi_add_CFA_def_cfa (15, s390_arch_size
== 64 ? 160 : 96);
2257 tc_s390_regname_to_dw2regnum (char *regname
)
2261 if (regname
[0] != 'c' && regname
[0] != 'a')
2263 regnum
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
, regname
);
2264 if (regname
[0] == 'f' && regnum
!= -1)
2267 else if (strcmp (regname
, "ap") == 0)
2269 else if (strcmp (regname
, "cc") == 0)
2275 s390_elf_final_processing (void)
2277 if (s390_arch_size
== 32 && (current_mode_mask
& (1 << S390_OPCODE_ZARCH
)))
2278 elf_elfheader (stdoutput
)->e_flags
|= EF_S390_HIGH_GPRS
;