1 /* tc-s390.c -- Assemble for the S390
2 Copyright 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
3 Contributed by Martin Schwidefsky (schwidefsky@de.ibm.com).
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
24 #include "safe-ctype.h"
26 #include "struc-symbol.h"
27 #include "dwarf2dbg.h"
29 #include "opcode/s390.h"
32 /* The default architecture. */
34 #define DEFAULT_ARCH "s390"
36 static char *default_arch
= DEFAULT_ARCH
;
37 /* Either 32 or 64, selects file format. */
38 static int s390_arch_size
;
39 /* Current architecture. Start with the smallest instruction set. */
40 static enum s390_opcode_arch_val current_architecture
= S390_OPCODE_ESA
;
41 static int current_arch_mask
= 1 << S390_OPCODE_ESA
;
42 static int current_arch_requested
= 0;
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 target specific pseudo-ops which we support. */
76 /* Define the prototypes for the pseudo-ops */
77 static void s390_byte
PARAMS ((int));
78 static void s390_elf_cons
PARAMS ((int));
79 static void s390_bss
PARAMS ((int));
80 static void s390_insn
PARAMS ((int));
81 static void s390_literals
PARAMS ((int));
83 const pseudo_typeS md_pseudo_table
[] =
85 { "align", s_align_bytes
, 0 },
86 /* Pseudo-ops which must be defined. */
87 { "bss", s390_bss
, 0 },
88 { "insn", s390_insn
, 0 },
89 /* Pseudo-ops which must be overridden. */
90 { "byte", s390_byte
, 0 },
91 { "short", s390_elf_cons
, 2 },
92 { "long", s390_elf_cons
, 4 },
93 { "quad", s390_elf_cons
, 8 },
94 { "ltorg", s390_literals
, 0 },
95 { "string", stringer
, 2 },
100 /* Structure to hold information about predefined registers. */
107 /* List of registers that are pre-defined:
109 Each access register has a predefined name of the form:
110 a<reg_num> which has the value <reg_num>.
112 Each control register has a predefined name of the form:
113 c<reg_num> which has the value <reg_num>.
115 Each general register has a predefined name of the form:
116 r<reg_num> which has the value <reg_num>.
118 Each floating point register a has predefined name of the form:
119 f<reg_num> which has the value <reg_num>.
121 There are individual registers as well:
125 The table is sorted. Suitable for searching by a binary search. */
127 static const struct pd_reg pre_defined_registers
[] =
129 { "a0", 0 }, /* Access registers */
146 { "c0", 0 }, /* Control registers */
163 { "f0", 0 }, /* Floating point registers */
180 { "lit", 13 }, /* Pointer to literal pool */
182 { "r0", 0 }, /* General purpose registers */
199 { "sp", 15 }, /* Stack pointer */
203 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
205 static int reg_name_search
206 PARAMS ((const struct pd_reg
*, int, const char *));
207 static bfd_boolean register_name
PARAMS ((expressionS
*));
208 static void init_default_arch
PARAMS ((void));
209 static void s390_insert_operand
210 PARAMS ((unsigned char *, const struct s390_operand
*, offsetT
, char *,
212 static char *md_gather_operands
213 PARAMS ((char *, unsigned char *, const struct s390_opcode
*));
215 /* Given NAME, find the register number associated with that name, return
216 the integer value associated with the given name or -1 on failure. */
219 reg_name_search (regs
, regcount
, name
)
220 const struct pd_reg
*regs
;
224 int middle
, low
, high
;
232 middle
= (low
+ high
) / 2;
233 cmp
= strcasecmp (name
, regs
[middle
].name
);
239 return regs
[middle
].value
;
248 * Summary of register_name().
250 * in: Input_line_pointer points to 1st char of operand.
252 * out: A expressionS.
253 * The operand may have been a register: in this case, X_op == O_register,
254 * X_add_number is set to the register number, and truth is returned.
255 * Input_line_pointer->(next non-blank) char after operand, or is in its
260 register_name (expressionP
)
261 expressionS
*expressionP
;
268 /* Find the spelling of the operand. */
269 start
= name
= input_line_pointer
;
270 if (name
[0] == '%' && ISALPHA (name
[1]))
271 name
= ++input_line_pointer
;
275 c
= get_symbol_end ();
276 reg_number
= reg_name_search (pre_defined_registers
, REG_NAME_CNT
, name
);
278 /* Put back the delimiting char. */
279 *input_line_pointer
= c
;
281 /* Look to see if it's in the register table. */
284 expressionP
->X_op
= O_register
;
285 expressionP
->X_add_number
= reg_number
;
287 /* Make the rest nice. */
288 expressionP
->X_add_symbol
= NULL
;
289 expressionP
->X_op_symbol
= NULL
;
293 /* Reset the line as if we had not done anything. */
294 input_line_pointer
= start
;
298 /* Local variables. */
300 /* Opformat hash table. */
301 static struct hash_control
*s390_opformat_hash
;
303 /* Opcode hash table. */
304 static struct hash_control
*s390_opcode_hash
;
306 /* Flags to set in the elf header */
307 static flagword s390_flags
= 0;
309 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE_" */
311 #ifndef WORKING_DOT_WORD
312 const int md_short_jump_size
= 4;
313 const int md_long_jump_size
= 4;
316 const char *md_shortopts
= "A:m:kVQ:";
317 struct option md_longopts
[] = {
318 {NULL
, no_argument
, NULL
, 0}
320 size_t md_longopts_size
= sizeof (md_longopts
);
322 /* Initialize the default opcode arch and word size from the default
323 architecture name. */
327 if (current_arch_requested
)
330 if (strcmp (default_arch
, "s390") == 0)
333 current_architecture
= S390_OPCODE_ESA
;
335 else if (strcmp (default_arch
, "s390x") == 0)
338 current_architecture
= S390_OPCODE_ESAME
;
341 as_fatal ("Invalid default architecture, broken assembler.");
342 current_arch_mask
= 1 << current_architecture
;
345 /* Called by TARGET_FORMAT. */
347 s390_target_format ()
349 /* We don't get a chance to initialize anything before we're called,
350 so handle that now. */
351 if (! s390_arch_size
)
352 init_default_arch ();
354 return s390_arch_size
== 64 ? "elf64-s390" : "elf32-s390";
358 md_parse_option (c
, arg
)
364 /* -k: Ignore for FreeBSD compatibility. */
368 if (arg
!= NULL
&& strcmp (arg
, "regnames") == 0)
371 else if (arg
!= NULL
&& strcmp (arg
, "no-regnames") == 0)
374 else if (arg
!= NULL
&& strcmp (arg
, "warn-areg-zero") == 0)
375 warn_areg_zero
= TRUE
;
377 else if (arg
!= NULL
&& strcmp (arg
, "31") == 0)
380 else if (arg
!= NULL
&& strcmp (arg
, "64") == 0)
385 as_bad (_("invalid switch -m%s"), arg
);
391 if (arg
!= NULL
&& strcmp (arg
, "esa") == 0)
392 current_architecture
= S390_OPCODE_ESA
;
393 else if (arg
!= NULL
&& strcmp (arg
, "esame") == 0)
394 current_architecture
= S390_OPCODE_ESAME
;
396 as_bad ("invalid architecture -A%s", arg
);
397 current_arch_mask
= 1 << current_architecture
;
398 current_arch_requested
= 1;
401 /* -V: SVR4 argument to print version ID. */
406 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
407 should be emitted or not. FIXME: Not implemented. */
419 md_show_usage (stream
)
422 fprintf (stream
, _("\
424 -mregnames Allow symbolic names for registers\n\
425 -mwarn-areg-zero Warn about zero base/index registers\n\
426 -mno-regnames Do not allow symbolic names for registers\n\
427 -m31 Set file format to 31 bit format\n\
428 -m64 Set file format to 64 bit format\n"));
429 fprintf (stream
, _("\
430 -V print assembler version number\n\
431 -Qy, -Qn ignored\n"));
434 /* This function is called when the assembler starts up. It is called
435 after the options have been parsed and the output file has been
441 register const struct s390_opcode
*op
;
442 const struct s390_opcode
*op_end
;
443 bfd_boolean dup_insn
= FALSE
;
446 /* Give a warning if the combination -m64-bit and -Aesa is used. */
447 if (s390_arch_size
== 64 && current_arch_mask
== (1 << S390_OPCODE_ESA
))
448 as_warn ("The 64 bit file format is used without esame instructions.");
450 /* Set the ELF flags if desired. */
452 bfd_set_private_flags (stdoutput
, s390_flags
);
454 /* Insert the opcode formats into a hash table. */
455 s390_opformat_hash
= hash_new ();
457 op_end
= s390_opformats
+ s390_num_opformats
;
458 for (op
= s390_opformats
; op
< op_end
; op
++)
460 retval
= hash_insert (s390_opformat_hash
, op
->name
, (PTR
) op
);
461 if (retval
!= (const char *) NULL
)
463 as_bad (_("Internal assembler error for instruction format %s"),
469 /* Insert the opcodes into a hash table. */
470 s390_opcode_hash
= hash_new ();
472 op_end
= s390_opcodes
+ s390_num_opcodes
;
473 for (op
= s390_opcodes
; op
< op_end
; op
++)
475 retval
= hash_insert (s390_opcode_hash
, op
->name
, (PTR
) op
);
476 if (retval
!= (const char *) NULL
)
478 as_bad (_("Internal assembler error for instruction %s"), op
->name
);
486 record_alignment (text_section
, 2);
487 record_alignment (data_section
, 2);
488 record_alignment (bss_section
, 2);
492 /* Called after all assembly has been done. */
496 if (s390_arch_size
== 64)
497 bfd_set_arch_mach (stdoutput
, bfd_arch_s390
, bfd_mach_s390_64
);
499 bfd_set_arch_mach (stdoutput
, bfd_arch_s390
, bfd_mach_s390_31
);
503 s390_align_code (fragP
, count
)
507 /* We use nop pattern 0x0707. */
510 memset (fragP
->fr_literal
+ fragP
->fr_fix
, 0x07, count
);
511 fragP
->fr_var
= count
;
515 /* Insert an operand value into an instruction. */
518 s390_insert_operand (insn
, operand
, val
, file
, line
)
520 const struct s390_operand
*operand
;
528 if (operand
->flags
& (S390_OPERAND_SIGNED
|S390_OPERAND_PCREL
))
532 max
= ((offsetT
) 1 << (operand
->bits
- 1)) - 1;
533 min
= - ((offsetT
) 1 << (operand
->bits
- 1));
534 /* Halve PCREL operands. */
535 if (operand
->flags
& S390_OPERAND_PCREL
)
537 /* Check for underflow / overflow. */
538 if (val
< min
|| val
> max
)
541 "operand out of range (%s not between %ld and %ld)";
544 if (operand
->flags
& S390_OPERAND_PCREL
)
550 sprint_value (buf
, val
);
551 if (file
== (char *) NULL
)
552 as_bad (err
, buf
, (int) min
, (int) max
);
554 as_bad_where (file
, line
, err
, buf
, (int) min
, (int) max
);
557 /* val is ok, now restrict it to operand->bits bits. */
558 uval
= (addressT
) val
& ((((addressT
) 1 << (operand
->bits
-1)) << 1) - 1);
564 max
= (((addressT
) 1 << (operand
->bits
- 1)) << 1) - 1;
566 uval
= (addressT
) val
;
567 /* Length x in an instructions has real length x+1. */
568 if (operand
->flags
& S390_OPERAND_LENGTH
)
570 /* Check for underflow / overflow. */
571 if (uval
< min
|| uval
> max
)
574 "operand out of range (%s not between %ld and %ld)";
577 if (operand
->flags
& S390_OPERAND_LENGTH
)
583 sprint_value (buf
, uval
);
584 if (file
== (char *) NULL
)
585 as_bad (err
, buf
, (int) min
, (int) max
);
587 as_bad_where (file
, line
, err
, buf
, (int) min
, (int) max
);
592 /* Insert fragments of the operand byte for byte. */
593 offset
= operand
->shift
+ operand
->bits
;
594 uval
<<= (-offset
) & 7;
595 insn
+= (offset
- 1) / 8;
603 /* Structure used to hold suffixes. */
620 elf_suffix_type suffix
;
623 static elf_suffix_type s390_elf_suffix
PARAMS ((char **, expressionS
*));
624 static int s390_exp_compare
PARAMS ((expressionS
*exp1
, expressionS
*exp2
));
625 static elf_suffix_type s390_lit_suffix
626 PARAMS ((char **, expressionS
*, elf_suffix_type
));
629 /* Parse @got/@plt/@gotoff. and return the desired relocation. */
630 static elf_suffix_type
631 s390_elf_suffix (str_p
, exp_p
)
635 static struct map_bfd mapping
[] =
637 { "got", 3, ELF_SUFFIX_GOT
},
638 { "got12", 5, ELF_SUFFIX_GOT
},
639 { "plt", 3, ELF_SUFFIX_PLT
},
640 { "gotent", 6, ELF_SUFFIX_GOTENT
},
641 { "gotoff", 6, ELF_SUFFIX_GOTOFF
},
642 { "gotplt", 6, ELF_SUFFIX_GOTPLT
},
643 { "pltoff", 6, ELF_SUFFIX_PLTOFF
},
644 { NULL
, 0, ELF_SUFFIX_NONE
}
653 return ELF_SUFFIX_NONE
;
656 while (ISALNUM (*str
))
660 for (ptr
= &mapping
[0]; ptr
->length
> 0; ptr
++)
661 if (len
== ptr
->length
662 && strncasecmp (ident
, ptr
->string
, ptr
->length
) == 0)
664 if (exp_p
->X_add_number
!= 0)
665 as_warn (_("identifier+constant@%s means identifier@%s+constant"),
666 ptr
->string
, ptr
->string
);
667 /* Now check for identifier@suffix+constant. */
668 if (*str
== '-' || *str
== '+')
670 char *orig_line
= input_line_pointer
;
673 input_line_pointer
= str
;
674 expression (&new_exp
);
676 switch (new_exp
.X_op
)
678 case O_constant
: /* X_add_number (a constant expression). */
679 exp_p
->X_add_number
+= new_exp
.X_add_number
;
680 str
= input_line_pointer
;
682 case O_symbol
: /* X_add_symbol + X_add_number. */
683 /* this case is used for e.g. xyz@PLT+.Label. */
684 exp_p
->X_add_number
+= new_exp
.X_add_number
;
685 exp_p
->X_op_symbol
= new_exp
.X_add_symbol
;
687 str
= input_line_pointer
;
689 case O_uminus
: /* (- X_add_symbol) + X_add_number. */
690 /* this case is used for e.g. xyz@PLT-.Label. */
691 exp_p
->X_add_number
+= new_exp
.X_add_number
;
692 exp_p
->X_op_symbol
= new_exp
.X_add_symbol
;
693 exp_p
->X_op
= O_subtract
;
694 str
= input_line_pointer
;
700 /* If s390_elf_suffix has not been called with
701 &input_line_pointer as first parameter, we have
702 clobbered the input_line_pointer. We have to
704 if (&input_line_pointer
!= str_p
)
705 input_line_pointer
= orig_line
;
711 return BFD_RELOC_UNUSED
;
714 /* Structure used to hold a literal pool entry. */
717 struct s390_lpe
*next
;
719 FLONUM_TYPE floatnum
; /* used if X_op == O_big && X_add_number <= 0 */
720 LITTLENUM_TYPE bignum
[4]; /* used if X_op == O_big && X_add_number > 0 */
722 bfd_reloc_code_real_type reloc
;
726 static struct s390_lpe
*lpe_free_list
= NULL
;
727 static struct s390_lpe
*lpe_list
= NULL
;
728 static struct s390_lpe
*lpe_list_tail
= NULL
;
729 static symbolS
*lp_sym
= NULL
;
730 static int lp_count
= 0;
731 static int lpe_count
= 0;
734 s390_exp_compare (exp1
, exp2
)
738 if (exp1
->X_op
!= exp2
->X_op
)
743 case O_constant
: /* X_add_number must be equal. */
745 return exp1
->X_add_number
== exp2
->X_add_number
;
748 as_bad (_("Can't handle O_big in s390_exp_compare"));
750 case O_symbol
: /* X_add_symbol & X_add_number must be equal. */
755 return (exp1
->X_add_symbol
== exp2
->X_add_symbol
)
756 && (exp1
->X_add_number
== exp2
->X_add_number
);
758 case O_multiply
: /* X_add_symbol,X_op_symbol&X_add_number must be equal. */
763 case O_bit_inclusive_or
:
765 case O_bit_exclusive_or
:
777 return (exp1
->X_add_symbol
== exp2
->X_add_symbol
)
778 && (exp1
->X_op_symbol
== exp2
->X_op_symbol
)
779 && (exp1
->X_add_number
== exp2
->X_add_number
);
785 /* Test for @lit and if its present make an entry in the literal pool and
786 modify the current expression to be an offset into the literal pool. */
787 static elf_suffix_type
788 s390_lit_suffix (str_p
, exp_p
, suffix
)
791 elf_suffix_type suffix
;
793 bfd_reloc_code_real_type reloc
;
797 struct s390_lpe
*lpe
;
801 return suffix
; /* No modification. */
803 /* We look for a suffix of the form "@lit1", "@lit2", "@lit4" or "@lit8". */
805 while (ISALNUM (*str
))
808 if (len
!= 4 || strncasecmp (ident
, "lit", 3) != 0
809 || (ident
[3]!='1' && ident
[3]!='2' && ident
[3]!='4' && ident
[3]!='8'))
810 return suffix
; /* no modification */
811 nbytes
= ident
[3] - '0';
813 reloc
= BFD_RELOC_UNUSED
;
814 if (suffix
== ELF_SUFFIX_GOT
)
817 reloc
= BFD_RELOC_390_GOT16
;
818 else if (nbytes
== 4)
819 reloc
= BFD_RELOC_32_GOT_PCREL
;
820 else if (nbytes
== 8)
821 reloc
= BFD_RELOC_390_GOT64
;
823 else if (suffix
== ELF_SUFFIX_PLT
)
826 reloc
= BFD_RELOC_390_PLT32
;
827 else if (nbytes
== 8)
828 reloc
= BFD_RELOC_390_PLT64
;
831 if (suffix
!= ELF_SUFFIX_NONE
&& reloc
== BFD_RELOC_UNUSED
)
832 as_bad (_("Invalid suffix for literal pool entry"));
834 /* Search the pool if the new entry is a duplicate. */
835 if (exp_p
->X_op
== O_big
)
837 /* Special processing for big numbers. */
838 for (lpe
= lpe_list
; lpe
!= NULL
; lpe
= lpe
->next
)
840 if (lpe
->ex
.X_op
== O_big
)
842 if (exp_p
->X_add_number
<= 0 && lpe
->ex
.X_add_number
<= 0)
844 if (memcmp (&generic_floating_point_number
, &lpe
->floatnum
,
845 sizeof (FLONUM_TYPE
)) == 0)
848 else if (exp_p
->X_add_number
== lpe
->ex
.X_add_number
)
850 if (memcmp (generic_bignum
, lpe
->bignum
,
851 sizeof (LITTLENUM_TYPE
)*exp_p
->X_add_number
) == 0)
859 /* Processing for 'normal' data types. */
860 for (lpe
= lpe_list
; lpe
!= NULL
; lpe
= lpe
->next
)
861 if (lpe
->nbytes
== nbytes
&& lpe
->reloc
== reloc
862 && s390_exp_compare (exp_p
, &lpe
->ex
) != 0)
869 if (lpe_free_list
!= NULL
)
872 lpe_free_list
= lpe_free_list
->next
;
876 lpe
= (struct s390_lpe
*) xmalloc (sizeof (struct s390_lpe
));
881 if (exp_p
->X_op
== O_big
)
883 if (exp_p
->X_add_number
<= 0)
884 lpe
->floatnum
= generic_floating_point_number
;
885 else if (exp_p
->X_add_number
<= 4)
886 memcpy (lpe
->bignum
, generic_bignum
,
887 exp_p
->X_add_number
* sizeof (LITTLENUM_TYPE
));
889 as_bad (_("Big number is too big"));
892 lpe
->nbytes
= nbytes
;
894 /* Literal pool name defined ? */
897 sprintf (tmp_name
, ".L\001%i", lp_count
);
898 lp_sym
= symbol_make (tmp_name
);
901 /* Make name for literal pool entry. */
902 sprintf (tmp_name
, ".L\001%i\002%i", lp_count
, lpe_count
);
904 lpe
->sym
= symbol_make (tmp_name
);
906 /* Add to literal pool list. */
908 if (lpe_list_tail
!= NULL
)
910 lpe_list_tail
->next
= lpe
;
914 lpe_list
= lpe_list_tail
= lpe
;
917 /* Now change exp_p to the offset into the literal pool.
918 Thats the expression: .L^Ax^By-.L^Ax */
919 exp_p
->X_add_symbol
= lpe
->sym
;
920 exp_p
->X_op_symbol
= lp_sym
;
921 exp_p
->X_op
= O_subtract
;
922 exp_p
->X_add_number
= 0;
926 /* We change the suffix type to ELF_SUFFIX_NONE, because
927 the difference of two local labels is just a number. */
928 return ELF_SUFFIX_NONE
;
931 /* Like normal .long/.short/.word, except support @got, etc.
932 clobbers input_line_pointer, checks end-of-line. */
934 s390_elf_cons (nbytes
)
935 register int nbytes
; /* 1=.byte, 2=.word, 4=.long */
938 elf_suffix_type suffix
;
940 if (is_it_end_of_statement ())
942 demand_empty_rest_of_line ();
950 if (exp
.X_op
== O_symbol
951 && *input_line_pointer
== '@'
952 && (suffix
= s390_elf_suffix (&input_line_pointer
, &exp
)) != ELF_SUFFIX_NONE
)
954 bfd_reloc_code_real_type reloc
;
955 reloc_howto_type
*reloc_howto
;
959 if (nbytes
== 2 && suffix
== ELF_SUFFIX_GOT
)
960 reloc
= BFD_RELOC_390_GOT16
;
961 else if (nbytes
== 4 && suffix
== ELF_SUFFIX_GOT
)
962 reloc
= BFD_RELOC_32_GOT_PCREL
;
963 else if (nbytes
== 8 && suffix
== ELF_SUFFIX_GOT
)
964 reloc
= BFD_RELOC_390_GOT64
;
965 else if (nbytes
== 2 && suffix
== ELF_SUFFIX_GOTOFF
)
966 reloc
= BFD_RELOC_16_GOTOFF
;
967 else if (nbytes
== 4 && suffix
== ELF_SUFFIX_GOTOFF
)
968 reloc
= BFD_RELOC_32_GOTOFF
;
969 else if (nbytes
== 8 && suffix
== ELF_SUFFIX_GOTOFF
)
970 reloc
= BFD_RELOC_390_GOTOFF64
;
971 else if (nbytes
== 2 && suffix
== ELF_SUFFIX_PLTOFF
)
972 reloc
= BFD_RELOC_390_PLTOFF16
;
973 else if (nbytes
== 4 && suffix
== ELF_SUFFIX_PLTOFF
)
974 reloc
= BFD_RELOC_390_PLTOFF32
;
975 else if (nbytes
== 8 && suffix
== ELF_SUFFIX_PLTOFF
)
976 reloc
= BFD_RELOC_390_PLTOFF64
;
977 else if (nbytes
== 4 && suffix
== ELF_SUFFIX_PLT
)
978 reloc
= BFD_RELOC_390_PLT32
;
979 else if (nbytes
== 8 && suffix
== ELF_SUFFIX_PLT
)
980 reloc
= BFD_RELOC_390_PLT64
;
981 else if (nbytes
== 4 && suffix
== ELF_SUFFIX_GOTPLT
)
982 reloc
= BFD_RELOC_390_GOTPLT32
;
983 else if (nbytes
== 8 && suffix
== ELF_SUFFIX_GOTPLT
)
984 reloc
= BFD_RELOC_390_GOTPLT64
;
986 reloc
= BFD_RELOC_UNUSED
;
988 if (reloc
!= BFD_RELOC_UNUSED
)
990 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, reloc
);
991 size
= bfd_get_reloc_size (reloc_howto
);
993 as_bad (_("%s relocations do not fit in %d bytes"),
994 reloc_howto
->name
, nbytes
);
995 where
= frag_more (nbytes
);
996 md_number_to_chars (where
, 0, size
);
997 /* To make fixup_segment do the pc relative conversion the
998 pcrel parameter on the fix_new_exp call needs to be FALSE. */
999 fix_new_exp (frag_now
, where
- frag_now
->fr_literal
,
1000 size
, &exp
, FALSE
, reloc
);
1003 as_bad (_("relocation not applicable"));
1006 emit_expr (&exp
, (unsigned int) nbytes
);
1008 while (*input_line_pointer
++ == ',');
1010 input_line_pointer
--; /* Put terminator back into stream. */
1011 demand_empty_rest_of_line ();
1014 /* We need to keep a list of fixups. We can't simply generate them as
1015 we go, because that would require us to first create the frag, and
1016 that would screw up references to ``.''. */
1022 bfd_reloc_code_real_type reloc
;
1025 #define MAX_INSN_FIXUPS (4)
1027 /* This routine is called for each instruction to be assembled. */
1030 md_gather_operands (str
, insn
, opcode
)
1032 unsigned char *insn
;
1033 const struct s390_opcode
*opcode
;
1035 struct s390_fixup fixups
[MAX_INSN_FIXUPS
];
1036 const struct s390_operand
*operand
;
1037 const unsigned char *opindex_ptr
;
1038 elf_suffix_type suffix
;
1039 bfd_reloc_code_real_type reloc
;
1045 while (ISSPACE (*str
))
1051 /* Gather the operands. */
1053 for (opindex_ptr
= opcode
->operands
; *opindex_ptr
!= 0; opindex_ptr
++)
1058 operand
= s390_operands
+ *opindex_ptr
;
1060 if (skip_optional
&& (operand
->flags
& S390_OPERAND_INDEX
))
1062 /* We do an early skip. For D(X,B) constructions the index
1063 register is skipped (X is optional). For D(L,B) the base
1064 register will be the skipped operand, because L is NOT
1070 /* Gather the operand. */
1071 hold
= input_line_pointer
;
1072 input_line_pointer
= str
;
1074 /* Parse the operand. */
1075 if (! register_name (&ex
))
1078 str
= input_line_pointer
;
1079 input_line_pointer
= hold
;
1081 /* Write the operand to the insn. */
1082 if (ex
.X_op
== O_illegal
)
1083 as_bad (_("illegal operand"));
1084 else if (ex
.X_op
== O_absent
)
1085 as_bad (_("missing operand"));
1086 else if (ex
.X_op
== O_register
|| ex
.X_op
== O_constant
)
1088 s390_lit_suffix (&str
, &ex
, ELF_SUFFIX_NONE
);
1090 if (ex
.X_op
!= O_register
&& ex
.X_op
!= O_constant
)
1092 /* We need to generate a fixup for the
1093 expression returned by s390_lit_suffix. */
1094 if (fc
>= MAX_INSN_FIXUPS
)
1095 as_fatal (_("too many fixups"));
1096 fixups
[fc
].exp
= ex
;
1097 fixups
[fc
].opindex
= *opindex_ptr
;
1098 fixups
[fc
].reloc
= BFD_RELOC_UNUSED
;
1103 if ((operand
->flags
& S390_OPERAND_INDEX
)
1104 && ex
.X_add_number
== 0
1106 as_warn ("index register specified but zero");
1107 if ((operand
->flags
& S390_OPERAND_BASE
)
1108 && ex
.X_add_number
== 0
1110 as_warn ("base register specified but zero");
1111 s390_insert_operand (insn
, operand
, ex
.X_add_number
, NULL
, 0);
1116 suffix
= s390_elf_suffix (&str
, &ex
);
1117 suffix
= s390_lit_suffix (&str
, &ex
, suffix
);
1118 reloc
= BFD_RELOC_UNUSED
;
1120 if (suffix
== ELF_SUFFIX_GOT
)
1122 if (operand
->flags
& S390_OPERAND_DISP
)
1123 reloc
= BFD_RELOC_390_GOT12
;
1124 else if ((operand
->flags
& S390_OPERAND_SIGNED
)
1125 && (operand
->bits
== 16))
1126 reloc
= BFD_RELOC_390_GOT16
;
1127 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1128 && (operand
->bits
== 32))
1129 reloc
= BFD_RELOC_390_GOTENT
;
1131 else if (suffix
== ELF_SUFFIX_PLT
)
1133 if ((operand
->flags
& S390_OPERAND_PCREL
)
1134 && (operand
->bits
== 16))
1135 reloc
= BFD_RELOC_390_PLT16DBL
;
1136 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1137 && (operand
->bits
== 32))
1138 reloc
= BFD_RELOC_390_PLT32DBL
;
1140 else if (suffix
== ELF_SUFFIX_GOTENT
)
1142 if ((operand
->flags
& S390_OPERAND_PCREL
)
1143 && (operand
->bits
== 32))
1144 reloc
= BFD_RELOC_390_GOTENT
;
1146 else if (suffix
== ELF_SUFFIX_GOTOFF
)
1148 if ((operand
->flags
& S390_OPERAND_SIGNED
)
1149 && (operand
->bits
== 16))
1150 reloc
= BFD_RELOC_16_GOTOFF
;
1152 else if (suffix
== ELF_SUFFIX_PLTOFF
)
1154 if ((operand
->flags
& S390_OPERAND_SIGNED
)
1155 && (operand
->bits
== 16))
1156 reloc
= BFD_RELOC_390_PLTOFF16
;
1158 else if (suffix
== ELF_SUFFIX_GOTPLT
)
1160 if ((operand
->flags
& S390_OPERAND_DISP
)
1161 && (operand
->bits
== 12))
1162 reloc
= BFD_RELOC_390_GOTPLT12
;
1163 else if ((operand
->flags
& S390_OPERAND_SIGNED
)
1164 && (operand
->bits
== 16))
1165 reloc
= BFD_RELOC_390_GOTPLT16
;
1166 else if ((operand
->flags
& S390_OPERAND_PCREL
)
1167 && (operand
->bits
== 32))
1168 reloc
= BFD_RELOC_390_GOTPLTENT
;
1171 if (suffix
!= ELF_SUFFIX_NONE
&& reloc
== BFD_RELOC_UNUSED
)
1172 as_bad (_("invalid operand suffix"));
1173 /* We need to generate a fixup of type 'reloc' for this
1175 if (fc
>= MAX_INSN_FIXUPS
)
1176 as_fatal (_("too many fixups"));
1177 fixups
[fc
].exp
= ex
;
1178 fixups
[fc
].opindex
= *opindex_ptr
;
1179 fixups
[fc
].reloc
= reloc
;
1183 /* Check the next character. The call to expression has advanced
1184 str past any whitespace. */
1185 if (operand
->flags
& S390_OPERAND_DISP
)
1187 /* After a displacement a block in parentheses can start. */
1190 /* Check if parethesed block can be skipped. If the next
1191 operand is neiter an optional operand nor a base register
1192 then we have a syntax error. */
1193 operand
= s390_operands
+ *(++opindex_ptr
);
1194 if (!(operand
->flags
& (S390_OPERAND_INDEX
|S390_OPERAND_BASE
)))
1195 as_bad (_("syntax error; missing '(' after displacement"));
1197 /* Ok, skip all operands until S390_OPERAND_BASE. */
1198 while (!(operand
->flags
& S390_OPERAND_BASE
))
1199 operand
= s390_operands
+ *(++opindex_ptr
);
1201 /* If there is a next operand it must be seperated by a comma. */
1202 if (opindex_ptr
[1] != '\0')
1205 as_bad (_("syntax error; expected ,"));
1210 /* We found an opening parentheses. */
1212 for (f
= str
; *f
!= '\0'; f
++)
1213 if (*f
== ',' || *f
== ')')
1215 /* If there is no comma until the closing parentheses OR
1216 there is a comma right after the opening parentheses,
1217 we have to skip optional operands. */
1218 if (*f
== ',' && f
== str
)
1220 /* comma directly after '(' ? */
1225 skip_optional
= (*f
!= ',');
1228 else if (operand
->flags
& S390_OPERAND_BASE
)
1230 /* After the base register the parenthesed block ends. */
1232 as_bad (_("syntax error; missing ')' after base register"));
1234 /* If there is a next operand it must be seperated by a comma. */
1235 if (opindex_ptr
[1] != '\0')
1238 as_bad (_("syntax error; expected ,"));
1243 /* We can find an 'early' closing parentheses in e.g. D(L) instead
1244 of D(L,B). In this case the base register has to be skipped. */
1247 operand
= s390_operands
+ *(++opindex_ptr
);
1249 if (!(operand
->flags
& S390_OPERAND_BASE
))
1250 as_bad (_("syntax error; ')' not allowed here"));
1253 /* If there is a next operand it must be seperated by a comma. */
1254 if (opindex_ptr
[1] != '\0')
1257 as_bad (_("syntax error; expected ,"));
1262 while (ISSPACE (*str
))
1269 if ((linefeed
= strchr (str
, '\n')) != NULL
)
1271 as_bad (_("junk at end of line: `%s'"), str
);
1272 if (linefeed
!= NULL
)
1276 /* Write out the instruction. */
1277 f
= frag_more (opcode
->oplen
);
1278 memcpy (f
, insn
, opcode
->oplen
);
1279 dwarf2_emit_insn (opcode
->oplen
);
1281 /* Create any fixups. At this point we do not use a
1282 bfd_reloc_code_real_type, but instead just use the
1283 BFD_RELOC_UNUSED plus the operand index. This lets us easily
1284 handle fixups for any operand type, although that is admittedly
1285 not a very exciting feature. We pick a BFD reloc type in
1287 for (i
= 0; i
< fc
; i
++)
1289 operand
= s390_operands
+ fixups
[i
].opindex
;
1291 if (fixups
[i
].reloc
!= BFD_RELOC_UNUSED
)
1293 reloc_howto_type
*reloc_howto
;
1297 reloc_howto
= bfd_reloc_type_lookup (stdoutput
, fixups
[i
].reloc
);
1301 size
= bfd_get_reloc_size (reloc_howto
);
1303 if (size
< 1 || size
> 4)
1306 fixP
= fix_new_exp (frag_now
,
1307 f
- frag_now
->fr_literal
+ (operand
->shift
/8),
1308 size
, &fixups
[i
].exp
, reloc_howto
->pc_relative
,
1310 /* Turn off overflow checking in fixup_segment. This is necessary
1311 because fixup_segment will signal an overflow for large 4 byte
1312 quantities for GOT12 relocations. */
1313 if ( fixups
[i
].reloc
== BFD_RELOC_390_GOT12
1314 || fixups
[i
].reloc
== BFD_RELOC_390_GOT16
)
1315 fixP
->fx_no_overflow
= 1;
1318 fix_new_exp (frag_now
, f
- frag_now
->fr_literal
, 4, &fixups
[i
].exp
,
1319 (operand
->flags
& S390_OPERAND_PCREL
) != 0,
1320 ((bfd_reloc_code_real_type
)
1321 (fixups
[i
].opindex
+ (int) BFD_RELOC_UNUSED
)));
1326 /* This routine is called for each instruction to be assembled. */
1332 const struct s390_opcode
*opcode
;
1333 unsigned char insn
[6];
1336 /* Get the opcode. */
1337 for (s
= str
; *s
!= '\0' && ! ISSPACE (*s
); s
++)
1342 /* Look up the opcode in the hash table. */
1343 opcode
= (struct s390_opcode
*) hash_find (s390_opcode_hash
, str
);
1344 if (opcode
== (const struct s390_opcode
*) NULL
)
1346 as_bad (_("Unrecognized opcode: `%s'"), str
);
1349 else if (!(opcode
->architecture
& current_arch_mask
))
1351 as_bad ("Opcode %s not available in this architecture", str
);
1355 memcpy (insn
, opcode
->opcode
, sizeof (insn
));
1356 md_gather_operands (s
, insn
, opcode
);
1359 #ifndef WORKING_DOT_WORD
1360 /* Handle long and short jumps. We don't support these */
1362 md_create_short_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
1364 addressT from_addr
, to_addr
;
1372 md_create_long_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
1374 addressT from_addr
, to_addr
;
1384 int ignore ATTRIBUTE_UNUSED
;
1386 /* We don't support putting frags in the BSS segment, we fake it
1387 by marking in_bss, then looking at s_skip for clues. */
1389 subseg_set (bss_section
, 0);
1390 demand_empty_rest_of_line ();
1393 /* Pseudo-op handling. */
1397 int ignore ATTRIBUTE_UNUSED
;
1400 const struct s390_opcode
*opformat
;
1401 unsigned char insn
[6];
1404 /* Get the opcode format. */
1405 s
= input_line_pointer
;
1406 while (*s
!= '\0' && *s
!= ',' && ! ISSPACE (*s
))
1409 as_bad (_("Invalid .insn format\n"));
1412 /* Look up the opcode in the hash table. */
1413 opformat
= (struct s390_opcode
*)
1414 hash_find (s390_opformat_hash
, input_line_pointer
);
1415 if (opformat
== (const struct s390_opcode
*) NULL
)
1417 as_bad (_("Unrecognized opcode format: `%s'"), input_line_pointer
);
1420 input_line_pointer
= s
;
1422 if (exp
.X_op
== O_constant
)
1424 if ( (opformat
->oplen
== 6 && exp
.X_op
> 0 && exp
.X_op
< (1ULL << 48))
1425 || (opformat
->oplen
== 4 && exp
.X_op
> 0 && exp
.X_op
< (1ULL << 32))
1426 || (opformat
->oplen
== 2 && exp
.X_op
> 0 && exp
.X_op
< (1ULL << 16)))
1427 md_number_to_chars (insn
, exp
.X_add_number
, opformat
->oplen
);
1429 as_bad (_("Invalid .insn format\n"));
1431 else if (exp
.X_op
== O_big
)
1433 if (exp
.X_add_number
> 0
1434 && opformat
->oplen
== 6
1435 && generic_bignum
[3] == 0)
1437 md_number_to_chars (insn
, generic_bignum
[2], 2);
1438 md_number_to_chars (&insn
[2], generic_bignum
[1], 2);
1439 md_number_to_chars (&insn
[4], generic_bignum
[0], 2);
1442 as_bad (_("Invalid .insn format\n"));
1445 as_bad (_("second operand of .insn not a constant\n"));
1447 if (strcmp (opformat
->name
, "e") != 0 && *input_line_pointer
++ != ',')
1448 as_bad (_("missing comma after insn constant\n"));
1450 if ((s
= strchr (input_line_pointer
, '\n')) != NULL
)
1452 input_line_pointer
= md_gather_operands (input_line_pointer
, insn
,
1456 demand_empty_rest_of_line ();
1459 /* The .byte pseudo-op. This is similar to the normal .byte
1460 pseudo-op, but it can also take a single ASCII string. */
1464 int ignore ATTRIBUTE_UNUSED
;
1466 if (*input_line_pointer
!= '\"')
1472 /* Gather characters. A real double quote is doubled. Unusual
1473 characters are not permitted. */
1474 ++input_line_pointer
;
1479 c
= *input_line_pointer
++;
1483 if (*input_line_pointer
!= '\"')
1485 ++input_line_pointer
;
1488 FRAG_APPEND_1_CHAR (c
);
1491 demand_empty_rest_of_line ();
1494 /* The .ltorg pseudo-op.This emits all literals defined since the last
1495 .ltorg or the invocation of gas. Literals are defined with the
1499 s390_literals (ignore
)
1500 int ignore ATTRIBUTE_UNUSED
;
1502 struct s390_lpe
*lpe
;
1504 if (lp_sym
== NULL
|| lpe_count
== 0)
1505 return; /* Nothing to be done. */
1507 /* Emit symbol for start of literal pool. */
1508 S_SET_SEGMENT (lp_sym
, now_seg
);
1509 S_SET_VALUE (lp_sym
, (valueT
) frag_now_fix ());
1510 lp_sym
->sy_frag
= frag_now
;
1515 lpe_list
= lpe_list
->next
;
1516 S_SET_SEGMENT (lpe
->sym
, now_seg
);
1517 S_SET_VALUE (lpe
->sym
, (valueT
) frag_now_fix ());
1518 lpe
->sym
->sy_frag
= frag_now
;
1520 /* Emit literal pool entry. */
1521 if (lpe
->reloc
!= BFD_RELOC_UNUSED
)
1523 reloc_howto_type
*reloc_howto
=
1524 bfd_reloc_type_lookup (stdoutput
, lpe
->reloc
);
1525 int size
= bfd_get_reloc_size (reloc_howto
);
1528 if (size
> lpe
->nbytes
)
1529 as_bad (_("%s relocations do not fit in %d bytes"),
1530 reloc_howto
->name
, lpe
->nbytes
);
1531 where
= frag_more (lpe
->nbytes
);
1532 md_number_to_chars (where
, 0, size
);
1533 fix_new_exp (frag_now
, where
- frag_now
->fr_literal
,
1534 size
, &lpe
->ex
, reloc_howto
->pc_relative
, lpe
->reloc
);
1538 if (lpe
->ex
.X_op
== O_big
)
1540 if (lpe
->ex
.X_add_number
<= 0)
1541 generic_floating_point_number
= lpe
->floatnum
;
1543 memcpy (generic_bignum
, lpe
->bignum
,
1544 lpe
->ex
.X_add_number
* sizeof (LITTLENUM_TYPE
));
1546 emit_expr (&lpe
->ex
, lpe
->nbytes
);
1549 lpe
->next
= lpe_free_list
;
1550 lpe_free_list
= lpe
;
1552 lpe_list_tail
= NULL
;
1558 /* Turn a string in input_line_pointer into a floating point constant
1559 of type type, and store the appropriate bytes in *litp. The number
1560 of LITTLENUMS emitted is stored in *sizep . An error message is
1561 returned, or NULL on OK. */
1564 md_atof (type
, litp
, sizep
)
1570 LITTLENUM_TYPE words
[4];
1586 return "bad call to md_atof";
1589 t
= atof_ieee (input_line_pointer
, type
, words
);
1591 input_line_pointer
= t
;
1595 for (i
= 0; i
< prec
; i
++)
1597 md_number_to_chars (litp
, (valueT
) words
[i
], 2);
1604 /* Align a section (I don't know why this is machine dependent). */
1607 md_section_align (seg
, addr
)
1611 int align
= bfd_get_section_alignment (stdoutput
, seg
);
1613 return ((addr
+ (1 << align
) - 1) & (-1 << align
));
1616 /* We don't have any form of relaxing. */
1619 md_estimate_size_before_relax (fragp
, seg
)
1620 fragS
*fragp ATTRIBUTE_UNUSED
;
1621 asection
*seg ATTRIBUTE_UNUSED
;
1627 /* Convert a machine dependent frag. We never generate these. */
1630 md_convert_frag (abfd
, sec
, fragp
)
1631 bfd
*abfd ATTRIBUTE_UNUSED
;
1632 asection
*sec ATTRIBUTE_UNUSED
;
1633 fragS
*fragp ATTRIBUTE_UNUSED
;
1639 md_undefined_symbol (name
)
1642 if (*name
== '_' && *(name
+ 1) == 'G'
1643 && strcmp (name
, "_GLOBAL_OFFSET_TABLE_") == 0)
1647 if (symbol_find (name
))
1648 as_bad (_("GOT already in symbol table"));
1649 GOT_symbol
= symbol_new (name
, undefined_section
,
1650 (valueT
) 0, &zero_address_frag
);
1657 /* Functions concerning relocs. */
1659 /* The location from which a PC relative jump should be calculated,
1660 given a PC relative reloc. */
1663 md_pcrel_from_section (fixp
, sec
)
1665 segT sec ATTRIBUTE_UNUSED
;
1667 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
1670 /* Here we decide which fixups can be adjusted to make them relative to
1671 the beginning of the section instead of the symbol. Basically we need
1672 to make sure that the dynamic relocations are done correctly, so in
1673 some cases we force the original symbol to be used. */
1675 tc_s390_fix_adjustable (fixP
)
1678 /* Don't adjust references to merge sections. */
1679 if ((S_GET_SEGMENT (fixP
->fx_addsy
)->flags
& SEC_MERGE
) != 0)
1681 /* adjust_reloc_syms doesn't know about the GOT. */
1682 if ( fixP
->fx_r_type
== BFD_RELOC_16_GOTOFF
1683 || fixP
->fx_r_type
== BFD_RELOC_32_GOTOFF
1684 || fixP
->fx_r_type
== BFD_RELOC_390_GOTOFF64
1685 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF16
1686 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF32
1687 || fixP
->fx_r_type
== BFD_RELOC_390_PLTOFF64
1688 || fixP
->fx_r_type
== BFD_RELOC_390_PLT16DBL
1689 || fixP
->fx_r_type
== BFD_RELOC_390_PLT32
1690 || fixP
->fx_r_type
== BFD_RELOC_390_PLT32DBL
1691 || fixP
->fx_r_type
== BFD_RELOC_390_PLT64
1692 || fixP
->fx_r_type
== BFD_RELOC_390_GOT12
1693 || fixP
->fx_r_type
== BFD_RELOC_390_GOT16
1694 || fixP
->fx_r_type
== BFD_RELOC_32_GOT_PCREL
1695 || fixP
->fx_r_type
== BFD_RELOC_390_GOT64
1696 || fixP
->fx_r_type
== BFD_RELOC_390_GOTENT
1697 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT12
1698 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT16
1699 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT32
1700 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLT64
1701 || fixP
->fx_r_type
== BFD_RELOC_390_GOTPLTENT
1702 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
1703 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
1708 /* Return true if we must always emit a reloc for a type and false if
1709 there is some hope of resolving it at assembly time. */
1711 tc_s390_force_relocation (fixp
)
1714 /* Ensure we emit a relocation for every reference to the global
1715 offset table or to the procedure link table. */
1716 switch (fixp
->fx_r_type
)
1718 case BFD_RELOC_390_GOT12
:
1719 case BFD_RELOC_32_GOT_PCREL
:
1720 case BFD_RELOC_32_GOTOFF
:
1721 case BFD_RELOC_390_GOTOFF64
:
1722 case BFD_RELOC_390_PLTOFF16
:
1723 case BFD_RELOC_390_PLTOFF32
:
1724 case BFD_RELOC_390_PLTOFF64
:
1725 case BFD_RELOC_390_GOTPC
:
1726 case BFD_RELOC_390_GOT16
:
1727 case BFD_RELOC_390_GOTPCDBL
:
1728 case BFD_RELOC_390_GOT64
:
1729 case BFD_RELOC_390_GOTENT
:
1730 case BFD_RELOC_390_PLT32
:
1731 case BFD_RELOC_390_PLT16DBL
:
1732 case BFD_RELOC_390_PLT32DBL
:
1733 case BFD_RELOC_390_PLT64
:
1734 case BFD_RELOC_390_GOTPLT12
:
1735 case BFD_RELOC_390_GOTPLT16
:
1736 case BFD_RELOC_390_GOTPLT32
:
1737 case BFD_RELOC_390_GOTPLT64
:
1738 case BFD_RELOC_390_GOTPLTENT
:
1744 return generic_force_reloc (fixp
);
1747 /* Apply a fixup to the object code. This is called for all the
1748 fixups we generated by the call to fix_new_exp, above. In the call
1749 above we used a reloc code which was the largest legal reloc code
1750 plus the operand index. Here we undo that to recover the operand
1751 index. At this point all symbol values should be fully resolved,
1752 and we attempt to completely resolve the reloc. If we can not do
1753 that, we determine the correct reloc code and put it back in the
1757 md_apply_fix3 (fixP
, valP
, seg
)
1760 segT seg ATTRIBUTE_UNUSED
;
1763 valueT value
= *valP
;
1765 where
= fixP
->fx_frag
->fr_literal
+ fixP
->fx_where
;
1767 if (fixP
->fx_subsy
!= NULL
)
1768 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1769 "cannot emit relocation %s against subsy symbol %s",
1770 bfd_get_reloc_code_name (fixP
->fx_r_type
),
1771 S_GET_NAME (fixP
->fx_subsy
));
1773 if (fixP
->fx_addsy
!= NULL
)
1776 value
+= fixP
->fx_frag
->fr_address
+ fixP
->fx_where
;
1781 if ((int) fixP
->fx_r_type
>= (int) BFD_RELOC_UNUSED
)
1783 const struct s390_operand
*operand
;
1786 opindex
= (int) fixP
->fx_r_type
- (int) BFD_RELOC_UNUSED
;
1787 operand
= &s390_operands
[opindex
];
1791 /* Insert the fully resolved operand value. */
1792 s390_insert_operand (where
, operand
, (offsetT
) value
,
1793 fixP
->fx_file
, fixP
->fx_line
);
1797 /* Determine a BFD reloc value based on the operand information.
1798 We are only prepared to turn a few of the operands into
1800 fixP
->fx_offset
= value
;
1801 if (operand
->bits
== 12 && operand
->shift
== 20)
1804 fixP
->fx_where
+= 2;
1805 fixP
->fx_r_type
= BFD_RELOC_390_12
;
1807 else if (operand
->bits
== 12 && operand
->shift
== 36)
1810 fixP
->fx_where
+= 4;
1811 fixP
->fx_r_type
= BFD_RELOC_390_12
;
1813 else if (operand
->bits
== 8 && operand
->shift
== 8)
1816 fixP
->fx_where
+= 1;
1817 fixP
->fx_r_type
= BFD_RELOC_8
;
1819 else if (operand
->bits
== 16 && operand
->shift
== 16)
1822 fixP
->fx_where
+= 2;
1823 if (operand
->flags
& S390_OPERAND_PCREL
)
1825 fixP
->fx_r_type
= BFD_RELOC_390_PC16DBL
;
1826 fixP
->fx_offset
+= 2;
1829 fixP
->fx_r_type
= BFD_RELOC_16
;
1831 else if (operand
->bits
== 32 && operand
->shift
== 16
1832 && (operand
->flags
& S390_OPERAND_PCREL
))
1835 fixP
->fx_where
+= 2;
1836 fixP
->fx_offset
+= 2;
1837 fixP
->fx_r_type
= BFD_RELOC_390_PC32DBL
;
1844 /* Use expr_symbol_where to see if this is an expression
1846 if (expr_symbol_where (fixP
->fx_addsy
, &sfile
, &sline
))
1847 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1848 _("unresolved expression that must be resolved"));
1850 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1851 _("unsupported relocation type"));
1858 switch (fixP
->fx_r_type
)
1864 md_number_to_chars (where
, value
, 1);
1866 case BFD_RELOC_390_12
:
1867 case BFD_RELOC_390_GOT12
:
1868 case BFD_RELOC_390_GOTPLT12
:
1873 mop
= bfd_getb16 ((unsigned char *) where
);
1874 mop
|= (unsigned short) (value
& 0xfff);
1875 bfd_putb16 ((bfd_vma
) mop
, (unsigned char *) where
);
1880 case BFD_RELOC_GPREL16
:
1881 case BFD_RELOC_16_GOT_PCREL
:
1882 case BFD_RELOC_16_GOTOFF
:
1884 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
1885 "cannot emit PC relative %s relocation%s%s",
1886 bfd_get_reloc_code_name (fixP
->fx_r_type
),
1887 fixP
->fx_addsy
!= NULL
? " against " : "",
1888 (fixP
->fx_addsy
!= NULL
1889 ? S_GET_NAME (fixP
->fx_addsy
)
1892 md_number_to_chars (where
, value
, 2);
1894 case BFD_RELOC_390_GOT16
:
1895 case BFD_RELOC_390_PLTOFF16
:
1896 case BFD_RELOC_390_GOTPLT16
:
1898 md_number_to_chars (where
, value
, 2);
1900 case BFD_RELOC_390_PC16DBL
:
1901 case BFD_RELOC_390_PLT16DBL
:
1904 md_number_to_chars (where
, (offsetT
) value
>> 1, 2);
1909 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
1911 fixP
->fx_r_type
= BFD_RELOC_32
;
1913 md_number_to_chars (where
, value
, 4);
1915 case BFD_RELOC_32_PCREL
:
1916 case BFD_RELOC_32_BASEREL
:
1917 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
1919 md_number_to_chars (where
, value
, 4);
1921 case BFD_RELOC_32_GOT_PCREL
:
1922 case BFD_RELOC_390_PLTOFF32
:
1923 case BFD_RELOC_390_PLT32
:
1924 case BFD_RELOC_390_GOTPLT32
:
1926 md_number_to_chars (where
, value
, 4);
1928 case BFD_RELOC_390_PC32DBL
:
1929 case BFD_RELOC_390_PLT32DBL
:
1930 case BFD_RELOC_390_GOTPCDBL
:
1931 case BFD_RELOC_390_GOTENT
:
1932 case BFD_RELOC_390_GOTPLTENT
:
1935 md_number_to_chars (where
, (offsetT
) value
>> 1, 4);
1938 case BFD_RELOC_32_GOTOFF
:
1940 md_number_to_chars (where
, value
, sizeof (int));
1943 case BFD_RELOC_390_GOTOFF64
:
1945 md_number_to_chars (where
, value
, 8);
1948 case BFD_RELOC_390_GOT64
:
1949 case BFD_RELOC_390_PLTOFF64
:
1950 case BFD_RELOC_390_PLT64
:
1951 case BFD_RELOC_390_GOTPLT64
:
1953 md_number_to_chars (where
, value
, 8);
1958 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
1960 fixP
->fx_r_type
= BFD_RELOC_64
;
1962 md_number_to_chars (where
, value
, 8);
1965 case BFD_RELOC_64_PCREL
:
1966 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
1968 md_number_to_chars (where
, value
, 8);
1971 case BFD_RELOC_VTABLE_INHERIT
:
1972 case BFD_RELOC_VTABLE_ENTRY
:
1978 const char *reloc_name
= bfd_get_reloc_code_name (fixP
->fx_r_type
);
1980 if (reloc_name
!= NULL
)
1981 fprintf (stderr
, "Gas failure, reloc type %s\n", reloc_name
);
1983 fprintf (stderr
, "Gas failure, reloc type #%i\n", fixP
->fx_r_type
);
1989 fixP
->fx_offset
= value
;
1993 /* Generate a reloc for a fixup. */
1996 tc_gen_reloc (seg
, fixp
)
1997 asection
*seg ATTRIBUTE_UNUSED
;
2000 bfd_reloc_code_real_type code
;
2003 code
= fixp
->fx_r_type
;
2004 if (GOT_symbol
&& fixp
->fx_addsy
== GOT_symbol
)
2006 if ( (s390_arch_size
== 32 && code
== BFD_RELOC_32_PCREL
)
2007 || (s390_arch_size
== 64 && code
== BFD_RELOC_64_PCREL
))
2008 code
= BFD_RELOC_390_GOTPC
;
2009 if (code
== BFD_RELOC_390_PC32DBL
)
2010 code
= BFD_RELOC_390_GOTPCDBL
;
2013 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
2014 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
2015 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
2016 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
2017 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
2018 if (reloc
->howto
== NULL
)
2020 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2021 _("cannot represent relocation type %s"),
2022 bfd_get_reloc_code_name (code
));
2023 /* Set howto to a garbage value so that we can keep going. */
2024 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, BFD_RELOC_32
);
2025 assert (reloc
->howto
!= NULL
);
2027 reloc
->addend
= fixp
->fx_offset
;