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