1 /* tc-ip2k.c -- Assembler for the Scenix IP2xxx. 2 Copyright (C) 2000-2014 Free Software Foundation, Inc. 3 4 This file is part of GAS, the GNU Assembler. 5 6 GAS is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3, or (at your option) 9 any later version. 10 11 GAS is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with GAS; see the file COPYING. If not, write to 18 the Free Software Foundation, 51 Franklin Street - Fifth Floor, 19 Boston, MA 02110-1301, USA. */ 20 21 #include "as.h" 22 #include "subsegs.h" 23 #include "symcat.h" 24 #include "opcodes/ip2k-desc.h" 25 #include "opcodes/ip2k-opc.h" 26 #include "cgen.h" 27 #include "elf/common.h" 28 #include "elf/ip2k.h" 29 #include "libbfd.h" 30 31 /* Structure to hold all of the different components describing 32 an individual instruction. */ 33 typedef struct 34 { 35 const CGEN_INSN * insn; 36 const CGEN_INSN * orig_insn; 37 CGEN_FIELDS fields; 38 #if CGEN_INT_INSN_P 39 CGEN_INSN_INT buffer [1]; 40 #define INSN_VALUE(buf) (*(buf)) 41 #else 42 unsigned char buffer [CGEN_MAX_INSN_SIZE]; 43 #define INSN_VALUE(buf) (buf) 44 #endif 45 char * addr; 46 fragS * frag; 47 int num_fixups; 48 fixS * fixups [GAS_CGEN_MAX_FIXUPS]; 49 int indices [MAX_OPERAND_INSTANCES]; 50 } 51 ip2k_insn; 52 53 const char comment_chars[] = ";"; 54 const char line_comment_chars[] = "#"; 55 const char line_separator_chars[] = ""; 56 const char EXP_CHARS[] = "eE"; 57 const char FLT_CHARS[] = "dD"; 58 59 /* Flag to detect when switching to code section where insn alignment is 60 implied. */ 61 static int force_code_align = 0; 62 63 /* Mach selected from command line. */ 64 static int ip2k_mach = 0; 65 static unsigned ip2k_mach_bitmask = 0; 66 67 68 static void 69 ip2k_elf_section_rtn (int i) 70 { 71 obj_elf_section(i); 72 73 if (force_code_align) 74 { 75 /* The s_align_ptwo function expects that we are just after a .align 76 directive and it will either try and read the align value or stop 77 if end of line so we must fake it out so it thinks we are at the 78 end of the line. */ 79 char *old_input_line_pointer = input_line_pointer; 80 input_line_pointer = "\n"; 81 s_align_ptwo (1); 82 force_code_align = 0; 83 /* Restore. */ 84 input_line_pointer = old_input_line_pointer; 85 } 86 } 87 88 static void 89 ip2k_elf_section_text (int i) 90 { 91 char *old_input_line_pointer; 92 obj_elf_text(i); 93 94 /* the s_align_ptwo function expects that we are just after a .align 95 directive and it will either try and read the align value or stop if 96 end of line so we must fake it out so it thinks we are at the end of 97 the line. */ 98 old_input_line_pointer = input_line_pointer; 99 input_line_pointer = "\n"; 100 s_align_ptwo (1); 101 force_code_align = 0; 102 /* Restore. */ 103 input_line_pointer = old_input_line_pointer; 104 } 105 106 /* The target specific pseudo-ops which we support. */ 107 const pseudo_typeS md_pseudo_table[] = 108 { 109 { "text", ip2k_elf_section_text, 0 }, 110 { "sect", ip2k_elf_section_rtn, 0 }, 111 { NULL, NULL, 0 } 112 }; 113 114 115 117 enum options 118 { 119 OPTION_CPU_IP2022 = OPTION_MD_BASE, 120 OPTION_CPU_IP2022EXT 121 }; 122 123 struct option md_longopts[] = 124 { 125 { "mip2022", no_argument, NULL, OPTION_CPU_IP2022 }, 126 { "mip2022ext", no_argument, NULL, OPTION_CPU_IP2022EXT }, 127 { NULL, no_argument, NULL, 0 }, 128 }; 129 size_t md_longopts_size = sizeof (md_longopts); 130 131 const char * md_shortopts = ""; 132 133 int 134 md_parse_option (int c ATTRIBUTE_UNUSED, char * arg ATTRIBUTE_UNUSED) 135 { 136 switch (c) 137 { 138 case OPTION_CPU_IP2022: 139 ip2k_mach = bfd_mach_ip2022; 140 ip2k_mach_bitmask = 1 << MACH_IP2022; 141 break; 142 143 case OPTION_CPU_IP2022EXT: 144 ip2k_mach = bfd_mach_ip2022ext; 145 ip2k_mach_bitmask = 1 << MACH_IP2022EXT; 146 break; 147 148 default: 149 return 0; 150 } 151 152 return 1; 153 } 154 155 void 156 md_show_usage (FILE * stream) 157 { 158 fprintf (stream, _("IP2K specific command line options:\n")); 159 fprintf (stream, _(" -mip2022 restrict to IP2022 insns \n")); 160 fprintf (stream, _(" -mip2022ext permit extended IP2022 insn\n")); 161 } 162 163 164 void 166 md_begin (void) 167 { 168 /* Initialize the `cgen' interface. */ 169 170 /* Set the machine number and endian. */ 171 gas_cgen_cpu_desc = ip2k_cgen_cpu_open (CGEN_CPU_OPEN_MACHS, 172 ip2k_mach_bitmask, 173 CGEN_CPU_OPEN_ENDIAN, 174 CGEN_ENDIAN_BIG, 175 CGEN_CPU_OPEN_END); 176 ip2k_cgen_init_asm (gas_cgen_cpu_desc); 177 178 /* This is a callback from cgen to gas to parse operands. */ 179 cgen_set_parse_operand_fn (gas_cgen_cpu_desc, gas_cgen_parse_operand); 180 181 /* Set the machine type. */ 182 bfd_default_set_arch_mach (stdoutput, bfd_arch_ip2k, ip2k_mach); 183 } 184 185 186 void 187 md_assemble (char * str) 188 { 189 ip2k_insn insn; 190 char * errmsg; 191 192 /* Initialize GAS's cgen interface for a new instruction. */ 193 gas_cgen_init_parse (); 194 195 insn.insn = ip2k_cgen_assemble_insn 196 (gas_cgen_cpu_desc, str, & insn.fields, insn.buffer, & errmsg); 197 198 if (!insn.insn) 199 { 200 as_bad ("%s", errmsg); 201 return; 202 } 203 204 /* Check for special relocation required by SKIP instructions. */ 205 if (CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_SKIPA)) 206 /* Unconditional skip has a 1-bit relocation of the current pc, so 207 that we emit either sb pcl.0 or snb pcl.0 depending on whether 208 the PCL (pc + 2) >> 1 is odd or even. */ 209 { 210 enum cgen_parse_operand_result result_type; 211 bfd_vma value; 212 const char *curpc_plus_2 = ".+2"; 213 const char *err; 214 215 err = cgen_parse_address (gas_cgen_cpu_desc, & curpc_plus_2, 216 IP2K_OPERAND_ADDR16CJP, 217 BFD_RELOC_IP2K_PC_SKIP, 218 & result_type, & value); 219 if (err) 220 { 221 as_bad ("%s", err); 222 return; 223 } 224 } 225 226 /* Doesn't really matter what we pass for RELAX_P here. */ 227 gas_cgen_finish_insn (insn.insn, insn.buffer, 228 CGEN_FIELDS_BITSIZE (& insn.fields), 1, NULL); 229 } 230 231 valueT 232 md_section_align (segT segment, valueT size) 233 { 234 int align = bfd_get_section_alignment (stdoutput, segment); 235 236 return ((size + (1 << align) - 1) & (-1 << align)); 237 } 238 239 240 symbolS * 241 md_undefined_symbol (char * name ATTRIBUTE_UNUSED) 242 { 243 return 0; 244 } 245 246 int 248 md_estimate_size_before_relax (fragS * fragP ATTRIBUTE_UNUSED, 249 segT segment ATTRIBUTE_UNUSED) 250 { 251 as_fatal (_("relaxation not supported\n")); 252 return 1; 253 } 254 255 256 /* *fragP has been relaxed to its final size, and now needs to have 257 the bytes inside it modified to conform to the new size. 258 259 Called after relaxation is finished. 260 fragP->fr_type == rs_machine_dependent. 261 fragP->fr_subtype is the subtype of what the address relaxed to. */ 262 263 void 264 md_convert_frag (bfd * abfd ATTRIBUTE_UNUSED, 265 segT sec ATTRIBUTE_UNUSED, 266 fragS * fragP ATTRIBUTE_UNUSED) 267 { 268 } 269 270 271 /* Functions concerning relocs. */ 273 274 long 275 md_pcrel_from (fixS *fixP ATTRIBUTE_UNUSED) 276 { 277 abort (); 278 } 279 280 281 /* Return the bfd reloc type for OPERAND of INSN at fixup FIXP. 282 Returns BFD_RELOC_NONE if no reloc type can be found. 283 *FIXP may be modified if desired. */ 284 285 bfd_reloc_code_real_type 286 md_cgen_lookup_reloc (const CGEN_INSN * insn ATTRIBUTE_UNUSED, 287 const CGEN_OPERAND * operand, 288 fixS * fixP ATTRIBUTE_UNUSED) 289 { 290 bfd_reloc_code_real_type result; 291 292 result = BFD_RELOC_NONE; 293 294 switch (operand->type) 295 { 296 case IP2K_OPERAND_FR: 297 case IP2K_OPERAND_ADDR16L: 298 case IP2K_OPERAND_ADDR16H: 299 case IP2K_OPERAND_LIT8: 300 /* These may have been processed at parse time. */ 301 if (fixP->fx_cgen.opinfo != 0) 302 result = fixP->fx_cgen.opinfo; 303 fixP->fx_no_overflow = 1; 304 break; 305 306 case IP2K_OPERAND_ADDR16CJP: 307 result = fixP->fx_cgen.opinfo; 308 if (result == 0 || result == BFD_RELOC_NONE) 309 result = BFD_RELOC_IP2K_ADDR16CJP; 310 fixP->fx_no_overflow = 1; 311 break; 312 313 case IP2K_OPERAND_ADDR16P: 314 result = BFD_RELOC_IP2K_PAGE3; 315 fixP->fx_no_overflow = 1; 316 break; 317 318 default: 319 result = BFD_RELOC_NONE; 320 break; 321 } 322 323 return result; 324 } 325 326 327 /* Write a value out to the object file, using the appropriate endianness. */ 328 329 void 330 md_number_to_chars (char * buf, valueT val, int n) 331 { 332 number_to_chars_bigendian (buf, val, n); 333 } 334 335 char * 336 md_atof (int type, char * litP, int * sizeP) 337 { 338 return ieee_md_atof (type, litP, sizeP, TRUE); 339 } 340 341 342 /* See whether we need to force a relocation into the output file. 343 Force most of them, since the linker's bfd relocation engine 344 understands range limits better than gas' cgen fixup engine. 345 Consider the case of a fixup intermediate value being larger than 346 the instruction it will be eventually encoded within. */ 347 348 int 349 ip2k_force_relocation (fixS * fix) 350 { 351 switch (fix->fx_r_type) 352 { 353 case BFD_RELOC_IP2K_FR9: 354 case BFD_RELOC_IP2K_FR_OFFSET: 355 case BFD_RELOC_IP2K_BANK: 356 case BFD_RELOC_IP2K_ADDR16CJP: 357 case BFD_RELOC_IP2K_PAGE3: 358 case BFD_RELOC_IP2K_LO8DATA: 359 case BFD_RELOC_IP2K_HI8DATA: 360 case BFD_RELOC_IP2K_EX8DATA: 361 case BFD_RELOC_IP2K_LO8INSN: 362 case BFD_RELOC_IP2K_HI8INSN: 363 case BFD_RELOC_IP2K_PC_SKIP: 364 case BFD_RELOC_IP2K_TEXT: 365 return 1; 366 367 case BFD_RELOC_16: 368 if (fix->fx_subsy && S_IS_DEFINED (fix->fx_subsy) 369 && fix->fx_addsy && S_IS_DEFINED (fix->fx_addsy) 370 && (S_GET_SEGMENT (fix->fx_addsy)->flags & SEC_CODE)) 371 { 372 fix->fx_r_type = BFD_RELOC_IP2K_TEXT; 373 return 0; 374 } 375 break; 376 377 default: 378 break; 379 } 380 381 return generic_force_reloc (fix); 382 } 383 384 void 385 ip2k_apply_fix (fixS *fixP, valueT *valueP, segT seg) 386 { 387 if (fixP->fx_r_type == BFD_RELOC_IP2K_TEXT 388 && ! fixP->fx_addsy 389 && ! fixP->fx_subsy) 390 { 391 *valueP = ((int)(* valueP)) / 2; 392 fixP->fx_r_type = BFD_RELOC_16; 393 } 394 else if (fixP->fx_r_type == BFD_RELOC_UNUSED + IP2K_OPERAND_FR) 395 { 396 /* Must be careful when we are fixing up an FR. We could be 397 fixing up an offset to (SP) or (DP) in which case we don't 398 want to step on the top 2 bits of the FR operand. The 399 gas_cgen_md_apply_fix doesn't know any better and overwrites 400 the entire operand. We counter this by adding the bits 401 to the new value. */ 402 char *where = fixP->fx_frag->fr_literal + fixP->fx_where; 403 404 /* Canonical name, since used a lot. */ 405 CGEN_CPU_DESC cd = gas_cgen_cpu_desc; 406 CGEN_INSN_INT insn_value 407 = cgen_get_insn_value (cd, (unsigned char *) where, 408 CGEN_INSN_BITSIZE (fixP->fx_cgen.insn)); 409 /* Preserve (DP) or (SP) specification. */ 410 *valueP += (insn_value & 0x180); 411 } 412 413 gas_cgen_md_apply_fix (fixP, valueP, seg); 414 } 415 416 int 417 ip2k_elf_section_flags (flagword flags, 418 bfd_vma attr ATTRIBUTE_UNUSED, 419 int type ATTRIBUTE_UNUSED) 420 { 421 /* This is used to detect when the section changes to an executable section. 422 This function is called by the elf section processing. When we note an 423 executable section specifier we set an internal flag to denote when 424 word alignment should be forced. */ 425 if (flags & SEC_CODE) 426 force_code_align = 1; 427 428 return flags; 429 } 430 431
