1 /* tc-s390.c -- Assemble for the S390
2 Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006
3 Free Software Foundation, Inc.
4 Contributed by Martin Schwidefsky (schwidefsky@de.ibm.com).
5
6 This file is part of GAS, the GNU Assembler.
7
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 2, or (at your option)
11 any later version.
12
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.
17
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
21 02110-1301, USA. */
22
23 #include "as.h"
24 #include "safe-ctype.h"
25 #include "subsegs.h"
26 #include "struc-symbol.h"
27 #include "dwarf2dbg.h"
28 #include "dw2gencfi.h"
29
30 #include "opcode/s390.h"
31 #include "elf/s390.h"
32
33 /* The default architecture. */
34 #ifndef DEFAULT_ARCH
35 #define DEFAULT_ARCH "s390"
36 #endif
37 static char *default_arch = DEFAULT_ARCH;
38 /* Either 32 or 64, selects file format. */
39 static int s390_arch_size = 0;
40
41 static unsigned int current_mode_mask = 0;
42 static unsigned int current_cpu = -1U;
43
44 /* Whether to use user friendly register names. Default is TRUE. */
45 #ifndef TARGET_REG_NAMES_P
46 #define TARGET_REG_NAMES_P TRUE
47 #endif
48
49 static bfd_boolean reg_names_p = TARGET_REG_NAMES_P;
50
51 /* Set to TRUE if we want to warn about zero base/index registers. */
52 static bfd_boolean warn_areg_zero = FALSE;
53
54 /* Generic assembler global variables which must be defined by all
55 targets. */
56
57 const char comment_chars[] = "#";
58
59 /* Characters which start a comment at the beginning of a line. */
60 const char line_comment_chars[] = "#";
61
62 /* Characters which may be used to separate multiple commands on a
63 single line. */
64 const char line_separator_chars[] = ";";
65
66 /* Characters which are used to indicate an exponent in a floating
67 point number. */
68 const char EXP_CHARS[] = "eE";
69
70 /* Characters which mean that a number is a floating point constant,
71 as in 0d1.0. */
72 const char FLT_CHARS[] = "dD";
73
74 /* The dwarf2 data alignment, adjusted for 32 or 64 bit. */
75 int s390_cie_data_alignment;
76
77 /* The target specific pseudo-ops which we support. */
78
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));
85
86 const pseudo_typeS md_pseudo_table[] =
87 {
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, 2 },
99 { NULL, NULL, 0 }
100 };
101
102
103 /* Structure to hold information about predefined registers. */
104 struct pd_reg
105 {
106 char *name;
107 int value;
108 };
109
110 /* List of registers that are pre-defined:
111
112 Each access register has a predefined name of the form:
113 a<reg_num> which has the value <reg_num>.
114
115 Each control register has a predefined name of the form:
116 c<reg_num> which has the value <reg_num>.
117
118 Each general register has a predefined name of the form:
119 r<reg_num> which has the value <reg_num>.
120
121 Each floating point register a has predefined name of the form:
122 f<reg_num> which has the value <reg_num>.
123
124 There are individual registers as well:
125 sp has the value 15
126 lit has the value 12
127
128 The table is sorted. Suitable for searching by a binary search. */
129
130 static const struct pd_reg pre_defined_registers[] =
131 {
132 { "a0", 0 }, /* Access registers */
133 { "a1", 1 },
134 { "a10", 10 },
135 { "a11", 11 },
136 { "a12", 12 },
137 { "a13", 13 },
138 { "a14", 14 },
139 { "a15", 15 },
140 { "a2", 2 },
141 { "a3", 3 },
142 { "a4", 4 },
143 { "a5", 5 },
144 { "a6", 6 },
145 { "a7", 7 },
146 { "a8", 8 },
147 { "a9", 9 },
148
149 { "c0", 0 }, /* Control registers */
150 { "c1", 1 },
151 { "c10", 10 },
152 { "c11", 11 },
153 { "c12", 12 },
154 { "c13", 13 },
155 { "c14", 14 },
156 { "c15", 15 },
157 { "c2", 2 },
158 { "c3", 3 },
159 { "c4", 4 },
160 { "c5", 5 },
161 { "c6", 6 },
162 { "c7", 7 },
163 { "c8", 8 },
164 { "c9", 9 },
165
166 { "f0", 0 }, /* Floating point registers */
167 { "f1", 1 },
168 { "f10", 10 },
169 { "f11", 11 },
170 { "f12", 12 },
171 { "f13", 13 },
172 { "f14", 14 },
173 { "f15", 15 },
174 { "f2", 2 },
175 { "f3", 3 },
176 { "f4", 4 },
177 { "f5", 5 },
178 { "f6", 6 },
179 { "f7", 7 },
180 { "f8", 8 },
181 { "f9", 9 },
182
183 { "lit", 13 }, /* Pointer to literal pool */
184
185 { "r0", 0 }, /* General purpose registers */
186 { "r1", 1 },
187 { "r10", 10 },
188 { "r11", 11 },
189 { "r12", 12 },
190 { "r13", 13 },
191 { "r14", 14 },
192 { "r15", 15 },
193 { "r2", 2 },
194 { "r3", 3 },
195 { "r4", 4 },
196 { "r5", 5 },
197 { "r6", 6 },
198 { "r7", 7 },
199 { "r8", 8 },
200 { "r9", 9 },
201
202 { "sp", 15 }, /* Stack pointer */
203
204 };
205
206 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
207
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 *,
214 unsigned int));
215 static char *md_gather_operands
216 PARAMS ((char *, unsigned char *, const struct s390_opcode *));
217
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. */
220
221 static int
reg_name_search(regs,regcount,name)222 reg_name_search (regs, regcount, name)
223 const struct pd_reg *regs;
224 int regcount;
225 const char *name;
226 {
227 int middle, low, high;
228 int cmp;
229
230 low = 0;
231 high = regcount - 1;
232
233 do
234 {
235 middle = (low + high) / 2;
236 cmp = strcasecmp (name, regs[middle].name);
237 if (cmp < 0)
238 high = middle - 1;
239 else if (cmp > 0)
240 low = middle + 1;
241 else
242 return regs[middle].value;
243 }
244 while (low <= high);
245
246 return -1;
247 }
248
249
250 /*
251 * Summary of register_name().
252 *
253 * in: Input_line_pointer points to 1st char of operand.
254 *
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
259 * original state.
260 */
261
262 static bfd_boolean
register_name(expressionP)263 register_name (expressionP)
264 expressionS *expressionP;
265 {
266 int reg_number;
267 char *name;
268 char *start;
269 char c;
270
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;
275 else
276 return FALSE;
277
278 c = get_symbol_end ();
279 reg_number = reg_name_search (pre_defined_registers, REG_NAME_CNT, name);
280
281 /* Put back the delimiting char. */
282 *input_line_pointer = c;
283
284 /* Look to see if it's in the register table. */
285 if (reg_number >= 0)
286 {
287 expressionP->X_op = O_register;
288 expressionP->X_add_number = reg_number;
289
290 /* Make the rest nice. */
291 expressionP->X_add_symbol = NULL;
292 expressionP->X_op_symbol = NULL;
293 return TRUE;
294 }
295
296 /* Reset the line as if we had not done anything. */
297 input_line_pointer = start;
298 return FALSE;
299 }
300
301 /* Local variables. */
302
303 /* Opformat hash table. */
304 static struct hash_control *s390_opformat_hash;
305
306 /* Opcode hash table. */
307 static struct hash_control *s390_opcode_hash;
308
309 /* Flags to set in the elf header */
310 static flagword s390_flags = 0;
311
312 symbolS *GOT_symbol; /* Pre-defined "_GLOBAL_OFFSET_TABLE_" */
313
314 #ifndef WORKING_DOT_WORD
315 int md_short_jump_size = 4;
316 int md_long_jump_size = 4;
317 #endif
318
319 const char *md_shortopts = "A:m:kVQ:";
320 struct option md_longopts[] = {
321 {NULL, no_argument, NULL, 0}
322 };
323 size_t md_longopts_size = sizeof (md_longopts);
324
325 /* Initialize the default opcode arch and word size from the default
326 architecture name if not specified by an option. */
327 static void
init_default_arch()328 init_default_arch ()
329 {
330 if (strcmp (default_arch, "s390") == 0)
331 {
332 if (s390_arch_size == 0)
333 s390_arch_size = 32;
334 }
335 else if (strcmp (default_arch, "s390x") == 0)
336 {
337 if (s390_arch_size == 0)
338 s390_arch_size = 64;
339 }
340 else
341 as_fatal ("Invalid default architecture, broken assembler.");
342
343 if (current_mode_mask == 0)
344 {
345 if (s390_arch_size == 32)
346 current_mode_mask = 1 << S390_OPCODE_ESA;
347 else
348 current_mode_mask = 1 << S390_OPCODE_ZARCH;
349 }
350 if (current_cpu == -1U)
351 {
352 if (current_mode_mask == (1 << S390_OPCODE_ESA))
353 current_cpu = S390_OPCODE_G5;
354 else
355 current_cpu = S390_OPCODE_Z900;
356 }
357 }
358
359 /* Called by TARGET_FORMAT. */
360 const char *
s390_target_format()361 s390_target_format ()
362 {
363 /* We don't get a chance to initialize anything before we're called,
364 so handle that now. */
365 init_default_arch ();
366
367 return s390_arch_size == 64 ? "elf64-s390" : "elf32-s390";
368 }
369
370 int
md_parse_option(c,arg)371 md_parse_option (c, arg)
372 int c;
373 char *arg;
374 {
375 switch (c)
376 {
377 /* -k: Ignore for FreeBSD compatibility. */
378 case 'k':
379 break;
380 case 'm':
381 if (arg != NULL && strcmp (arg, "regnames") == 0)
382 reg_names_p = TRUE;
383
384 else if (arg != NULL && strcmp (arg, "no-regnames") == 0)
385 reg_names_p = FALSE;
386
387 else if (arg != NULL && strcmp (arg, "warn-areg-zero") == 0)
388 warn_areg_zero = TRUE;
389
390 else if (arg != NULL && strcmp (arg, "31") == 0)
391 s390_arch_size = 32;
392
393 else if (arg != NULL && strcmp (arg, "64") == 0)
394 s390_arch_size = 64;
395
396 else if (arg != NULL && strcmp (arg, "esa") == 0)
397 current_mode_mask = 1 << S390_OPCODE_ESA;
398
399 else if (arg != NULL && strcmp (arg, "zarch") == 0)
400 current_mode_mask = 1 << S390_OPCODE_ZARCH;
401
402 else if (arg != NULL && strncmp (arg, "arch=", 5) == 0)
403 {
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;
416 else
417 {
418 as_bad (_("invalid switch -m%s"), arg);
419 return 0;
420 }
421 }
422
423 else
424 {
425 as_bad (_("invalid switch -m%s"), arg);
426 return 0;
427 }
428 break;
429
430 case 'A':
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;
436 else
437 as_bad ("invalid architecture -A%s", arg);
438 break;
439
440 /* -V: SVR4 argument to print version ID. */
441 case 'V':
442 print_version_id ();
443 break;
444
445 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
446 should be emitted or not. FIXME: Not implemented. */
447 case 'Q':
448 break;
449
450 default:
451 return 0;
452 }
453
454 return 1;
455 }
456
457 void
md_show_usage(stream)458 md_show_usage (stream)
459 FILE *stream;
460 {
461 fprintf (stream, _("\
462 S390 options:\n\
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"));
471 }
472
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
475 opened. */
476
477 void
md_begin()478 md_begin ()
479 {
480 register const struct s390_opcode *op;
481 const struct s390_opcode *op_end;
482 bfd_boolean dup_insn = FALSE;
483 const char *retval;
484
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.");
488
489 s390_cie_data_alignment = -s390_arch_size / 8;
490
491 /* Set the ELF flags if desired. */
492 if (s390_flags)
493 bfd_set_private_flags (stdoutput, s390_flags);
494
495 /* Insert the opcode formats into a hash table. */
496 s390_opformat_hash = hash_new ();
497
498 op_end = s390_opformats + s390_num_opformats;
499 for (op = s390_opformats; op < op_end; op++)
500 {
501 retval = hash_insert (s390_opformat_hash, op->name, (PTR) op);
502 if (retval != (const char *) NULL)
503 {
504 as_bad (_("Internal assembler error for instruction format %s"),
505 op->name);
506 dup_insn = TRUE;
507 }
508 }
509
510 /* Insert the opcodes into a hash table. */
511 s390_opcode_hash = hash_new ();
512
513 op_end = s390_opcodes + s390_num_opcodes;
514 for (op = s390_opcodes; op < op_end; op++)
515 if (op->min_cpu <= current_cpu)
516 {
517 retval = hash_insert (s390_opcode_hash, op->name, (PTR) op);
518 if (retval != (const char *) NULL)
519 {
520 as_bad (_("Internal assembler error for instruction %s"),
521 op->name);
522 dup_insn = TRUE;
523 }
524 while (op < op_end - 1 && strcmp (op->name, op[1].name) == 0)
525 op++;
526 }
527
528 if (dup_insn)
529 abort ();
530
531 record_alignment (text_section, 2);
532 record_alignment (data_section, 2);
533 record_alignment (bss_section, 2);
534
535 }
536
537 /* Called after all assembly has been done. */
538 void
s390_md_end()539 s390_md_end ()
540 {
541 if (s390_arch_size == 64)
542 bfd_set_arch_mach (stdoutput, bfd_arch_s390, bfd_mach_s390_64);
543 else
544 bfd_set_arch_mach (stdoutput, bfd_arch_s390, bfd_mach_s390_31);
545 }
546
547 /* Insert an operand value into an instruction. */
548
549 static void
s390_insert_operand(insn,operand,val,file,line)550 s390_insert_operand (insn, operand, val, file, line)
551 unsigned char *insn;
552 const struct s390_operand *operand;
553 offsetT val;
554 char *file;
555 unsigned int line;
556 {
557 addressT uval;
558 int offset;
559
560 if (operand->flags & (S390_OPERAND_SIGNED|S390_OPERAND_PCREL))
561 {
562 offsetT min, max;
563
564 max = ((offsetT) 1 << (operand->bits - 1)) - 1;
565 min = - ((offsetT) 1 << (operand->bits - 1));
566 /* Halve PCREL operands. */
567 if (operand->flags & S390_OPERAND_PCREL)
568 val >>= 1;
569 /* Check for underflow / overflow. */
570 if (val < min || val > max)
571 {
572 const char *err =
573 "operand out of range (%s not between %ld and %ld)";
574 char buf[100];
575
576 if (operand->flags & S390_OPERAND_PCREL)
577 {
578 val <<= 1;
579 min <<= 1;
580 max <<= 1;
581 }
582 sprint_value (buf, val);
583 if (file == (char *) NULL)
584 as_bad (err, buf, (int) min, (int) max);
585 else
586 as_bad_where (file, line, err, buf, (int) min, (int) max);
587 return;
588 }
589 /* val is ok, now restrict it to operand->bits bits. */
590 uval = (addressT) val & ((((addressT) 1 << (operand->bits-1)) << 1) - 1);
591 /* val is restrict, now check for special case. */
592 if (operand->bits == 20 && operand->shift == 20)
593 uval = (uval >> 12) | ((uval & 0xfff) << 8);
594 }
595 else
596 {
597 addressT min, max;
598
599 max = (((addressT) 1 << (operand->bits - 1)) << 1) - 1;
600 min = (offsetT) 0;
601 uval = (addressT) val;
602 /* Length x in an instructions has real length x+1. */
603 if (operand->flags & S390_OPERAND_LENGTH)
604 uval--;
605 /* Check for underflow / overflow. */
606 if (uval < min || uval > max)
607 {
608 if (operand->flags & S390_OPERAND_LENGTH)
609 {
610 uval++;
611 min++;
612 max++;
613 }
614
615 as_bad_value_out_of_range (_("operand"), uval, (offsetT) min, (offsetT) max, file, line);
616
617 return;
618 }
619 }
620
621 /* Insert fragments of the operand byte for byte. */
622 offset = operand->shift + operand->bits;
623 uval <<= (-offset) & 7;
624 insn += (offset - 1) / 8;
625 while (uval != 0)
626 {
627 *insn-- |= uval;
628 uval >>= 8;
629 }
630 }
631
632 struct map_tls
633 {
634 char *string;
635 int length;
636 bfd_reloc_code_real_type reloc;
637 };
638
639 static bfd_reloc_code_real_type s390_tls_suffix
640 PARAMS ((char **, expressionS *));
641
642 /* Parse tls marker and return the desired relocation. */
643 static bfd_reloc_code_real_type
s390_tls_suffix(str_p,exp_p)644 s390_tls_suffix (str_p, exp_p)
645 char **str_p;
646 expressionS *exp_p;
647 {
648 static struct map_tls mapping[] =
649 {
650 { "tls_load", 8, BFD_RELOC_390_TLS_LOAD },
651 { "tls_gdcall", 10, BFD_RELOC_390_TLS_GDCALL },
652 { "tls_ldcall", 10, BFD_RELOC_390_TLS_LDCALL },
653 { NULL, 0, BFD_RELOC_UNUSED }
654 };
655 struct map_tls *ptr;
656 char *orig_line;
657 char *str;
658 char *ident;
659 int len;
660
661 str = *str_p;
662 if (*str++ != ':')
663 return BFD_RELOC_UNUSED;
664
665 ident = str;
666 while (ISIDNUM (*str))
667 str++;
668 len = str - ident;
669 if (*str++ != ':')
670 return BFD_RELOC_UNUSED;
671
672 orig_line = input_line_pointer;
673 input_line_pointer = str;
674 expression (exp_p);
675 str = input_line_pointer;
676 if (&input_line_pointer != str_p)
677 input_line_pointer = orig_line;
678
679 if (exp_p->X_op != O_symbol)
680 return BFD_RELOC_UNUSED;
681
682 for (ptr = &mapping[0]; ptr->length > 0; ptr++)
683 if (len == ptr->length
684 && strncasecmp (ident, ptr->string, ptr->length) == 0)
685 {
686 /* Found a matching tls suffix. */
687 *str_p = str;
688 return ptr->reloc;
689 }
690 return BFD_RELOC_UNUSED;
691 }
692
693 /* Structure used to hold suffixes. */
694 typedef enum
695 {
696 ELF_SUFFIX_NONE = 0,
697 ELF_SUFFIX_GOT,
698 ELF_SUFFIX_PLT,
699 ELF_SUFFIX_GOTENT,
700 ELF_SUFFIX_GOTOFF,
701 ELF_SUFFIX_GOTPLT,
702 ELF_SUFFIX_PLTOFF,
703 ELF_SUFFIX_TLS_GD,
704 ELF_SUFFIX_TLS_GOTIE,
705 ELF_SUFFIX_TLS_IE,
706 ELF_SUFFIX_TLS_LDM,
707 ELF_SUFFIX_TLS_LDO,
708 ELF_SUFFIX_TLS_LE
709 }
710 elf_suffix_type;
711
712 struct map_bfd
713 {
714 char *string;
715 int length;
716 elf_suffix_type suffix;
717 };
718
719 static elf_suffix_type s390_elf_suffix PARAMS ((char **, expressionS *));
720 static int s390_exp_compare PARAMS ((expressionS *exp1, expressionS *exp2));
721 static elf_suffix_type s390_lit_suffix
722 PARAMS ((char **, expressionS *, elf_suffix_type));
723
724
725 /* Parse @got/@plt/@gotoff. and return the desired relocation. */
726 static elf_suffix_type
s390_elf_suffix(str_p,exp_p)727 s390_elf_suffix (str_p, exp_p)
728 char **str_p;
729 expressionS *exp_p;
730 {
731 static struct map_bfd mapping[] =
732 {
733 { "got", 3, ELF_SUFFIX_GOT },
734 { "got12", 5, ELF_SUFFIX_GOT },
735 { "plt", 3, ELF_SUFFIX_PLT },
736 { "gotent", 6, ELF_SUFFIX_GOTENT },
737 { "gotoff", 6, ELF_SUFFIX_GOTOFF },
738 { "gotplt", 6, ELF_SUFFIX_GOTPLT },
739 { "pltoff", 6, ELF_SUFFIX_PLTOFF },
740 { "tlsgd", 5, ELF_SUFFIX_TLS_GD },
741 { "gotntpoff", 9, ELF_SUFFIX_TLS_GOTIE },
742 { "indntpoff", 9, ELF_SUFFIX_TLS_IE },
743 { "tlsldm", 6, ELF_SUFFIX_TLS_LDM },
744 { "dtpoff", 6, ELF_SUFFIX_TLS_LDO },
745 { "ntpoff", 6, ELF_SUFFIX_TLS_LE },
746 { NULL, 0, ELF_SUFFIX_NONE }
747 };
748
749 struct map_bfd *ptr;
750 char *str = *str_p;
751 char *ident;
752 int len;
753
754 if (*str++ != '@')
755 return ELF_SUFFIX_NONE;
756
757 ident = str;
758 while (ISALNUM (*str))
759 str++;
760 len = str - ident;
761
762 for (ptr = &mapping[0]; ptr->length > 0; ptr++)
763 if (len == ptr->length
764 && strncasecmp (ident, ptr->string, ptr->length) == 0)
765 {
766 if (exp_p->X_add_number != 0)
767 as_warn (_("identifier+constant@%s means identifier@%s+constant"),
768 ptr->string, ptr->string);
769 /* Now check for identifier@suffix+constant. */
770 if (*str == '-' || *str == '+')
771 {
772 char *orig_line = input_line_pointer;
773 expressionS new_exp;
774
775 input_line_pointer = str;
776 expression (&new_exp);
777
778 switch (new_exp.X_op)
779 {
780 case O_constant: /* X_add_number (a constant expression). */
781 exp_p->X_add_number += new_exp.X_add_number;
782 str = input_line_pointer;
783 break;
784 case O_symbol: /* X_add_symbol + X_add_number. */
785 /* this case is used for e.g. xyz@PLT+.Label. */
786 exp_p->X_add_number += new_exp.X_add_number;
787 exp_p->X_op_symbol = new_exp.X_add_symbol;
788 exp_p->X_op = O_add;
789 str = input_line_pointer;
790 break;
791 case O_uminus: /* (- X_add_symbol) + X_add_number. */
792 /* this case is used for e.g. xyz@PLT-.Label. */
793 exp_p->X_add_number += new_exp.X_add_number;
794 exp_p->X_op_symbol = new_exp.X_add_symbol;
795 exp_p->X_op = O_subtract;
796 str = input_line_pointer;
797 break;
798 default:
799 break;
800 }
801
802 /* If s390_elf_suffix has not been called with
803 &input_line_pointer as first parameter, we have
804 clobbered the input_line_pointer. We have to
805 undo that. */
806 if (&input_line_pointer != str_p)
807 input_line_pointer = orig_line;
808 }
809 *str_p = str;
810 return ptr->suffix;
811 }
812
813 return BFD_RELOC_UNUSED;
814 }
815
816 /* Structure used to hold a literal pool entry. */
817 struct s390_lpe
818 {
819 struct s390_lpe *next;
820 expressionS ex;
821 FLONUM_TYPE floatnum; /* used if X_op == O_big && X_add_number <= 0 */
822 LITTLENUM_TYPE bignum[4]; /* used if X_op == O_big && X_add_number > 0 */
823 int nbytes;
824 bfd_reloc_code_real_type reloc;
825 symbolS *sym;
826 };
827
828 static struct s390_lpe *lpe_free_list = NULL;
829 static struct s390_lpe *lpe_list = NULL;
830 static struct s390_lpe *lpe_list_tail = NULL;
831 static symbolS *lp_sym = NULL;
832 static int lp_count = 0;
833 static int lpe_count = 0;
834
835 static int
s390_exp_compare(exp1,exp2)836 s390_exp_compare (exp1, exp2)
837 expressionS *exp1;
838 expressionS *exp2;
839 {
840 if (exp1->X_op != exp2->X_op)
841 return 0;
842
843 switch (exp1->X_op)
844 {
845 case O_constant: /* X_add_number must be equal. */
846 case O_register:
847 return exp1->X_add_number == exp2->X_add_number;
848
849 case O_big:
850 as_bad (_("Can't handle O_big in s390_exp_compare"));
851
852 case O_symbol: /* X_add_symbol & X_add_number must be equal. */
853 case O_symbol_rva:
854 case O_uminus:
855 case O_bit_not:
856 case O_logical_not:
857 return (exp1->X_add_symbol == exp2->X_add_symbol)
858 && (exp1->X_add_number == exp2->X_add_number);
859
860 case O_multiply: /* X_add_symbol,X_op_symbol&X_add_number must be equal. */
861 case O_divide:
862 case O_modulus:
863 case O_left_shift:
864 case O_right_shift:
865 case O_bit_inclusive_or:
866 case O_bit_or_not:
867 case O_bit_exclusive_or:
868 case O_bit_and:
869 case O_add:
870 case O_subtract:
871 case O_eq:
872 case O_ne:
873 case O_lt:
874 case O_le:
875 case O_ge:
876 case O_gt:
877 case O_logical_and:
878 case O_logical_or:
879 return (exp1->X_add_symbol == exp2->X_add_symbol)
880 && (exp1->X_op_symbol == exp2->X_op_symbol)
881 && (exp1->X_add_number == exp2->X_add_number);
882 default:
883 return 0;
884 }
885 }
886
887 /* Test for @lit and if its present make an entry in the literal pool and
888 modify the current expression to be an offset into the literal pool. */
889 static elf_suffix_type
s390_lit_suffix(str_p,exp_p,suffix)890 s390_lit_suffix (str_p, exp_p, suffix)
891 char **str_p;
892 expressionS *exp_p;
893 elf_suffix_type suffix;
894 {
895 bfd_reloc_code_real_type reloc;
896 char tmp_name[64];
897 char *str = *str_p;
898 char *ident;
899 struct s390_lpe *lpe;
900 int nbytes, len;
901
902 if (*str++ != ':')
903 return suffix; /* No modification. */
904
905 /* We look for a suffix of the form "@lit1", "@lit2", "@lit4" or "@lit8". */
906 ident = str;
907 while (ISALNUM (*str))
908 str++;
909 len = str - ident;
910 if (len != 4 || strncasecmp (ident, "lit", 3) != 0
911 || (ident[3]!='1' && ident[3]!='2' && ident[3]!='4' && ident[3]!='8'))
912 return suffix; /* no modification */
913 nbytes = ident[3] - '0';
914
915 reloc = BFD_RELOC_UNUSED;
916 if (suffix == ELF_SUFFIX_GOT)
917 {
918 if (nbytes == 2)
919 reloc = BFD_RELOC_390_GOT16;
920 else if (nbytes == 4)
921 reloc = BFD_RELOC_32_GOT_PCREL;
922 else if (nbytes == 8)
923 reloc = BFD_RELOC_390_GOT64;
924 }
925 else if (suffix == ELF_SUFFIX_PLT)
926 {
927 if (nbytes == 4)
928 reloc = BFD_RELOC_390_PLT32;
929 else if (nbytes == 8)
930 reloc = BFD_RELOC_390_PLT64;
931 }
932
933 if (suffix != ELF_SUFFIX_NONE && reloc == BFD_RELOC_UNUSED)
934 as_bad (_("Invalid suffix for literal pool entry"));
935
936 /* Search the pool if the new entry is a duplicate. */
937 if (exp_p->X_op == O_big)
938 {
939 /* Special processing for big numbers. */
940 for (lpe = lpe_list; lpe != NULL; lpe = lpe->next)
941 {
942 if (lpe->ex.X_op == O_big)
943 {
944 if (exp_p->X_add_number <= 0 && lpe->ex.X_add_number <= 0)
945 {
946 if (memcmp (&generic_floating_point_number, &lpe->floatnum,
947 sizeof (FLONUM_TYPE)) == 0)
948 break;
949 }
950 else if (exp_p->X_add_number == lpe->ex.X_add_number)
951 {
952 if (memcmp (generic_bignum, lpe->bignum,
953 sizeof (LITTLENUM_TYPE)*exp_p->X_add_number) == 0)
954 break;
955 }
956 }
957 }
958 }
959 else
960 {
961 /* Processing for 'normal' data types. */
962 for (lpe = lpe_list; lpe != NULL; lpe = lpe->next)
963 if (lpe->nbytes == nbytes && lpe->reloc == reloc
964 && s390_exp_compare (exp_p, &lpe->ex) != 0)
965 break;
966 }
967
968 if (lpe == NULL)
969 {
970 /* A new literal. */
971 if (lpe_free_list != NULL)
972 {
973 lpe = lpe_free_list;
974 lpe_free_list = lpe_free_list->next;
975 }
976 else
977 {
978 lpe = (struct s390_lpe *) xmalloc (sizeof (struct s390_lpe));
979 }
980
981 lpe->ex = *exp_p;
982
983 if (exp_p->X_op == O_big)
984 {
985 if (exp_p->X_add_number <= 0)
986 lpe->floatnum = generic_floating_point_number;
987 else if (exp_p->X_add_number <= 4)
988 memcpy (lpe->bignum, generic_bignum,
989 exp_p->X_add_number * sizeof (LITTLENUM_TYPE));
990 else
991 as_bad (_("Big number is too big"));
992 }
993
994 lpe->nbytes = nbytes;
995 lpe->reloc = reloc;
996 /* Literal pool name defined ? */
997 if (lp_sym == NULL)
998 {
999 sprintf (tmp_name, ".L\001%i", lp_count);
1000 lp_sym = symbol_make (tmp_name);
1001 }
1002
1003 /* Make name for literal pool entry. */
1004 sprintf (tmp_name, ".L\001%i\002%i", lp_count, lpe_count);
1005 lpe_count++;
1006 lpe->sym = symbol_make (tmp_name);
1007
1008 /* Add to literal pool list. */
1009 lpe->next = NULL;
1010 if (lpe_list_tail != NULL)
1011 {
1012 lpe_list_tail->next = lpe;
1013 lpe_list_tail = lpe;
1014 }
1015 else
1016 lpe_list = lpe_list_tail = lpe;
1017 }
1018
1019 /* Now change exp_p to the offset into the literal pool.
1020 Thats the expression: .L^Ax^By-.L^Ax */
1021 exp_p->X_add_symbol = lpe->sym;
1022 exp_p->X_op_symbol = lp_sym;
1023 exp_p->X_op = O_subtract;
1024 exp_p->X_add_number = 0;
1025
1026 *str_p = str;
1027
1028 /* We change the suffix type to ELF_SUFFIX_NONE, because
1029 the difference of two local labels is just a number. */
1030 return ELF_SUFFIX_NONE;
1031 }
1032
1033 /* Like normal .long/.short/.word, except support @got, etc.
1034 clobbers input_line_pointer, checks end-of-line. */
1035 static void
s390_elf_cons(nbytes)1036 s390_elf_cons (nbytes)
1037 register int nbytes; /* 1=.byte, 2=.word, 4=.long */
1038 {
1039 expressionS exp;
1040 elf_suffix_type suffix;
1041
1042 if (is_it_end_of_statement ())
1043 {
1044 demand_empty_rest_of_line ();
1045 return;
1046 }
1047
1048 do
1049 {
1050 expression (&exp);
1051
1052 if (exp.X_op == O_symbol
1053 && *input_line_pointer == '@'
1054 && (suffix = s390_elf_suffix (&input_line_pointer, &exp)) != ELF_SUFFIX_NONE)
1055 {
1056 bfd_reloc_code_real_type reloc;
1057 reloc_howto_type *reloc_howto;
1058 int size;
1059 char *where;
1060
1061 if (nbytes == 2)
1062 {
1063 static bfd_reloc_code_real_type tab2[] =
1064 {
1065 BFD_RELOC_UNUSED, /* ELF_SUFFIX_NONE */
1066 BFD_RELOC_390_GOT16, /* ELF_SUFFIX_GOT */
1067 BFD_RELOC_UNUSED, /* ELF_SUFFIX_PLT */
1068 BFD_RELOC_UNUSED, /* ELF_SUFFIX_GOTENT */
1069 BFD_RELOC_16_GOTOFF, /* ELF_SUFFIX_GOTOFF */
1070 BFD_RELOC_UNUSED, /* ELF_SUFFIX_GOTPLT */
1071 BFD_RELOC_390_PLTOFF16, /* ELF_SUFFIX_PLTOFF */
1072 BFD_RELOC_UNUSED, /* ELF_SUFFIX_TLS_GD */
1073 BFD_RELOC_UNUSED, /* ELF_SUFFIX_TLS_GOTIE */
1074 BFD_RELOC_UNUSED, /* ELF_SUFFIX_TLS_IE */
1075 BFD_RELOC_UNUSED, /* ELF_SUFFIX_TLS_LDM */
1076 BFD_RELOC_UNUSED, /* ELF_SUFFIX_TLS_LDO */
1077 BFD_RELOC_UNUSED /* ELF_SUFFIX_TLS_LE */
1078 };
1079 reloc = tab2[suffix];
1080 }
1081 else if (nbytes == 4)
1082 {
1083 static bfd_reloc_code_real_type tab4[] =
1084 {
1085 BFD_RELOC_UNUSED, /* ELF_SUFFIX_NONE */
1086 BFD_RELOC_32_GOT_PCREL, /* ELF_SUFFIX_GOT */
1087 BFD_RELOC_390_PLT32, /* ELF_SUFFIX_PLT */
1088 BFD_RELOC_UNUSED, /* ELF_SUFFIX_GOTENT */
1089 BFD_RELOC_32_GOTOFF, /* ELF_SUFFIX_GOTOFF */
1090 BFD_RELOC_390_GOTPLT32, /* ELF_SUFFIX_GOTPLT */
1091 BFD_RELOC_390_PLTOFF32, /* ELF_SUFFIX_PLTOFF */
1092 BFD_RELOC_390_TLS_GD32, /* ELF_SUFFIX_TLS_GD */
1093 BFD_RELOC_390_TLS_GOTIE32, /* ELF_SUFFIX_TLS_GOTIE */
1094 BFD_RELOC_390_TLS_IE32, /* ELF_SUFFIX_TLS_IE */
1095 BFD_RELOC_390_TLS_LDM32, /* ELF_SUFFIX_TLS_LDM */
1096 BFD_RELOC_390_TLS_LDO32, /* ELF_SUFFIX_TLS_LDO */
1097 BFD_RELOC_390_TLS_LE32 /* ELF_SUFFIX_TLS_LE */
1098 };
1099 reloc = tab4[suffix];
1100 }
1101 else if (nbytes == 8)
1102 {
1103 static bfd_reloc_code_real_type tab8[] =
1104 {
1105 BFD_RELOC_UNUSED, /* ELF_SUFFIX_NONE */
1106 BFD_RELOC_390_GOT64, /* ELF_SUFFIX_GOT */
1107 BFD_RELOC_390_PLT64, /* ELF_SUFFIX_PLT */
1108 BFD_RELOC_UNUSED, /* ELF_SUFFIX_GOTENT */
1109 BFD_RELOC_390_GOTOFF64, /* ELF_SUFFIX_GOTOFF */
1110 BFD_RELOC_390_GOTPLT64, /* ELF_SUFFIX_GOTPLT */
1111 BFD_RELOC_390_PLTOFF64, /* ELF_SUFFIX_PLTOFF */
1112 BFD_RELOC_390_TLS_GD64, /* ELF_SUFFIX_TLS_GD */
1113 BFD_RELOC_390_TLS_GOTIE64, /* ELF_SUFFIX_TLS_GOTIE */
1114 BFD_RELOC_390_TLS_IE64, /* ELF_SUFFIX_TLS_IE */
1115 BFD_RELOC_390_TLS_LDM64, /* ELF_SUFFIX_TLS_LDM */
1116 BFD_RELOC_390_TLS_LDO64, /* ELF_SUFFIX_TLS_LDO */
1117 BFD_RELOC_390_TLS_LE64 /* ELF_SUFFIX_TLS_LE */
1118 };
1119 reloc = tab8[suffix];
1120 }
1121 else
1122 reloc = BFD_RELOC_UNUSED;
1123
1124 if (reloc != BFD_RELOC_UNUSED
1125 && (reloc_howto = bfd_reloc_type_lookup (stdoutput, reloc)))
1126 {
1127 size = bfd_get_reloc_size (reloc_howto);
1128 if (size > nbytes)
1129 as_bad (_("%s relocations do not fit in %d bytes"),
1130 reloc_howto->name, nbytes);
1131 where = frag_more (nbytes);
1132 md_number_to_chars (where, 0, size);
1133 /* To make fixup_segment do the pc relative conversion the
1134 pcrel parameter on the fix_new_exp call needs to be FALSE. */
1135 fix_new_exp (frag_now, where - frag_now->fr_literal,
1136 size, &exp, FALSE, reloc);
1137 }
1138 else
1139 as_bad (_("relocation not applicable"));
1140 }
1141 else
1142 emit_expr (&exp, (unsigned int) nbytes);
1143 }
1144 while (*input_line_pointer++ == ',');
1145
1146 input_line_pointer--; /* Put terminator back into stream. */
1147 demand_empty_rest_of_line ();
1148 }
1149
1150 /* We need to keep a list of fixups. We can't simply generate them as
1151 we go, because that would require us to first create the frag, and
1152 that would screw up references to ``.''. */
1153
1154 struct s390_fixup
1155 {
1156 expressionS exp;
1157 int opindex;
1158 bfd_reloc_code_real_type reloc;
1159 };
1160
1161 #define MAX_INSN_FIXUPS (4)
1162
1163 /* This routine is called for each instruction to be assembled. */
1164
1165 static char *
md_gather_operands(str,insn,opcode)1166 md_gather_operands (str, insn, opcode)
1167 char *str;
1168 unsigned char *insn;
1169 const struct s390_opcode *opcode;
1170 {
1171 struct s390_fixup fixups[MAX_INSN_FIXUPS];
1172 const struct s390_operand *operand;
1173 const unsigned char *opindex_ptr;
1174 expressionS ex;
1175 elf_suffix_type suffix;
1176 bfd_reloc_code_real_type reloc;
1177 int skip_optional;
1178 int parentheses;
1179 char *f;
1180 int fc, i;
1181
1182 while (ISSPACE (*str))
1183 str++;
1184
1185 parentheses = 0;
1186 skip_optional = 0;
1187
1188 /* Gather the operands. */
1189 fc = 0;
1190 for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
1191 {
1192 char *hold;
1193
1194 operand = s390_operands + *opindex_ptr;
1195
1196 if (skip_optional && (operand->flags & S390_OPERAND_INDEX))
1197 {
1198 /* We do an early skip. For D(X,B) constructions the index
1199 register is skipped (X is optional). For D(L,B) the base
1200 register will be the skipped operand, because L is NOT
1201 optional. */
1202 skip_optional = 0;
1203 continue;
1204 }
1205
1206 /* Gather the operand. */
1207 hold = input_line_pointer;
1208 input_line_pointer = str;
1209
1210 /* Parse the operand. */
1211 if (! register_name (&ex))
1212 expression (&ex);
1213
1214 str = input_line_pointer;
1215 input_line_pointer = hold;
1216
1217 /* Write the operand to the insn. */
1218 if (ex.X_op == O_illegal)
1219 as_bad (_("illegal operand"));
1220 else if (ex.X_op == O_absent)
1221 as_bad (_("missing operand"));
1222 else if (ex.X_op == O_register || ex.X_op == O_constant)
1223 {
1224 s390_lit_suffix (&str, &ex, ELF_SUFFIX_NONE);
1225
1226 if (ex.X_op != O_register && ex.X_op != O_constant)
1227 {
1228 /* We need to generate a fixup for the
1229 expression returned by s390_lit_suffix. */
1230 if (fc >= MAX_INSN_FIXUPS)
1231 as_fatal (_("too many fixups"));
1232 fixups[fc].exp = ex;
1233 fixups[fc].opindex = *opindex_ptr;
1234 fixups[fc].reloc = BFD_RELOC_UNUSED;
1235 ++fc;
1236 }
1237 else
1238 {
1239 if ((operand->flags & S390_OPERAND_INDEX)
1240 && ex.X_add_number == 0
1241 && warn_areg_zero)
1242 as_warn ("index register specified but zero");
1243 if ((operand->flags & S390_OPERAND_BASE)
1244 && ex.X_add_number == 0
1245 && warn_areg_zero)
1246 as_warn ("base register specified but zero");
1247 s390_insert_operand (insn, operand, ex.X_add_number, NULL, 0);
1248 }
1249 }
1250 else
1251 {
1252 suffix = s390_elf_suffix (&str, &ex);
1253 suffix = s390_lit_suffix (&str, &ex, suffix);
1254 reloc = BFD_RELOC_UNUSED;
1255
1256 if (suffix == ELF_SUFFIX_GOT)
1257 {
1258 if ((operand->flags & S390_OPERAND_DISP) &&
1259 (operand->bits == 12))
1260 reloc = BFD_RELOC_390_GOT12;
1261 else if ((operand->flags & S390_OPERAND_DISP) &&
1262 (operand->bits == 20))
1263 reloc = BFD_RELOC_390_GOT20;
1264 else if ((operand->flags & S390_OPERAND_SIGNED)
1265 && (operand->bits == 16))
1266 reloc = BFD_RELOC_390_GOT16;
1267 else if ((operand->flags & S390_OPERAND_PCREL)
1268 && (operand->bits == 32))
1269 reloc = BFD_RELOC_390_GOTENT;
1270 }
1271 else if (suffix == ELF_SUFFIX_PLT)
1272 {
1273 if ((operand->flags & S390_OPERAND_PCREL)
1274 && (operand->bits == 16))
1275 reloc = BFD_RELOC_390_PLT16DBL;
1276 else if ((operand->flags & S390_OPERAND_PCREL)
1277 && (operand->bits == 32))
1278 reloc = BFD_RELOC_390_PLT32DBL;
1279 }
1280 else if (suffix == ELF_SUFFIX_GOTENT)
1281 {
1282 if ((operand->flags & S390_OPERAND_PCREL)
1283 && (operand->bits == 32))
1284 reloc = BFD_RELOC_390_GOTENT;
1285 }
1286 else if (suffix == ELF_SUFFIX_GOTOFF)
1287 {
1288 if ((operand->flags & S390_OPERAND_SIGNED)
1289 && (operand->bits == 16))
1290 reloc = BFD_RELOC_16_GOTOFF;
1291 }
1292 else if (suffix == ELF_SUFFIX_PLTOFF)
1293 {
1294 if ((operand->flags & S390_OPERAND_SIGNED)
1295 && (operand->bits == 16))
1296 reloc = BFD_RELOC_390_PLTOFF16;
1297 }
1298 else if (suffix == ELF_SUFFIX_GOTPLT)
1299 {
1300 if ((operand->flags & S390_OPERAND_DISP)
1301 && (operand->bits == 12))
1302 reloc = BFD_RELOC_390_GOTPLT12;
1303 else if ((operand->flags & S390_OPERAND_SIGNED)
1304 && (operand->bits == 16))
1305 reloc = BFD_RELOC_390_GOTPLT16;
1306 else if ((operand->flags & S390_OPERAND_PCREL)
1307 && (operand->bits == 32))
1308 reloc = BFD_RELOC_390_GOTPLTENT;
1309 }
1310 else if (suffix == ELF_SUFFIX_TLS_GOTIE)
1311 {
1312 if ((operand->flags & S390_OPERAND_DISP)
1313 && (operand->bits == 12))
1314 reloc = BFD_RELOC_390_TLS_GOTIE12;
1315 else if ((operand->flags & S390_OPERAND_DISP)
1316 && (operand->bits == 20))
1317 reloc = BFD_RELOC_390_TLS_GOTIE20;
1318 }
1319 else if (suffix == ELF_SUFFIX_TLS_IE)
1320 {
1321 if ((operand->flags & S390_OPERAND_PCREL)
1322 && (operand->bits == 32))
1323 reloc = BFD_RELOC_390_TLS_IEENT;
1324 }
1325
1326 if (suffix != ELF_SUFFIX_NONE && reloc == BFD_RELOC_UNUSED)
1327 as_bad (_("invalid operand suffix"));
1328 /* We need to generate a fixup of type 'reloc' for this
1329 expression. */
1330 if (fc >= MAX_INSN_FIXUPS)
1331 as_fatal (_("too many fixups"));
1332 fixups[fc].exp = ex;
1333 fixups[fc].opindex = *opindex_ptr;
1334 fixups[fc].reloc = reloc;
1335 ++fc;
1336 }
1337
1338 /* Check the next character. The call to expression has advanced
1339 str past any whitespace. */
1340 if (operand->flags & S390_OPERAND_DISP)
1341 {
1342 /* After a displacement a block in parentheses can start. */
1343 if (*str != '(')
1344 {
1345 /* Check if parenthesized block can be skipped. If the next
1346 operand is neiter an optional operand nor a base register
1347 then we have a syntax error. */
1348 operand = s390_operands + *(++opindex_ptr);
1349 if (!(operand->flags & (S390_OPERAND_INDEX|S390_OPERAND_BASE)))
1350 as_bad (_("syntax error; missing '(' after displacement"));
1351
1352 /* Ok, skip all operands until S390_OPERAND_BASE. */
1353 while (!(operand->flags & S390_OPERAND_BASE))
1354 operand = s390_operands + *(++opindex_ptr);
1355
1356 /* If there is a next operand it must be separated by a comma. */
1357 if (opindex_ptr[1] != '\0')
1358 {
1359 if (*str != ',')
1360 {
1361 while (opindex_ptr[1] != '\0')
1362 {
1363 operand = s390_operands + *(++opindex_ptr);
1364 if (operand->flags & S390_OPERAND_OPTIONAL)
1365 continue;
1366 as_bad (_("syntax error; expected ,"));
1367 break;
1368 }
1369 }
1370 else
1371 str++;
1372 }
1373 }
1374 else
1375 {
1376 /* We found an opening parentheses. */
1377 str++;
1378 for (f = str; *f != '\0'; f++)
1379 if (*f == ',' || *f == ')')
1380 break;
1381 /* If there is no comma until the closing parentheses OR
1382 there is a comma right after the opening parentheses,
1383 we have to skip optional operands. */
1384 if (*f == ',' && f == str)
1385 {
1386 /* comma directly after '(' ? */
1387 skip_optional = 1;
1388 str++;
1389 }
1390 else
1391 skip_optional = (*f != ',');
1392 }
1393 }
1394 else if (operand->flags & S390_OPERAND_BASE)
1395 {
1396 /* After the base register the parenthesed block ends. */
1397 if (*str++ != ')')
1398 as_bad (_("syntax error; missing ')' after base register"));
1399 skip_optional = 0;
1400 /* If there is a next operand it must be separated by a comma. */
1401 if (opindex_ptr[1] != '\0')
1402 {
1403 if (*str != ',')
1404 {
1405 while (opindex_ptr[1] != '\0')
1406 {
1407 operand = s390_operands + *(++opindex_ptr);
1408 if (operand->flags & S390_OPERAND_OPTIONAL)
1409 continue;
1410 as_bad (_("syntax error; expected ,"));
1411 break;
1412 }
1413 }
1414 else
1415 str++;
1416 }
1417 }
1418 else
1419 {
1420 /* We can find an 'early' closing parentheses in e.g. D(L) instead
1421 of D(L,B). In this case the base register has to be skipped. */
1422 if (*str == ')')
1423 {
1424 operand = s390_operands + *(++opindex_ptr);
1425
1426 if (!(operand->flags & S390_OPERAND_BASE))
1427 as_bad (_("syntax error; ')' not allowed here"));
1428 str++;
1429 }
1430 /* If there is a next operand it must be separated by a comma. */
1431 if (opindex_ptr[1] != '\0')
1432 {
1433 if (*str != ',')
1434 {
1435 while (opindex_ptr[1] != '\0')
1436 {
1437 operand = s390_operands + *(++opindex_ptr);
1438 if (operand->flags & S390_OPERAND_OPTIONAL)
1439 continue;
1440 as_bad (_("syntax error; expected ,"));
1441 break;
1442 }
1443 }
1444 else
1445 str++;
1446 }
1447 }
1448 }
1449
1450 while (ISSPACE (*str))
1451 ++str;
1452
1453 /* Check for tls instruction marker. */
1454 reloc = s390_tls_suffix (&str, &ex);
1455 if (reloc != BFD_RELOC_UNUSED)
1456 {
1457 /* We need to generate a fixup of type 'reloc' for this
1458 instruction. */
1459 if (fc >= MAX_INSN_FIXUPS)
1460 as_fatal (_("too many fixups"));
1461 fixups[fc].exp = ex;
1462 fixups[fc].opindex = -1;
1463 fixups[fc].reloc = reloc;
1464 ++fc;
1465 }
1466
1467 if (*str != '\0')
1468 {
1469 char *linefeed;
1470
1471 if ((linefeed = strchr (str, '\n')) != NULL)
1472 *linefeed = '\0';
1473 as_bad (_("junk at end of line: `%s'"), str);
1474 if (linefeed != NULL)
1475 *linefeed = '\n';
1476 }
1477
1478 /* Write out the instruction. */
1479 f = frag_more (opcode->oplen);
1480 memcpy (f, insn, opcode->oplen);
1481 dwarf2_emit_insn (opcode->oplen);
1482
1483 /* Create any fixups. At this point we do not use a
1484 bfd_reloc_code_real_type, but instead just use the
1485 BFD_RELOC_UNUSED plus the operand index. This lets us easily
1486 handle fixups for any operand type, although that is admittedly
1487 not a very exciting feature. We pick a BFD reloc type in
1488 md_apply_fix. */
1489 for (i = 0; i < fc; i++)
1490 {
1491
1492 if (fixups[i].opindex < 0)
1493 {
1494 /* Create tls instruction marker relocation. */
1495 fix_new_exp (frag_now, f - frag_now->fr_literal, opcode->oplen,
1496 &fixups[i].exp, 0, fixups[i].reloc);
1497 continue;
1498 }
1499
1500 operand = s390_operands + fixups[i].opindex;
1501
1502 if (fixups[i].reloc != BFD_RELOC_UNUSED)
1503 {
1504 reloc_howto_type *reloc_howto;
1505 fixS *fixP;
1506 int size;
1507
1508 reloc_howto = bfd_reloc_type_lookup (stdoutput, fixups[i].reloc);
1509 if (!reloc_howto)
1510 abort ();
1511
1512 size = bfd_get_reloc_size (reloc_howto);
1513
1514 if (size < 1 || size > 4)
1515 abort ();
1516
1517 fixP = fix_new_exp (frag_now,
1518 f - frag_now->fr_literal + (operand->shift/8),
1519 size, &fixups[i].exp, reloc_howto->pc_relative,
1520 fixups[i].reloc);
1521 /* Turn off overflow checking in fixup_segment. This is necessary
1522 because fixup_segment will signal an overflow for large 4 byte
1523 quantities for GOT12 relocations. */
1524 if ( fixups[i].reloc == BFD_RELOC_390_GOT12
1525 || fixups[i].reloc == BFD_RELOC_390_GOT20
1526 || fixups[i].reloc == BFD_RELOC_390_GOT16)
1527 fixP->fx_no_overflow = 1;
1528 }
1529 else
1530 fix_new_exp (frag_now, f - frag_now->fr_literal, 4, &fixups[i].exp,
1531 (operand->flags & S390_OPERAND_PCREL) != 0,
1532 ((bfd_reloc_code_real_type)
1533 (fixups[i].opindex + (int) BFD_RELOC_UNUSED)));
1534 }
1535 return str;
1536 }
1537
1538 /* This routine is called for each instruction to be assembled. */
1539
1540 void
md_assemble(str)1541 md_assemble (str)
1542 char *str;
1543 {
1544 const struct s390_opcode *opcode;
1545 unsigned char insn[6];
1546 char *s;
1547
1548 /* Get the opcode. */
1549 for (s = str; *s != '\0' && ! ISSPACE (*s); s++)
1550 ;
1551 if (*s != '\0')
1552 *s++ = '\0';
1553
1554 /* Look up the opcode in the hash table. */
1555 opcode = (struct s390_opcode *) hash_find (s390_opcode_hash, str);
1556 if (opcode == (const struct s390_opcode *) NULL)
1557 {
1558 as_bad (_("Unrecognized opcode: `%s'"), str);
1559 return;
1560 }
1561 else if (!(opcode->modes & current_mode_mask))
1562 {
1563 as_bad ("Opcode %s not available in this mode", str);
1564 return;
1565 }
1566 memcpy (insn, opcode->opcode, sizeof (insn));
1567 md_gather_operands (s, insn, opcode);
1568 }
1569
1570 #ifndef WORKING_DOT_WORD
1571 /* Handle long and short jumps. We don't support these */
1572 void
md_create_short_jump(ptr,from_addr,to_addr,frag,to_symbol)1573 md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
1574 char *ptr;
1575 addressT from_addr, to_addr;
1576 fragS *frag;
1577 symbolS *to_symbol;
1578 {
1579 abort ();
1580 }
1581
1582 void
md_create_long_jump(ptr,from_addr,to_addr,frag,to_symbol)1583 md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
1584 char *ptr;
1585 addressT from_addr, to_addr;
1586 fragS *frag;
1587 symbolS *to_symbol;
1588 {
1589 abort ();
1590 }
1591 #endif
1592
1593 void
s390_bss(ignore)1594 s390_bss (ignore)
1595 int ignore ATTRIBUTE_UNUSED;
1596 {
1597 /* We don't support putting frags in the BSS segment, we fake it
1598 by marking in_bss, then looking at s_skip for clues. */
1599
1600 subseg_set (bss_section, 0);
1601 demand_empty_rest_of_line ();
1602 }
1603
1604 /* Pseudo-op handling. */
1605
1606 void
s390_insn(ignore)1607 s390_insn (ignore)
1608 int ignore ATTRIBUTE_UNUSED;
1609 {
1610 expressionS exp;
1611 const struct s390_opcode *opformat;
1612 unsigned char insn[6];
1613 char *s;
1614
1615 /* Get the opcode format. */
1616 s = input_line_pointer;
1617 while (*s != '\0' && *s != ',' && ! ISSPACE (*s))
1618 s++;
1619 if (*s != ',')
1620 as_bad (_("Invalid .insn format\n"));
1621 *s++ = '\0';
1622
1623 /* Look up the opcode in the hash table. */
1624 opformat = (struct s390_opcode *)
1625 hash_find (s390_opformat_hash, input_line_pointer);
1626 if (opformat == (const struct s390_opcode *) NULL)
1627 {
1628 as_bad (_("Unrecognized opcode format: `%s'"), input_line_pointer);
1629 return;
1630 }
1631 input_line_pointer = s;
1632 expression (&exp);
1633 if (exp.X_op == O_constant)
1634 {
1635 if ( ( opformat->oplen == 6
1636 && (addressT) exp.X_add_number < (1ULL << 48))
1637 || ( opformat->oplen == 4
1638 && (addressT) exp.X_add_number < (1ULL << 32))
1639 || ( opformat->oplen == 2
1640 && (addressT) exp.X_add_number < (1ULL << 16)))
1641 md_number_to_chars ((char *) insn, exp.X_add_number, opformat->oplen);
1642 else
1643 as_bad (_("Invalid .insn format\n"));
1644 }
1645 else if (exp.X_op == O_big)
1646 {
1647 if (exp.X_add_number > 0
1648 && opformat->oplen == 6
1649 && generic_bignum[3] == 0)
1650 {
1651 md_number_to_chars ((char *) insn, generic_bignum[2], 2);
1652 md_number_to_chars ((char *) &insn[2], generic_bignum[1], 2);
1653 md_number_to_chars ((char *) &insn[4], generic_bignum[0], 2);
1654 }
1655 else
1656 as_bad (_("Invalid .insn format\n"));
1657 }
1658 else
1659 as_bad (_("second operand of .insn not a constant\n"));
1660
1661 if (strcmp (opformat->name, "e") != 0 && *input_line_pointer++ != ',')
1662 as_bad (_("missing comma after insn constant\n"));
1663
1664 if ((s = strchr (input_line_pointer, '\n')) != NULL)
1665 *s = '\0';
1666 input_line_pointer = md_gather_operands (input_line_pointer, insn,
1667 opformat);
1668 if (s != NULL)
1669 *s = '\n';
1670 demand_empty_rest_of_line ();
1671 }
1672
1673 /* The .byte pseudo-op. This is similar to the normal .byte
1674 pseudo-op, but it can also take a single ASCII string. */
1675
1676 static void
s390_byte(ignore)1677 s390_byte (ignore)
1678 int ignore ATTRIBUTE_UNUSED;
1679 {
1680 if (*input_line_pointer != '\"')
1681 {
1682 cons (1);
1683 return;
1684 }
1685
1686 /* Gather characters. A real double quote is doubled. Unusual
1687 characters are not permitted. */
1688 ++input_line_pointer;
1689 while (1)
1690 {
1691 char c;
1692
1693 c = *input_line_pointer++;
1694
1695 if (c == '\"')
1696 {
1697 if (*input_line_pointer != '\"')
1698 break;
1699 ++input_line_pointer;
1700 }
1701
1702 FRAG_APPEND_1_CHAR (c);
1703 }
1704
1705 demand_empty_rest_of_line ();
1706 }
1707
1708 /* The .ltorg pseudo-op.This emits all literals defined since the last
1709 .ltorg or the invocation of gas. Literals are defined with the
1710 @lit suffix. */
1711
1712 static void
s390_literals(ignore)1713 s390_literals (ignore)
1714 int ignore ATTRIBUTE_UNUSED;
1715 {
1716 struct s390_lpe *lpe;
1717
1718 if (lp_sym == NULL || lpe_count == 0)
1719 return; /* Nothing to be done. */
1720
1721 /* Emit symbol for start of literal pool. */
1722 S_SET_SEGMENT (lp_sym, now_seg);
1723 S_SET_VALUE (lp_sym, (valueT) frag_now_fix ());
1724 lp_sym->sy_frag = frag_now;
1725
1726 while (lpe_list)
1727 {
1728 lpe = lpe_list;
1729 lpe_list = lpe_list->next;
1730 S_SET_SEGMENT (lpe->sym, now_seg);
1731 S_SET_VALUE (lpe->sym, (valueT) frag_now_fix ());
1732 lpe->sym->sy_frag = frag_now;
1733
1734 /* Emit literal pool entry. */
1735 if (lpe->reloc != BFD_RELOC_UNUSED)
1736 {
1737 reloc_howto_type *reloc_howto =
1738 bfd_reloc_type_lookup (stdoutput, lpe->reloc);
1739 int size = bfd_get_reloc_size (reloc_howto);
1740 char *where;
1741
1742 if (size > lpe->nbytes)
1743 as_bad (_("%s relocations do not fit in %d bytes"),
1744 reloc_howto->name, lpe->nbytes);
1745 where = frag_more (lpe->nbytes);
1746 md_number_to_chars (where, 0, size);
1747 fix_new_exp (frag_now, where - frag_now->fr_literal,
1748 size, &lpe->ex, reloc_howto->pc_relative, lpe->reloc);
1749 }
1750 else
1751 {
1752 if (lpe->ex.X_op == O_big)
1753 {
1754 if (lpe->ex.X_add_number <= 0)
1755 generic_floating_point_number = lpe->floatnum;
1756 else
1757 memcpy (generic_bignum, lpe->bignum,
1758 lpe->ex.X_add_number * sizeof (LITTLENUM_TYPE));
1759 }
1760 emit_expr (&lpe->ex, lpe->nbytes);
1761 }
1762
1763 lpe->next = lpe_free_list;
1764 lpe_free_list = lpe;
1765 }
1766 lpe_list_tail = NULL;
1767 lp_sym = NULL;
1768 lp_count++;
1769 lpe_count = 0;
1770 }
1771
1772 /* Turn a string in input_line_pointer into a floating point constant
1773 of type type, and store the appropriate bytes in *litp. The number
1774 of LITTLENUMS emitted is stored in *sizep . An error message is
1775 returned, or NULL on OK. */
1776
1777 char *
md_atof(type,litp,sizep)1778 md_atof (type, litp, sizep)
1779 int type;
1780 char *litp;
1781 int *sizep;
1782 {
1783 int prec;
1784 LITTLENUM_TYPE words[4];
1785 char *t;
1786 int i;
1787
1788 switch (type)
1789 {
1790 case 'f':
1791 prec = 2;
1792 break;
1793
1794 case 'd':
1795 prec = 4;
1796 break;
1797
1798 default:
1799 *sizep = 0;
1800 return "bad call to md_atof";
1801 }
1802
1803 t = atof_ieee (input_line_pointer, type, words);
1804 if (t)
1805 input_line_pointer = t;
1806
1807 *sizep = prec * 2;
1808
1809 for (i = 0; i < prec; i++)
1810 {
1811 md_number_to_chars (litp, (valueT) words[i], 2);
1812 litp += 2;
1813 }
1814
1815 return NULL;
1816 }
1817
1818 /* Align a section (I don't know why this is machine dependent). */
1819
1820 valueT
md_section_align(seg,addr)1821 md_section_align (seg, addr)
1822 asection *seg;
1823 valueT addr;
1824 {
1825 int align = bfd_get_section_alignment (stdoutput, seg);
1826
1827 return ((addr + (1 << align) - 1) & (-1 << align));
1828 }
1829
1830 /* We don't have any form of relaxing. */
1831
1832 int
md_estimate_size_before_relax(fragp,seg)1833 md_estimate_size_before_relax (fragp, seg)
1834 fragS *fragp ATTRIBUTE_UNUSED;
1835 asection *seg ATTRIBUTE_UNUSED;
1836 {
1837 abort ();
1838 return 0;
1839 }
1840
1841 /* Convert a machine dependent frag. We never generate these. */
1842
1843 void
md_convert_frag(abfd,sec,fragp)1844 md_convert_frag (abfd, sec, fragp)
1845 bfd *abfd ATTRIBUTE_UNUSED;
1846 asection *sec ATTRIBUTE_UNUSED;
1847 fragS *fragp ATTRIBUTE_UNUSED;
1848 {
1849 abort ();
1850 }
1851
1852 symbolS *
md_undefined_symbol(name)1853 md_undefined_symbol (name)
1854 char *name;
1855 {
1856 if (*name == '_' && *(name + 1) == 'G'
1857 && strcmp (name, "_GLOBAL_OFFSET_TABLE_") == 0)
1858 {
1859 if (!GOT_symbol)
1860 {
1861 if (symbol_find (name))
1862 as_bad (_("GOT already in symbol table"));
1863 GOT_symbol = symbol_new (name, undefined_section,
1864 (valueT) 0, &zero_address_frag);
1865 }
1866 return GOT_symbol;
1867 }
1868 return 0;
1869 }
1870
1871 /* Functions concerning relocs. */
1872
1873 /* The location from which a PC relative jump should be calculated,
1874 given a PC relative reloc. */
1875
1876 long
md_pcrel_from_section(fixp,sec)1877 md_pcrel_from_section (fixp, sec)
1878 fixS *fixp;
1879 segT sec ATTRIBUTE_UNUSED;
1880 {
1881 return fixp->fx_frag->fr_address + fixp->fx_where;
1882 }
1883
1884 /* Here we decide which fixups can be adjusted to make them relative to
1885 the beginning of the section instead of the symbol. Basically we need
1886 to make sure that the dynamic relocations are done correctly, so in
1887 some cases we force the original symbol to be used. */
1888 int
tc_s390_fix_adjustable(fixP)1889 tc_s390_fix_adjustable (fixP)
1890 fixS *fixP;
1891 {
1892 /* Don't adjust references to merge sections. */
1893 if ((S_GET_SEGMENT (fixP->fx_addsy)->flags & SEC_MERGE) != 0)
1894 return 0;
1895 /* adjust_reloc_syms doesn't know about the GOT. */
1896 if ( fixP->fx_r_type == BFD_RELOC_16_GOTOFF
1897 || fixP->fx_r_type == BFD_RELOC_32_GOTOFF
1898 || fixP->fx_r_type == BFD_RELOC_390_GOTOFF64
1899 || fixP->fx_r_type == BFD_RELOC_390_PLTOFF16
1900 || fixP->fx_r_type == BFD_RELOC_390_PLTOFF32
1901 || fixP->fx_r_type == BFD_RELOC_390_PLTOFF64
1902 || fixP->fx_r_type == BFD_RELOC_390_PLT16DBL
1903 || fixP->fx_r_type == BFD_RELOC_390_PLT32
1904 || fixP->fx_r_type == BFD_RELOC_390_PLT32DBL
1905 || fixP->fx_r_type == BFD_RELOC_390_PLT64
1906 || fixP->fx_r_type == BFD_RELOC_390_GOT12
1907 || fixP->fx_r_type == BFD_RELOC_390_GOT20
1908 || fixP->fx_r_type == BFD_RELOC_390_GOT16
1909 || fixP->fx_r_type == BFD_RELOC_32_GOT_PCREL
1910 || fixP->fx_r_type == BFD_RELOC_390_GOT64
1911 || fixP->fx_r_type == BFD_RELOC_390_GOTENT
1912 || fixP->fx_r_type == BFD_RELOC_390_GOTPLT12
1913 || fixP->fx_r_type == BFD_RELOC_390_GOTPLT16
1914 || fixP->fx_r_type == BFD_RELOC_390_GOTPLT20
1915 || fixP->fx_r_type == BFD_RELOC_390_GOTPLT32
1916 || fixP->fx_r_type == BFD_RELOC_390_GOTPLT64
1917 || fixP->fx_r_type == BFD_RELOC_390_GOTPLTENT
1918 || fixP->fx_r_type == BFD_RELOC_390_TLS_LOAD
1919 || fixP->fx_r_type == BFD_RELOC_390_TLS_GDCALL
1920 || fixP->fx_r_type == BFD_RELOC_390_TLS_LDCALL
1921 || fixP->fx_r_type == BFD_RELOC_390_TLS_GD32
1922 || fixP->fx_r_type == BFD_RELOC_390_TLS_GD64
1923 || fixP->fx_r_type == BFD_RELOC_390_TLS_GOTIE12
1924 || fixP->fx_r_type == BFD_RELOC_390_TLS_GOTIE20
1925 || fixP->fx_r_type == BFD_RELOC_390_TLS_GOTIE32
1926 || fixP->fx_r_type == BFD_RELOC_390_TLS_GOTIE64
1927 || fixP->fx_r_type == BFD_RELOC_390_TLS_LDM32
1928 || fixP->fx_r_type == BFD_RELOC_390_TLS_LDM64
1929 || fixP->fx_r_type == BFD_RELOC_390_TLS_IE32
1930 || fixP->fx_r_type == BFD_RELOC_390_TLS_IE64
1931 || fixP->fx_r_type == BFD_RELOC_390_TLS_IEENT
1932 || fixP->fx_r_type == BFD_RELOC_390_TLS_LE32
1933 || fixP->fx_r_type == BFD_RELOC_390_TLS_LE64
1934 || fixP->fx_r_type == BFD_RELOC_390_TLS_LDO32
1935 || fixP->fx_r_type == BFD_RELOC_390_TLS_LDO64
1936 || fixP->fx_r_type == BFD_RELOC_390_TLS_DTPMOD
1937 || fixP->fx_r_type == BFD_RELOC_390_TLS_DTPOFF
1938 || fixP->fx_r_type == BFD_RELOC_390_TLS_TPOFF
1939 || fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
1940 || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
1941 return 0;
1942 return 1;
1943 }
1944
1945 /* Return true if we must always emit a reloc for a type and false if
1946 there is some hope of resolving it at assembly time. */
1947 int
tc_s390_force_relocation(fixp)1948 tc_s390_force_relocation (fixp)
1949 struct fix *fixp;
1950 {
1951 /* Ensure we emit a relocation for every reference to the global
1952 offset table or to the procedure link table. */
1953 switch (fixp->fx_r_type)
1954 {
1955 case BFD_RELOC_390_GOT12:
1956 case BFD_RELOC_390_GOT20:
1957 case BFD_RELOC_32_GOT_PCREL:
1958 case BFD_RELOC_32_GOTOFF:
1959 case BFD_RELOC_390_GOTOFF64:
1960 case BFD_RELOC_390_PLTOFF16:
1961 case BFD_RELOC_390_PLTOFF32:
1962 case BFD_RELOC_390_PLTOFF64:
1963 case BFD_RELOC_390_GOTPC:
1964 case BFD_RELOC_390_GOT16:
1965 case BFD_RELOC_390_GOTPCDBL:
1966 case BFD_RELOC_390_GOT64:
1967 case BFD_RELOC_390_GOTENT:
1968 case BFD_RELOC_390_PLT32:
1969 case BFD_RELOC_390_PLT16DBL:
1970 case BFD_RELOC_390_PLT32DBL:
1971 case BFD_RELOC_390_PLT64:
1972 case BFD_RELOC_390_GOTPLT12:
1973 case BFD_RELOC_390_GOTPLT16:
1974 case BFD_RELOC_390_GOTPLT20:
1975 case BFD_RELOC_390_GOTPLT32:
1976 case BFD_RELOC_390_GOTPLT64:
1977 case BFD_RELOC_390_GOTPLTENT:
1978 return 1;
1979 default:
1980 break;;
1981 }
1982
1983 return generic_force_reloc (fixp);
1984 }
1985
1986 /* Apply a fixup to the object code. This is called for all the
1987 fixups we generated by the call to fix_new_exp, above. In the call
1988 above we used a reloc code which was the largest legal reloc code
1989 plus the operand index. Here we undo that to recover the operand
1990 index. At this point all symbol values should be fully resolved,
1991 and we attempt to completely resolve the reloc. If we can not do
1992 that, we determine the correct reloc code and put it back in the
1993 fixup. */
1994
1995 void
md_apply_fix(fixP,valP,seg)1996 md_apply_fix (fixP, valP, seg)
1997 fixS *fixP;
1998 valueT *valP;
1999 segT seg ATTRIBUTE_UNUSED;
2000 {
2001 char *where;
2002 valueT value = *valP;
2003
2004 where = fixP->fx_frag->fr_literal + fixP->fx_where;
2005
2006 if (fixP->fx_subsy != NULL)
2007 as_bad_where (fixP->fx_file, fixP->fx_line,
2008 "cannot emit relocation %s against subsy symbol %s",
2009 bfd_get_reloc_code_name (fixP->fx_r_type),
2010 S_GET_NAME (fixP->fx_subsy));
2011
2012 if (fixP->fx_addsy != NULL)
2013 {
2014 if (fixP->fx_pcrel)
2015 value += fixP->fx_frag->fr_address + fixP->fx_where;
2016 }
2017 else
2018 fixP->fx_done = 1;
2019
2020 if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED)
2021 {
2022 const struct s390_operand *operand;
2023 int opindex;
2024
2025 opindex = (int) fixP->fx_r_type - (int) BFD_RELOC_UNUSED;
2026 operand = &s390_operands[opindex];
2027
2028 if (fixP->fx_done)
2029 {
2030 /* Insert the fully resolved operand value. */
2031 s390_insert_operand ((unsigned char *) where, operand,
2032 (offsetT) value, fixP->fx_file, fixP->fx_line);
2033 return;
2034 }
2035
2036 /* Determine a BFD reloc value based on the operand information.
2037 We are only prepared to turn a few of the operands into
2038 relocs. */
2039 fixP->fx_offset = value;
2040 if (operand->bits == 12 && operand->shift == 20)
2041 {
2042 fixP->fx_size = 2;
2043 fixP->fx_where += 2;
2044 fixP->fx_r_type = BFD_RELOC_390_12;
2045 }
2046 else if (operand->bits == 12 && operand->shift == 36)
2047 {
2048 fixP->fx_size = 2;
2049 fixP->fx_where += 4;
2050 fixP->fx_r_type = BFD_RELOC_390_12;
2051 }
2052 else if (operand->bits == 20 && operand->shift == 20)
2053 {
2054 fixP->fx_size = 2;
2055 fixP->fx_where += 2;
2056 fixP->fx_r_type = BFD_RELOC_390_20;
2057 }
2058 else if (operand->bits == 8 && operand->shift == 8)
2059 {
2060 fixP->fx_size = 1;
2061 fixP->fx_where += 1;
2062 fixP->fx_r_type = BFD_RELOC_8;
2063 }
2064 else if (operand->bits == 16 && operand->shift == 16)
2065 {
2066 fixP->fx_size = 2;
2067 fixP->fx_where += 2;
2068 if (operand->flags & S390_OPERAND_PCREL)
2069 {
2070 fixP->fx_r_type = BFD_RELOC_390_PC16DBL;
2071 fixP->fx_offset += 2;
2072 }
2073 else
2074 fixP->fx_r_type = BFD_RELOC_16;
2075 }
2076 else if (operand->bits == 32 && operand->shift == 16
2077 && (operand->flags & S390_OPERAND_PCREL))
2078 {
2079 fixP->fx_size = 4;
2080 fixP->fx_where += 2;
2081 fixP->fx_offset += 2;
2082 fixP->fx_r_type = BFD_RELOC_390_PC32DBL;
2083 }
2084 else
2085 {
2086 char *sfile;
2087 unsigned int sline;
2088
2089 /* Use expr_symbol_where to see if this is an expression
2090 symbol. */
2091 if (expr_symbol_where (fixP->fx_addsy, &sfile, &sline))
2092 as_bad_where (fixP->fx_file, fixP->fx_line,
2093 _("unresolved expression that must be resolved"));
2094 else
2095 as_bad_where (fixP->fx_file, fixP->fx_line,
2096 _("unsupported relocation type"));
2097 fixP->fx_done = 1;
2098 return;
2099 }
2100 }
2101 else
2102 {
2103 switch (fixP->fx_r_type)
2104 {
2105 case BFD_RELOC_8:
2106 if (fixP->fx_pcrel)
2107 abort ();
2108 if (fixP->fx_done)
2109 md_number_to_chars (where, value, 1);
2110 break;
2111 case BFD_RELOC_390_12:
2112 case BFD_RELOC_390_GOT12:
2113 case BFD_RELOC_390_GOTPLT12:
2114 if (fixP->fx_done)
2115 {
2116 unsigned short mop;
2117
2118 mop = bfd_getb16 ((unsigned char *) where);
2119 mop |= (unsigned short) (value & 0xfff);
2120 bfd_putb16 ((bfd_vma) mop, (unsigned char *) where);
2121 }
2122 break;
2123
2124 case BFD_RELOC_390_20:
2125 case BFD_RELOC_390_GOT20:
2126 case BFD_RELOC_390_GOTPLT20:
2127 if (fixP->fx_done)
2128 {
2129 unsigned int mop;
2130 mop = bfd_getb32 ((unsigned char *) where);
2131 mop |= (unsigned int) ((value & 0xfff) << 8 |
2132 (value & 0xff000) >> 12);
2133 bfd_putb32 ((bfd_vma) mop, (unsigned char *) where);
2134 }
2135 break;
2136
2137 case BFD_RELOC_16:
2138 case BFD_RELOC_GPREL16:
2139 case BFD_RELOC_16_GOT_PCREL:
2140 case BFD_RELOC_16_GOTOFF:
2141 if (fixP->fx_pcrel)
2142 as_bad_where (fixP->fx_file, fixP->fx_line,
2143 "cannot emit PC relative %s relocation%s%s",
2144 bfd_get_reloc_code_name (fixP->fx_r_type),
2145 fixP->fx_addsy != NULL ? " against " : "",
2146 (fixP->fx_addsy != NULL
2147 ? S_GET_NAME (fixP->fx_addsy)
2148 : ""));
2149 if (fixP->fx_done)
2150 md_number_to_chars (where, value, 2);
2151 break;
2152 case BFD_RELOC_390_GOT16:
2153 case BFD_RELOC_390_PLTOFF16:
2154 case BFD_RELOC_390_GOTPLT16:
2155 if (fixP->fx_done)
2156 md_number_to_chars (where, value, 2);
2157 break;
2158 case BFD_RELOC_390_PC16DBL:
2159 case BFD_RELOC_390_PLT16DBL:
2160 value += 2;
2161 if (fixP->fx_done)
2162 md_number_to_chars (where, (offsetT) value >> 1, 2);
2163 break;
2164
2165 case BFD_RELOC_32:
2166 if (fixP->fx_pcrel)
2167 fixP->fx_r_type = BFD_RELOC_32_PCREL;
2168 else
2169 fixP->fx_r_type = BFD_RELOC_32;
2170 if (fixP->fx_done)
2171 md_number_to_chars (where, value, 4);
2172 break;
2173 case BFD_RELOC_32_PCREL:
2174 case BFD_RELOC_32_BASEREL:
2175 fixP->fx_r_type = BFD_RELOC_32_PCREL;
2176 if (fixP->fx_done)
2177 md_number_to_chars (where, value, 4);
2178 break;
2179 case BFD_RELOC_32_GOT_PCREL:
2180 case BFD_RELOC_390_PLTOFF32:
2181 case BFD_RELOC_390_PLT32:
2182 case BFD_RELOC_390_GOTPLT32:
2183 if (fixP->fx_done)
2184 md_number_to_chars (where, value, 4);
2185 break;
2186 case BFD_RELOC_390_PC32DBL:
2187 case BFD_RELOC_390_PLT32DBL:
2188 case BFD_RELOC_390_GOTPCDBL:
2189 case BFD_RELOC_390_GOTENT:
2190 case BFD_RELOC_390_GOTPLTENT:
2191 value += 2;
2192 if (fixP->fx_done)
2193 md_number_to_chars (where, (offsetT) value >> 1, 4);
2194 break;
2195
2196 case BFD_RELOC_32_GOTOFF:
2197 if (fixP->fx_done)
2198 md_number_to_chars (where, value, sizeof (int));
2199 break;
2200
2201 case BFD_RELOC_390_GOTOFF64:
2202 if (fixP->fx_done)
2203 md_number_to_chars (where, value, 8);
2204 break;
2205
2206 case BFD_RELOC_390_GOT64:
2207 case BFD_RELOC_390_PLTOFF64:
2208 case BFD_RELOC_390_PLT64:
2209 case BFD_RELOC_390_GOTPLT64:
2210 if (fixP->fx_done)
2211 md_number_to_chars (where, value, 8);
2212 break;
2213
2214 case BFD_RELOC_64:
2215 if (fixP->fx_pcrel)
2216 fixP->fx_r_type = BFD_RELOC_64_PCREL;
2217 else
2218 fixP->fx_r_type = BFD_RELOC_64;
2219 if (fixP->fx_done)
2220 md_number_to_chars (where, value, 8);
2221 break;
2222
2223 case BFD_RELOC_64_PCREL:
2224 fixP->fx_r_type = BFD_RELOC_64_PCREL;
2225 if (fixP->fx_done)
2226 md_number_to_chars (where, value, 8);
2227 break;
2228
2229 case BFD_RELOC_VTABLE_INHERIT:
2230 case BFD_RELOC_VTABLE_ENTRY:
2231 fixP->fx_done = 0;
2232 return;
2233
2234 case BFD_RELOC_390_TLS_LOAD:
2235 case BFD_RELOC_390_TLS_GDCALL:
2236 case BFD_RELOC_390_TLS_LDCALL:
2237 case BFD_RELOC_390_TLS_GD32:
2238 case BFD_RELOC_390_TLS_GD64:
2239 case BFD_RELOC_390_TLS_GOTIE12:
2240 case BFD_RELOC_390_TLS_GOTIE20:
2241 case BFD_RELOC_390_TLS_GOTIE32:
2242 case BFD_RELOC_390_TLS_GOTIE64:
2243 case BFD_RELOC_390_TLS_LDM32:
2244 case BFD_RELOC_390_TLS_LDM64:
2245 case BFD_RELOC_390_TLS_IE32:
2246 case BFD_RELOC_390_TLS_IE64:
2247 case BFD_RELOC_390_TLS_LE32:
2248 case BFD_RELOC_390_TLS_LE64:
2249 case BFD_RELOC_390_TLS_LDO32:
2250 case BFD_RELOC_390_TLS_LDO64:
2251 case BFD_RELOC_390_TLS_DTPMOD:
2252 case BFD_RELOC_390_TLS_DTPOFF:
2253 case BFD_RELOC_390_TLS_TPOFF:
2254 S_SET_THREAD_LOCAL (fixP->fx_addsy);
2255 /* Fully resolved at link time. */
2256 break;
2257 case BFD_RELOC_390_TLS_IEENT:
2258 /* Fully resolved at link time. */
2259 S_SET_THREAD_LOCAL (fixP->fx_addsy);
2260 value += 2;
2261 break;
2262
2263 default:
2264 {
2265 const char *reloc_name = bfd_get_reloc_code_name (fixP->fx_r_type);
2266
2267 if (reloc_name != NULL)
2268 fprintf (stderr, "Gas failure, reloc type %s\n", reloc_name);
2269 else
2270 fprintf (stderr, "Gas failure, reloc type #%i\n", fixP->fx_r_type);
2271 fflush (stderr);
2272 abort ();
2273 }
2274 }
2275
2276 fixP->fx_offset = value;
2277 }
2278 }
2279
2280 /* Generate a reloc for a fixup. */
2281
2282 arelent *
tc_gen_reloc(seg,fixp)2283 tc_gen_reloc (seg, fixp)
2284 asection *seg ATTRIBUTE_UNUSED;
2285 fixS *fixp;
2286 {
2287 bfd_reloc_code_real_type code;
2288 arelent *reloc;
2289
2290 code = fixp->fx_r_type;
2291 if (GOT_symbol && fixp->fx_addsy == GOT_symbol)
2292 {
2293 if ( (s390_arch_size == 32 && code == BFD_RELOC_32_PCREL)
2294 || (s390_arch_size == 64 && code == BFD_RELOC_64_PCREL))
2295 code = BFD_RELOC_390_GOTPC;
2296 if (code == BFD_RELOC_390_PC32DBL)
2297 code = BFD_RELOC_390_GOTPCDBL;
2298 }
2299
2300 reloc = (arelent *) xmalloc (sizeof (arelent));
2301 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
2302 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
2303 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
2304 reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
2305 if (reloc->howto == NULL)
2306 {
2307 as_bad_where (fixp->fx_file, fixp->fx_line,
2308 _("cannot represent relocation type %s"),
2309 bfd_get_reloc_code_name (code));
2310 /* Set howto to a garbage value so that we can keep going. */
2311 reloc->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_32);
2312 assert (reloc->howto != NULL);
2313 }
2314 reloc->addend = fixp->fx_offset;
2315
2316 return reloc;
2317 }
2318
2319 void
s390_cfi_frame_initial_instructions()2320 s390_cfi_frame_initial_instructions ()
2321 {
2322 cfi_add_CFA_def_cfa (15, s390_arch_size == 64 ? 160 : 96);
2323 }
2324
2325 int
tc_s390_regname_to_dw2regnum(char * regname)2326 tc_s390_regname_to_dw2regnum (char *regname)
2327 {
2328 int regnum = -1;
2329
2330 if (regname[0] != 'c' && regname[0] != 'a')
2331 {
2332 regnum = reg_name_search (pre_defined_registers, REG_NAME_CNT, regname);
2333 if (regname[0] == 'f' && regnum != -1)
2334 regnum += 16;
2335 }
2336 else if (strcmp (regname, "ap") == 0)
2337 regnum = 32;
2338 else if (strcmp (regname, "cc") == 0)
2339 regnum = 33;
2340 return regnum;
2341 }
2342