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
;
404 as_bad (_("invalid switch -m%s"), arg
);
411 as_bad (_("invalid switch -m%s"), arg
);
417 /* Option -A is deprecated. Still available for compatibility. */
418 if (arg
!= NULL
&& strcmp (arg
, "esa") == 0)
419 current_cpu
= S390_OPCODE_G5
;
420 else if (arg
!= NULL
&& strcmp (arg
, "esame") == 0)
421 current_cpu
= S390_OPCODE_Z900
;
423 as_bad (_("invalid architecture -A%s"), arg
);
426 /* -V: SVR4 argument to print version ID. */
431 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
432 should be emitted or not. FIXME: Not implemented. */
444 md_show_usage (FILE *stream
)
446 fprintf (stream
, _("\
448 -mregnames Allow symbolic names for registers\n\
449 -mwarn-areg-zero Warn about zero base/index registers\n\
450 -mno-regnames Do not allow symbolic names for registers\n\
451 -m31 Set file format to 31 bit format\n\
452 -m64 Set file format to 64 bit format\n"));
453 fprintf (stream
, _("\
454 -V print assembler version number\n\
455 -Qy, -Qn ignored\n"));
458 /* This function is called when the assembler starts up. It is called
459 after the options have been parsed and the output file has been
465 register const struct s390_opcode
*op
;
466 const struct s390_opcode
*op_end
;
467 bfd_boolean dup_insn
= FALSE
;
470 /* Give a warning if the combination -m64-bit and -Aesa is used. */
471 if (s390_arch_size
== 64 && current_cpu
< S390_OPCODE_Z900
)
472 as_warn (_("The 64 bit file format is used without esame instructions."));
474 s390_cie_data_alignment
= -s390_arch_size
/ 8;
476 /* Set the ELF flags if desired. */
478 bfd_set_private_flags (stdoutput
, s390_flags
);
480 /* Insert the opcode formats into a hash table. */
481 s390_opformat_hash
= hash_new ();
483 op_end
= s390_opformats
+ s390_num_opformats
;
484 for (op
= s390_opformats
; op
< op_end
; op
++)
486 retval
= hash_insert (s390_opformat_hash
, op
->name
, (void *) op
);
487 if (retval
!= (const char *) NULL
)
489 as_bad (_("Internal assembler error for instruction format %s"),
495 /* Insert the opcodes into a hash table. */
496 s390_opcode_hash
= hash_new ();
498 op_end
= s390_opcodes
+ s390_num_opcodes
;
499 for (op
= s390_opcodes
; op
< op_end
; op
++)
501 while (op
< op_end
- 1 && strcmp(op
->name
, op
[1].name
) == 0)
503 if (op
->min_cpu
<= current_cpu
&& (op
->modes
& current_mode_mask
))
507 retval
= hash_insert (s390_opcode_hash
, op
->name
, (void *) op
);
508 if (retval
!= (const char *) NULL
)
510 as_bad (_("Internal assembler error for instruction %s"),
514 while (op
< op_end
- 1 && strcmp (op
->name
, op
[1].name
) == 0)
521 record_alignment (text_section
, 2);
522 record_alignment (data_section
, 2);
523 record_alignment (bss_section
, 2);
527 /* Called after all assembly has been done. */
531 if (s390_arch_size
== 64)
532 bfd_set_arch_mach (stdoutput
, bfd_arch_s390
, bfd_mach_s390_64
);
534 bfd_set_arch_mach (stdoutput
, bfd_arch_s390
, bfd_mach_s390_31
);
537 /* Insert an operand value into an instruction. */
540 s390_insert_operand (unsigned char *insn
,
541 const struct s390_operand
*operand
,
549 if (operand
->flags
& (S390_OPERAND_SIGNED
|S390_OPERAND_PCREL
))
553 max
= ((offsetT
) 1 << (operand
->bits
- 1)) - 1;
554 min
= - ((offsetT
) 1 << (operand
->bits
- 1));
555 /* Halve PCREL operands. */
556 if (operand
->flags
& S390_OPERAND_PCREL
)
558 /* Check for underflow / overflow. */
559 if (val
< min
|| val
> max
)
562 _("operand out of range (%s not between %ld and %ld)");
565 if (operand
->flags
& S390_OPERAND_PCREL
)
571 sprint_value (buf
, val
);
572 if (file
== (char *) NULL
)
573 as_bad (err
, buf
, (int) min
, (int) max
);
575 as_bad_where (file
, line
, err
, buf
, (int) min
, (int) max
);
578 /* val is ok, now restrict it to operand->bits bits. */
579 uval
= (addressT
) val
& ((((addressT
) 1 << (operand
->bits
-1)) << 1) - 1);
580 /* val is restrict, now check for special case. */
581 if (operand
->bits
== 20 && operand
->shift
== 20)
582 uval
= (uval
>> 12) | ((uval
& 0xfff) << 8);
588 max
= (((addressT
) 1 << (operand
->bits
- 1)) << 1) - 1;
590 uval
= (addressT
) val
;
591 /* Length x in an instructions has real length x+1. */
592 if (operand
->flags
& S390_OPERAND_LENGTH
)
594 /* Check for underflow / overflow. */
595 if (uval
< min
|| uval
> max
)
597 if (operand
->flags
& S390_OPERAND_LENGTH
)
604 as_bad_value_out_of_range (_("operand"), uval
, (offsetT
) min
, (offsetT
) max
, file
, line
);
610 /* Insert fragments of the operand byte for byte. */
611 offset
= operand
->shift
+ operand
->bits
;
612 uval
<<= (-offset
) & 7;
613 insn
+= (offset
- 1) / 8;
625 bfd_reloc_code_real_type reloc
;
628 /* Parse tls marker and return the desired relocation. */
629 static bfd_reloc_code_real_type
630 s390_tls_suffix (char **str_p
, expressionS
*exp_p
)
632 static struct map_tls mapping
[] =
634 { "tls_load", 8, BFD_RELOC_390_TLS_LOAD
},
635 { "tls_gdcall", 10, BFD_RELOC_390_TLS_GDCALL
},
636 { "tls_ldcall", 10, BFD_RELOC_390_TLS_LDCALL
},
637 { NULL
, 0, BFD_RELOC_UNUSED
}
647 return BFD_RELOC_UNUSED
;
650 while (ISIDNUM (*str
))
654 return BFD_RELOC_UNUSED
;
656 orig_line
= input_line_pointer
;
657 input_line_pointer
= str
;
659 str
= input_line_pointer
;
660 if (&input_line_pointer
!= str_p
)
661 input_line_pointer
= orig_line
;
663 if (exp_p
->X_op
!= O_symbol
)
664 return BFD_RELOC_UNUSED
;
666 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
667 if (len
== ptr
->length
668 && strncasecmp (ident
, ptr
->string
, ptr
->length
) == 0)
670 /* Found a matching tls suffix. */
674 return BFD_RELOC_UNUSED
;
677 /* Structure used to hold suffixes. */
688 ELF_SUFFIX_TLS_GOTIE
,
700 elf_suffix_type suffix
;
704 /* Parse @got/@plt/@gotoff. and return the desired relocation. */
705 static elf_suffix_type
706 s390_elf_suffix (char **str_p
, expressionS
*exp_p
)
708 static struct map_bfd mapping
[] =
710 { "got", 3, ELF_SUFFIX_GOT
},
711 { "got12", 5, ELF_SUFFIX_GOT
},
712 { "plt", 3, ELF_SUFFIX_PLT
},
713 { "gotent", 6, ELF_SUFFIX_GOTENT
},
714 { "gotoff", 6, ELF_SUFFIX_GOTOFF
},
715 { "gotplt", 6, ELF_SUFFIX_GOTPLT
},
716 { "pltoff", 6, ELF_SUFFIX_PLTOFF
},
717 { "tlsgd", 5, ELF_SUFFIX_TLS_GD
},
718 { "gotntpoff", 9, ELF_SUFFIX_TLS_GOTIE
},
719 { "indntpoff", 9, ELF_SUFFIX_TLS_IE
},
720 { "tlsldm", 6, ELF_SUFFIX_TLS_LDM
},
721 { "dtpoff", 6, ELF_SUFFIX_TLS_LDO
},
722 { "ntpoff", 6, ELF_SUFFIX_TLS_LE
},
723 { NULL
, 0, ELF_SUFFIX_NONE
}
732 return ELF_SUFFIX_NONE
;
735 while (ISALNUM (*str
))
739 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
740 if (len
== ptr
->length
741 && strncasecmp (ident
, ptr
->string
, ptr
->length
) == 0)
743 if (exp_p
->X_add_number
!= 0)
744 as_warn (_("identifier+constant@%s means identifier@%s+constant"),
745 ptr
->string
, ptr
->string
);
746 /* Now check for identifier@suffix+constant. */
747 if (*str
== '-' || *str
== '+')
749 char *orig_line
= input_line_pointer
;
752 input_line_pointer
= str
;
753 expression (&new_exp
);
755 switch (new_exp
.X_op
)
757 case O_constant
: /* X_add_number (a constant expression). */
758 exp_p
->X_add_number
+= new_exp
.X_add_number
;
759 str
= input_line_pointer
;
761 case O_symbol
: /* X_add_symbol + X_add_number. */
762 /* this case is used for e.g. xyz@PLT+.Label. */
763 exp_p
->X_add_number
+= new_exp
.X_add_number
;
764 exp_p
->X_op_symbol
= new_exp
.X_add_symbol
;
766 str
= input_line_pointer
;
768 case O_uminus
: /* (- 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
;
772 exp_p
->X_op
= O_subtract
;
773 str
= input_line_pointer
;
779 /* If s390_elf_suffix has not been called with
780 &input_line_pointer as first parameter, we have
781 clobbered the input_line_pointer. We have to
783 if (&input_line_pointer
!= str_p
)
784 input_line_pointer
= orig_line
;
790 return BFD_RELOC_UNUSED
;
793 /* Structure used to hold a literal pool entry. */
796 struct s390_lpe
*next
;
798 FLONUM_TYPE floatnum
; /* used if X_op == O_big && X_add_number <= 0 */
799 LITTLENUM_TYPE bignum
[4]; /* used if X_op == O_big && X_add_number > 0 */
801 bfd_reloc_code_real_type reloc
;
805 static struct s390_lpe
*lpe_free_list
= NULL
;
806 static struct s390_lpe
*lpe_list
= NULL
;
807 static struct s390_lpe
*lpe_list_tail
= NULL
;
808 static symbolS
*lp_sym
= NULL
;
809 static int lp_count
= 0;
810 static int lpe_count
= 0;
813 s390_exp_compare (expressionS
*exp1
, expressionS
*exp2
)
815 if (exp1
->X_op
!= exp2
->X_op
)
820 case O_constant
: /* X_add_number must be equal. */
822 return exp1
->X_add_number
== exp2
->X_add_number
;
825 as_bad (_("Can't handle O_big in s390_exp_compare"));
827 case O_symbol
: /* X_add_symbol & X_add_number must be equal. */
832 return (exp1
->X_add_symbol
== exp2
->X_add_symbol
)
833 && (exp1
->X_add_number
== exp2
->X_add_number
);
835 case O_multiply
: /* X_add_symbol,X_op_symbol&X_add_number must be equal. */
840 case O_bit_inclusive_or
:
842 case O_bit_exclusive_or
:
854 return (exp1
->X_add_symbol
== exp2
->X_add_symbol
)
855 && (exp1
->X_op_symbol
== exp2
->X_op_symbol
)
856 && (exp1
->X_add_number
== exp2
->X_add_number
);
862 /* Test for @lit and if its present make an entry in the literal pool and
863 modify the current expression to be an offset into the literal pool. */
864 static elf_suffix_type
865 s390_lit_suffix (char **str_p
, expressionS
*exp_p
, elf_suffix_type suffix
)
867 bfd_reloc_code_real_type reloc
;
871 struct s390_lpe
*lpe
;
875 return suffix
; /* No modification. */
877 /* We look for a suffix of the form "@lit1", "@lit2", "@lit4" or "@lit8". */
879 while (ISALNUM (*str
))
882 if (len
!= 4 || strncasecmp (ident
, "lit", 3) != 0
883 || (ident
[3]!='1' && ident
[3]!='2' && ident
[3]!='4' && ident
[3]!='8'))
884 return suffix
; /* no modification */
885 nbytes
= ident
[3] - '0';
887 reloc
= BFD_RELOC_UNUSED
;
888 if (suffix
== ELF_SUFFIX_GOT
)
891 reloc
= BFD_RELOC_390_GOT16
;
892 else if (nbytes
== 4)
893 reloc
= BFD_RELOC_32_GOT_PCREL
;
894 else if (nbytes
== 8)
895 reloc
= BFD_RELOC_390_GOT64
;
897 else if (suffix
== ELF_SUFFIX_PLT
)
900 reloc
= BFD_RELOC_390_PLT32
;
901 else if (nbytes
== 8)
902 reloc
= BFD_RELOC_390_PLT64
;
905 if (suffix
!= ELF_SUFFIX_NONE
&& reloc
== BFD_RELOC_UNUSED
)
906 as_bad (_("Invalid suffix for literal pool entry"));
908 /* Search the pool if the new entry is a duplicate. */
909 if (exp_p
->X_op
== O_big
)
911 /* Special processing for big numbers. */
912 for (lpe
= lpe_list
; lpe
!= NULL
; lpe
= lpe
->next
)
914 if (lpe
->ex
.X_op
== O_big
)
916 if (exp_p
->X_add_number
<= 0 && lpe
->ex
.X_add_number
<= 0)
918 if (memcmp (&generic_floating_point_number
, &lpe
->floatnum
,
919 sizeof (FLONUM_TYPE
)) == 0)
922 else if (exp_p
->X_add_number
== lpe
->ex
.X_add_number
)
924 if (memcmp (generic_bignum
, lpe
->bignum
,
925 sizeof (LITTLENUM_TYPE
)*exp_p
->X_add_number
) == 0)
933 /* Processing for 'normal' data types. */
934 for (lpe
= lpe_list
; lpe
!= NULL
; lpe
= lpe
->next
)
935 if (lpe
->nbytes
== nbytes
&& lpe
->reloc
== reloc
936 && s390_exp_compare (exp_p
, &lpe
->ex
) != 0)
943 if (lpe_free_list
!= NULL
)
946 lpe_free_list
= lpe_free_list
->next
;
950 lpe
= (struct s390_lpe
*) xmalloc (sizeof (struct s390_lpe
));
955 if (exp_p
->X_op
== O_big
)
957 if (exp_p
->X_add_number
<= 0)
958 lpe
->floatnum
= generic_floating_point_number
;
959 else if (exp_p
->X_add_number
<= 4)
960 memcpy (lpe
->bignum
, generic_bignum
,
961 exp_p
->X_add_number
* sizeof (LITTLENUM_TYPE
));
963 as_bad (_("Big number is too big"));
966 lpe
->nbytes
= nbytes
;
968 /* Literal pool name defined ? */
971 sprintf (tmp_name
, ".L\001%i", lp_count
);
972 lp_sym
= symbol_make (tmp_name
);
975 /* Make name for literal pool entry. */
976 sprintf (tmp_name
, ".L\001%i\002%i", lp_count
, lpe_count
);
978 lpe
->sym
= symbol_make (tmp_name
);
980 /* Add to literal pool list. */
982 if (lpe_list_tail
!= NULL
)
984 lpe_list_tail
->next
= lpe
;
988 lpe_list
= lpe_list_tail
= lpe
;
991 /* Now change exp_p to the offset into the literal pool.
992 Thats the expression: .L^Ax^By-.L^Ax */
993 exp_p
->X_add_symbol
= lpe
->sym
;
994 exp_p
->X_op_symbol
= lp_sym
;
995 exp_p
->X_op
= O_subtract
;
996 exp_p
->X_add_number
= 0;
1000 /* We change the suffix type to ELF_SUFFIX_NONE, because
1001 the difference of two local labels is just a number. */
1002 return ELF_SUFFIX_NONE
;
1005 /* Like normal .long/.short/.word, except support @got, etc.
1006 clobbers input_line_pointer, checks end-of-line. */
1008 s390_elf_cons (int nbytes
/* 1=.byte, 2=.word, 4=.long */)
1011 elf_suffix_type suffix
;
1013 if (is_it_end_of_statement ())
1015 demand_empty_rest_of_line ();
1023 if (exp
.X_op
== O_symbol
1024 && *input_line_pointer
== '@'
1025 && (suffix
= s390_elf_suffix (&input_line_pointer
, &exp
)) != ELF_SUFFIX_NONE
)
1027 bfd_reloc_code_real_type reloc
;
1028 reloc_howto_type
*reloc_howto
;
1034 static bfd_reloc_code_real_type tab2
[] =
1036 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_NONE */
1037 BFD_RELOC_390_GOT16
, /* ELF_SUFFIX_GOT */
1038 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_PLT */
1039 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTENT */
1040 BFD_RELOC_16_GOTOFF
, /* ELF_SUFFIX_GOTOFF */
1041 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTPLT */
1042 BFD_RELOC_390_PLTOFF16
, /* ELF_SUFFIX_PLTOFF */
1043 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_GD */
1044 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_GOTIE */
1045 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_IE */
1046 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_LDM */
1047 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_LDO */
1048 BFD_RELOC_UNUSED
/* ELF_SUFFIX_TLS_LE */
1050 reloc
= tab2
[suffix
];
1052 else if (nbytes
== 4)
1054 static bfd_reloc_code_real_type tab4
[] =
1056 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_NONE */
1057 BFD_RELOC_32_GOT_PCREL
, /* ELF_SUFFIX_GOT */
1058 BFD_RELOC_390_PLT32
, /* ELF_SUFFIX_PLT */
1059 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTENT */
1060 BFD_RELOC_32_GOTOFF
, /* ELF_SUFFIX_GOTOFF */
1061 BFD_RELOC_390_GOTPLT32
, /* ELF_SUFFIX_GOTPLT */
1062 BFD_RELOC_390_PLTOFF32
, /* ELF_SUFFIX_PLTOFF */
1063 BFD_RELOC_390_TLS_GD32
, /* ELF_SUFFIX_TLS_GD */
1064 BFD_RELOC_390_TLS_GOTIE32
, /* ELF_SUFFIX_TLS_GOTIE */
1065 BFD_RELOC_390_TLS_IE32
, /* ELF_SUFFIX_TLS_IE */
1066 BFD_RELOC_390_TLS_LDM32
, /* ELF_SUFFIX_TLS_LDM */
1067 BFD_RELOC_390_TLS_LDO32
, /* ELF_SUFFIX_TLS_LDO */
1068 BFD_RELOC_390_TLS_LE32
/* ELF_SUFFIX_TLS_LE */
1070 reloc
= tab4
[suffix
];
1072 else if (nbytes
== 8)
1074 static bfd_reloc_code_real_type tab8
[] =
1076 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_NONE */
1077 BFD_RELOC_390_GOT64
, /* ELF_SUFFIX_GOT */
1078 BFD_RELOC_390_PLT64
, /* ELF_SUFFIX_PLT */
1079 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTENT */
1080 BFD_RELOC_390_GOTOFF64
, /* ELF_SUFFIX_GOTOFF */
1081 BFD_RELOC_390_GOTPLT64
, /* ELF_SUFFIX_GOTPLT */
1082 BFD_RELOC_390_PLTOFF64
, /* ELF_SUFFIX_PLTOFF */
1083 BFD_RELOC_390_TLS_GD64
, /* ELF_SUFFIX_TLS_GD */
1084 BFD_RELOC_390_TLS_GOTIE64
, /* ELF_SUFFIX_TLS_GOTIE */
1085 BFD_RELOC_390_TLS_IE64
, /* ELF_SUFFIX_TLS_IE */
1086 BFD_RELOC_390_TLS_LDM64
, /* ELF_SUFFIX_TLS_LDM */
1087 BFD_RELOC_390_TLS_LDO64
, /* ELF_SUFFIX_TLS_LDO */
1088 BFD_RELOC_390_TLS_LE64
/* ELF_SUFFIX_TLS_LE */
1090 reloc
= tab8
[suffix
];
1093 reloc
= BFD_RELOC_UNUSED
;
1095 if (reloc
!= BFD_RELOC_UNUSED
1096 && (reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
)))
1098 size
= bfd_get_reloc_size (reloc_howto
);
1100 as_bad (_("%s relocations do not fit in %d bytes"),
1101 reloc_howto
->name
, nbytes
);
1102 where
= frag_more (nbytes
);
1103 md_number_to_chars (where
, 0, size
);
1104 /* To make fixup_segment do the pc relative conversion the
1105 pcrel parameter on the fix_new_exp call needs to be FALSE. */
1106 fix_new_exp (frag_now
, where
- frag_now
->fr_literal
,
1107 size
, &exp
, FALSE
, reloc
);
1110 as_bad (_("relocation not applicable"));
1113 emit_expr (&exp
, (unsigned int) nbytes
);
1115 while (*input_line_pointer
++ == ',');
1117 input_line_pointer
--; /* Put terminator back into stream. */
1118 demand_empty_rest_of_line ();
1121 /* We need to keep a list of fixups. We can't simply generate them as
1122 we go, because that would require us to first create the frag, and
1123 that would screw up references to ``.''. */
1129 bfd_reloc_code_real_type reloc
;
1132 #define MAX_INSN_FIXUPS (4)
1134 /* This routine is called for each instruction to be assembled. */
1137 md_gather_operands (char *str
,
1138 unsigned char *insn
,
1139 const struct s390_opcode
*opcode
)
1141 struct s390_fixup fixups
[MAX_INSN_FIXUPS
];
1142 const struct s390_operand
*operand
;
1143 const unsigned char *opindex_ptr
;
1145 elf_suffix_type suffix
;
1146 bfd_reloc_code_real_type reloc
;
1151 while (ISSPACE (*str
))
1156 /* Gather the operands. */
1158 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
1162 operand
= s390_operands
+ *opindex_ptr
;
1164 if (skip_optional
&& (operand
->flags
& S390_OPERAND_INDEX
))
1166 /* We do an early skip. For D(X,B) constructions the index
1167 register is skipped (X is optional). For D(L,B) the base
1168 register will be the skipped operand, because L is NOT
1174 /* Gather the operand. */
1175 hold
= input_line_pointer
;
1176 input_line_pointer
= str
;
1178 /* Parse the operand. */
1179 if (! register_name (&ex
))
1182 str
= input_line_pointer
;
1183 input_line_pointer
= hold
;
1185 /* Write the operand to the insn. */
1186 if (ex
.X_op
== O_illegal
)
1187 as_bad (_("illegal operand"));
1188 else if (ex
.X_op
== O_absent
)
1190 /* No operands, check if all operands can be skipped. */
1191 while (*opindex_ptr
!= 0 && operand
->flags
& S390_OPERAND_OPTIONAL
)
1193 if (operand
->flags
& S390_OPERAND_DISP
)
1195 /* An optional displacement makes the whole D(X,B)
1196 D(L,B) or D(B) block optional. */
1198 operand
= s390_operands
+ *(++opindex_ptr
);
1199 } while (!(operand
->flags
& S390_OPERAND_BASE
));
1201 operand
= s390_operands
+ *(++opindex_ptr
);
1203 if (opindex_ptr
[0] == '\0')
1205 as_bad (_("missing operand"));
1207 else if (ex
.X_op
== O_register
|| ex
.X_op
== O_constant
)
1209 s390_lit_suffix (&str
, &ex
, ELF_SUFFIX_NONE
);
1211 if (ex
.X_op
!= O_register
&& ex
.X_op
!= O_constant
)
1213 /* We need to generate a fixup for the
1214 expression returned by s390_lit_suffix. */
1215 if (fc
>= MAX_INSN_FIXUPS
)
1216 as_fatal (_("too many fixups"));
1217 fixups
[fc
].exp
= ex
;
1218 fixups
[fc
].opindex
= *opindex_ptr
;
1219 fixups
[fc
].reloc
= BFD_RELOC_UNUSED
;
1224 if ((operand
->flags
& S390_OPERAND_INDEX
)
1225 && ex
.X_add_number
== 0
1227 as_warn (_("index register specified but zero"));
1228 if ((operand
->flags
& S390_OPERAND_BASE
)
1229 && ex
.X_add_number
== 0
1231 as_warn (_("base register specified but zero"));
1232 s390_insert_operand (insn
, operand
, ex
.X_add_number
, NULL
, 0);
1237 suffix
= s390_elf_suffix (&str
, &ex
);
1238 suffix
= s390_lit_suffix (&str
, &ex
, suffix
);
1239 reloc
= BFD_RELOC_UNUSED
;
1241 if (suffix
== ELF_SUFFIX_GOT
)
1243 if ((operand
->flags
& S390_OPERAND_DISP
) &&
1244 (operand
->bits
== 12))
1245 reloc
= BFD_RELOC_390_GOT12
;
1246 else if ((operand
->flags
& S390_OPERAND_DISP
) &&
1247 (operand
->bits
== 20))
1248 reloc
= BFD_RELOC_390_GOT20
;
1249 else if ((operand
->flags
& S390_OPERAND_SIGNED
)
1250 && (operand
->bits
== 16))
1251 reloc
= BFD_RELOC_390_GOT16
;
1252 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1253 && (operand
->bits
== 32))
1254 reloc
= BFD_RELOC_390_GOTENT
;
1256 else if (suffix
== ELF_SUFFIX_PLT
)
1258 if ((operand
->flags
& S390_OPERAND_PCREL
)
1259 && (operand
->bits
== 16))
1260 reloc
= BFD_RELOC_390_PLT16DBL
;
1261 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1262 && (operand
->bits
== 32))
1263 reloc
= BFD_RELOC_390_PLT32DBL
;
1265 else if (suffix
== ELF_SUFFIX_GOTENT
)
1267 if ((operand
->flags
& S390_OPERAND_PCREL
)
1268 && (operand
->bits
== 32))
1269 reloc
= BFD_RELOC_390_GOTENT
;
1271 else if (suffix
== ELF_SUFFIX_GOTOFF
)
1273 if ((operand
->flags
& S390_OPERAND_SIGNED
)
1274 && (operand
->bits
== 16))
1275 reloc
= BFD_RELOC_16_GOTOFF
;
1277 else if (suffix
== ELF_SUFFIX_PLTOFF
)
1279 if ((operand
->flags
& S390_OPERAND_SIGNED
)
1280 && (operand
->bits
== 16))
1281 reloc
= BFD_RELOC_390_PLTOFF16
;
1283 else if (suffix
== ELF_SUFFIX_GOTPLT
)
1285 if ((operand
->flags
& S390_OPERAND_DISP
)
1286 && (operand
->bits
== 12))
1287 reloc
= BFD_RELOC_390_GOTPLT12
;
1288 else if ((operand
->flags
& S390_OPERAND_SIGNED
)
1289 && (operand
->bits
== 16))
1290 reloc
= BFD_RELOC_390_GOTPLT16
;
1291 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1292 && (operand
->bits
== 32))
1293 reloc
= BFD_RELOC_390_GOTPLTENT
;
1295 else if (suffix
== ELF_SUFFIX_TLS_GOTIE
)
1297 if ((operand
->flags
& S390_OPERAND_DISP
)
1298 && (operand
->bits
== 12))
1299 reloc
= BFD_RELOC_390_TLS_GOTIE12
;
1300 else if ((operand
->flags
& S390_OPERAND_DISP
)
1301 && (operand
->bits
== 20))
1302 reloc
= BFD_RELOC_390_TLS_GOTIE20
;
1304 else if (suffix
== ELF_SUFFIX_TLS_IE
)
1306 if ((operand
->flags
& S390_OPERAND_PCREL
)
1307 && (operand
->bits
== 32))
1308 reloc
= BFD_RELOC_390_TLS_IEENT
;
1311 if (suffix
!= ELF_SUFFIX_NONE
&& reloc
== BFD_RELOC_UNUSED
)
1312 as_bad (_("invalid operand suffix"));
1313 /* We need to generate a fixup of type 'reloc' for this
1315 if (fc
>= MAX_INSN_FIXUPS
)
1316 as_fatal (_("too many fixups"));
1317 fixups
[fc
].exp
= ex
;
1318 fixups
[fc
].opindex
= *opindex_ptr
;
1319 fixups
[fc
].reloc
= reloc
;
1323 /* Check the next character. The call to expression has advanced
1324 str past any whitespace. */
1325 if (operand
->flags
& S390_OPERAND_DISP
)
1327 /* After a displacement a block in parentheses can start. */
1330 /* Check if parenthesized block can be skipped. If the next
1331 operand is neiter an optional operand nor a base register
1332 then we have a syntax error. */
1333 operand
= s390_operands
+ *(++opindex_ptr
);
1334 if (!(operand
->flags
& (S390_OPERAND_INDEX
|S390_OPERAND_BASE
)))
1335 as_bad (_("syntax error; missing '(' after displacement"));
1337 /* Ok, skip all operands until S390_OPERAND_BASE. */
1338 while (!(operand
->flags
& S390_OPERAND_BASE
))
1339 operand
= s390_operands
+ *(++opindex_ptr
);
1341 /* If there is a next operand it must be separated by a comma. */
1342 if (opindex_ptr
[1] != '\0')
1346 while (opindex_ptr
[1] != '\0')
1348 operand
= s390_operands
+ *(++opindex_ptr
);
1349 if (operand
->flags
& S390_OPERAND_OPTIONAL
)
1351 as_bad (_("syntax error; expected ,"));
1361 /* We found an opening parentheses. */
1363 for (f
= str
; *f
!= '\0'; f
++)
1364 if (*f
== ',' || *f
== ')')
1366 /* If there is no comma until the closing parentheses OR
1367 there is a comma right after the opening parentheses,
1368 we have to skip optional operands. */
1369 if (*f
== ',' && f
== str
)
1371 /* comma directly after '(' ? */
1376 skip_optional
= (*f
!= ',');
1379 else if (operand
->flags
& S390_OPERAND_BASE
)
1381 /* After the base register the parenthesed block ends. */
1383 as_bad (_("syntax error; missing ')' after base register"));
1385 /* If there is a next operand it must be separated by a comma. */
1386 if (opindex_ptr
[1] != '\0')
1390 while (opindex_ptr
[1] != '\0')
1392 operand
= s390_operands
+ *(++opindex_ptr
);
1393 if (operand
->flags
& S390_OPERAND_OPTIONAL
)
1395 as_bad (_("syntax error; expected ,"));
1405 /* We can find an 'early' closing parentheses in e.g. D(L) instead
1406 of D(L,B). In this case the base register has to be skipped. */
1409 operand
= s390_operands
+ *(++opindex_ptr
);
1411 if (!(operand
->flags
& S390_OPERAND_BASE
))
1412 as_bad (_("syntax error; ')' not allowed here"));
1415 /* If there is a next operand it must be separated by a comma. */
1416 if (opindex_ptr
[1] != '\0')
1420 while (opindex_ptr
[1] != '\0')
1422 operand
= s390_operands
+ *(++opindex_ptr
);
1423 if (operand
->flags
& S390_OPERAND_OPTIONAL
)
1425 as_bad (_("syntax error; expected ,"));
1435 while (ISSPACE (*str
))
1438 /* Check for tls instruction marker. */
1439 reloc
= s390_tls_suffix (&str
, &ex
);
1440 if (reloc
!= BFD_RELOC_UNUSED
)
1442 /* We need to generate a fixup of type 'reloc' for this
1444 if (fc
>= MAX_INSN_FIXUPS
)
1445 as_fatal (_("too many fixups"));
1446 fixups
[fc
].exp
= ex
;
1447 fixups
[fc
].opindex
= -1;
1448 fixups
[fc
].reloc
= reloc
;
1456 if ((linefeed
= strchr (str
, '\n')) != NULL
)
1458 as_bad (_("junk at end of line: `%s'"), str
);
1459 if (linefeed
!= NULL
)
1463 /* Write out the instruction. */
1464 f
= frag_more (opcode
->oplen
);
1465 memcpy (f
, insn
, opcode
->oplen
);
1466 dwarf2_emit_insn (opcode
->oplen
);
1468 /* Create any fixups. At this point we do not use a
1469 bfd_reloc_code_real_type, but instead just use the
1470 BFD_RELOC_UNUSED plus the operand index. This lets us easily
1471 handle fixups for any operand type, although that is admittedly
1472 not a very exciting feature. We pick a BFD reloc type in
1474 for (i
= 0; i
< fc
; i
++)
1477 if (fixups
[i
].opindex
< 0)
1479 /* Create tls instruction marker relocation. */
1480 fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, opcode
->oplen
,
1481 &fixups
[i
].exp
, 0, fixups
[i
].reloc
);
1485 operand
= s390_operands
+ fixups
[i
].opindex
;
1487 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
1489 reloc_howto_type
*reloc_howto
;
1493 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
1497 size
= bfd_get_reloc_size (reloc_howto
);
1499 if (size
< 1 || size
> 4)
1502 fixP
= fix_new_exp (frag_now
,
1503 f
- frag_now
->fr_literal
+ (operand
->shift
/8),
1504 size
, &fixups
[i
].exp
, reloc_howto
->pc_relative
,
1506 /* Turn off overflow checking in fixup_segment. This is necessary
1507 because fixup_segment will signal an overflow for large 4 byte
1508 quantities for GOT12 relocations. */
1509 if ( fixups
[i
].reloc
== BFD_RELOC_390_GOT12
1510 || fixups
[i
].reloc
== BFD_RELOC_390_GOT20
1511 || fixups
[i
].reloc
== BFD_RELOC_390_GOT16
)
1512 fixP
->fx_no_overflow
= 1;
1515 fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, 4, &fixups
[i
].exp
,
1516 (operand
->flags
& S390_OPERAND_PCREL
) != 0,
1517 ((bfd_reloc_code_real_type
)
1518 (fixups
[i
].opindex
+ (int) BFD_RELOC_UNUSED
)));
1523 /* This routine is called for each instruction to be assembled. */
1526 md_assemble (char *str
)
1528 const struct s390_opcode
*opcode
;
1529 unsigned char insn
[6];
1532 /* Get the opcode. */
1533 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
1538 /* Look up the opcode in the hash table. */
1539 opcode
= (struct s390_opcode
*) hash_find (s390_opcode_hash
, str
);
1540 if (opcode
== (const struct s390_opcode
*) NULL
)
1542 as_bad (_("Unrecognized opcode: `%s'"), str
);
1545 else if (!(opcode
->modes
& current_mode_mask
))
1547 as_bad (_("Opcode %s not available in this mode"), str
);
1550 memcpy (insn
, opcode
->opcode
, sizeof (insn
));
1551 md_gather_operands (s
, insn
, opcode
);
1554 #ifndef WORKING_DOT_WORD
1555 /* Handle long and short jumps. We don't support these */
1557 md_create_short_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
1559 addressT from_addr
, to_addr
;
1567 md_create_long_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
1569 addressT from_addr
, to_addr
;
1578 s390_bss (int ignore ATTRIBUTE_UNUSED
)
1580 /* We don't support putting frags in the BSS segment, we fake it
1581 by marking in_bss, then looking at s_skip for clues. */
1583 subseg_set (bss_section
, 0);
1584 demand_empty_rest_of_line ();
1587 /* Pseudo-op handling. */
1590 s390_insn (int ignore ATTRIBUTE_UNUSED
)
1593 const struct s390_opcode
*opformat
;
1594 unsigned char insn
[6];
1597 /* Get the opcode format. */
1598 s
= input_line_pointer
;
1599 while (*s
!= '\0' && *s
!= ',' && ! ISSPACE (*s
))
1602 as_bad (_("Invalid .insn format\n"));
1605 /* Look up the opcode in the hash table. */
1606 opformat
= (struct s390_opcode
*)
1607 hash_find (s390_opformat_hash
, input_line_pointer
);
1608 if (opformat
== (const struct s390_opcode
*) NULL
)
1610 as_bad (_("Unrecognized opcode format: `%s'"), input_line_pointer
);
1613 input_line_pointer
= s
;
1615 if (exp
.X_op
== O_constant
)
1617 if ( ( opformat
->oplen
== 6
1618 && (addressT
) exp
.X_add_number
< (1ULL << 48))
1619 || ( opformat
->oplen
== 4
1620 && (addressT
) exp
.X_add_number
< (1ULL << 32))
1621 || ( opformat
->oplen
== 2
1622 && (addressT
) exp
.X_add_number
< (1ULL << 16)))
1623 md_number_to_chars ((char *) insn
, exp
.X_add_number
, opformat
->oplen
);
1625 as_bad (_("Invalid .insn format\n"));
1627 else if (exp
.X_op
== O_big
)
1629 if (exp
.X_add_number
> 0
1630 && opformat
->oplen
== 6
1631 && generic_bignum
[3] == 0)
1633 md_number_to_chars ((char *) insn
, generic_bignum
[2], 2);
1634 md_number_to_chars ((char *) &insn
[2], generic_bignum
[1], 2);
1635 md_number_to_chars ((char *) &insn
[4], generic_bignum
[0], 2);
1638 as_bad (_("Invalid .insn format\n"));
1641 as_bad (_("second operand of .insn not a constant\n"));
1643 if (strcmp (opformat
->name
, "e") != 0 && *input_line_pointer
++ != ',')
1644 as_bad (_("missing comma after insn constant\n"));
1646 if ((s
= strchr (input_line_pointer
, '\n')) != NULL
)
1648 input_line_pointer
= md_gather_operands (input_line_pointer
, insn
,
1652 demand_empty_rest_of_line ();
1655 /* The .byte pseudo-op. This is similar to the normal .byte
1656 pseudo-op, but it can also take a single ASCII string. */
1659 s390_byte (int ignore ATTRIBUTE_UNUSED
)
1661 if (*input_line_pointer
!= '\"')
1667 /* Gather characters. A real double quote is doubled. Unusual
1668 characters are not permitted. */
1669 ++input_line_pointer
;
1674 c
= *input_line_pointer
++;
1678 if (*input_line_pointer
!= '\"')
1680 ++input_line_pointer
;
1683 FRAG_APPEND_1_CHAR (c
);
1686 demand_empty_rest_of_line ();
1689 /* The .ltorg pseudo-op.This emits all literals defined since the last
1690 .ltorg or the invocation of gas. Literals are defined with the
1694 s390_literals (int ignore ATTRIBUTE_UNUSED
)
1696 struct s390_lpe
*lpe
;
1698 if (lp_sym
== NULL
|| lpe_count
== 0)
1699 return; /* Nothing to be done. */
1701 /* Emit symbol for start of literal pool. */
1702 S_SET_SEGMENT (lp_sym
, now_seg
);
1703 S_SET_VALUE (lp_sym
, (valueT
) frag_now_fix ());
1704 lp_sym
->sy_frag
= frag_now
;
1709 lpe_list
= lpe_list
->next
;
1710 S_SET_SEGMENT (lpe
->sym
, now_seg
);
1711 S_SET_VALUE (lpe
->sym
, (valueT
) frag_now_fix ());
1712 lpe
->sym
->sy_frag
= frag_now
;
1714 /* Emit literal pool entry. */
1715 if (lpe
->reloc
!= BFD_RELOC_UNUSED
)
1717 reloc_howto_type
*reloc_howto
=
1718 bfd_reloc_type_lookup (stdoutput
, lpe
->reloc
);
1719 int size
= bfd_get_reloc_size (reloc_howto
);
1722 if (size
> lpe
->nbytes
)
1723 as_bad (_("%s relocations do not fit in %d bytes"),
1724 reloc_howto
->name
, lpe
->nbytes
);
1725 where
= frag_more (lpe
->nbytes
);
1726 md_number_to_chars (where
, 0, size
);
1727 fix_new_exp (frag_now
, where
- frag_now
->fr_literal
,
1728 size
, &lpe
->ex
, reloc_howto
->pc_relative
, lpe
->reloc
);
1732 if (lpe
->ex
.X_op
== O_big
)
1734 if (lpe
->ex
.X_add_number
<= 0)
1735 generic_floating_point_number
= lpe
->floatnum
;
1737 memcpy (generic_bignum
, lpe
->bignum
,
1738 lpe
->ex
.X_add_number
* sizeof (LITTLENUM_TYPE
));
1740 emit_expr (&lpe
->ex
, lpe
->nbytes
);
1743 lpe
->next
= lpe_free_list
;
1744 lpe_free_list
= lpe
;
1746 lpe_list_tail
= NULL
;
1753 md_atof (int type
, char *litp
, int *sizep
)
1755 return ieee_md_atof (type
, litp
, sizep
, TRUE
);
1758 /* Align a section (I don't know why this is machine dependent). */
1761 md_section_align (asection
*seg
, valueT addr
)
1763 int align
= bfd_get_section_alignment (stdoutput
, seg
);
1765 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
1768 /* We don't have any form of relaxing. */
1771 md_estimate_size_before_relax (fragS
*fragp ATTRIBUTE_UNUSED
,
1772 asection
*seg ATTRIBUTE_UNUSED
)
1778 /* Convert a machine dependent frag. We never generate these. */
1781 md_convert_frag (bfd
*abfd ATTRIBUTE_UNUSED
,
1782 asection
*sec ATTRIBUTE_UNUSED
,
1783 fragS
*fragp ATTRIBUTE_UNUSED
)
1789 md_undefined_symbol (char *name
)
1791 if (*name
== '_' && *(name
+ 1) == 'G'
1792 && strcmp (name
, "_GLOBAL_OFFSET_TABLE_") == 0)
1796 if (symbol_find (name
))
1797 as_bad (_("GOT already in symbol table"));
1798 GOT_symbol
= symbol_new (name
, undefined_section
,
1799 (valueT
) 0, &zero_address_frag
);
1806 /* Functions concerning relocs. */
1808 /* The location from which a PC relative jump should be calculated,
1809 given a PC relative reloc. */
1812 md_pcrel_from_section (fixS
*fixp
, segT sec ATTRIBUTE_UNUSED
)
1814 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
1817 /* Here we decide which fixups can be adjusted to make them relative to
1818 the beginning of the section instead of the symbol. Basically we need
1819 to make sure that the dynamic relocations are done correctly, so in
1820 some cases we force the original symbol to be used. */
1822 tc_s390_fix_adjustable (fixS
*fixP
)
1824 /* Don't adjust references to merge sections. */
1825 if ((S_GET_SEGMENT (fixP
->fx_addsy
)->flags
& SEC_MERGE
) != 0)
1827 /* adjust_reloc_syms doesn't know about the GOT. */
1828 if ( fixP
->fx_r_type
== BFD_RELOC_16_GOTOFF
1829 || fixP
->fx_r_type
== BFD_RELOC_32_GOTOFF
1830 || fixP
->fx_r_type
== BFD_RELOC_390_GOTOFF64
1831 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF16
1832 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF32
1833 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF64
1834 || fixP
->fx_r_type
== BFD_RELOC_390_PLT16DBL
1835 || fixP
->fx_r_type
== BFD_RELOC_390_PLT32
1836 || fixP
->fx_r_type
== BFD_RELOC_390_PLT32DBL
1837 || fixP
->fx_r_type
== BFD_RELOC_390_PLT64
1838 || fixP
->fx_r_type
== BFD_RELOC_390_GOT12
1839 || fixP
->fx_r_type
== BFD_RELOC_390_GOT20
1840 || fixP
->fx_r_type
== BFD_RELOC_390_GOT16
1841 || fixP
->fx_r_type
== BFD_RELOC_32_GOT_PCREL
1842 || fixP
->fx_r_type
== BFD_RELOC_390_GOT64
1843 || fixP
->fx_r_type
== BFD_RELOC_390_GOTENT
1844 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT12
1845 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT16
1846 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT20
1847 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT32
1848 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT64
1849 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLTENT
1850 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LOAD
1851 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GDCALL
1852 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDCALL
1853 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GD32
1854 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GD64
1855 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE12
1856 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE20
1857 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE32
1858 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE64
1859 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDM32
1860 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDM64
1861 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IE32
1862 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IE64
1863 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IEENT
1864 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LE32
1865 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LE64
1866 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDO32
1867 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDO64
1868 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_DTPMOD
1869 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_DTPOFF
1870 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_TPOFF
1871 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
1872 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
1877 /* Return true if we must always emit a reloc for a type and false if
1878 there is some hope of resolving it at assembly time. */
1880 tc_s390_force_relocation (struct fix
*fixp
)
1882 /* Ensure we emit a relocation for every reference to the global
1883 offset table or to the procedure link table. */
1884 switch (fixp
->fx_r_type
)
1886 case BFD_RELOC_390_GOT12
:
1887 case BFD_RELOC_390_GOT20
:
1888 case BFD_RELOC_32_GOT_PCREL
:
1889 case BFD_RELOC_32_GOTOFF
:
1890 case BFD_RELOC_390_GOTOFF64
:
1891 case BFD_RELOC_390_PLTOFF16
:
1892 case BFD_RELOC_390_PLTOFF32
:
1893 case BFD_RELOC_390_PLTOFF64
:
1894 case BFD_RELOC_390_GOTPC
:
1895 case BFD_RELOC_390_GOT16
:
1896 case BFD_RELOC_390_GOTPCDBL
:
1897 case BFD_RELOC_390_GOT64
:
1898 case BFD_RELOC_390_GOTENT
:
1899 case BFD_RELOC_390_PLT32
:
1900 case BFD_RELOC_390_PLT16DBL
:
1901 case BFD_RELOC_390_PLT32DBL
:
1902 case BFD_RELOC_390_PLT64
:
1903 case BFD_RELOC_390_GOTPLT12
:
1904 case BFD_RELOC_390_GOTPLT16
:
1905 case BFD_RELOC_390_GOTPLT20
:
1906 case BFD_RELOC_390_GOTPLT32
:
1907 case BFD_RELOC_390_GOTPLT64
:
1908 case BFD_RELOC_390_GOTPLTENT
:
1914 return generic_force_reloc (fixp
);
1917 /* Apply a fixup to the object code. This is called for all the
1918 fixups we generated by the call to fix_new_exp, above. In the call
1919 above we used a reloc code which was the largest legal reloc code
1920 plus the operand index. Here we undo that to recover the operand
1921 index. At this point all symbol values should be fully resolved,
1922 and we attempt to completely resolve the reloc. If we can not do
1923 that, we determine the correct reloc code and put it back in the
1927 md_apply_fix (fixS
*fixP
, valueT
*valP
, segT seg ATTRIBUTE_UNUSED
)
1930 valueT value
= *valP
;
1932 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
1934 if (fixP
->fx_subsy
!= NULL
)
1935 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1936 _("cannot emit relocation %s against subsy symbol %s"),
1937 bfd_get_reloc_code_name (fixP
->fx_r_type
),
1938 S_GET_NAME (fixP
->fx_subsy
));
1940 if (fixP
->fx_addsy
!= NULL
)
1943 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
1948 if ((int) fixP
->fx_r_type
>= (int) BFD_RELOC_UNUSED
)
1950 const struct s390_operand
*operand
;
1953 opindex
= (int) fixP
->fx_r_type
- (int) BFD_RELOC_UNUSED
;
1954 operand
= &s390_operands
[opindex
];
1958 /* Insert the fully resolved operand value. */
1959 s390_insert_operand ((unsigned char *) where
, operand
,
1960 (offsetT
) value
, fixP
->fx_file
, fixP
->fx_line
);
1964 /* Determine a BFD reloc value based on the operand information.
1965 We are only prepared to turn a few of the operands into
1967 fixP
->fx_offset
= value
;
1968 if (operand
->bits
== 12 && operand
->shift
== 20)
1971 fixP
->fx_where
+= 2;
1972 fixP
->fx_r_type
= BFD_RELOC_390_12
;
1974 else if (operand
->bits
== 12 && operand
->shift
== 36)
1977 fixP
->fx_where
+= 4;
1978 fixP
->fx_r_type
= BFD_RELOC_390_12
;
1980 else if (operand
->bits
== 20 && operand
->shift
== 20)
1983 fixP
->fx_where
+= 2;
1984 fixP
->fx_r_type
= BFD_RELOC_390_20
;
1986 else if (operand
->bits
== 8 && operand
->shift
== 8)
1989 fixP
->fx_where
+= 1;
1990 fixP
->fx_r_type
= BFD_RELOC_8
;
1992 else if (operand
->bits
== 16 && operand
->shift
== 16)
1995 fixP
->fx_where
+= 2;
1996 if (operand
->flags
& S390_OPERAND_PCREL
)
1998 fixP
->fx_r_type
= BFD_RELOC_390_PC16DBL
;
1999 fixP
->fx_offset
+= 2;
2002 fixP
->fx_r_type
= BFD_RELOC_16
;
2004 else if (operand
->bits
== 32 && operand
->shift
== 16
2005 && (operand
->flags
& S390_OPERAND_PCREL
))
2008 fixP
->fx_where
+= 2;
2009 fixP
->fx_offset
+= 2;
2010 fixP
->fx_r_type
= BFD_RELOC_390_PC32DBL
;
2017 /* Use expr_symbol_where to see if this is an expression
2019 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
2020 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2021 _("unresolved expression that must be resolved"));
2023 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2024 _("unsupported relocation type"));
2031 switch (fixP
->fx_r_type
)
2037 md_number_to_chars (where
, value
, 1);
2039 case BFD_RELOC_390_12
:
2040 case BFD_RELOC_390_GOT12
:
2041 case BFD_RELOC_390_GOTPLT12
:
2046 mop
= bfd_getb16 ((unsigned char *) where
);
2047 mop
|= (unsigned short) (value
& 0xfff);
2048 bfd_putb16 ((bfd_vma
) mop
, (unsigned char *) where
);
2052 case BFD_RELOC_390_20
:
2053 case BFD_RELOC_390_GOT20
:
2054 case BFD_RELOC_390_GOTPLT20
:
2058 mop
= bfd_getb32 ((unsigned char *) where
);
2059 mop
|= (unsigned int) ((value
& 0xfff) << 8 |
2060 (value
& 0xff000) >> 12);
2061 bfd_putb32 ((bfd_vma
) mop
, (unsigned char *) where
);
2066 case BFD_RELOC_GPREL16
:
2067 case BFD_RELOC_16_GOT_PCREL
:
2068 case BFD_RELOC_16_GOTOFF
:
2070 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2071 _("cannot emit PC relative %s relocation%s%s"),
2072 bfd_get_reloc_code_name (fixP
->fx_r_type
),
2073 fixP
->fx_addsy
!= NULL
? " against " : "",
2074 (fixP
->fx_addsy
!= NULL
2075 ? S_GET_NAME (fixP
->fx_addsy
)
2078 md_number_to_chars (where
, value
, 2);
2080 case BFD_RELOC_390_GOT16
:
2081 case BFD_RELOC_390_PLTOFF16
:
2082 case BFD_RELOC_390_GOTPLT16
:
2084 md_number_to_chars (where
, value
, 2);
2086 case BFD_RELOC_390_PC16DBL
:
2087 case BFD_RELOC_390_PLT16DBL
:
2090 md_number_to_chars (where
, (offsetT
) value
>> 1, 2);
2095 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
2097 fixP
->fx_r_type
= BFD_RELOC_32
;
2099 md_number_to_chars (where
, value
, 4);
2101 case BFD_RELOC_32_PCREL
:
2102 case BFD_RELOC_32_BASEREL
:
2103 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
2105 md_number_to_chars (where
, value
, 4);
2107 case BFD_RELOC_32_GOT_PCREL
:
2108 case BFD_RELOC_390_PLTOFF32
:
2109 case BFD_RELOC_390_PLT32
:
2110 case BFD_RELOC_390_GOTPLT32
:
2112 md_number_to_chars (where
, value
, 4);
2114 case BFD_RELOC_390_PC32DBL
:
2115 case BFD_RELOC_390_PLT32DBL
:
2116 case BFD_RELOC_390_GOTPCDBL
:
2117 case BFD_RELOC_390_GOTENT
:
2118 case BFD_RELOC_390_GOTPLTENT
:
2121 md_number_to_chars (where
, (offsetT
) value
>> 1, 4);
2124 case BFD_RELOC_32_GOTOFF
:
2126 md_number_to_chars (where
, value
, sizeof (int));
2129 case BFD_RELOC_390_GOTOFF64
:
2131 md_number_to_chars (where
, value
, 8);
2134 case BFD_RELOC_390_GOT64
:
2135 case BFD_RELOC_390_PLTOFF64
:
2136 case BFD_RELOC_390_PLT64
:
2137 case BFD_RELOC_390_GOTPLT64
:
2139 md_number_to_chars (where
, value
, 8);
2144 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
2146 fixP
->fx_r_type
= BFD_RELOC_64
;
2148 md_number_to_chars (where
, value
, 8);
2151 case BFD_RELOC_64_PCREL
:
2152 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
2154 md_number_to_chars (where
, value
, 8);
2157 case BFD_RELOC_VTABLE_INHERIT
:
2158 case BFD_RELOC_VTABLE_ENTRY
:
2162 case BFD_RELOC_390_TLS_LOAD
:
2163 case BFD_RELOC_390_TLS_GDCALL
:
2164 case BFD_RELOC_390_TLS_LDCALL
:
2165 case BFD_RELOC_390_TLS_GD32
:
2166 case BFD_RELOC_390_TLS_GD64
:
2167 case BFD_RELOC_390_TLS_GOTIE12
:
2168 case BFD_RELOC_390_TLS_GOTIE20
:
2169 case BFD_RELOC_390_TLS_GOTIE32
:
2170 case BFD_RELOC_390_TLS_GOTIE64
:
2171 case BFD_RELOC_390_TLS_LDM32
:
2172 case BFD_RELOC_390_TLS_LDM64
:
2173 case BFD_RELOC_390_TLS_IE32
:
2174 case BFD_RELOC_390_TLS_IE64
:
2175 case BFD_RELOC_390_TLS_LE32
:
2176 case BFD_RELOC_390_TLS_LE64
:
2177 case BFD_RELOC_390_TLS_LDO32
:
2178 case BFD_RELOC_390_TLS_LDO64
:
2179 case BFD_RELOC_390_TLS_DTPMOD
:
2180 case BFD_RELOC_390_TLS_DTPOFF
:
2181 case BFD_RELOC_390_TLS_TPOFF
:
2182 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
2183 /* Fully resolved at link time. */
2185 case BFD_RELOC_390_TLS_IEENT
:
2186 /* Fully resolved at link time. */
2187 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
2193 const char *reloc_name
= bfd_get_reloc_code_name (fixP
->fx_r_type
);
2195 if (reloc_name
!= NULL
)
2196 as_fatal (_("Gas failure, reloc type %s\n"), reloc_name
);
2198 as_fatal (_("Gas failure, reloc type #%i\n"), fixP
->fx_r_type
);
2202 fixP
->fx_offset
= value
;
2206 /* Generate a reloc for a fixup. */
2209 tc_gen_reloc (asection
*seg ATTRIBUTE_UNUSED
, fixS
*fixp
)
2211 bfd_reloc_code_real_type code
;
2214 code
= fixp
->fx_r_type
;
2215 if (GOT_symbol
&& fixp
->fx_addsy
== GOT_symbol
)
2217 if ( (s390_arch_size
== 32 && code
== BFD_RELOC_32_PCREL
)
2218 || (s390_arch_size
== 64 && code
== BFD_RELOC_64_PCREL
))
2219 code
= BFD_RELOC_390_GOTPC
;
2220 if (code
== BFD_RELOC_390_PC32DBL
)
2221 code
= BFD_RELOC_390_GOTPCDBL
;
2224 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
2225 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
2226 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
2227 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
2228 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
2229 if (reloc
->howto
== NULL
)
2231 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2232 _("cannot represent relocation type %s"),
2233 bfd_get_reloc_code_name (code
));
2234 /* Set howto to a garbage value so that we can keep going. */
2235 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, BFD_RELOC_32
);
2236 gas_assert (reloc
->howto
!= NULL
);
2238 reloc
->addend
= fixp
->fx_offset
;
2244 s390_cfi_frame_initial_instructions (void)
2246 cfi_add_CFA_def_cfa (15, s390_arch_size
== 64 ? 160 : 96);
2250 tc_s390_regname_to_dw2regnum (char *regname
)
2254 if (regname
[0] != 'c' && regname
[0] != 'a')
2256 regnum
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
, regname
);
2257 if (regname
[0] == 'f' && regnum
!= -1)
2260 else if (strcmp (regname
, "ap") == 0)
2262 else if (strcmp (regname
, "cc") == 0)
2268 s390_elf_final_processing (void)
2270 if (s390_arch_size
== 32 && (current_mode_mask
& (1 << S390_OPCODE_ZARCH
)))
2271 elf_elfheader (stdoutput
)->e_flags
|= EF_S390_HIGH_GPRS
;