1 /* tc-s390.c -- Assemble for the S390
2 Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
3 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
PARAMS ((int));
81 static void s390_elf_cons
PARAMS ((int));
82 static void s390_bss
PARAMS ((int));
83 static void s390_insn
PARAMS ((int));
84 static void s390_literals
PARAMS ((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 static int reg_name_search
209 PARAMS ((const struct pd_reg
*, int, const char *));
210 static bfd_boolean register_name
PARAMS ((expressionS
*));
211 static void init_default_arch
PARAMS ((void));
212 static void s390_insert_operand
213 PARAMS ((unsigned char *, const struct s390_operand
*, offsetT
, char *,
215 static char *md_gather_operands
216 PARAMS ((char *, unsigned char *, const struct s390_opcode
*));
218 /* Given NAME, find the register number associated with that name, return
219 the integer value associated with the given name or -1 on failure. */
222 reg_name_search (regs
, regcount
, name
)
223 const struct pd_reg
*regs
;
227 int middle
, low
, high
;
235 middle
= (low
+ high
) / 2;
236 cmp
= strcasecmp (name
, regs
[middle
].name
);
242 return regs
[middle
].value
;
251 * Summary of register_name().
253 * in: Input_line_pointer points to 1st char of operand.
255 * out: A expressionS.
256 * The operand may have been a register: in this case, X_op == O_register,
257 * X_add_number is set to the register number, and truth is returned.
258 * Input_line_pointer->(next non-blank) char after operand, or is in its
263 register_name (expressionP
)
264 expressionS
*expressionP
;
271 /* Find the spelling of the operand. */
272 start
= name
= input_line_pointer
;
273 if (name
[0] == '%' && ISALPHA (name
[1]))
274 name
= ++input_line_pointer
;
278 c
= get_symbol_end ();
279 reg_number
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
, name
);
281 /* Put back the delimiting char. */
282 *input_line_pointer
= c
;
284 /* Look to see if it's in the register table. */
287 expressionP
->X_op
= O_register
;
288 expressionP
->X_add_number
= reg_number
;
290 /* Make the rest nice. */
291 expressionP
->X_add_symbol
= NULL
;
292 expressionP
->X_op_symbol
= NULL
;
296 /* Reset the line as if we had not done anything. */
297 input_line_pointer
= start
;
301 /* Local variables. */
303 /* Opformat hash table. */
304 static struct hash_control
*s390_opformat_hash
;
306 /* Opcode hash table. */
307 static struct hash_control
*s390_opcode_hash
;
309 /* Flags to set in the elf header */
310 static flagword s390_flags
= 0;
312 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE_" */
314 #ifndef WORKING_DOT_WORD
315 int md_short_jump_size
= 4;
316 int md_long_jump_size
= 4;
319 const char *md_shortopts
= "A:m:kVQ:";
320 struct option md_longopts
[] = {
321 {NULL
, no_argument
, NULL
, 0}
323 size_t md_longopts_size
= sizeof (md_longopts
);
325 /* Initialize the default opcode arch and word size from the default
326 architecture name if not specified by an option. */
330 if (strcmp (default_arch
, "s390") == 0)
332 if (s390_arch_size
== 0)
335 else if (strcmp (default_arch
, "s390x") == 0)
337 if (s390_arch_size
== 0)
341 as_fatal ("Invalid default architecture, broken assembler.");
343 if (current_mode_mask
== 0)
345 if (s390_arch_size
== 32)
346 current_mode_mask
= 1 << S390_OPCODE_ESA
;
348 current_mode_mask
= 1 << S390_OPCODE_ZARCH
;
350 if (current_cpu
== -1U)
352 if (current_mode_mask
== (1 << S390_OPCODE_ESA
))
353 current_cpu
= S390_OPCODE_G5
;
355 current_cpu
= S390_OPCODE_Z900
;
359 /* Called by TARGET_FORMAT. */
361 s390_target_format ()
363 /* We don't get a chance to initialize anything before we're called,
364 so handle that now. */
365 init_default_arch ();
367 return s390_arch_size
== 64 ? "elf64-s390" : "elf32-s390";
371 md_parse_option (c
, arg
)
377 /* -k: Ignore for FreeBSD compatibility. */
381 if (arg
!= NULL
&& strcmp (arg
, "regnames") == 0)
384 else if (arg
!= NULL
&& strcmp (arg
, "no-regnames") == 0)
387 else if (arg
!= NULL
&& strcmp (arg
, "warn-areg-zero") == 0)
388 warn_areg_zero
= TRUE
;
390 else if (arg
!= NULL
&& strcmp (arg
, "31") == 0)
393 else if (arg
!= NULL
&& strcmp (arg
, "64") == 0)
396 else if (arg
!= NULL
&& strcmp (arg
, "esa") == 0)
397 current_mode_mask
= 1 << S390_OPCODE_ESA
;
399 else if (arg
!= NULL
&& strcmp (arg
, "zarch") == 0)
400 current_mode_mask
= 1 << S390_OPCODE_ZARCH
;
402 else if (arg
!= NULL
&& strncmp (arg
, "arch=", 5) == 0)
404 if (strcmp (arg
+ 5, "g5") == 0)
405 current_cpu
= S390_OPCODE_G5
;
406 else if (strcmp (arg
+ 5, "g6") == 0)
407 current_cpu
= S390_OPCODE_G6
;
408 else if (strcmp (arg
+ 5, "z900") == 0)
409 current_cpu
= S390_OPCODE_Z900
;
410 else if (strcmp (arg
+ 5, "z990") == 0)
411 current_cpu
= S390_OPCODE_Z990
;
412 else if (strcmp (arg
+ 5, "z9-109") == 0)
413 current_cpu
= S390_OPCODE_Z9_109
;
414 else if (strcmp (arg
+ 5, "z9-ec") == 0)
415 current_cpu
= S390_OPCODE_Z9_EC
;
418 as_bad (_("invalid switch -m%s"), arg
);
425 as_bad (_("invalid switch -m%s"), arg
);
431 /* Option -A is deprecated. Still available for compatibility. */
432 if (arg
!= NULL
&& strcmp (arg
, "esa") == 0)
433 current_cpu
= S390_OPCODE_G5
;
434 else if (arg
!= NULL
&& strcmp (arg
, "esame") == 0)
435 current_cpu
= S390_OPCODE_Z900
;
437 as_bad ("invalid architecture -A%s", arg
);
440 /* -V: SVR4 argument to print version ID. */
445 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
446 should be emitted or not. FIXME: Not implemented. */
458 md_show_usage (stream
)
461 fprintf (stream
, _("\
463 -mregnames Allow symbolic names for registers\n\
464 -mwarn-areg-zero Warn about zero base/index registers\n\
465 -mno-regnames Do not allow symbolic names for registers\n\
466 -m31 Set file format to 31 bit format\n\
467 -m64 Set file format to 64 bit format\n"));
468 fprintf (stream
, _("\
469 -V print assembler version number\n\
470 -Qy, -Qn ignored\n"));
473 /* This function is called when the assembler starts up. It is called
474 after the options have been parsed and the output file has been
480 register const struct s390_opcode
*op
;
481 const struct s390_opcode
*op_end
;
482 bfd_boolean dup_insn
= FALSE
;
485 /* Give a warning if the combination -m64-bit and -Aesa is used. */
486 if (s390_arch_size
== 64 && current_cpu
< S390_OPCODE_Z900
)
487 as_warn ("The 64 bit file format is used without esame instructions.");
489 s390_cie_data_alignment
= -s390_arch_size
/ 8;
491 /* Set the ELF flags if desired. */
493 bfd_set_private_flags (stdoutput
, s390_flags
);
495 /* Insert the opcode formats into a hash table. */
496 s390_opformat_hash
= hash_new ();
498 op_end
= s390_opformats
+ s390_num_opformats
;
499 for (op
= s390_opformats
; op
< op_end
; op
++)
501 retval
= hash_insert (s390_opformat_hash
, op
->name
, (PTR
) op
);
502 if (retval
!= (const char *) NULL
)
504 as_bad (_("Internal assembler error for instruction format %s"),
510 /* Insert the opcodes into a hash table. */
511 s390_opcode_hash
= hash_new ();
513 op_end
= s390_opcodes
+ s390_num_opcodes
;
514 for (op
= s390_opcodes
; op
< op_end
; op
++)
516 while (op
< op_end
- 1 && strcmp(op
->name
, op
[1].name
) == 0)
518 if (op
->min_cpu
<= current_cpu
&& (op
->modes
& current_mode_mask
))
522 retval
= hash_insert (s390_opcode_hash
, op
->name
, (PTR
) op
);
523 if (retval
!= (const char *) NULL
)
525 as_bad (_("Internal assembler error for instruction %s"),
529 while (op
< op_end
- 1 && strcmp (op
->name
, op
[1].name
) == 0)
536 record_alignment (text_section
, 2);
537 record_alignment (data_section
, 2);
538 record_alignment (bss_section
, 2);
542 /* Called after all assembly has been done. */
546 if (s390_arch_size
== 64)
547 bfd_set_arch_mach (stdoutput
, bfd_arch_s390
, bfd_mach_s390_64
);
549 bfd_set_arch_mach (stdoutput
, bfd_arch_s390
, bfd_mach_s390_31
);
552 /* Insert an operand value into an instruction. */
555 s390_insert_operand (insn
, operand
, val
, file
, line
)
557 const struct s390_operand
*operand
;
565 if (operand
->flags
& (S390_OPERAND_SIGNED
|S390_OPERAND_PCREL
))
569 max
= ((offsetT
) 1 << (operand
->bits
- 1)) - 1;
570 min
= - ((offsetT
) 1 << (operand
->bits
- 1));
571 /* Halve PCREL operands. */
572 if (operand
->flags
& S390_OPERAND_PCREL
)
574 /* Check for underflow / overflow. */
575 if (val
< min
|| val
> max
)
578 "operand out of range (%s not between %ld and %ld)";
581 if (operand
->flags
& S390_OPERAND_PCREL
)
587 sprint_value (buf
, val
);
588 if (file
== (char *) NULL
)
589 as_bad (err
, buf
, (int) min
, (int) max
);
591 as_bad_where (file
, line
, err
, buf
, (int) min
, (int) max
);
594 /* val is ok, now restrict it to operand->bits bits. */
595 uval
= (addressT
) val
& ((((addressT
) 1 << (operand
->bits
-1)) << 1) - 1);
596 /* val is restrict, now check for special case. */
597 if (operand
->bits
== 20 && operand
->shift
== 20)
598 uval
= (uval
>> 12) | ((uval
& 0xfff) << 8);
604 max
= (((addressT
) 1 << (operand
->bits
- 1)) << 1) - 1;
606 uval
= (addressT
) val
;
607 /* Length x in an instructions has real length x+1. */
608 if (operand
->flags
& S390_OPERAND_LENGTH
)
610 /* Check for underflow / overflow. */
611 if (uval
< min
|| uval
> max
)
613 if (operand
->flags
& S390_OPERAND_LENGTH
)
620 as_bad_value_out_of_range (_("operand"), uval
, (offsetT
) min
, (offsetT
) max
, file
, line
);
626 /* Insert fragments of the operand byte for byte. */
627 offset
= operand
->shift
+ operand
->bits
;
628 uval
<<= (-offset
) & 7;
629 insn
+= (offset
- 1) / 8;
641 bfd_reloc_code_real_type reloc
;
644 static bfd_reloc_code_real_type s390_tls_suffix
645 PARAMS ((char **, expressionS
*));
647 /* Parse tls marker and return the desired relocation. */
648 static bfd_reloc_code_real_type
649 s390_tls_suffix (str_p
, exp_p
)
653 static struct map_tls mapping
[] =
655 { "tls_load", 8, BFD_RELOC_390_TLS_LOAD
},
656 { "tls_gdcall", 10, BFD_RELOC_390_TLS_GDCALL
},
657 { "tls_ldcall", 10, BFD_RELOC_390_TLS_LDCALL
},
658 { NULL
, 0, BFD_RELOC_UNUSED
}
668 return BFD_RELOC_UNUSED
;
671 while (ISIDNUM (*str
))
675 return BFD_RELOC_UNUSED
;
677 orig_line
= input_line_pointer
;
678 input_line_pointer
= str
;
680 str
= input_line_pointer
;
681 if (&input_line_pointer
!= str_p
)
682 input_line_pointer
= orig_line
;
684 if (exp_p
->X_op
!= O_symbol
)
685 return BFD_RELOC_UNUSED
;
687 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
688 if (len
== ptr
->length
689 && strncasecmp (ident
, ptr
->string
, ptr
->length
) == 0)
691 /* Found a matching tls suffix. */
695 return BFD_RELOC_UNUSED
;
698 /* Structure used to hold suffixes. */
709 ELF_SUFFIX_TLS_GOTIE
,
721 elf_suffix_type suffix
;
724 static elf_suffix_type s390_elf_suffix
PARAMS ((char **, expressionS
*));
725 static int s390_exp_compare
PARAMS ((expressionS
*exp1
, expressionS
*exp2
));
726 static elf_suffix_type s390_lit_suffix
727 PARAMS ((char **, expressionS
*, elf_suffix_type
));
730 /* Parse @got/@plt/@gotoff. and return the desired relocation. */
731 static elf_suffix_type
732 s390_elf_suffix (str_p
, exp_p
)
736 static struct map_bfd mapping
[] =
738 { "got", 3, ELF_SUFFIX_GOT
},
739 { "got12", 5, ELF_SUFFIX_GOT
},
740 { "plt", 3, ELF_SUFFIX_PLT
},
741 { "gotent", 6, ELF_SUFFIX_GOTENT
},
742 { "gotoff", 6, ELF_SUFFIX_GOTOFF
},
743 { "gotplt", 6, ELF_SUFFIX_GOTPLT
},
744 { "pltoff", 6, ELF_SUFFIX_PLTOFF
},
745 { "tlsgd", 5, ELF_SUFFIX_TLS_GD
},
746 { "gotntpoff", 9, ELF_SUFFIX_TLS_GOTIE
},
747 { "indntpoff", 9, ELF_SUFFIX_TLS_IE
},
748 { "tlsldm", 6, ELF_SUFFIX_TLS_LDM
},
749 { "dtpoff", 6, ELF_SUFFIX_TLS_LDO
},
750 { "ntpoff", 6, ELF_SUFFIX_TLS_LE
},
751 { NULL
, 0, ELF_SUFFIX_NONE
}
760 return ELF_SUFFIX_NONE
;
763 while (ISALNUM (*str
))
767 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
768 if (len
== ptr
->length
769 && strncasecmp (ident
, ptr
->string
, ptr
->length
) == 0)
771 if (exp_p
->X_add_number
!= 0)
772 as_warn (_("identifier+constant@%s means identifier@%s+constant"),
773 ptr
->string
, ptr
->string
);
774 /* Now check for identifier@suffix+constant. */
775 if (*str
== '-' || *str
== '+')
777 char *orig_line
= input_line_pointer
;
780 input_line_pointer
= str
;
781 expression (&new_exp
);
783 switch (new_exp
.X_op
)
785 case O_constant
: /* X_add_number (a constant expression). */
786 exp_p
->X_add_number
+= new_exp
.X_add_number
;
787 str
= input_line_pointer
;
789 case O_symbol
: /* X_add_symbol + X_add_number. */
790 /* this case is used for e.g. xyz@PLT+.Label. */
791 exp_p
->X_add_number
+= new_exp
.X_add_number
;
792 exp_p
->X_op_symbol
= new_exp
.X_add_symbol
;
794 str
= input_line_pointer
;
796 case O_uminus
: /* (- X_add_symbol) + X_add_number. */
797 /* this case is used for e.g. xyz@PLT-.Label. */
798 exp_p
->X_add_number
+= new_exp
.X_add_number
;
799 exp_p
->X_op_symbol
= new_exp
.X_add_symbol
;
800 exp_p
->X_op
= O_subtract
;
801 str
= input_line_pointer
;
807 /* If s390_elf_suffix has not been called with
808 &input_line_pointer as first parameter, we have
809 clobbered the input_line_pointer. We have to
811 if (&input_line_pointer
!= str_p
)
812 input_line_pointer
= orig_line
;
818 return BFD_RELOC_UNUSED
;
821 /* Structure used to hold a literal pool entry. */
824 struct s390_lpe
*next
;
826 FLONUM_TYPE floatnum
; /* used if X_op == O_big && X_add_number <= 0 */
827 LITTLENUM_TYPE bignum
[4]; /* used if X_op == O_big && X_add_number > 0 */
829 bfd_reloc_code_real_type reloc
;
833 static struct s390_lpe
*lpe_free_list
= NULL
;
834 static struct s390_lpe
*lpe_list
= NULL
;
835 static struct s390_lpe
*lpe_list_tail
= NULL
;
836 static symbolS
*lp_sym
= NULL
;
837 static int lp_count
= 0;
838 static int lpe_count
= 0;
841 s390_exp_compare (exp1
, exp2
)
845 if (exp1
->X_op
!= exp2
->X_op
)
850 case O_constant
: /* X_add_number must be equal. */
852 return exp1
->X_add_number
== exp2
->X_add_number
;
855 as_bad (_("Can't handle O_big in s390_exp_compare"));
857 case O_symbol
: /* X_add_symbol & X_add_number must be equal. */
862 return (exp1
->X_add_symbol
== exp2
->X_add_symbol
)
863 && (exp1
->X_add_number
== exp2
->X_add_number
);
865 case O_multiply
: /* X_add_symbol,X_op_symbol&X_add_number must be equal. */
870 case O_bit_inclusive_or
:
872 case O_bit_exclusive_or
:
884 return (exp1
->X_add_symbol
== exp2
->X_add_symbol
)
885 && (exp1
->X_op_symbol
== exp2
->X_op_symbol
)
886 && (exp1
->X_add_number
== exp2
->X_add_number
);
892 /* Test for @lit and if its present make an entry in the literal pool and
893 modify the current expression to be an offset into the literal pool. */
894 static elf_suffix_type
895 s390_lit_suffix (str_p
, exp_p
, suffix
)
898 elf_suffix_type suffix
;
900 bfd_reloc_code_real_type reloc
;
904 struct s390_lpe
*lpe
;
908 return suffix
; /* No modification. */
910 /* We look for a suffix of the form "@lit1", "@lit2", "@lit4" or "@lit8". */
912 while (ISALNUM (*str
))
915 if (len
!= 4 || strncasecmp (ident
, "lit", 3) != 0
916 || (ident
[3]!='1' && ident
[3]!='2' && ident
[3]!='4' && ident
[3]!='8'))
917 return suffix
; /* no modification */
918 nbytes
= ident
[3] - '0';
920 reloc
= BFD_RELOC_UNUSED
;
921 if (suffix
== ELF_SUFFIX_GOT
)
924 reloc
= BFD_RELOC_390_GOT16
;
925 else if (nbytes
== 4)
926 reloc
= BFD_RELOC_32_GOT_PCREL
;
927 else if (nbytes
== 8)
928 reloc
= BFD_RELOC_390_GOT64
;
930 else if (suffix
== ELF_SUFFIX_PLT
)
933 reloc
= BFD_RELOC_390_PLT32
;
934 else if (nbytes
== 8)
935 reloc
= BFD_RELOC_390_PLT64
;
938 if (suffix
!= ELF_SUFFIX_NONE
&& reloc
== BFD_RELOC_UNUSED
)
939 as_bad (_("Invalid suffix for literal pool entry"));
941 /* Search the pool if the new entry is a duplicate. */
942 if (exp_p
->X_op
== O_big
)
944 /* Special processing for big numbers. */
945 for (lpe
= lpe_list
; lpe
!= NULL
; lpe
= lpe
->next
)
947 if (lpe
->ex
.X_op
== O_big
)
949 if (exp_p
->X_add_number
<= 0 && lpe
->ex
.X_add_number
<= 0)
951 if (memcmp (&generic_floating_point_number
, &lpe
->floatnum
,
952 sizeof (FLONUM_TYPE
)) == 0)
955 else if (exp_p
->X_add_number
== lpe
->ex
.X_add_number
)
957 if (memcmp (generic_bignum
, lpe
->bignum
,
958 sizeof (LITTLENUM_TYPE
)*exp_p
->X_add_number
) == 0)
966 /* Processing for 'normal' data types. */
967 for (lpe
= lpe_list
; lpe
!= NULL
; lpe
= lpe
->next
)
968 if (lpe
->nbytes
== nbytes
&& lpe
->reloc
== reloc
969 && s390_exp_compare (exp_p
, &lpe
->ex
) != 0)
976 if (lpe_free_list
!= NULL
)
979 lpe_free_list
= lpe_free_list
->next
;
983 lpe
= (struct s390_lpe
*) xmalloc (sizeof (struct s390_lpe
));
988 if (exp_p
->X_op
== O_big
)
990 if (exp_p
->X_add_number
<= 0)
991 lpe
->floatnum
= generic_floating_point_number
;
992 else if (exp_p
->X_add_number
<= 4)
993 memcpy (lpe
->bignum
, generic_bignum
,
994 exp_p
->X_add_number
* sizeof (LITTLENUM_TYPE
));
996 as_bad (_("Big number is too big"));
999 lpe
->nbytes
= nbytes
;
1001 /* Literal pool name defined ? */
1004 sprintf (tmp_name
, ".L\001%i", lp_count
);
1005 lp_sym
= symbol_make (tmp_name
);
1008 /* Make name for literal pool entry. */
1009 sprintf (tmp_name
, ".L\001%i\002%i", lp_count
, lpe_count
);
1011 lpe
->sym
= symbol_make (tmp_name
);
1013 /* Add to literal pool list. */
1015 if (lpe_list_tail
!= NULL
)
1017 lpe_list_tail
->next
= lpe
;
1018 lpe_list_tail
= lpe
;
1021 lpe_list
= lpe_list_tail
= lpe
;
1024 /* Now change exp_p to the offset into the literal pool.
1025 Thats the expression: .L^Ax^By-.L^Ax */
1026 exp_p
->X_add_symbol
= lpe
->sym
;
1027 exp_p
->X_op_symbol
= lp_sym
;
1028 exp_p
->X_op
= O_subtract
;
1029 exp_p
->X_add_number
= 0;
1033 /* We change the suffix type to ELF_SUFFIX_NONE, because
1034 the difference of two local labels is just a number. */
1035 return ELF_SUFFIX_NONE
;
1038 /* Like normal .long/.short/.word, except support @got, etc.
1039 clobbers input_line_pointer, checks end-of-line. */
1041 s390_elf_cons (nbytes
)
1042 register int nbytes
; /* 1=.byte, 2=.word, 4=.long */
1045 elf_suffix_type suffix
;
1047 if (is_it_end_of_statement ())
1049 demand_empty_rest_of_line ();
1057 if (exp
.X_op
== O_symbol
1058 && *input_line_pointer
== '@'
1059 && (suffix
= s390_elf_suffix (&input_line_pointer
, &exp
)) != ELF_SUFFIX_NONE
)
1061 bfd_reloc_code_real_type reloc
;
1062 reloc_howto_type
*reloc_howto
;
1068 static bfd_reloc_code_real_type tab2
[] =
1070 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_NONE */
1071 BFD_RELOC_390_GOT16
, /* ELF_SUFFIX_GOT */
1072 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_PLT */
1073 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTENT */
1074 BFD_RELOC_16_GOTOFF
, /* ELF_SUFFIX_GOTOFF */
1075 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTPLT */
1076 BFD_RELOC_390_PLTOFF16
, /* ELF_SUFFIX_PLTOFF */
1077 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_GD */
1078 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_GOTIE */
1079 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_IE */
1080 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_LDM */
1081 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_TLS_LDO */
1082 BFD_RELOC_UNUSED
/* ELF_SUFFIX_TLS_LE */
1084 reloc
= tab2
[suffix
];
1086 else if (nbytes
== 4)
1088 static bfd_reloc_code_real_type tab4
[] =
1090 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_NONE */
1091 BFD_RELOC_32_GOT_PCREL
, /* ELF_SUFFIX_GOT */
1092 BFD_RELOC_390_PLT32
, /* ELF_SUFFIX_PLT */
1093 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTENT */
1094 BFD_RELOC_32_GOTOFF
, /* ELF_SUFFIX_GOTOFF */
1095 BFD_RELOC_390_GOTPLT32
, /* ELF_SUFFIX_GOTPLT */
1096 BFD_RELOC_390_PLTOFF32
, /* ELF_SUFFIX_PLTOFF */
1097 BFD_RELOC_390_TLS_GD32
, /* ELF_SUFFIX_TLS_GD */
1098 BFD_RELOC_390_TLS_GOTIE32
, /* ELF_SUFFIX_TLS_GOTIE */
1099 BFD_RELOC_390_TLS_IE32
, /* ELF_SUFFIX_TLS_IE */
1100 BFD_RELOC_390_TLS_LDM32
, /* ELF_SUFFIX_TLS_LDM */
1101 BFD_RELOC_390_TLS_LDO32
, /* ELF_SUFFIX_TLS_LDO */
1102 BFD_RELOC_390_TLS_LE32
/* ELF_SUFFIX_TLS_LE */
1104 reloc
= tab4
[suffix
];
1106 else if (nbytes
== 8)
1108 static bfd_reloc_code_real_type tab8
[] =
1110 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_NONE */
1111 BFD_RELOC_390_GOT64
, /* ELF_SUFFIX_GOT */
1112 BFD_RELOC_390_PLT64
, /* ELF_SUFFIX_PLT */
1113 BFD_RELOC_UNUSED
, /* ELF_SUFFIX_GOTENT */
1114 BFD_RELOC_390_GOTOFF64
, /* ELF_SUFFIX_GOTOFF */
1115 BFD_RELOC_390_GOTPLT64
, /* ELF_SUFFIX_GOTPLT */
1116 BFD_RELOC_390_PLTOFF64
, /* ELF_SUFFIX_PLTOFF */
1117 BFD_RELOC_390_TLS_GD64
, /* ELF_SUFFIX_TLS_GD */
1118 BFD_RELOC_390_TLS_GOTIE64
, /* ELF_SUFFIX_TLS_GOTIE */
1119 BFD_RELOC_390_TLS_IE64
, /* ELF_SUFFIX_TLS_IE */
1120 BFD_RELOC_390_TLS_LDM64
, /* ELF_SUFFIX_TLS_LDM */
1121 BFD_RELOC_390_TLS_LDO64
, /* ELF_SUFFIX_TLS_LDO */
1122 BFD_RELOC_390_TLS_LE64
/* ELF_SUFFIX_TLS_LE */
1124 reloc
= tab8
[suffix
];
1127 reloc
= BFD_RELOC_UNUSED
;
1129 if (reloc
!= BFD_RELOC_UNUSED
1130 && (reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
)))
1132 size
= bfd_get_reloc_size (reloc_howto
);
1134 as_bad (_("%s relocations do not fit in %d bytes"),
1135 reloc_howto
->name
, nbytes
);
1136 where
= frag_more (nbytes
);
1137 md_number_to_chars (where
, 0, size
);
1138 /* To make fixup_segment do the pc relative conversion the
1139 pcrel parameter on the fix_new_exp call needs to be FALSE. */
1140 fix_new_exp (frag_now
, where
- frag_now
->fr_literal
,
1141 size
, &exp
, FALSE
, reloc
);
1144 as_bad (_("relocation not applicable"));
1147 emit_expr (&exp
, (unsigned int) nbytes
);
1149 while (*input_line_pointer
++ == ',');
1151 input_line_pointer
--; /* Put terminator back into stream. */
1152 demand_empty_rest_of_line ();
1155 /* We need to keep a list of fixups. We can't simply generate them as
1156 we go, because that would require us to first create the frag, and
1157 that would screw up references to ``.''. */
1163 bfd_reloc_code_real_type reloc
;
1166 #define MAX_INSN_FIXUPS (4)
1168 /* This routine is called for each instruction to be assembled. */
1171 md_gather_operands (str
, insn
, opcode
)
1173 unsigned char *insn
;
1174 const struct s390_opcode
*opcode
;
1176 struct s390_fixup fixups
[MAX_INSN_FIXUPS
];
1177 const struct s390_operand
*operand
;
1178 const unsigned char *opindex_ptr
;
1180 elf_suffix_type suffix
;
1181 bfd_reloc_code_real_type reloc
;
1187 while (ISSPACE (*str
))
1193 /* Gather the operands. */
1195 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
1199 operand
= s390_operands
+ *opindex_ptr
;
1201 if (skip_optional
&& (operand
->flags
& S390_OPERAND_INDEX
))
1203 /* We do an early skip. For D(X,B) constructions the index
1204 register is skipped (X is optional). For D(L,B) the base
1205 register will be the skipped operand, because L is NOT
1211 /* Gather the operand. */
1212 hold
= input_line_pointer
;
1213 input_line_pointer
= str
;
1215 /* Parse the operand. */
1216 if (! register_name (&ex
))
1219 str
= input_line_pointer
;
1220 input_line_pointer
= hold
;
1222 /* Write the operand to the insn. */
1223 if (ex
.X_op
== O_illegal
)
1224 as_bad (_("illegal operand"));
1225 else if (ex
.X_op
== O_absent
)
1226 as_bad (_("missing operand"));
1227 else if (ex
.X_op
== O_register
|| ex
.X_op
== O_constant
)
1229 s390_lit_suffix (&str
, &ex
, ELF_SUFFIX_NONE
);
1231 if (ex
.X_op
!= O_register
&& ex
.X_op
!= O_constant
)
1233 /* We need to generate a fixup for the
1234 expression returned by s390_lit_suffix. */
1235 if (fc
>= MAX_INSN_FIXUPS
)
1236 as_fatal (_("too many fixups"));
1237 fixups
[fc
].exp
= ex
;
1238 fixups
[fc
].opindex
= *opindex_ptr
;
1239 fixups
[fc
].reloc
= BFD_RELOC_UNUSED
;
1244 if ((operand
->flags
& S390_OPERAND_INDEX
)
1245 && ex
.X_add_number
== 0
1247 as_warn ("index register specified but zero");
1248 if ((operand
->flags
& S390_OPERAND_BASE
)
1249 && ex
.X_add_number
== 0
1251 as_warn ("base register specified but zero");
1252 s390_insert_operand (insn
, operand
, ex
.X_add_number
, NULL
, 0);
1257 suffix
= s390_elf_suffix (&str
, &ex
);
1258 suffix
= s390_lit_suffix (&str
, &ex
, suffix
);
1259 reloc
= BFD_RELOC_UNUSED
;
1261 if (suffix
== ELF_SUFFIX_GOT
)
1263 if ((operand
->flags
& S390_OPERAND_DISP
) &&
1264 (operand
->bits
== 12))
1265 reloc
= BFD_RELOC_390_GOT12
;
1266 else if ((operand
->flags
& S390_OPERAND_DISP
) &&
1267 (operand
->bits
== 20))
1268 reloc
= BFD_RELOC_390_GOT20
;
1269 else if ((operand
->flags
& S390_OPERAND_SIGNED
)
1270 && (operand
->bits
== 16))
1271 reloc
= BFD_RELOC_390_GOT16
;
1272 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1273 && (operand
->bits
== 32))
1274 reloc
= BFD_RELOC_390_GOTENT
;
1276 else if (suffix
== ELF_SUFFIX_PLT
)
1278 if ((operand
->flags
& S390_OPERAND_PCREL
)
1279 && (operand
->bits
== 16))
1280 reloc
= BFD_RELOC_390_PLT16DBL
;
1281 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1282 && (operand
->bits
== 32))
1283 reloc
= BFD_RELOC_390_PLT32DBL
;
1285 else if (suffix
== ELF_SUFFIX_GOTENT
)
1287 if ((operand
->flags
& S390_OPERAND_PCREL
)
1288 && (operand
->bits
== 32))
1289 reloc
= BFD_RELOC_390_GOTENT
;
1291 else if (suffix
== ELF_SUFFIX_GOTOFF
)
1293 if ((operand
->flags
& S390_OPERAND_SIGNED
)
1294 && (operand
->bits
== 16))
1295 reloc
= BFD_RELOC_16_GOTOFF
;
1297 else if (suffix
== ELF_SUFFIX_PLTOFF
)
1299 if ((operand
->flags
& S390_OPERAND_SIGNED
)
1300 && (operand
->bits
== 16))
1301 reloc
= BFD_RELOC_390_PLTOFF16
;
1303 else if (suffix
== ELF_SUFFIX_GOTPLT
)
1305 if ((operand
->flags
& S390_OPERAND_DISP
)
1306 && (operand
->bits
== 12))
1307 reloc
= BFD_RELOC_390_GOTPLT12
;
1308 else if ((operand
->flags
& S390_OPERAND_SIGNED
)
1309 && (operand
->bits
== 16))
1310 reloc
= BFD_RELOC_390_GOTPLT16
;
1311 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1312 && (operand
->bits
== 32))
1313 reloc
= BFD_RELOC_390_GOTPLTENT
;
1315 else if (suffix
== ELF_SUFFIX_TLS_GOTIE
)
1317 if ((operand
->flags
& S390_OPERAND_DISP
)
1318 && (operand
->bits
== 12))
1319 reloc
= BFD_RELOC_390_TLS_GOTIE12
;
1320 else if ((operand
->flags
& S390_OPERAND_DISP
)
1321 && (operand
->bits
== 20))
1322 reloc
= BFD_RELOC_390_TLS_GOTIE20
;
1324 else if (suffix
== ELF_SUFFIX_TLS_IE
)
1326 if ((operand
->flags
& S390_OPERAND_PCREL
)
1327 && (operand
->bits
== 32))
1328 reloc
= BFD_RELOC_390_TLS_IEENT
;
1331 if (suffix
!= ELF_SUFFIX_NONE
&& reloc
== BFD_RELOC_UNUSED
)
1332 as_bad (_("invalid operand suffix"));
1333 /* We need to generate a fixup of type 'reloc' for this
1335 if (fc
>= MAX_INSN_FIXUPS
)
1336 as_fatal (_("too many fixups"));
1337 fixups
[fc
].exp
= ex
;
1338 fixups
[fc
].opindex
= *opindex_ptr
;
1339 fixups
[fc
].reloc
= reloc
;
1343 /* Check the next character. The call to expression has advanced
1344 str past any whitespace. */
1345 if (operand
->flags
& S390_OPERAND_DISP
)
1347 /* After a displacement a block in parentheses can start. */
1350 /* Check if parenthesized block can be skipped. If the next
1351 operand is neiter an optional operand nor a base register
1352 then we have a syntax error. */
1353 operand
= s390_operands
+ *(++opindex_ptr
);
1354 if (!(operand
->flags
& (S390_OPERAND_INDEX
|S390_OPERAND_BASE
)))
1355 as_bad (_("syntax error; missing '(' after displacement"));
1357 /* Ok, skip all operands until S390_OPERAND_BASE. */
1358 while (!(operand
->flags
& S390_OPERAND_BASE
))
1359 operand
= s390_operands
+ *(++opindex_ptr
);
1361 /* If there is a next operand it must be separated by a comma. */
1362 if (opindex_ptr
[1] != '\0')
1366 while (opindex_ptr
[1] != '\0')
1368 operand
= s390_operands
+ *(++opindex_ptr
);
1369 if (operand
->flags
& S390_OPERAND_OPTIONAL
)
1371 as_bad (_("syntax error; expected ,"));
1381 /* We found an opening parentheses. */
1383 for (f
= str
; *f
!= '\0'; f
++)
1384 if (*f
== ',' || *f
== ')')
1386 /* If there is no comma until the closing parentheses OR
1387 there is a comma right after the opening parentheses,
1388 we have to skip optional operands. */
1389 if (*f
== ',' && f
== str
)
1391 /* comma directly after '(' ? */
1396 skip_optional
= (*f
!= ',');
1399 else if (operand
->flags
& S390_OPERAND_BASE
)
1401 /* After the base register the parenthesed block ends. */
1403 as_bad (_("syntax error; missing ')' after base register"));
1405 /* If there is a next operand it must be separated by a comma. */
1406 if (opindex_ptr
[1] != '\0')
1410 while (opindex_ptr
[1] != '\0')
1412 operand
= s390_operands
+ *(++opindex_ptr
);
1413 if (operand
->flags
& S390_OPERAND_OPTIONAL
)
1415 as_bad (_("syntax error; expected ,"));
1425 /* We can find an 'early' closing parentheses in e.g. D(L) instead
1426 of D(L,B). In this case the base register has to be skipped. */
1429 operand
= s390_operands
+ *(++opindex_ptr
);
1431 if (!(operand
->flags
& S390_OPERAND_BASE
))
1432 as_bad (_("syntax error; ')' not allowed here"));
1435 /* If there is a next operand it must be separated by a comma. */
1436 if (opindex_ptr
[1] != '\0')
1440 while (opindex_ptr
[1] != '\0')
1442 operand
= s390_operands
+ *(++opindex_ptr
);
1443 if (operand
->flags
& S390_OPERAND_OPTIONAL
)
1445 as_bad (_("syntax error; expected ,"));
1455 while (ISSPACE (*str
))
1458 /* Check for tls instruction marker. */
1459 reloc
= s390_tls_suffix (&str
, &ex
);
1460 if (reloc
!= BFD_RELOC_UNUSED
)
1462 /* We need to generate a fixup of type 'reloc' for this
1464 if (fc
>= MAX_INSN_FIXUPS
)
1465 as_fatal (_("too many fixups"));
1466 fixups
[fc
].exp
= ex
;
1467 fixups
[fc
].opindex
= -1;
1468 fixups
[fc
].reloc
= reloc
;
1476 if ((linefeed
= strchr (str
, '\n')) != NULL
)
1478 as_bad (_("junk at end of line: `%s'"), str
);
1479 if (linefeed
!= NULL
)
1483 /* Write out the instruction. */
1484 f
= frag_more (opcode
->oplen
);
1485 memcpy (f
, insn
, opcode
->oplen
);
1486 dwarf2_emit_insn (opcode
->oplen
);
1488 /* Create any fixups. At this point we do not use a
1489 bfd_reloc_code_real_type, but instead just use the
1490 BFD_RELOC_UNUSED plus the operand index. This lets us easily
1491 handle fixups for any operand type, although that is admittedly
1492 not a very exciting feature. We pick a BFD reloc type in
1494 for (i
= 0; i
< fc
; i
++)
1497 if (fixups
[i
].opindex
< 0)
1499 /* Create tls instruction marker relocation. */
1500 fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, opcode
->oplen
,
1501 &fixups
[i
].exp
, 0, fixups
[i
].reloc
);
1505 operand
= s390_operands
+ fixups
[i
].opindex
;
1507 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
1509 reloc_howto_type
*reloc_howto
;
1513 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
1517 size
= bfd_get_reloc_size (reloc_howto
);
1519 if (size
< 1 || size
> 4)
1522 fixP
= fix_new_exp (frag_now
,
1523 f
- frag_now
->fr_literal
+ (operand
->shift
/8),
1524 size
, &fixups
[i
].exp
, reloc_howto
->pc_relative
,
1526 /* Turn off overflow checking in fixup_segment. This is necessary
1527 because fixup_segment will signal an overflow for large 4 byte
1528 quantities for GOT12 relocations. */
1529 if ( fixups
[i
].reloc
== BFD_RELOC_390_GOT12
1530 || fixups
[i
].reloc
== BFD_RELOC_390_GOT20
1531 || fixups
[i
].reloc
== BFD_RELOC_390_GOT16
)
1532 fixP
->fx_no_overflow
= 1;
1535 fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, 4, &fixups
[i
].exp
,
1536 (operand
->flags
& S390_OPERAND_PCREL
) != 0,
1537 ((bfd_reloc_code_real_type
)
1538 (fixups
[i
].opindex
+ (int) BFD_RELOC_UNUSED
)));
1543 /* This routine is called for each instruction to be assembled. */
1549 const struct s390_opcode
*opcode
;
1550 unsigned char insn
[6];
1553 /* Get the opcode. */
1554 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
1559 /* Look up the opcode in the hash table. */
1560 opcode
= (struct s390_opcode
*) hash_find (s390_opcode_hash
, str
);
1561 if (opcode
== (const struct s390_opcode
*) NULL
)
1563 as_bad (_("Unrecognized opcode: `%s'"), str
);
1566 else if (!(opcode
->modes
& current_mode_mask
))
1568 as_bad ("Opcode %s not available in this mode", str
);
1571 memcpy (insn
, opcode
->opcode
, sizeof (insn
));
1572 md_gather_operands (s
, insn
, opcode
);
1575 #ifndef WORKING_DOT_WORD
1576 /* Handle long and short jumps. We don't support these */
1578 md_create_short_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
1580 addressT from_addr
, to_addr
;
1588 md_create_long_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
1590 addressT from_addr
, to_addr
;
1600 int ignore ATTRIBUTE_UNUSED
;
1602 /* We don't support putting frags in the BSS segment, we fake it
1603 by marking in_bss, then looking at s_skip for clues. */
1605 subseg_set (bss_section
, 0);
1606 demand_empty_rest_of_line ();
1609 /* Pseudo-op handling. */
1613 int ignore ATTRIBUTE_UNUSED
;
1616 const struct s390_opcode
*opformat
;
1617 unsigned char insn
[6];
1620 /* Get the opcode format. */
1621 s
= input_line_pointer
;
1622 while (*s
!= '\0' && *s
!= ',' && ! ISSPACE (*s
))
1625 as_bad (_("Invalid .insn format\n"));
1628 /* Look up the opcode in the hash table. */
1629 opformat
= (struct s390_opcode
*)
1630 hash_find (s390_opformat_hash
, input_line_pointer
);
1631 if (opformat
== (const struct s390_opcode
*) NULL
)
1633 as_bad (_("Unrecognized opcode format: `%s'"), input_line_pointer
);
1636 input_line_pointer
= s
;
1638 if (exp
.X_op
== O_constant
)
1640 if ( ( opformat
->oplen
== 6
1641 && (addressT
) exp
.X_add_number
< (1ULL << 48))
1642 || ( opformat
->oplen
== 4
1643 && (addressT
) exp
.X_add_number
< (1ULL << 32))
1644 || ( opformat
->oplen
== 2
1645 && (addressT
) exp
.X_add_number
< (1ULL << 16)))
1646 md_number_to_chars ((char *) insn
, exp
.X_add_number
, opformat
->oplen
);
1648 as_bad (_("Invalid .insn format\n"));
1650 else if (exp
.X_op
== O_big
)
1652 if (exp
.X_add_number
> 0
1653 && opformat
->oplen
== 6
1654 && generic_bignum
[3] == 0)
1656 md_number_to_chars ((char *) insn
, generic_bignum
[2], 2);
1657 md_number_to_chars ((char *) &insn
[2], generic_bignum
[1], 2);
1658 md_number_to_chars ((char *) &insn
[4], generic_bignum
[0], 2);
1661 as_bad (_("Invalid .insn format\n"));
1664 as_bad (_("second operand of .insn not a constant\n"));
1666 if (strcmp (opformat
->name
, "e") != 0 && *input_line_pointer
++ != ',')
1667 as_bad (_("missing comma after insn constant\n"));
1669 if ((s
= strchr (input_line_pointer
, '\n')) != NULL
)
1671 input_line_pointer
= md_gather_operands (input_line_pointer
, insn
,
1675 demand_empty_rest_of_line ();
1678 /* The .byte pseudo-op. This is similar to the normal .byte
1679 pseudo-op, but it can also take a single ASCII string. */
1683 int ignore ATTRIBUTE_UNUSED
;
1685 if (*input_line_pointer
!= '\"')
1691 /* Gather characters. A real double quote is doubled. Unusual
1692 characters are not permitted. */
1693 ++input_line_pointer
;
1698 c
= *input_line_pointer
++;
1702 if (*input_line_pointer
!= '\"')
1704 ++input_line_pointer
;
1707 FRAG_APPEND_1_CHAR (c
);
1710 demand_empty_rest_of_line ();
1713 /* The .ltorg pseudo-op.This emits all literals defined since the last
1714 .ltorg or the invocation of gas. Literals are defined with the
1718 s390_literals (ignore
)
1719 int ignore ATTRIBUTE_UNUSED
;
1721 struct s390_lpe
*lpe
;
1723 if (lp_sym
== NULL
|| lpe_count
== 0)
1724 return; /* Nothing to be done. */
1726 /* Emit symbol for start of literal pool. */
1727 S_SET_SEGMENT (lp_sym
, now_seg
);
1728 S_SET_VALUE (lp_sym
, (valueT
) frag_now_fix ());
1729 lp_sym
->sy_frag
= frag_now
;
1734 lpe_list
= lpe_list
->next
;
1735 S_SET_SEGMENT (lpe
->sym
, now_seg
);
1736 S_SET_VALUE (lpe
->sym
, (valueT
) frag_now_fix ());
1737 lpe
->sym
->sy_frag
= frag_now
;
1739 /* Emit literal pool entry. */
1740 if (lpe
->reloc
!= BFD_RELOC_UNUSED
)
1742 reloc_howto_type
*reloc_howto
=
1743 bfd_reloc_type_lookup (stdoutput
, lpe
->reloc
);
1744 int size
= bfd_get_reloc_size (reloc_howto
);
1747 if (size
> lpe
->nbytes
)
1748 as_bad (_("%s relocations do not fit in %d bytes"),
1749 reloc_howto
->name
, lpe
->nbytes
);
1750 where
= frag_more (lpe
->nbytes
);
1751 md_number_to_chars (where
, 0, size
);
1752 fix_new_exp (frag_now
, where
- frag_now
->fr_literal
,
1753 size
, &lpe
->ex
, reloc_howto
->pc_relative
, lpe
->reloc
);
1757 if (lpe
->ex
.X_op
== O_big
)
1759 if (lpe
->ex
.X_add_number
<= 0)
1760 generic_floating_point_number
= lpe
->floatnum
;
1762 memcpy (generic_bignum
, lpe
->bignum
,
1763 lpe
->ex
.X_add_number
* sizeof (LITTLENUM_TYPE
));
1765 emit_expr (&lpe
->ex
, lpe
->nbytes
);
1768 lpe
->next
= lpe_free_list
;
1769 lpe_free_list
= lpe
;
1771 lpe_list_tail
= NULL
;
1778 md_atof (int type
, char *litp
, int *sizep
)
1780 return ieee_md_atof (type
, litp
, sizep
, TRUE
);
1783 /* Align a section (I don't know why this is machine dependent). */
1786 md_section_align (seg
, addr
)
1790 int align
= bfd_get_section_alignment (stdoutput
, seg
);
1792 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
1795 /* We don't have any form of relaxing. */
1798 md_estimate_size_before_relax (fragp
, seg
)
1799 fragS
*fragp ATTRIBUTE_UNUSED
;
1800 asection
*seg ATTRIBUTE_UNUSED
;
1806 /* Convert a machine dependent frag. We never generate these. */
1809 md_convert_frag (abfd
, sec
, fragp
)
1810 bfd
*abfd ATTRIBUTE_UNUSED
;
1811 asection
*sec ATTRIBUTE_UNUSED
;
1812 fragS
*fragp ATTRIBUTE_UNUSED
;
1818 md_undefined_symbol (name
)
1821 if (*name
== '_' && *(name
+ 1) == 'G'
1822 && strcmp (name
, "_GLOBAL_OFFSET_TABLE_") == 0)
1826 if (symbol_find (name
))
1827 as_bad (_("GOT already in symbol table"));
1828 GOT_symbol
= symbol_new (name
, undefined_section
,
1829 (valueT
) 0, &zero_address_frag
);
1836 /* Functions concerning relocs. */
1838 /* The location from which a PC relative jump should be calculated,
1839 given a PC relative reloc. */
1842 md_pcrel_from_section (fixp
, sec
)
1844 segT sec ATTRIBUTE_UNUSED
;
1846 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
1849 /* Here we decide which fixups can be adjusted to make them relative to
1850 the beginning of the section instead of the symbol. Basically we need
1851 to make sure that the dynamic relocations are done correctly, so in
1852 some cases we force the original symbol to be used. */
1854 tc_s390_fix_adjustable (fixP
)
1857 /* Don't adjust references to merge sections. */
1858 if ((S_GET_SEGMENT (fixP
->fx_addsy
)->flags
& SEC_MERGE
) != 0)
1860 /* adjust_reloc_syms doesn't know about the GOT. */
1861 if ( fixP
->fx_r_type
== BFD_RELOC_16_GOTOFF
1862 || fixP
->fx_r_type
== BFD_RELOC_32_GOTOFF
1863 || fixP
->fx_r_type
== BFD_RELOC_390_GOTOFF64
1864 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF16
1865 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF32
1866 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF64
1867 || fixP
->fx_r_type
== BFD_RELOC_390_PLT16DBL
1868 || fixP
->fx_r_type
== BFD_RELOC_390_PLT32
1869 || fixP
->fx_r_type
== BFD_RELOC_390_PLT32DBL
1870 || fixP
->fx_r_type
== BFD_RELOC_390_PLT64
1871 || fixP
->fx_r_type
== BFD_RELOC_390_GOT12
1872 || fixP
->fx_r_type
== BFD_RELOC_390_GOT20
1873 || fixP
->fx_r_type
== BFD_RELOC_390_GOT16
1874 || fixP
->fx_r_type
== BFD_RELOC_32_GOT_PCREL
1875 || fixP
->fx_r_type
== BFD_RELOC_390_GOT64
1876 || fixP
->fx_r_type
== BFD_RELOC_390_GOTENT
1877 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT12
1878 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT16
1879 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT20
1880 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT32
1881 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT64
1882 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLTENT
1883 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LOAD
1884 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GDCALL
1885 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDCALL
1886 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GD32
1887 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GD64
1888 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE12
1889 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE20
1890 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE32
1891 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_GOTIE64
1892 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDM32
1893 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDM64
1894 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IE32
1895 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IE64
1896 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_IEENT
1897 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LE32
1898 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LE64
1899 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDO32
1900 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_LDO64
1901 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_DTPMOD
1902 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_DTPOFF
1903 || fixP
->fx_r_type
== BFD_RELOC_390_TLS_TPOFF
1904 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
1905 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
1910 /* Return true if we must always emit a reloc for a type and false if
1911 there is some hope of resolving it at assembly time. */
1913 tc_s390_force_relocation (fixp
)
1916 /* Ensure we emit a relocation for every reference to the global
1917 offset table or to the procedure link table. */
1918 switch (fixp
->fx_r_type
)
1920 case BFD_RELOC_390_GOT12
:
1921 case BFD_RELOC_390_GOT20
:
1922 case BFD_RELOC_32_GOT_PCREL
:
1923 case BFD_RELOC_32_GOTOFF
:
1924 case BFD_RELOC_390_GOTOFF64
:
1925 case BFD_RELOC_390_PLTOFF16
:
1926 case BFD_RELOC_390_PLTOFF32
:
1927 case BFD_RELOC_390_PLTOFF64
:
1928 case BFD_RELOC_390_GOTPC
:
1929 case BFD_RELOC_390_GOT16
:
1930 case BFD_RELOC_390_GOTPCDBL
:
1931 case BFD_RELOC_390_GOT64
:
1932 case BFD_RELOC_390_GOTENT
:
1933 case BFD_RELOC_390_PLT32
:
1934 case BFD_RELOC_390_PLT16DBL
:
1935 case BFD_RELOC_390_PLT32DBL
:
1936 case BFD_RELOC_390_PLT64
:
1937 case BFD_RELOC_390_GOTPLT12
:
1938 case BFD_RELOC_390_GOTPLT16
:
1939 case BFD_RELOC_390_GOTPLT20
:
1940 case BFD_RELOC_390_GOTPLT32
:
1941 case BFD_RELOC_390_GOTPLT64
:
1942 case BFD_RELOC_390_GOTPLTENT
:
1948 return generic_force_reloc (fixp
);
1951 /* Apply a fixup to the object code. This is called for all the
1952 fixups we generated by the call to fix_new_exp, above. In the call
1953 above we used a reloc code which was the largest legal reloc code
1954 plus the operand index. Here we undo that to recover the operand
1955 index. At this point all symbol values should be fully resolved,
1956 and we attempt to completely resolve the reloc. If we can not do
1957 that, we determine the correct reloc code and put it back in the
1961 md_apply_fix (fixP
, valP
, seg
)
1964 segT seg ATTRIBUTE_UNUSED
;
1967 valueT value
= *valP
;
1969 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
1971 if (fixP
->fx_subsy
!= NULL
)
1972 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1973 "cannot emit relocation %s against subsy symbol %s",
1974 bfd_get_reloc_code_name (fixP
->fx_r_type
),
1975 S_GET_NAME (fixP
->fx_subsy
));
1977 if (fixP
->fx_addsy
!= NULL
)
1980 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
1985 if ((int) fixP
->fx_r_type
>= (int) BFD_RELOC_UNUSED
)
1987 const struct s390_operand
*operand
;
1990 opindex
= (int) fixP
->fx_r_type
- (int) BFD_RELOC_UNUSED
;
1991 operand
= &s390_operands
[opindex
];
1995 /* Insert the fully resolved operand value. */
1996 s390_insert_operand ((unsigned char *) where
, operand
,
1997 (offsetT
) value
, fixP
->fx_file
, fixP
->fx_line
);
2001 /* Determine a BFD reloc value based on the operand information.
2002 We are only prepared to turn a few of the operands into
2004 fixP
->fx_offset
= value
;
2005 if (operand
->bits
== 12 && operand
->shift
== 20)
2008 fixP
->fx_where
+= 2;
2009 fixP
->fx_r_type
= BFD_RELOC_390_12
;
2011 else if (operand
->bits
== 12 && operand
->shift
== 36)
2014 fixP
->fx_where
+= 4;
2015 fixP
->fx_r_type
= BFD_RELOC_390_12
;
2017 else if (operand
->bits
== 20 && operand
->shift
== 20)
2020 fixP
->fx_where
+= 2;
2021 fixP
->fx_r_type
= BFD_RELOC_390_20
;
2023 else if (operand
->bits
== 8 && operand
->shift
== 8)
2026 fixP
->fx_where
+= 1;
2027 fixP
->fx_r_type
= BFD_RELOC_8
;
2029 else if (operand
->bits
== 16 && operand
->shift
== 16)
2032 fixP
->fx_where
+= 2;
2033 if (operand
->flags
& S390_OPERAND_PCREL
)
2035 fixP
->fx_r_type
= BFD_RELOC_390_PC16DBL
;
2036 fixP
->fx_offset
+= 2;
2039 fixP
->fx_r_type
= BFD_RELOC_16
;
2041 else if (operand
->bits
== 32 && operand
->shift
== 16
2042 && (operand
->flags
& S390_OPERAND_PCREL
))
2045 fixP
->fx_where
+= 2;
2046 fixP
->fx_offset
+= 2;
2047 fixP
->fx_r_type
= BFD_RELOC_390_PC32DBL
;
2054 /* Use expr_symbol_where to see if this is an expression
2056 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
2057 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2058 _("unresolved expression that must be resolved"));
2060 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2061 _("unsupported relocation type"));
2068 switch (fixP
->fx_r_type
)
2074 md_number_to_chars (where
, value
, 1);
2076 case BFD_RELOC_390_12
:
2077 case BFD_RELOC_390_GOT12
:
2078 case BFD_RELOC_390_GOTPLT12
:
2083 mop
= bfd_getb16 ((unsigned char *) where
);
2084 mop
|= (unsigned short) (value
& 0xfff);
2085 bfd_putb16 ((bfd_vma
) mop
, (unsigned char *) where
);
2089 case BFD_RELOC_390_20
:
2090 case BFD_RELOC_390_GOT20
:
2091 case BFD_RELOC_390_GOTPLT20
:
2095 mop
= bfd_getb32 ((unsigned char *) where
);
2096 mop
|= (unsigned int) ((value
& 0xfff) << 8 |
2097 (value
& 0xff000) >> 12);
2098 bfd_putb32 ((bfd_vma
) mop
, (unsigned char *) where
);
2103 case BFD_RELOC_GPREL16
:
2104 case BFD_RELOC_16_GOT_PCREL
:
2105 case BFD_RELOC_16_GOTOFF
:
2107 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
2108 "cannot emit PC relative %s relocation%s%s",
2109 bfd_get_reloc_code_name (fixP
->fx_r_type
),
2110 fixP
->fx_addsy
!= NULL
? " against " : "",
2111 (fixP
->fx_addsy
!= NULL
2112 ? S_GET_NAME (fixP
->fx_addsy
)
2115 md_number_to_chars (where
, value
, 2);
2117 case BFD_RELOC_390_GOT16
:
2118 case BFD_RELOC_390_PLTOFF16
:
2119 case BFD_RELOC_390_GOTPLT16
:
2121 md_number_to_chars (where
, value
, 2);
2123 case BFD_RELOC_390_PC16DBL
:
2124 case BFD_RELOC_390_PLT16DBL
:
2127 md_number_to_chars (where
, (offsetT
) value
>> 1, 2);
2132 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
2134 fixP
->fx_r_type
= BFD_RELOC_32
;
2136 md_number_to_chars (where
, value
, 4);
2138 case BFD_RELOC_32_PCREL
:
2139 case BFD_RELOC_32_BASEREL
:
2140 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
2142 md_number_to_chars (where
, value
, 4);
2144 case BFD_RELOC_32_GOT_PCREL
:
2145 case BFD_RELOC_390_PLTOFF32
:
2146 case BFD_RELOC_390_PLT32
:
2147 case BFD_RELOC_390_GOTPLT32
:
2149 md_number_to_chars (where
, value
, 4);
2151 case BFD_RELOC_390_PC32DBL
:
2152 case BFD_RELOC_390_PLT32DBL
:
2153 case BFD_RELOC_390_GOTPCDBL
:
2154 case BFD_RELOC_390_GOTENT
:
2155 case BFD_RELOC_390_GOTPLTENT
:
2158 md_number_to_chars (where
, (offsetT
) value
>> 1, 4);
2161 case BFD_RELOC_32_GOTOFF
:
2163 md_number_to_chars (where
, value
, sizeof (int));
2166 case BFD_RELOC_390_GOTOFF64
:
2168 md_number_to_chars (where
, value
, 8);
2171 case BFD_RELOC_390_GOT64
:
2172 case BFD_RELOC_390_PLTOFF64
:
2173 case BFD_RELOC_390_PLT64
:
2174 case BFD_RELOC_390_GOTPLT64
:
2176 md_number_to_chars (where
, value
, 8);
2181 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
2183 fixP
->fx_r_type
= BFD_RELOC_64
;
2185 md_number_to_chars (where
, value
, 8);
2188 case BFD_RELOC_64_PCREL
:
2189 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
2191 md_number_to_chars (where
, value
, 8);
2194 case BFD_RELOC_VTABLE_INHERIT
:
2195 case BFD_RELOC_VTABLE_ENTRY
:
2199 case BFD_RELOC_390_TLS_LOAD
:
2200 case BFD_RELOC_390_TLS_GDCALL
:
2201 case BFD_RELOC_390_TLS_LDCALL
:
2202 case BFD_RELOC_390_TLS_GD32
:
2203 case BFD_RELOC_390_TLS_GD64
:
2204 case BFD_RELOC_390_TLS_GOTIE12
:
2205 case BFD_RELOC_390_TLS_GOTIE20
:
2206 case BFD_RELOC_390_TLS_GOTIE32
:
2207 case BFD_RELOC_390_TLS_GOTIE64
:
2208 case BFD_RELOC_390_TLS_LDM32
:
2209 case BFD_RELOC_390_TLS_LDM64
:
2210 case BFD_RELOC_390_TLS_IE32
:
2211 case BFD_RELOC_390_TLS_IE64
:
2212 case BFD_RELOC_390_TLS_LE32
:
2213 case BFD_RELOC_390_TLS_LE64
:
2214 case BFD_RELOC_390_TLS_LDO32
:
2215 case BFD_RELOC_390_TLS_LDO64
:
2216 case BFD_RELOC_390_TLS_DTPMOD
:
2217 case BFD_RELOC_390_TLS_DTPOFF
:
2218 case BFD_RELOC_390_TLS_TPOFF
:
2219 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
2220 /* Fully resolved at link time. */
2222 case BFD_RELOC_390_TLS_IEENT
:
2223 /* Fully resolved at link time. */
2224 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
2230 const char *reloc_name
= bfd_get_reloc_code_name (fixP
->fx_r_type
);
2232 if (reloc_name
!= NULL
)
2233 fprintf (stderr
, "Gas failure, reloc type %s\n", reloc_name
);
2235 fprintf (stderr
, "Gas failure, reloc type #%i\n", fixP
->fx_r_type
);
2241 fixP
->fx_offset
= value
;
2245 /* Generate a reloc for a fixup. */
2248 tc_gen_reloc (seg
, fixp
)
2249 asection
*seg ATTRIBUTE_UNUSED
;
2252 bfd_reloc_code_real_type code
;
2255 code
= fixp
->fx_r_type
;
2256 if (GOT_symbol
&& fixp
->fx_addsy
== GOT_symbol
)
2258 if ( (s390_arch_size
== 32 && code
== BFD_RELOC_32_PCREL
)
2259 || (s390_arch_size
== 64 && code
== BFD_RELOC_64_PCREL
))
2260 code
= BFD_RELOC_390_GOTPC
;
2261 if (code
== BFD_RELOC_390_PC32DBL
)
2262 code
= BFD_RELOC_390_GOTPCDBL
;
2265 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
2266 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
2267 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
2268 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
2269 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
2270 if (reloc
->howto
== NULL
)
2272 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2273 _("cannot represent relocation type %s"),
2274 bfd_get_reloc_code_name (code
));
2275 /* Set howto to a garbage value so that we can keep going. */
2276 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, BFD_RELOC_32
);
2277 assert (reloc
->howto
!= NULL
);
2279 reloc
->addend
= fixp
->fx_offset
;
2285 s390_cfi_frame_initial_instructions ()
2287 cfi_add_CFA_def_cfa (15, s390_arch_size
== 64 ? 160 : 96);
2291 tc_s390_regname_to_dw2regnum (char *regname
)
2295 if (regname
[0] != 'c' && regname
[0] != 'a')
2297 regnum
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
, regname
);
2298 if (regname
[0] == 'f' && regnum
!= -1)
2301 else if (strcmp (regname
, "ap") == 0)
2303 else if (strcmp (regname
, "cc") == 0)