1 /* tc-tic54x.c -- Assembly code for the Texas Instruments TMS320C54X 2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 3 2009, 2010 Free Software Foundation, Inc. 4 Contributed by Timothy Wall (twall@cygnus.com) 5 6 This file is part of GAS, the GNU Assembler. 7 8 GAS is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3, or (at your option) 11 any later version. 12 13 GAS is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with GAS; see the file COPYING. If not, write to the Free 20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 21 02110-1301, USA. */ 22 23 /* Texas Instruments TMS320C54X machine specific gas. 24 Written by Timothy Wall (twall@alum.mit.edu). 25 26 Valuable things to do: 27 Pipeline conflict warnings 28 We encode/decode "ld #_label, dp" differently in relocatable files 29 This means we're not compatible with TI output containing those 30 expressions. We store the upper nine bits; TI stores the lower nine 31 bits. How they recover the original upper nine bits is beyond me. 32 33 Tests to add to expect testsuite: 34 '=' and '==' with .if, .elseif, and .break 35 36 Incompatibilities (mostly trivial): 37 We don't allow ''' 38 We fill text section with zeroes instead of "nop"s 39 We don't convert '' or "" to a single instance 40 We don't convert '' to '\0' 41 We don't allow strings with .byte/.half/.short/.long 42 Probably details of the subsym stuff are different 43 TI sets labels to be data type 4 (T_INT); GAS uses T_NULL. 44 45 COFF1 limits section names to 8 characters. 46 Some of the default behavior changed from COFF1 to COFF2. */ 47 48 #include <limits.h> 49 #include "as.h" 50 #include "safe-ctype.h" 51 #include "sb.h" 52 #include "macro.h" 53 #include "subsegs.h" 54 #include "struc-symbol.h" 55 #include "opcode/tic54x.h" 56 #include "obj-coff.h" 57 #include <math.h> 58 59 60 static struct stag 61 { 62 symbolS *sym; /* Symbol for this stag; value is offset. */ 63 const char *name; /* Shortcut to symbol name. */ 64 bfd_vma size; /* Size of struct/union. */ 65 int current_bitfield_offset; /* Temporary for tracking fields. */ 66 int is_union; 67 struct stag_field /* List of fields. */ 68 { 69 const char *name; 70 bfd_vma offset; /* Of start of this field. */ 71 int bitfield_offset; /* Of start of this field. */ 72 struct stag *stag; /* If field is struct/union. */ 73 struct stag_field *next; 74 } *field; 75 /* For nesting; used only in stag construction. */ 76 struct stag *inner; /* Enclosed .struct. */ 77 struct stag *outer; /* Enclosing .struct. */ 78 } *current_stag = NULL; 79 80 #define MAX_LINE 256 /* Lines longer than this are truncated by TI's asm. */ 81 82 typedef struct _tic54x_insn 83 { 84 const insn_template *tm; /* Opcode template. */ 85 86 char mnemonic[MAX_LINE]; /* Opcode name/mnemonic. */ 87 char parmnemonic[MAX_LINE]; /* 2nd mnemonic of parallel insn. */ 88 89 int opcount; 90 struct opstruct 91 { 92 char buf[MAX_LINE]; 93 enum optype type; 94 expressionS exp; 95 } operands[MAX_OPERANDS]; 96 97 int paropcount; 98 struct opstruct paroperands[MAX_OPERANDS]; 99 100 int is_lkaddr; 101 int lkoperand; 102 int words; /* Size of insn in 16-bit words. */ 103 int using_default_dst; /* Do we need to explicitly set an 104 omitted OP_DST operand? */ 105 struct 106 { 107 unsigned short word; /* Final encoded opcode data. */ 108 int unresolved; 109 int r_nchars; /* Relocation size. */ 110 bfd_reloc_code_real_type r_type; /* Relocation type. */ 111 expressionS addr_expr; /* Storage for unresolved expressions. */ 112 } opcode[3]; 113 } tic54x_insn; 114 115 enum cpu_version 116 { 117 VNONE = 0, V541 = 1, V542 = 2, V543 = 3, V545 = 5, V548 = 8, V549 = 9, 118 V545LP = 15, V546LP = 16 119 }; 120 121 enum address_mode 122 { 123 c_mode, /* 16-bit addresses. */ 124 far_mode /* >16-bit addresses. */ 125 }; 126 127 static segT stag_saved_seg; 128 static subsegT stag_saved_subseg; 129 130 const char comment_chars[] = ";"; 131 const char line_comment_chars[] = ";*#"; /* At column zero only. */ 132 const char line_separator_chars[] = ""; /* Not permitted. */ 133 134 int emitting_long = 0; 135 136 /* Characters which indicate that this is a floating point constant. */ 137 const char FLT_CHARS[] = "fF"; 138 139 /* Characters that can be used to separate mantissa from exp in FP 140 nums. */ 141 const char EXP_CHARS[] = "eE"; 142 143 const char *md_shortopts = ""; 144 145 #define OPTION_ADDRESS_MODE (OPTION_MD_BASE) 146 #define OPTION_CPU_VERSION (OPTION_ADDRESS_MODE + 1) 147 #define OPTION_COFF_VERSION (OPTION_CPU_VERSION + 1) 148 #define OPTION_STDERR_TO_FILE (OPTION_COFF_VERSION + 1) 149 150 struct option md_longopts[] = 151 { 152 { "mfar-mode", no_argument, NULL, OPTION_ADDRESS_MODE }, 153 { "mf", no_argument, NULL, OPTION_ADDRESS_MODE }, 154 { "mcpu", required_argument, NULL, OPTION_CPU_VERSION }, 155 { "merrors-to-file", required_argument, NULL, OPTION_STDERR_TO_FILE }, 156 { "me", required_argument, NULL, OPTION_STDERR_TO_FILE }, 157 { NULL, no_argument, NULL, 0}, 158 }; 159 160 size_t md_longopts_size = sizeof (md_longopts); 161 162 static int assembly_begun = 0; 163 /* Addressing mode is not entirely implemented; the latest rev of the Other 164 assembler doesn't seem to make any distinction whatsoever; all relocations 165 are stored as extended relocatiosn. Older versions used REL16 vs RELEXT16, 166 but now it seems all relocations are RELEXT16. We use all RELEXT16. 167 168 The cpu version is kind of a waste of time as well. There is one 169 instruction (RND) for LP devices only, and several for devices with 170 extended addressing only. We include it for compatibility. */ 171 static enum address_mode amode = c_mode; 172 static enum cpu_version cpu = VNONE; 173 174 /* Include string substitutions in listing? */ 175 static int listing_sslist = 0; 176 177 /* Did we do subsym substitutions on the line? */ 178 static int substitution_line = 0; 179 180 /* Last label seen. */ 181 static symbolS *last_label_seen = NULL; 182 183 /* This ensures that all new labels are unique. */ 184 static int local_label_id; 185 186 static struct hash_control *subsym_recurse_hash; /* Prevent infinite recurse. */ 187 static struct hash_control *math_hash; /* Built-in math functions. */ 188 /* Allow maximum levels of macro nesting; level 0 is the main substitution 189 symbol table. The other assembler only does 32 levels, so there! */ 190 static struct hash_control *subsym_hash[100]; 191 192 /* Keep track of local labels so we can substitute them before GAS sees them 193 since macros use their own 'namespace' for local labels, use a separate hash 194 195 We do our own local label handling 'cuz it's subtly different from the 196 stock GAS handling. 197 198 We use our own macro nesting counter, since GAS overloads it when expanding 199 other things (like conditionals and repeat loops). */ 200 static int macro_level = 0; 201 static struct hash_control *local_label_hash[100]; 202 /* Keep track of struct/union tags. */ 203 static struct hash_control *stag_hash; 204 static struct hash_control *op_hash; 205 static struct hash_control *parop_hash; 206 static struct hash_control *reg_hash; 207 static struct hash_control *mmreg_hash; 208 static struct hash_control *cc_hash; 209 static struct hash_control *cc2_hash; 210 static struct hash_control *cc3_hash; 211 static struct hash_control *sbit_hash; 212 static struct hash_control *misc_symbol_hash; 213 214 /* Only word (et al.), align, or conditionals are allowed within 215 .struct/.union. */ 216 #define ILLEGAL_WITHIN_STRUCT() \ 217 do \ 218 if (current_stag != NULL) \ 219 { \ 220 as_bad (_("pseudo-op illegal within .struct/.union")); \ 221 return; \ 222 } \ 223 while (0) 224 225 226 static void subsym_create_or_replace (char *, char *); 227 static char *subsym_lookup (char *, int); 228 static char *subsym_substitute (char *, int); 229 230 231 void 232 md_show_usage (FILE *stream) 233 { 234 fprintf (stream, _("C54x-specific command line options:\n")); 235 fprintf (stream, _("-mfar-mode | -mf Use extended addressing\n")); 236 fprintf (stream, _("-mcpu=<CPU version> Specify the CPU version\n")); 237 fprintf (stream, _("-merrors-to-file <filename>\n")); 238 fprintf (stream, _("-me <filename> Redirect errors to a file\n")); 239 } 240 241 /* Output a single character (upper octect is zero). */ 242 243 static void 244 tic54x_emit_char (char c) 245 { 246 expressionS expn; 247 248 expn.X_op = O_constant; 249 expn.X_add_number = c; 250 emit_expr (&expn, 2); 251 } 252 253 /* Walk backwards in the frag chain. */ 254 255 static fragS * 256 frag_prev (fragS *frag, segT seg) 257 { 258 segment_info_type *seginfo = seg_info (seg); 259 fragS *fragp; 260 261 for (fragp = seginfo->frchainP->frch_root; fragp; fragp = fragp->fr_next) 262 if (fragp->fr_next == frag) 263 return fragp; 264 265 return NULL; 266 } 267 268 static fragS * 269 bit_offset_frag (fragS *frag, segT seg) 270 { 271 while (frag != NULL) 272 { 273 if (frag->fr_fix == 0 274 && frag->fr_opcode == NULL 275 && frag->tc_frag_data == 0) 276 frag = frag_prev (frag, seg); 277 else 278 return frag; 279 } 280 return NULL; 281 } 282 283 /* Return the number of bits allocated in the most recent word, or zero if 284 none. .field/.space/.bes may leave words partially allocated. */ 285 286 static int 287 frag_bit_offset (fragS *frag, segT seg) 288 { 289 frag = bit_offset_frag (frag, seg); 290 291 if (frag) 292 return frag->fr_opcode != NULL ? -1 : frag->tc_frag_data; 293 294 return 0; 295 } 296 297 /* Read an expression from a C string; returns a pointer past the end of the 298 expression. */ 299 300 static char * 301 parse_expression (char *str, expressionS *expn) 302 { 303 char *s; 304 char *tmp; 305 306 tmp = input_line_pointer; /* Save line pointer. */ 307 input_line_pointer = str; 308 expression (expn); 309 s = input_line_pointer; 310 input_line_pointer = tmp; /* Restore line pointer. */ 311 return s; /* Return pointer to where parsing stopped. */ 312 } 313 314 /* .asg "character-string"|character-string, symbol 315 316 .eval is the only pseudo-op allowed to perform arithmetic on substitution 317 symbols. all other use of symbols defined with .asg are currently 318 unsupported. */ 319 320 static void 321 tic54x_asg (int x ATTRIBUTE_UNUSED) 322 { 323 int c; 324 char *name; 325 char *str; 326 char *tmp; 327 int quoted = *input_line_pointer == '"'; 328 329 ILLEGAL_WITHIN_STRUCT (); 330 331 if (quoted) 332 { 333 int len; 334 str = demand_copy_C_string (&len); 335 c = *input_line_pointer; 336 } 337 else 338 { 339 str = input_line_pointer; 340 while ((c = *input_line_pointer) != ',') 341 { 342 if (is_end_of_line[(int) *input_line_pointer]) 343 break; 344 ++input_line_pointer; 345 } 346 *input_line_pointer = 0; 347 } 348 if (c != ',') 349 { 350 as_bad (_("Comma and symbol expected for '.asg STRING, SYMBOL'")); 351 ignore_rest_of_line (); 352 return; 353 } 354 355 name = ++input_line_pointer; 356 c = get_symbol_end (); /* Get terminator. */ 357 if (!ISALPHA (*name)) 358 { 359 as_bad (_("symbols assigned with .asg must begin with a letter")); 360 ignore_rest_of_line (); 361 return; 362 } 363 364 tmp = xmalloc (strlen (str) + 1); 365 strcpy (tmp, str); 366 str = tmp; 367 tmp = xmalloc (strlen (name) + 1); 368 strcpy (tmp, name); 369 name = tmp; 370 subsym_create_or_replace (name, str); 371 *input_line_pointer = c; 372 demand_empty_rest_of_line (); 373 } 374 375 /* .eval expression, symbol 376 There's something screwy about this. The other assembler sometimes does and 377 sometimes doesn't substitute symbols defined with .eval. 378 We'll put the symbols into the subsym table as well as the normal symbol 379 table, since that's what works best. */ 380 381 static void 382 tic54x_eval (int x ATTRIBUTE_UNUSED) 383 { 384 char c; 385 int value; 386 char *name; 387 symbolS *symbolP; 388 char valuestr[32], *tmp; 389 int quoted; 390 391 ILLEGAL_WITHIN_STRUCT (); 392 393 SKIP_WHITESPACE (); 394 395 quoted = *input_line_pointer == '"'; 396 if (quoted) 397 ++input_line_pointer; 398 value = get_absolute_expression (); 399 if (quoted) 400 { 401 if (*input_line_pointer != '"') 402 { 403 as_bad (_("Unterminated string after absolute expression")); 404 ignore_rest_of_line (); 405 return; 406 } 407 ++input_line_pointer; 408 } 409 if (*input_line_pointer++ != ',') 410 { 411 as_bad (_("Comma and symbol expected for '.eval EXPR, SYMBOL'")); 412 ignore_rest_of_line (); 413 return; 414 } 415 name = input_line_pointer; 416 c = get_symbol_end (); /* Get terminator. */ 417 tmp = xmalloc (strlen (name) + 1); 418 name = strcpy (tmp, name); 419 *input_line_pointer = c; 420 421 if (!ISALPHA (*name)) 422 { 423 as_bad (_("symbols assigned with .eval must begin with a letter")); 424 ignore_rest_of_line (); 425 return; 426 } 427 symbolP = symbol_new (name, absolute_section, 428 (valueT) value, &zero_address_frag); 429 SF_SET_LOCAL (symbolP); 430 symbol_table_insert (symbolP); 431 432 /* The "other" assembler sometimes doesn't put .eval's in the subsym table 433 But since there's not written rule as to when, don't even bother trying 434 to match their behavior. */ 435 sprintf (valuestr, "%d", value); 436 tmp = xmalloc (strlen (valuestr) + 1); 437 strcpy (tmp, valuestr); 438 subsym_create_or_replace (name, tmp); 439 440 demand_empty_rest_of_line (); 441 } 442 443 /* .bss symbol, size [, [blocking flag] [, alignment flag] 444 445 alignment is to a longword boundary; blocking is to 128-word boundary. 446 447 1) if there is a hole in memory, this directive should attempt to fill it 448 (not yet implemented). 449 450 2) if the blocking flag is not set, allocate at the current SPC 451 otherwise, check to see if the current SPC plus the space to be 452 allocated crosses the page boundary (128 words). 453 if there's not enough space, create a hole and align with the next page 454 boundary. 455 (not yet implemented). */ 456 457 static void 458 tic54x_bss (int x ATTRIBUTE_UNUSED) 459 { 460 char c; 461 char *name; 462 char *p; 463 int words; 464 segT current_seg; 465 subsegT current_subseg; 466 symbolS *symbolP; 467 int block = 0; 468 int align = 0; 469 470 ILLEGAL_WITHIN_STRUCT (); 471 472 current_seg = now_seg; /* Save current seg. */ 473 current_subseg = now_subseg; /* Save current subseg. */ 474 475 name = input_line_pointer; 476 c = get_symbol_end (); /* Get terminator. */ 477 if (c != ',') 478 { 479 as_bad (_(".bss size argument missing\n")); 480 ignore_rest_of_line (); 481 return; 482 } 483 484 ++input_line_pointer; 485 words = get_absolute_expression (); 486 if (words < 0) 487 { 488 as_bad (_(".bss size %d < 0!"), words); 489 ignore_rest_of_line (); 490 return; 491 } 492 493 if (*input_line_pointer == ',') 494 { 495 /* The blocking flag may be missing. */ 496 ++input_line_pointer; 497 if (*input_line_pointer != ',') 498 block = get_absolute_expression (); 499 else 500 block = 0; 501 502 if (*input_line_pointer == ',') 503 { 504 ++input_line_pointer; 505 align = get_absolute_expression (); 506 } 507 else 508 align = 0; 509 } 510 else 511 block = align = 0; 512 513 subseg_set (bss_section, 0); 514 symbolP = symbol_find_or_make (name); 515 516 if (S_GET_SEGMENT (symbolP) == bss_section) 517 symbolP->sy_frag->fr_symbol = (symbolS *) NULL; 518 519 symbol_set_frag (symbolP, frag_now); 520 p = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP, 521 (offsetT) (words * OCTETS_PER_BYTE), (char *) 0); 522 *p = 0; /* Fill char. */ 523 524 S_SET_SEGMENT (symbolP, bss_section); 525 526 /* The symbol may already have been created with a preceding 527 ".globl" directive -- be careful not to step on storage class 528 in that case. Otherwise, set it to static. */ 529 if (S_GET_STORAGE_CLASS (symbolP) != C_EXT) 530 S_SET_STORAGE_CLASS (symbolP, C_STAT); 531 532 if (align) 533 { 534 /* s_align eats end of line; restore it */ 535 s_align_bytes (4); 536 --input_line_pointer; 537 } 538 539 if (block) 540 bss_section->flags |= SEC_TIC54X_BLOCK; 541 542 subseg_set (current_seg, current_subseg); /* Restore current seg. */ 543 demand_empty_rest_of_line (); 544 } 545 546 static void 547 stag_add_field_symbols (struct stag *stag, 548 const char *path, 549 bfd_vma base_offset, 550 symbolS *rootsym, 551 const char *root_stag_name) 552 { 553 char prefix[strlen (path) + 2]; 554 struct stag_field *field = stag->field; 555 556 /* Construct a symbol for every field contained within this structure 557 including fields within structure fields. */ 558 strcpy (prefix, path); 559 if (*path) 560 strcat (prefix, "."); 561 562 while (field != NULL) 563 { 564 int len = strlen (prefix) + strlen (field->name) + 2; 565 char *name = xmalloc (len); 566 strcpy (name, prefix); 567 strcat (name, field->name); 568 569 if (rootsym == NULL) 570 { 571 symbolS *sym; 572 sym = symbol_new (name, absolute_section, 573 (field->stag ? field->offset : 574 (valueT) (base_offset + field->offset)), 575 &zero_address_frag); 576 SF_SET_LOCAL (sym); 577 symbol_table_insert (sym); 578 } 579 else 580 { 581 char *replacement = xmalloc (strlen (name) 582 + strlen (stag->name) + 2); 583 strcpy (replacement, S_GET_NAME (rootsym)); 584 strcat (replacement, "+"); 585 strcat (replacement, root_stag_name); 586 strcat (replacement, name + strlen (S_GET_NAME (rootsym))); 587 hash_insert (subsym_hash[0], name, replacement); 588 } 589 590 /* Recurse if the field is a structure. 591 Note the field offset is relative to the outermost struct. */ 592 if (field->stag != NULL) 593 stag_add_field_symbols (field->stag, name, 594 field->offset, 595 rootsym, root_stag_name); 596 field = field->next; 597 } 598 } 599 600 /* Keep track of stag fields so that when structures are nested we can add the 601 complete dereferencing symbols to the symbol table. */ 602 603 static void 604 stag_add_field (struct stag *parent, 605 const char *name, 606 bfd_vma offset, 607 struct stag *stag) 608 { 609 struct stag_field *sfield = xmalloc (sizeof (struct stag_field)); 610 611 memset (sfield, 0, sizeof (*sfield)); 612 sfield->name = strcpy (xmalloc (strlen (name) + 1), name); 613 sfield->offset = offset; 614 sfield->bitfield_offset = parent->current_bitfield_offset; 615 sfield->stag = stag; 616 if (parent->field == NULL) 617 parent->field = sfield; 618 else 619 { 620 struct stag_field *sf = parent->field; 621 while (sf->next != NULL) 622 sf = sf->next; 623 sf->next = sfield; 624 } 625 /* Only create a symbol for this field if the parent has no name. */ 626 if (!strncmp (".fake", parent->name, 5)) 627 { 628 symbolS *sym = symbol_new (name, absolute_section, 629 (valueT) offset, &zero_address_frag); 630 SF_SET_LOCAL (sym); 631 symbol_table_insert (sym); 632 } 633 } 634 635 /* [STAG] .struct [OFFSET] 636 Start defining structure offsets (symbols in absolute section). */ 637 638 static void 639 tic54x_struct (int arg) 640 { 641 int start_offset = 0; 642 int is_union = arg; 643 644 if (!current_stag) 645 { 646 /* Starting a new struct, switch to absolute section. */ 647 stag_saved_seg = now_seg; 648 stag_saved_subseg = now_subseg; 649 subseg_set (absolute_section, 0); 650 } 651 /* Align the current pointer. */ 652 else if (current_stag->current_bitfield_offset != 0) 653 { 654 ++abs_section_offset; 655 current_stag->current_bitfield_offset = 0; 656 } 657 658 /* Offset expression is only meaningful for global .structs. */ 659 if (!is_union) 660 { 661 /* Offset is ignored in inner structs. */ 662 SKIP_WHITESPACE (); 663 if (!is_end_of_line[(int) *input_line_pointer]) 664 start_offset = get_absolute_expression (); 665 else 666 start_offset = 0; 667 } 668 669 if (current_stag) 670 { 671 /* Nesting, link to outer one. */ 672 current_stag->inner = (struct stag *) xmalloc (sizeof (struct stag)); 673 memset (current_stag->inner, 0, sizeof (struct stag)); 674 current_stag->inner->outer = current_stag; 675 current_stag = current_stag->inner; 676 if (start_offset) 677 as_warn (_("Offset on nested structures is ignored")); 678 start_offset = abs_section_offset; 679 } 680 else 681 { 682 current_stag = (struct stag *) xmalloc (sizeof (struct stag)); 683 memset (current_stag, 0, sizeof (struct stag)); 684 abs_section_offset = start_offset; 685 } 686 current_stag->is_union = is_union; 687 688 if (line_label == NULL) 689 { 690 static int struct_count = 0; 691 char fake[] = ".fake_stagNNNNNNN"; 692 sprintf (fake, ".fake_stag%d", struct_count++); 693 current_stag->sym = symbol_new (fake, absolute_section, 694 (valueT) abs_section_offset, 695 &zero_address_frag); 696 } 697 else 698 { 699 char label[strlen (S_GET_NAME (line_label)) + 1]; 700 strcpy (label, S_GET_NAME (line_label)); 701 current_stag->sym = symbol_new (label, absolute_section, 702 (valueT) abs_section_offset, 703 &zero_address_frag); 704 } 705 current_stag->name = S_GET_NAME (current_stag->sym); 706 SF_SET_LOCAL (current_stag->sym); 707 /* Nested .structs don't go into the symbol table. */ 708 if (current_stag->outer == NULL) 709 symbol_table_insert (current_stag->sym); 710 711 line_label = NULL; 712 } 713 714 /* [LABEL] .endstruct 715 finish defining structure offsets; optional LABEL's value will be the size 716 of the structure. */ 717 718 static void 719 tic54x_endstruct (int is_union) 720 { 721 int size; 722 const char *path = 723 !strncmp (current_stag->name, ".fake", 5) ? "" : current_stag->name; 724 725 if (!current_stag || current_stag->is_union != is_union) 726 { 727 as_bad (_(".end%s without preceding .%s"), 728 is_union ? "union" : "struct", 729 is_union ? "union" : "struct"); 730 ignore_rest_of_line (); 731 return; 732 } 733 734 /* Align end of structures. */ 735 if (current_stag->current_bitfield_offset) 736 { 737 ++abs_section_offset; 738 current_stag->current_bitfield_offset = 0; 739 } 740 741 if (current_stag->is_union) 742 size = current_stag->size; 743 else 744 size = abs_section_offset - S_GET_VALUE (current_stag->sym); 745 if (line_label != NULL) 746 { 747 S_SET_VALUE (line_label, size); 748 symbol_table_insert (line_label); 749 line_label = NULL; 750 } 751 752 /* Union size has already been calculated. */ 753 if (!current_stag->is_union) 754 current_stag->size = size; 755 /* Nested .structs don't get put in the stag table. */ 756 if (current_stag->outer == NULL) 757 { 758 hash_insert (stag_hash, current_stag->name, current_stag); 759 stag_add_field_symbols (current_stag, path, 760 S_GET_VALUE (current_stag->sym), 761 NULL, NULL); 762 } 763 current_stag = current_stag->outer; 764 765 /* If this is a nested .struct/.union, add it as a field to the enclosing 766 one. otherwise, restore the section we were in. */ 767 if (current_stag != NULL) 768 { 769 stag_add_field (current_stag, current_stag->inner->name, 770 S_GET_VALUE (current_stag->inner->sym), 771 current_stag->inner); 772 } 773 else 774 subseg_set (stag_saved_seg, stag_saved_subseg); 775 } 776 777 /* [LABEL] .tag STAG 778 Reference a structure within a structure, as a sized field with an optional 779 label. 780 If used outside of a .struct/.endstruct, overlays the given structure 781 format on the existing allocated space. */ 782 783 static void 784 tic54x_tag (int ignore ATTRIBUTE_UNUSED) 785 { 786 char *name = input_line_pointer; 787 int c = get_symbol_end (); 788 struct stag *stag = (struct stag *) hash_find (stag_hash, name); 789 790 if (!stag) 791 { 792 if (*name) 793 as_bad (_("Unrecognized struct/union tag '%s'"), name); 794 else 795 as_bad (_(".tag requires a structure tag")); 796 ignore_rest_of_line (); 797 return; 798 } 799 if (line_label == NULL) 800 { 801 as_bad (_("Label required for .tag")); 802 ignore_rest_of_line (); 803 return; 804 } 805 else 806 { 807 char label[strlen (S_GET_NAME (line_label)) + 1]; 808 809 strcpy (label, S_GET_NAME (line_label)); 810 if (current_stag != NULL) 811 stag_add_field (current_stag, label, 812 abs_section_offset - S_GET_VALUE (current_stag->sym), 813 stag); 814 else 815 { 816 symbolS *sym = symbol_find (label); 817 818 if (!sym) 819 { 820 as_bad (_(".tag target '%s' undefined"), label); 821 ignore_rest_of_line (); 822 return; 823 } 824 stag_add_field_symbols (stag, S_GET_NAME (sym), 825 S_GET_VALUE (stag->sym), sym, stag->name); 826 } 827 } 828 829 /* Bump by the struct size, but only if we're within a .struct section. */ 830 if (current_stag != NULL && !current_stag->is_union) 831 abs_section_offset += stag->size; 832 833 *input_line_pointer = c; 834 demand_empty_rest_of_line (); 835 line_label = NULL; 836 } 837 838 /* Handle all .byte, .char, .double, .field, .float, .half, .int, .long, 839 .short, .string, .ubyte, .uchar, .uhalf, .uint, .ulong, .ushort, .uword, 840 and .word. */ 841 842 static void 843 tic54x_struct_field (int type) 844 { 845 int size; 846 int count = 1; 847 int new_bitfield_offset = 0; 848 int field_align = current_stag->current_bitfield_offset != 0; 849 int longword_align = 0; 850 851 SKIP_WHITESPACE (); 852 if (!is_end_of_line[(int) *input_line_pointer]) 853 count = get_absolute_expression (); 854 855 switch (type) 856 { 857 case 'b': 858 case 'B': 859 case 'c': 860 case 'C': 861 case 'h': 862 case 'H': 863 case 'i': 864 case 'I': 865 case 's': 866 case 'S': 867 case 'w': 868 case 'W': 869 case '*': /* String. */ 870 size = 1; 871 break; 872 case 'f': 873 case 'l': 874 case 'L': 875 longword_align = 1; 876 size = 2; 877 break; 878 case '.': /* Bitfield. */ 879 size = 0; 880 if (count < 1 || count > 32) 881 { 882 as_bad (_(".field count '%d' out of range (1 <= X <= 32)"), count); 883 ignore_rest_of_line (); 884 return; 885 } 886 if (current_stag->current_bitfield_offset + count > 16) 887 { 888 /* Set the appropriate size and new field offset. */ 889 if (count == 32) 890 { 891 size = 2; 892 count = 1; 893 } 894 else if (count > 16) 895 { 896 size = 1; 897 count = 1; 898 new_bitfield_offset = count - 16; 899 } 900 else 901 new_bitfield_offset = count; 902 } 903 else 904 { 905 field_align = 0; 906 new_bitfield_offset = current_stag->current_bitfield_offset + count; 907 } 908 break; 909 default: 910 as_bad (_("Unrecognized field type '%c'"), type); 911 ignore_rest_of_line (); 912 return; 913 } 914 915 if (field_align) 916 { 917 /* Align to the actual starting position of the field. */ 918 current_stag->current_bitfield_offset = 0; 919 ++abs_section_offset; 920 } 921 /* Align to longword boundary. */ 922 if (longword_align && (abs_section_offset & 0x1)) 923 ++abs_section_offset; 924 925 if (line_label == NULL) 926 { 927 static int fieldno = 0; 928 char fake[] = ".fake_fieldNNNNN"; 929 930 sprintf (fake, ".fake_field%d", fieldno++); 931 stag_add_field (current_stag, fake, 932 abs_section_offset - S_GET_VALUE (current_stag->sym), 933 NULL); 934 } 935 else 936 { 937 char label[strlen (S_GET_NAME (line_label) + 1)]; 938 939 strcpy (label, S_GET_NAME (line_label)); 940 stag_add_field (current_stag, label, 941 abs_section_offset - S_GET_VALUE (current_stag->sym), 942 NULL); 943 } 944 945 if (current_stag->is_union) 946 { 947 /* Note we treat the element as if it were an array of COUNT. */ 948 if (current_stag->size < (unsigned) size * count) 949 current_stag->size = size * count; 950 } 951 else 952 { 953 abs_section_offset += (unsigned) size * count; 954 current_stag->current_bitfield_offset = new_bitfield_offset; 955 } 956 line_label = NULL; 957 } 958 959 /* Handle .byte, .word. .int, .long and all variants. */ 960 961 static void 962 tic54x_cons (int type) 963 { 964 unsigned int c; 965 int octets; 966 967 /* If we're within a .struct construct, don't actually allocate space. */ 968 if (current_stag != NULL) 969 { 970 tic54x_struct_field (type); 971 return; 972 } 973 974 #ifdef md_flush_pending_output 975 md_flush_pending_output (); 976 #endif 977 978 generate_lineno_debug (); 979 980 /* Align long words to long word boundaries (4 octets). */ 981 if (type == 'l' || type == 'L') 982 { 983 frag_align (2, 0, 2); 984 /* If there's a label, assign it to the first allocated word. */ 985 if (line_label != NULL) 986 { 987 symbol_set_frag (line_label, frag_now); 988 S_SET_VALUE (line_label, frag_now_fix ()); 989 } 990 } 991 992 switch (type) 993 { 994 case 'l': 995 case 'L': 996 case 'x': 997 octets = 4; 998 break; 999 case 'b': 1000 case 'B': 1001 case 'c': 1002 case 'C': 1003 octets = 1; 1004 break; 1005 default: 1006 octets = 2; 1007 break; 1008 } 1009 1010 do 1011 { 1012 if (*input_line_pointer == '"') 1013 { 1014 input_line_pointer++; 1015 while (is_a_char (c = next_char_of_string ())) 1016 tic54x_emit_char (c); 1017 know (input_line_pointer[-1] == '\"'); 1018 } 1019 else 1020 { 1021 expressionS expn; 1022 1023 input_line_pointer = parse_expression (input_line_pointer, &expn); 1024 if (expn.X_op == O_constant) 1025 { 1026 offsetT value = expn.X_add_number; 1027 /* Truncate overflows. */ 1028 switch (octets) 1029 { 1030 case 1: 1031 if ((value > 0 && value > 0xFF) 1032 || (value < 0 && value < - 0x100)) 1033 as_warn (_("Overflow in expression, truncated to 8 bits")); 1034 break; 1035 case 2: 1036 if ((value > 0 && value > 0xFFFF) 1037 || (value < 0 && value < - 0x10000)) 1038 as_warn (_("Overflow in expression, truncated to 16 bits")); 1039 break; 1040 } 1041 } 1042 if (expn.X_op != O_constant && octets < 2) 1043 { 1044 /* Disallow .byte with a non constant expression that will 1045 require relocation. */ 1046 as_bad (_("Relocatable values require at least WORD storage")); 1047 ignore_rest_of_line (); 1048 return; 1049 } 1050 1051 if (expn.X_op != O_constant 1052 && amode == c_mode 1053 && octets == 4) 1054 { 1055 /* FIXME -- at one point TI tools used to output REL16 1056 relocations, but I don't think the latest tools do at all 1057 The current tools output extended relocations regardless of 1058 the addressing mode (I actually think that ".c_mode" is 1059 totally ignored in the latest tools). */ 1060 amode = far_mode; 1061 emitting_long = 1; 1062 emit_expr (&expn, 4); 1063 emitting_long = 0; 1064 amode = c_mode; 1065 } 1066 else 1067 { 1068 emitting_long = octets == 4; 1069 emit_expr (&expn, (octets == 1) ? 2 : octets); 1070 emitting_long = 0; 1071 } 1072 } 1073 } 1074 while (*input_line_pointer++ == ','); 1075 1076 input_line_pointer--; /* Put terminator back into stream. */ 1077 demand_empty_rest_of_line (); 1078 } 1079 1080 /* .global <symbol>[,...,<symbolN>] 1081 .def <symbol>[,...,<symbolN>] 1082 .ref <symbol>[,...,<symbolN>] 1083 1084 These all identify global symbols. 1085 1086 .def means the symbol is defined in the current module and can be accessed 1087 by other files. The symbol should be placed in the symbol table. 1088 1089 .ref means the symbol is used in the current module but defined in another 1090 module. The linker is to resolve this symbol's definition at link time. 1091 1092 .global should act as a .ref or .def, as needed. 1093 1094 global, def and ref all have symbol storage classes of C_EXT. 1095 1096 I can't identify any difference in how the "other" c54x assembler treats 1097 these, so we ignore the type here. */ 1098 1099 void 1100 tic54x_global (int type) 1101 { 1102 char *name; 1103 int c; 1104 symbolS *symbolP; 1105 1106 if (type == 'r') 1107 as_warn (_("Use of .def/.ref is deprecated. Use .global instead")); 1108 1109 ILLEGAL_WITHIN_STRUCT (); 1110 1111 do 1112 { 1113 name = input_line_pointer; 1114 c = get_symbol_end (); 1115 symbolP = symbol_find_or_make (name); 1116 1117 *input_line_pointer = c; 1118 S_SET_STORAGE_CLASS (symbolP, C_EXT); 1119 if (c == ',') 1120 { 1121 input_line_pointer++; 1122 if (is_end_of_line[(int) *input_line_pointer]) 1123 c = *input_line_pointer; 1124 } 1125 } 1126 while (c == ','); 1127 1128 demand_empty_rest_of_line (); 1129 } 1130 1131 /* Remove the symbol from the local label hash lookup. */ 1132 1133 static void 1134 tic54x_remove_local_label (const char *key, void *value ATTRIBUTE_UNUSED) 1135 { 1136 void *elem = hash_delete (local_label_hash[macro_level], key, FALSE); 1137 free (elem); 1138 } 1139 1140 /* Reset all local labels. */ 1141 1142 static void 1143 tic54x_clear_local_labels (int ignored ATTRIBUTE_UNUSED) 1144 { 1145 hash_traverse (local_label_hash[macro_level], tic54x_remove_local_label); 1146 } 1147 1148 /* .text 1149 .data 1150 .sect "section name" 1151 1152 Initialized section 1153 make sure local labels get cleared when changing sections 1154 1155 ARG is 't' for text, 'd' for data, or '*' for a named section 1156 1157 For compatibility, '*' sections are SEC_CODE if instructions are 1158 encountered, or SEC_DATA if not. 1159 */ 1160 1161 static void 1162 tic54x_sect (int arg) 1163 { 1164 ILLEGAL_WITHIN_STRUCT (); 1165 1166 /* Local labels are cleared when changing sections. */ 1167 tic54x_clear_local_labels (0); 1168 1169 if (arg == 't') 1170 s_text (0); 1171 else if (arg == 'd') 1172 s_data (0); 1173 else 1174 { 1175 char *name = NULL; 1176 int len; 1177 1178 /* If there are quotes, remove them. */ 1179 if (*input_line_pointer == '"') 1180 { 1181 name = demand_copy_C_string (&len); 1182 demand_empty_rest_of_line (); 1183 name = strcpy (xmalloc (len + 10), name); 1184 } 1185 else 1186 { 1187 int c; 1188 name = input_line_pointer; 1189 c = get_symbol_end (); 1190 len = strlen(name); 1191 name = strcpy (xmalloc (len + 10), name); 1192 *input_line_pointer = c; 1193 demand_empty_rest_of_line (); 1194 } 1195 /* Make sure all named initialized sections flagged properly. If we 1196 encounter instructions, we'll flag it with SEC_CODE as well. */ 1197 strcat (name, ",\"w\"\n"); 1198 input_scrub_insert_line (name); 1199 obj_coff_section (0); 1200 1201 /* If there was a line label, make sure that it gets assigned the proper 1202 section. This is for compatibility, even though the actual behavior 1203 is not explicitly defined. For consistency, we make .sect behave 1204 like .usect, since that is probably what people expect. */ 1205 if (line_label != NULL) 1206 { 1207 S_SET_SEGMENT (line_label, now_seg); 1208 symbol_set_frag (line_label, frag_now); 1209 S_SET_VALUE (line_label, frag_now_fix ()); 1210 if (S_GET_STORAGE_CLASS (line_label) != C_EXT) 1211 S_SET_STORAGE_CLASS (line_label, C_LABEL); 1212 } 1213 } 1214 } 1215 1216 /* [symbol] .space space_in_bits 1217 [symbol] .bes space_in_bits 1218 BES puts the symbol at the *last* word allocated 1219 1220 cribbed from s_space. */ 1221 1222 static void 1223 tic54x_space (int arg) 1224 { 1225 expressionS expn; 1226 char *p = 0; 1227 int octets = 0; 1228 long words; 1229 int bits_per_byte = (OCTETS_PER_BYTE * 8); 1230 int bit_offset = 0; 1231 symbolS *label = line_label; 1232 int bes = arg; 1233 1234 ILLEGAL_WITHIN_STRUCT (); 1235 1236 #ifdef md_flush_pending_output 1237 md_flush_pending_output (); 1238 #endif 1239 1240 /* Read the bit count. */ 1241 expression (&expn); 1242 1243 /* Some expressions are unresolvable until later in the assembly pass; 1244 postpone until relaxation/fixup. we also have to postpone if a previous 1245 partial allocation has not been completed yet. */ 1246 if (expn.X_op != O_constant || frag_bit_offset (frag_now, now_seg) == -1) 1247 { 1248 struct bit_info *bi = xmalloc (sizeof (struct bit_info)); 1249 1250 bi->seg = now_seg; 1251 bi->type = bes; 1252 bi->sym = label; 1253 p = frag_var (rs_machine_dependent, 1254 65536 * 2, 1, (relax_substateT) 0, 1255 make_expr_symbol (&expn), (offsetT) 0, 1256 (char *) bi); 1257 if (p) 1258 *p = 0; 1259 1260 return; 1261 } 1262 1263 /* Reduce the required size by any bit offsets currently left over 1264 from a previous .space/.bes/.field directive. */ 1265 bit_offset = frag_now->tc_frag_data; 1266 if (bit_offset != 0 && bit_offset < 16) 1267 { 1268 int spare_bits = bits_per_byte - bit_offset; 1269 1270 if (spare_bits >= expn.X_add_number) 1271 { 1272 /* Don't have to do anything; sufficient bits have already been 1273 allocated; just point the label to the right place. */ 1274 if (label != NULL) 1275 { 1276 symbol_set_frag (label, frag_now); 1277 S_SET_VALUE (label, frag_now_fix () - 1); 1278 label = NULL; 1279 } 1280 frag_now->tc_frag_data += expn.X_add_number; 1281 goto getout; 1282 } 1283 expn.X_add_number -= spare_bits; 1284 /* Set the label to point to the first word allocated, which in this 1285 case is the previous word, which was only partially filled. */ 1286 if (!bes && label != NULL) 1287 { 1288 symbol_set_frag (label, frag_now); 1289 S_SET_VALUE (label, frag_now_fix () - 1); 1290 label = NULL; 1291 } 1292 } 1293 /* Convert bits to bytes/words and octets, rounding up. */ 1294 words = ((expn.X_add_number + bits_per_byte - 1) / bits_per_byte); 1295 /* How many do we have left over? */ 1296 bit_offset = expn.X_add_number % bits_per_byte; 1297 octets = words * OCTETS_PER_BYTE; 1298 if (octets < 0) 1299 { 1300 as_warn (_(".space/.bes repeat count is negative, ignored")); 1301 goto getout; 1302 } 1303 else if (octets == 0) 1304 { 1305 as_warn (_(".space/.bes repeat count is zero, ignored")); 1306 goto getout; 1307 } 1308 1309 /* If we are in the absolute section, just bump the offset. */ 1310 if (now_seg == absolute_section) 1311 { 1312 abs_section_offset += words; 1313 if (bes && label != NULL) 1314 S_SET_VALUE (label, abs_section_offset - 1); 1315 frag_now->tc_frag_data = bit_offset; 1316 goto getout; 1317 } 1318 1319 if (!need_pass_2) 1320 p = frag_var (rs_fill, 1, 1, 1321 (relax_substateT) 0, (symbolS *) 0, 1322 (offsetT) octets, (char *) 0); 1323 1324 /* Make note of how many bits of this word we've allocated so far. */ 1325 frag_now->tc_frag_data = bit_offset; 1326 1327 /* .bes puts label at *last* word allocated. */ 1328 if (bes && label != NULL) 1329 { 1330 symbol_set_frag (label, frag_now); 1331 S_SET_VALUE (label, frag_now_fix () - 1); 1332 } 1333 1334 if (p) 1335 *p = 0; 1336 1337 getout: 1338 1339 demand_empty_rest_of_line (); 1340 } 1341 1342 /* [symbol] .usect "section-name", size-in-words 1343 [, [blocking-flag] [, alignment-flag]] 1344 1345 Uninitialized section. 1346 Non-zero blocking means that if the section would cross a page (128-word) 1347 boundary, it will be page-aligned. 1348 Non-zero alignment aligns on a longword boundary. 1349 1350 Has no effect on the current section. */ 1351 1352 static void 1353 tic54x_usect (int x ATTRIBUTE_UNUSED) 1354 { 1355 char c; 1356 char *name; 1357 char *section_name; 1358 char *p; 1359 segT seg; 1360 int size, blocking_flag, alignment_flag; 1361 segT current_seg; 1362 subsegT current_subseg; 1363 flagword flags; 1364 1365 ILLEGAL_WITHIN_STRUCT (); 1366 1367 current_seg = now_seg; /* Save current seg. */ 1368 current_subseg = now_subseg; /* Save current subseg. */ 1369 1370 if (*input_line_pointer == '"') 1371 input_line_pointer++; 1372 section_name = input_line_pointer; 1373 c = get_symbol_end (); /* Get terminator. */ 1374 input_line_pointer++; /* Skip null symbol terminator. */ 1375 name = xmalloc (input_line_pointer - section_name + 1); 1376 strcpy (name, section_name); 1377 1378 if (*input_line_pointer == ',') 1379 ++input_line_pointer; 1380 else if (c != ',') 1381 { 1382 as_bad (_("Missing size argument")); 1383 ignore_rest_of_line (); 1384 return; 1385 } 1386 1387 size = get_absolute_expression (); 1388 1389 /* Read a possibly present third argument (blocking flag). */ 1390 if (*input_line_pointer == ',') 1391 { 1392 ++input_line_pointer; 1393 if (*input_line_pointer != ',') 1394 blocking_flag = get_absolute_expression (); 1395 else 1396 blocking_flag = 0; 1397 1398 /* Read a possibly present fourth argument (alignment flag). */ 1399 if (*input_line_pointer == ',') 1400 { 1401 ++input_line_pointer; 1402 alignment_flag = get_absolute_expression (); 1403 } 1404 else 1405 alignment_flag = 0; 1406 } 1407 else 1408 blocking_flag = alignment_flag = 0; 1409 1410 seg = subseg_new (name, 0); 1411 flags = bfd_get_section_flags (stdoutput, seg) | SEC_ALLOC; 1412 1413 if (alignment_flag) 1414 { 1415 /* s_align eats end of line; restore it. */ 1416 s_align_bytes (4); 1417 --input_line_pointer; 1418 } 1419 1420 if (line_label != NULL) 1421 { 1422 S_SET_SEGMENT (line_label, seg); 1423 symbol_set_frag (line_label, frag_now); 1424 S_SET_VALUE (line_label, frag_now_fix ()); 1425 /* Set scl to label, since that's what TI does. */ 1426 if (S_GET_STORAGE_CLASS (line_label) != C_EXT) 1427 S_SET_STORAGE_CLASS (line_label, C_LABEL); 1428 } 1429 1430 seg_info (seg)->bss = 1; /* Uninitialized data. */ 1431 1432 p = frag_var (rs_fill, 1, 1, 1433 (relax_substateT) 0, (symbolS *) line_label, 1434 size * OCTETS_PER_BYTE, (char *) 0); 1435 *p = 0; 1436 1437 if (blocking_flag) 1438 flags |= SEC_TIC54X_BLOCK; 1439 1440 if (!bfd_set_section_flags (stdoutput, seg, flags)) 1441 as_warn (_("Error setting flags for \"%s\": %s"), name, 1442 bfd_errmsg (bfd_get_error ())); 1443 1444 subseg_set (current_seg, current_subseg); /* Restore current seg. */ 1445 demand_empty_rest_of_line (); 1446 } 1447 1448 static enum cpu_version 1449 lookup_version (const char *ver) 1450 { 1451 enum cpu_version version = VNONE; 1452 1453 if (ver[0] == '5' && ver[1] == '4') 1454 { 1455 if (strlen (ver) == 3 1456 && (ver[2] == '1' || ver[2] == '2' || ver[2] == '3' 1457 || ver[2] == '5' || ver[2] == '8' || ver[2] == '9')) 1458 version = ver[2] - '0'; 1459 else if (strlen (ver) == 5 1460 && TOUPPER (ver[3]) == 'L' 1461 && TOUPPER (ver[4]) == 'P' 1462 && (ver[2] == '5' || ver[2] == '6')) 1463 version = ver[2] - '0' + 10; 1464 } 1465 1466 return version; 1467 } 1468 1469 static void 1470 set_cpu (enum cpu_version version) 1471 { 1472 cpu = version; 1473 if (version == V545LP || version == V546LP) 1474 { 1475 symbolS *symbolP = symbol_new ("__allow_lp", absolute_section, 1476 (valueT) 1, &zero_address_frag); 1477 SF_SET_LOCAL (symbolP); 1478 symbol_table_insert (symbolP); 1479 } 1480 } 1481 1482 /* .version cpu-version 1483 cpu-version may be one of the following: 1484 541 1485 542 1486 543 1487 545 1488 545LP 1489 546LP 1490 548 1491 549 1492 1493 This is for compatibility only. It currently has no affect on assembly. */ 1494 static int cpu_needs_set = 1; 1495 1496 static void 1497 tic54x_version (int x ATTRIBUTE_UNUSED) 1498 { 1499 enum cpu_version version = VNONE; 1500 enum cpu_version old_version = cpu; 1501 int c; 1502 char *ver; 1503 1504 ILLEGAL_WITHIN_STRUCT (); 1505 1506 SKIP_WHITESPACE (); 1507 ver = input_line_pointer; 1508 while (!is_end_of_line[(int) *input_line_pointer]) 1509 ++input_line_pointer; 1510 c = *input_line_pointer; 1511 *input_line_pointer = 0; 1512 1513 version = lookup_version (ver); 1514 1515 if (cpu != VNONE && cpu != version) 1516 as_warn (_("CPU version has already been set")); 1517 1518 if (version == VNONE) 1519 { 1520 as_bad (_("Unrecognized version '%s'"), ver); 1521 ignore_rest_of_line (); 1522 return; 1523 } 1524 else if (assembly_begun && version != old_version) 1525 { 1526 as_bad (_("Changing of CPU version on the fly not supported")); 1527 ignore_rest_of_line (); 1528 return; 1529 } 1530 1531 set_cpu (version); 1532 1533 *input_line_pointer = c; 1534 demand_empty_rest_of_line (); 1535 } 1536 1537 /* 'f' = float, 'x' = xfloat, 'd' = double, 'l' = ldouble. */ 1538 1539 static void 1540 tic54x_float_cons (int type) 1541 { 1542 if (current_stag != 0) 1543 tic54x_struct_field ('f'); 1544 1545 #ifdef md_flush_pending_output 1546 md_flush_pending_output (); 1547 #endif 1548 1549 /* Align to long word boundary (4 octets) unless it's ".xfloat". */ 1550 if (type != 'x') 1551 { 1552 frag_align (2, 0, 2); 1553 /* If there's a label, assign it to the first allocated word. */ 1554 if (line_label != NULL) 1555 { 1556 symbol_set_frag (line_label, frag_now); 1557 S_SET_VALUE (line_label, frag_now_fix ()); 1558 } 1559 } 1560 1561 float_cons ('f'); 1562 } 1563 1564 /* The argument is capitalized if it should be zero-terminated 1565 's' is normal string with upper 8-bits zero-filled, 'p' is packed. 1566 Code copied from stringer, and slightly modified so that strings are packed 1567 and encoded into the correct octets. */ 1568 1569 static void 1570 tic54x_stringer (int type) 1571 { 1572 unsigned int c; 1573 int append_zero = type == 'S' || type == 'P'; 1574 int packed = type == 'p' || type == 'P'; 1575 int last_char = -1; /* Packed strings need two bytes at a time to encode. */ 1576 1577 if (current_stag != NULL) 1578 { 1579 tic54x_struct_field ('*'); 1580 return; 1581 } 1582 1583 #ifdef md_flush_pending_output 1584 md_flush_pending_output (); 1585 #endif 1586 1587 c = ','; /* Do loop. */ 1588 while (c == ',') 1589 { 1590 SKIP_WHITESPACE (); 1591 switch (*input_line_pointer) 1592 { 1593 default: 1594 { 1595 unsigned short value = get_absolute_expression (); 1596 FRAG_APPEND_1_CHAR ( value & 0xFF); 1597 FRAG_APPEND_1_CHAR ((value >> 8) & 0xFF); 1598 break; 1599 } 1600 case '\"': 1601 ++input_line_pointer; /* -> 1st char of string. */ 1602 while (is_a_char (c = next_char_of_string ())) 1603 { 1604 if (!packed) 1605 { 1606 FRAG_APPEND_1_CHAR (c); 1607 FRAG_APPEND_1_CHAR (0); 1608 } 1609 else 1610 { 1611 /* Packed strings are filled MS octet first. */ 1612 if (last_char == -1) 1613 last_char = c; 1614 else 1615 { 1616 FRAG_APPEND_1_CHAR (c); 1617 FRAG_APPEND_1_CHAR (last_char); 1618 last_char = -1; 1619 } 1620 } 1621 } 1622 if (append_zero) 1623 { 1624 if (packed && last_char != -1) 1625 { 1626 FRAG_APPEND_1_CHAR (0); 1627 FRAG_APPEND_1_CHAR (last_char); 1628 last_char = -1; 1629 } 1630 else 1631 { 1632 FRAG_APPEND_1_CHAR (0); 1633 FRAG_APPEND_1_CHAR (0); 1634 } 1635 } 1636 know (input_line_pointer[-1] == '\"'); 1637 break; 1638 } 1639 SKIP_WHITESPACE (); 1640 c = *input_line_pointer; 1641 if (!is_end_of_line[c]) 1642 ++input_line_pointer; 1643 } 1644 1645 /* Finish up any leftover packed string. */ 1646 if (packed && last_char != -1) 1647 { 1648 FRAG_APPEND_1_CHAR (0); 1649 FRAG_APPEND_1_CHAR (last_char); 1650 } 1651 demand_empty_rest_of_line (); 1652 } 1653 1654 static void 1655 tic54x_p2align (int arg ATTRIBUTE_UNUSED) 1656 { 1657 as_bad (_("p2align not supported on this target")); 1658 } 1659 1660 static void 1661 tic54x_align_words (int arg) 1662 { 1663 /* Only ".align" with no argument is allowed within .struct/.union. */ 1664 int count = arg; 1665 1666 if (!is_end_of_line[(int) *input_line_pointer]) 1667 { 1668 if (arg == 2) 1669 as_warn (_("Argument to .even ignored")); 1670 else 1671 count = get_absolute_expression (); 1672 } 1673 1674 if (current_stag != NULL && arg == 128) 1675 { 1676 if (current_stag->current_bitfield_offset != 0) 1677 { 1678 current_stag->current_bitfield_offset = 0; 1679 ++abs_section_offset; 1680 } 1681 demand_empty_rest_of_line (); 1682 return; 1683 } 1684 1685 ILLEGAL_WITHIN_STRUCT (); 1686 1687 s_align_bytes (count << 1); 1688 } 1689 1690 /* Initialize multiple-bit fields withing a single word of memory. */ 1691 1692 static void 1693 tic54x_field (int ignore ATTRIBUTE_UNUSED) 1694 { 1695 expressionS expn; 1696 int size = 16; 1697 char *p; 1698 valueT value; 1699 symbolS *label = line_label; 1700 1701 if (current_stag != NULL) 1702 { 1703 tic54x_struct_field ('.'); 1704 return; 1705 } 1706 1707 input_line_pointer = parse_expression (input_line_pointer, &expn); 1708 1709 if (*input_line_pointer == ',') 1710 { 1711 ++input_line_pointer; 1712 size = get_absolute_expression (); 1713 if (size < 1 || size > 32) 1714 { 1715 as_bad (_("Invalid field size, must be from 1 to 32")); 1716 ignore_rest_of_line (); 1717 return; 1718 } 1719 } 1720 1721 /* Truncate values to the field width. */ 1722 if (expn.X_op != O_constant) 1723 { 1724 /* If the expression value is relocatable, the field size *must* 1725 be 16. */ 1726 if (size != 16) 1727 { 1728 as_bad (_("field size must be 16 when value is relocatable")); 1729 ignore_rest_of_line (); 1730 return; 1731 } 1732 1733 frag_now->tc_frag_data = 0; 1734 emit_expr (&expn, 2); 1735 } 1736 else 1737 { 1738 unsigned long fmask = (size == 32) ? 0xFFFFFFFF : (1ul << size) - 1; 1739 1740 value = expn.X_add_number; 1741 expn.X_add_number &= fmask; 1742 if (value != (valueT) expn.X_add_number) 1743 as_warn (_("field value truncated")); 1744 value = expn.X_add_number; 1745 /* Bits are stored MS first. */ 1746 while (size >= 16) 1747 { 1748 frag_now->tc_frag_data = 0; 1749 p = frag_more (2); 1750 md_number_to_chars (p, (value >> (size - 16)) & 0xFFFF, 2); 1751 size -= 16; 1752 } 1753 if (size > 0) 1754 { 1755 int bit_offset = frag_bit_offset (frag_now, now_seg); 1756 1757 fragS *alloc_frag = bit_offset_frag (frag_now, now_seg); 1758 if (bit_offset == -1) 1759 { 1760 struct bit_info *bi = xmalloc (sizeof (struct bit_info)); 1761 /* We don't know the previous offset at this time, so store the 1762 info we need and figure it out later. */ 1763 expressionS size_exp; 1764 1765 size_exp.X_op = O_constant; 1766 size_exp.X_add_number = size; 1767 bi->seg = now_seg; 1768 bi->type = TYPE_FIELD; 1769 bi->value = value; 1770 p = frag_var (rs_machine_dependent, 1771 4, 1, (relax_substateT) 0, 1772 make_expr_symbol (&size_exp), (offsetT) 0, 1773 (char *) bi); 1774 goto getout; 1775 } 1776 else if (bit_offset == 0 || bit_offset + size > 16) 1777 { 1778 /* Align a new field. */ 1779 p = frag_more (2); 1780 frag_now->tc_frag_data = 0; 1781 alloc_frag = frag_now; 1782 } 1783 else 1784 { 1785 /* Put the new value entirely within the existing one. */ 1786 p = alloc_frag == frag_now ? 1787 frag_now->fr_literal + frag_now_fix_octets () - 2 : 1788 alloc_frag->fr_literal; 1789 if (label != NULL) 1790 { 1791 symbol_set_frag (label, alloc_frag); 1792 if (alloc_frag == frag_now) 1793 S_SET_VALUE (label, frag_now_fix () - 1); 1794 label = NULL; 1795 } 1796 } 1797 value <<= 16 - alloc_frag->tc_frag_data - size; 1798 1799 /* OR in existing value. */ 1800 if (alloc_frag->tc_frag_data) 1801 value |= ((unsigned short) p[1] << 8) | p[0]; 1802 md_number_to_chars (p, value, 2); 1803 alloc_frag->tc_frag_data += size; 1804 if (alloc_frag->tc_frag_data == 16) 1805 alloc_frag->tc_frag_data = 0; 1806 } 1807 } 1808 getout: 1809 demand_empty_rest_of_line (); 1810 } 1811 1812 /* Ideally, we want to check SEC_LOAD and SEC_HAS_CONTENTS, but those aren't 1813 available yet. seg_info ()->bss is the next best thing. */ 1814 1815 static int 1816 tic54x_initialized_section (segT seg) 1817 { 1818 return !seg_info (seg)->bss; 1819 } 1820 1821 /* .clink ["section name"] 1822 1823 Marks the section as conditionally linked (link only if contents are 1824 referenced elsewhere. 1825 Without a name, refers to the current initialized section. 1826 Name is required for uninitialized sections. */ 1827 1828 static void 1829 tic54x_clink (int ignored ATTRIBUTE_UNUSED) 1830 { 1831 segT seg = now_seg; 1832 1833 ILLEGAL_WITHIN_STRUCT (); 1834 1835 if (*input_line_pointer == '\"') 1836 { 1837 char *section_name = ++input_line_pointer; 1838 char *name; 1839 1840 while (is_a_char (next_char_of_string ())) 1841 ; 1842 know (input_line_pointer[-1] == '\"'); 1843 input_line_pointer[-1] = 0; 1844 name = xmalloc (input_line_pointer - section_name + 1); 1845 strcpy (name, section_name); 1846 1847 seg = bfd_get_section_by_name (stdoutput, name); 1848 if (seg == NULL) 1849 { 1850 as_bad (_("Unrecognized section '%s'"), section_name); 1851 ignore_rest_of_line (); 1852 return; 1853 } 1854 } 1855 else 1856 { 1857 if (!tic54x_initialized_section (seg)) 1858 { 1859 as_bad (_("Current section is unitialized, " 1860 "section name required for .clink")); 1861 ignore_rest_of_line (); 1862 return; 1863 } 1864 } 1865 1866 seg->flags |= SEC_TIC54X_CLINK; 1867 1868 demand_empty_rest_of_line (); 1869 } 1870 1871 /* Change the default include directory to be the current source file's 1872 directory, instead of the current working directory. If DOT is non-zero, 1873 set to "." instead. */ 1874 1875 static void 1876 tic54x_set_default_include (int dot) 1877 { 1878 char *dir = "."; 1879 char *tmp = NULL; 1880 1881 if (!dot) 1882 { 1883 char *curfile; 1884 unsigned lineno; 1885 1886 as_where (&curfile, &lineno); 1887 dir = strcpy (xmalloc (strlen (curfile) + 1), curfile); 1888 tmp = strrchr (dir, '/'); 1889 } 1890 if (tmp != NULL) 1891 { 1892 int len; 1893 1894 *tmp = '\0'; 1895 len = strlen (dir); 1896 if (include_dir_count == 0) 1897 { 1898 include_dirs = (char **) xmalloc (sizeof (*include_dirs)); 1899 include_dir_count = 1; 1900 } 1901 include_dirs[0] = dir; 1902 if (len > include_dir_maxlen) 1903 include_dir_maxlen = len; 1904 } 1905 else if (include_dirs != NULL) 1906 include_dirs[0] = "."; 1907 } 1908 1909 /* .include "filename" | filename 1910 .copy "filename" | filename 1911 1912 FIXME 'include' file should be omitted from any output listing, 1913 'copy' should be included in any output listing 1914 FIXME -- prevent any included files from changing listing (compat only) 1915 FIXME -- need to include source file directory in search path; what's a 1916 good way to do this? 1917 1918 Entering/exiting included/copied file clears all local labels. */ 1919 1920 static void 1921 tic54x_include (int ignored ATTRIBUTE_UNUSED) 1922 { 1923 char newblock[] = " .newblock\n"; 1924 char *filename; 1925 char *input; 1926 int len, c = -1; 1927 1928 ILLEGAL_WITHIN_STRUCT (); 1929 1930 SKIP_WHITESPACE (); 1931 1932 if (*input_line_pointer == '"') 1933 { 1934 filename = demand_copy_C_string (&len); 1935 demand_empty_rest_of_line (); 1936 } 1937 else 1938 { 1939 filename = input_line_pointer; 1940 while (!is_end_of_line[(int) *input_line_pointer]) 1941 ++input_line_pointer; 1942 c = *input_line_pointer; 1943 *input_line_pointer = '\0'; 1944 filename = strcpy (xmalloc (strlen (filename) + 1), filename); 1945 *input_line_pointer = c; 1946 demand_empty_rest_of_line (); 1947 } 1948 /* Insert a partial line with the filename (for the sake of s_include) 1949 and a .newblock. 1950 The included file will be inserted before the newblock, so that the 1951 newblock is executed after the included file is processed. */ 1952 input = xmalloc (sizeof (newblock) + strlen (filename) + 4); 1953 sprintf (input, "\"%s\"\n%s", filename, newblock); 1954 input_scrub_insert_line (input); 1955 1956 tic54x_clear_local_labels (0); 1957 1958 tic54x_set_default_include (0); 1959 1960 s_include (0); 1961 } 1962 1963 static void 1964 tic54x_message (int type) 1965 { 1966 char *msg; 1967 char c; 1968 int len; 1969 1970 ILLEGAL_WITHIN_STRUCT (); 1971 1972 if (*input_line_pointer == '"') 1973 msg = demand_copy_C_string (&len); 1974 else 1975 { 1976 msg = input_line_pointer; 1977 while (!is_end_of_line[(int) *input_line_pointer]) 1978 ++input_line_pointer; 1979 c = *input_line_pointer; 1980 *input_line_pointer = 0; 1981 msg = strcpy (xmalloc (strlen (msg) + 1), msg); 1982 *input_line_pointer = c; 1983 } 1984 1985 switch (type) 1986 { 1987 case 'm': 1988 as_tsktsk ("%s", msg); 1989 break; 1990 case 'w': 1991 as_warn ("%s", msg); 1992 break; 1993 case 'e': 1994 as_bad ("%s", msg); 1995 break; 1996 } 1997 1998 demand_empty_rest_of_line (); 1999 } 2000 2001 /* .label <symbol> 2002 Define a special symbol that refers to the loadtime address rather than the 2003 runtime address within the current section. 2004 2005 This symbol gets a special storage class so that when it is resolved, it is 2006 resolved relative to the load address (lma) of the section rather than the 2007 run address (vma). */ 2008 2009 static void 2010 tic54x_label (int ignored ATTRIBUTE_UNUSED) 2011 { 2012 char *name = input_line_pointer; 2013 symbolS *symbolP; 2014 int c; 2015 2016 ILLEGAL_WITHIN_STRUCT (); 2017 2018 c = get_symbol_end (); 2019 symbolP = colon (name); 2020 S_SET_STORAGE_CLASS (symbolP, C_STATLAB); 2021 2022 *input_line_pointer = c; 2023 demand_empty_rest_of_line (); 2024 } 2025 2026 /* .mmregs 2027 Install all memory-mapped register names into the symbol table as 2028 absolute local symbols. */ 2029 2030 static void 2031 tic54x_mmregs (int ignored ATTRIBUTE_UNUSED) 2032 { 2033 symbol *sym; 2034 2035 ILLEGAL_WITHIN_STRUCT (); 2036 2037 for (sym = (symbol *) mmregs; sym->name; sym++) 2038 { 2039 symbolS *symbolP = symbol_new (sym->name, absolute_section, 2040 (valueT) sym->value, &zero_address_frag); 2041 SF_SET_LOCAL (symbolP); 2042 symbol_table_insert (symbolP); 2043 } 2044 } 2045 2046 /* .loop [count] 2047 Count defaults to 1024. */ 2048 2049 static void 2050 tic54x_loop (int count) 2051 { 2052 ILLEGAL_WITHIN_STRUCT (); 2053 2054 SKIP_WHITESPACE (); 2055 if (!is_end_of_line[(int) *input_line_pointer]) 2056 count = get_absolute_expression (); 2057 2058 do_repeat (count, "LOOP", "ENDLOOP"); 2059 } 2060 2061 /* Normally, endloop gets eaten by the preceding loop. */ 2062 2063 static void 2064 tic54x_endloop (int ignore ATTRIBUTE_UNUSED) 2065 { 2066 as_bad (_("ENDLOOP without corresponding LOOP")); 2067 ignore_rest_of_line (); 2068 } 2069 2070 /* .break [condition]. */ 2071 2072 static void 2073 tic54x_break (int ignore ATTRIBUTE_UNUSED) 2074 { 2075 int cond = 1; 2076 2077 ILLEGAL_WITHIN_STRUCT (); 2078 2079 SKIP_WHITESPACE (); 2080 if (!is_end_of_line[(int) *input_line_pointer]) 2081 cond = get_absolute_expression (); 2082 2083 if (cond) 2084 end_repeat (substitution_line ? 1 : 0); 2085 } 2086 2087 static void 2088 set_address_mode (int mode) 2089 { 2090 amode = mode; 2091 if (mode == far_mode) 2092 { 2093 symbolS *symbolP = symbol_new ("__allow_far", absolute_section, 2094 (valueT) 1, &zero_address_frag); 2095 SF_SET_LOCAL (symbolP); 2096 symbol_table_insert (symbolP); 2097 } 2098 } 2099 2100 static int address_mode_needs_set = 1; 2101 2102 static void 2103 tic54x_address_mode (int mode) 2104 { 2105 if (assembly_begun && amode != (unsigned) mode) 2106 { 2107 as_bad (_("Mixing of normal and extended addressing not supported")); 2108 ignore_rest_of_line (); 2109 return; 2110 } 2111 if (mode == far_mode && cpu != VNONE && cpu != V548 && cpu != V549) 2112 { 2113 as_bad (_("Extended addressing not supported on the specified CPU")); 2114 ignore_rest_of_line (); 2115 return; 2116 } 2117 2118 set_address_mode (mode); 2119 demand_empty_rest_of_line (); 2120 } 2121 2122 /* .sblock "section"|section [,...,"section"|section] 2123 Designate initialized sections for blocking. */ 2124 2125 static void 2126 tic54x_sblock (int ignore ATTRIBUTE_UNUSED) 2127 { 2128 int c = ','; 2129 2130 ILLEGAL_WITHIN_STRUCT (); 2131 2132 while (c == ',') 2133 { 2134 segT seg; 2135 char *name; 2136 2137 if (*input_line_pointer == '"') 2138 { 2139 int len; 2140 2141 name = demand_copy_C_string (&len); 2142 } 2143 else 2144 { 2145 char *section_name = input_line_pointer; 2146 2147 c = get_symbol_end (); 2148 name = xmalloc (strlen (section_name) + 1); 2149 strcpy (name, section_name); 2150 *input_line_pointer = c; 2151 } 2152 2153 seg = bfd_get_section_by_name (stdoutput, name); 2154 if (seg == NULL) 2155 { 2156 as_bad (_("Unrecognized section '%s'"), name); 2157 ignore_rest_of_line (); 2158 return; 2159 } 2160 else if (!tic54x_initialized_section (seg)) 2161 { 2162 as_bad (_(".sblock may be used for initialized sections only")); 2163 ignore_rest_of_line (); 2164 return; 2165 } 2166 seg->flags |= SEC_TIC54X_BLOCK; 2167 2168 c = *input_line_pointer; 2169 if (!is_end_of_line[(int) c]) 2170 ++input_line_pointer; 2171 } 2172 2173 demand_empty_rest_of_line (); 2174 } 2175 2176 /* symbol .set value 2177 symbol .equ value 2178 2179 value must be defined externals; no forward-referencing allowed 2180 symbols assigned with .set/.equ may not be redefined. */ 2181 2182 static void 2183 tic54x_set (int ignore ATTRIBUTE_UNUSED) 2184 { 2185 symbolS *symbolP; 2186 char *name; 2187 2188 ILLEGAL_WITHIN_STRUCT (); 2189 2190 if (!line_label) 2191 { 2192 as_bad (_("Symbol missing for .set/.equ")); 2193 ignore_rest_of_line (); 2194 return; 2195 } 2196 name = xstrdup (S_GET_NAME (line_label)); 2197 line_label = NULL; 2198 if ((symbolP = symbol_find (name)) == NULL 2199 && (symbolP = md_undefined_symbol (name)) == NULL) 2200 { 2201 symbolP = symbol_new (name, absolute_section, 0, &zero_address_frag); 2202 S_SET_STORAGE_CLASS (symbolP, C_STAT); 2203 } 2204 free (name); 2205 S_SET_DATA_TYPE (symbolP, T_INT); 2206 S_SET_SEGMENT (symbolP, absolute_section); 2207 symbol_table_insert (symbolP); 2208 pseudo_set (symbolP); 2209 demand_empty_rest_of_line (); 2210 } 2211 2212 /* .fclist 2213 .fcnolist 2214 List false conditional blocks. */ 2215 2216 static void 2217 tic54x_fclist (int show) 2218 { 2219 if (show) 2220 listing &= ~LISTING_NOCOND; 2221 else 2222 listing |= LISTING_NOCOND; 2223 demand_empty_rest_of_line (); 2224 } 2225 2226 static void 2227 tic54x_sslist (int show) 2228 { 2229 ILLEGAL_WITHIN_STRUCT (); 2230 2231 listing_sslist = show; 2232 } 2233 2234 /* .var SYM[,...,SYMN] 2235 Define a substitution string to be local to a macro. */ 2236 2237 static void 2238 tic54x_var (int ignore ATTRIBUTE_UNUSED) 2239 { 2240 static char empty[] = ""; 2241 char *name; 2242 int c; 2243 2244 ILLEGAL_WITHIN_STRUCT (); 2245 2246 if (macro_level == 0) 2247 { 2248 as_bad (_(".var may only be used within a macro definition")); 2249 ignore_rest_of_line (); 2250 return; 2251 } 2252 do 2253 { 2254 if (!ISALPHA (*input_line_pointer)) 2255 { 2256 as_bad (_("Substitution symbols must begin with a letter")); 2257 ignore_rest_of_line (); 2258 return; 2259 } 2260 name = input_line_pointer; 2261 c = get_symbol_end (); 2262 /* .var symbols start out with a null string. */ 2263 name = strcpy (xmalloc (strlen (name) + 1), name); 2264 hash_insert (subsym_hash[macro_level], name, empty); 2265 *input_line_pointer = c; 2266 if (c == ',') 2267 { 2268 ++input_line_pointer; 2269 if (is_end_of_line[(int) *input_line_pointer]) 2270 c = *input_line_pointer; 2271 } 2272 } 2273 while (c == ','); 2274 2275 demand_empty_rest_of_line (); 2276 } 2277 2278 /* .mlib <macro library filename> 2279 2280 Macro libraries are archived (standard AR-format) text macro definitions 2281 Expand the file and include it. 2282 2283 FIXME need to try the source file directory as well. */ 2284 2285 static void 2286 tic54x_mlib (int ignore ATTRIBUTE_UNUSED) 2287 { 2288 char *filename; 2289 char *path; 2290 int len, i; 2291 bfd *abfd, *mbfd; 2292 2293 ILLEGAL_WITHIN_STRUCT (); 2294 2295 /* Parse the filename. */ 2296 if (*input_line_pointer == '"') 2297 { 2298 if ((filename = demand_copy_C_string (&len)) == NULL) 2299 return; 2300 } 2301 else 2302 { 2303 SKIP_WHITESPACE (); 2304 len = 0; 2305 while (!is_end_of_line[(int) *input_line_pointer] 2306 && !ISSPACE (*input_line_pointer)) 2307 { 2308 obstack_1grow (¬es, *input_line_pointer); 2309 ++input_line_pointer; 2310 ++len; 2311 } 2312 obstack_1grow (¬es, '\0'); 2313 filename = obstack_finish (¬es); 2314 } 2315 demand_empty_rest_of_line (); 2316 2317 tic54x_set_default_include (0); 2318 path = xmalloc ((unsigned long) len + include_dir_maxlen + 5); 2319 2320 for (i = 0; i < include_dir_count; i++) 2321 { 2322 FILE *try; 2323 2324 strcpy (path, include_dirs[i]); 2325 strcat (path, "/"); 2326 strcat (path, filename); 2327 if ((try = fopen (path, "r")) != NULL) 2328 { 2329 fclose (try); 2330 break; 2331 } 2332 } 2333 2334 if (i >= include_dir_count) 2335 { 2336 free (path); 2337 path = filename; 2338 } 2339 2340 /* FIXME: if path is found, malloc'd storage is not freed. Of course, this 2341 happens all over the place, and since the assembler doesn't usually keep 2342 running for a very long time, it really doesn't matter. */ 2343 register_dependency (path); 2344 2345 /* Expand all archive entries to temporary files and include them. */ 2346 abfd = bfd_openr (path, NULL); 2347 if (!abfd) 2348 { 2349 as_bad (_("can't open macro library file '%s' for reading: %s"), 2350 path, bfd_errmsg (bfd_get_error ())); 2351 ignore_rest_of_line (); 2352 return; 2353 } 2354 if (!bfd_check_format (abfd, bfd_archive)) 2355 { 2356 as_bad (_("File '%s' not in macro archive format"), path); 2357 ignore_rest_of_line (); 2358 return; 2359 } 2360 2361 /* Open each BFD as binary (it should be straight ASCII text). */ 2362 for (mbfd = bfd_openr_next_archived_file (abfd, NULL); 2363 mbfd != NULL; mbfd = bfd_openr_next_archived_file (abfd, mbfd)) 2364 { 2365 /* Get a size at least as big as the archive member. */ 2366 bfd_size_type size = bfd_get_size (mbfd); 2367 char *buf = xmalloc (size); 2368 char *fname = tmpnam (NULL); 2369 FILE *ftmp; 2370 2371 /* We're not sure how big it is, but it will be smaller than "size". */ 2372 bfd_bread (buf, size, mbfd); 2373 2374 /* Write to a temporary file, then use s_include to include it 2375 a bit of a hack. */ 2376 ftmp = fopen (fname, "w+b"); 2377 fwrite ((void *) buf, size, 1, ftmp); 2378 if (buf[size - 1] != '\n') 2379 fwrite ("\n", 1, 1, ftmp); 2380 fclose (ftmp); 2381 free (buf); 2382 input_scrub_insert_file (fname); 2383 unlink (fname); 2384 } 2385 } 2386 2387 const pseudo_typeS md_pseudo_table[] = 2388 { 2389 { "algebraic", s_ignore , 0 }, 2390 { "align" , tic54x_align_words , 128 }, 2391 { "ascii" , tic54x_stringer , 'p' }, 2392 { "asciz" , tic54x_stringer , 'P' }, 2393 { "even" , tic54x_align_words , 2 }, 2394 { "asg" , tic54x_asg , 0 }, 2395 { "eval" , tic54x_eval , 0 }, 2396 { "bss" , tic54x_bss , 0 }, 2397 { "byte" , tic54x_cons , 'b' }, 2398 { "ubyte" , tic54x_cons , 'B' }, 2399 { "char" , tic54x_cons , 'c' }, 2400 { "uchar" , tic54x_cons , 'C' }, 2401 { "clink" , tic54x_clink , 0 }, 2402 { "c_mode" , tic54x_address_mode , c_mode }, 2403 { "copy" , tic54x_include , 'c' }, 2404 { "include" , tic54x_include , 'i' }, 2405 { "data" , tic54x_sect , 'd' }, 2406 { "double" , tic54x_float_cons , 'd' }, 2407 { "ldouble" , tic54x_float_cons , 'l' }, 2408 { "drlist" , s_ignore , 0 }, 2409 { "drnolist" , s_ignore , 0 }, 2410 { "emsg" , tic54x_message , 'e' }, 2411 { "mmsg" , tic54x_message , 'm' }, 2412 { "wmsg" , tic54x_message , 'w' }, 2413 { "far_mode" , tic54x_address_mode , far_mode }, 2414 { "fclist" , tic54x_fclist , 1 }, 2415 { "fcnolist" , tic54x_fclist , 0 }, 2416 { "field" , tic54x_field , -1 }, 2417 { "float" , tic54x_float_cons , 'f' }, 2418 { "xfloat" , tic54x_float_cons , 'x' }, 2419 { "global" , tic54x_global , 'g' }, 2420 { "def" , tic54x_global , 'd' }, 2421 { "ref" , tic54x_global , 'r' }, 2422 { "half" , tic54x_cons , 'h' }, 2423 { "uhalf" , tic54x_cons , 'H' }, 2424 { "short" , tic54x_cons , 's' }, 2425 { "ushort" , tic54x_cons , 'S' }, 2426 { "if" , s_if , (int) O_ne }, 2427 { "elseif" , s_elseif , (int) O_ne }, 2428 { "else" , s_else , 0 }, 2429 { "endif" , s_endif , 0 }, 2430 { "int" , tic54x_cons , 'i' }, 2431 { "uint" , tic54x_cons , 'I' }, 2432 { "word" , tic54x_cons , 'w' }, 2433 { "uword" , tic54x_cons , 'W' }, 2434 { "label" , tic54x_label , 0 }, /* Loadtime 2435 address. */ 2436 { "length" , s_ignore , 0 }, 2437 { "width" , s_ignore , 0 }, 2438 { "long" , tic54x_cons , 'l' }, 2439 { "ulong" , tic54x_cons , 'L' }, 2440 { "xlong" , tic54x_cons , 'x' }, 2441 { "loop" , tic54x_loop , 1024 }, 2442 { "break" , tic54x_break , 0 }, 2443 { "endloop" , tic54x_endloop , 0 }, 2444 { "mlib" , tic54x_mlib , 0 }, 2445 { "mlist" , s_ignore , 0 }, 2446 { "mnolist" , s_ignore , 0 }, 2447 { "mmregs" , tic54x_mmregs , 0 }, 2448 { "newblock" , tic54x_clear_local_labels, 0 }, 2449 { "option" , s_ignore , 0 }, 2450 { "p2align" , tic54x_p2align , 0 }, 2451 { "sblock" , tic54x_sblock , 0 }, 2452 { "sect" , tic54x_sect , '*' }, 2453 { "set" , tic54x_set , 0 }, 2454 { "equ" , tic54x_set , 0 }, 2455 { "space" , tic54x_space , 0 }, 2456 { "bes" , tic54x_space , 1 }, 2457 { "sslist" , tic54x_sslist , 1 }, 2458 { "ssnolist" , tic54x_sslist , 0 }, 2459 { "string" , tic54x_stringer , 's' }, 2460 { "pstring" , tic54x_stringer , 'p' }, 2461 { "struct" , tic54x_struct , 0 }, 2462 { "tag" , tic54x_tag , 0 }, 2463 { "endstruct", tic54x_endstruct , 0 }, 2464 { "tab" , s_ignore , 0 }, 2465 { "text" , tic54x_sect , 't' }, 2466 { "union" , tic54x_struct , 1 }, 2467 { "endunion" , tic54x_endstruct , 1 }, 2468 { "usect" , tic54x_usect , 0 }, 2469 { "var" , tic54x_var , 0 }, 2470 { "version" , tic54x_version , 0 }, 2471 {0 , 0 , 0 } 2472 }; 2473 2474 int 2475 md_parse_option (int c, char *arg) 2476 { 2477 switch (c) 2478 { 2479 default: 2480 return 0; 2481 case OPTION_COFF_VERSION: 2482 { 2483 int version = atoi (arg); 2484 2485 if (version != 0 && version != 1 && version != 2) 2486 as_fatal (_("Bad COFF version '%s'"), arg); 2487 /* FIXME -- not yet implemented. */ 2488 break; 2489 } 2490 case OPTION_CPU_VERSION: 2491 { 2492 cpu = lookup_version (arg); 2493 cpu_needs_set = 1; 2494 if (cpu == VNONE) 2495 as_fatal (_("Bad CPU version '%s'"), arg); 2496 break; 2497 } 2498 case OPTION_ADDRESS_MODE: 2499 amode = far_mode; 2500 address_mode_needs_set = 1; 2501 break; 2502 case OPTION_STDERR_TO_FILE: 2503 { 2504 char *filename = arg; 2505 FILE *fp = fopen (filename, "w+"); 2506 2507 if (fp == NULL) 2508 as_fatal (_("Can't redirect stderr to the file '%s'"), filename); 2509 fclose (fp); 2510 if ((fp = freopen (filename, "w+", stderr)) == NULL) 2511 as_fatal (_("Can't redirect stderr to the file '%s'"), filename); 2512 break; 2513 } 2514 } 2515 2516 return 1; 2517 } 2518 2519 /* Create a "local" substitution string hash table for a new macro level 2520 Some docs imply that macros have to use .newblock in order to be able 2521 to re-use a local label. We effectively do an automatic .newblock by 2522 deleting the local label hash between macro invocations. */ 2523 2524 void 2525 tic54x_macro_start (void) 2526 { 2527 ++macro_level; 2528 subsym_hash[macro_level] = hash_new (); 2529 local_label_hash[macro_level] = hash_new (); 2530 } 2531 2532 void 2533 tic54x_macro_info (const macro_entry *macro) 2534 { 2535 const formal_entry *entry; 2536 2537 /* Put the formal args into the substitution symbol table. */ 2538 for (entry = macro->formals; entry; entry = entry->next) 2539 { 2540 char *name = strncpy (xmalloc (entry->name.len + 1), 2541 entry->name.ptr, entry->name.len); 2542 char *value = strncpy (xmalloc (entry->actual.len + 1), 2543 entry->actual.ptr, entry->actual.len); 2544 2545 name[entry->name.len] = '\0'; 2546 value[entry->actual.len] = '\0'; 2547 hash_insert (subsym_hash[macro_level], name, value); 2548 } 2549 } 2550 2551 /* Get rid of this macro's .var's, arguments, and local labels. */ 2552 2553 void 2554 tic54x_macro_end (void) 2555 { 2556 hash_die (subsym_hash[macro_level]); 2557 subsym_hash[macro_level] = NULL; 2558 hash_die (local_label_hash[macro_level]); 2559 local_label_hash[macro_level] = NULL; 2560 --macro_level; 2561 } 2562 2563 static int 2564 subsym_symlen (char *a, char *ignore ATTRIBUTE_UNUSED) 2565 { 2566 return strlen (a); 2567 } 2568 2569 /* Compare symbol A to string B. */ 2570 2571 static int 2572 subsym_symcmp (char *a, char *b) 2573 { 2574 return strcmp (a, b); 2575 } 2576 2577 /* Return the index of the first occurrence of B in A, or zero if none 2578 assumes b is an integer char value as a string. Index is one-based. */ 2579 2580 static int 2581 subsym_firstch (char *a, char *b) 2582 { 2583 int val = atoi (b); 2584 char *tmp = strchr (a, val); 2585 2586 return tmp ? tmp - a + 1 : 0; 2587 } 2588 2589 /* Similar to firstch, but returns index of last occurrence of B in A. */ 2590 2591 static int 2592 subsym_lastch (char *a, char *b) 2593 { 2594 int val = atoi (b); 2595 char *tmp = strrchr (a, val); 2596 2597 return tmp ? tmp - a + 1 : 0; 2598 } 2599 2600 /* Returns 1 if string A is defined in the symbol table (NOT the substitution 2601 symbol table). */ 2602 2603 static int 2604 subsym_isdefed (char *a, char *ignore ATTRIBUTE_UNUSED) 2605 { 2606 symbolS *symbolP = symbol_find (a); 2607 2608 return symbolP != NULL; 2609 } 2610 2611 /* Assign first member of comma-separated list B (e.g. "1,2,3") to the symbol 2612 A, or zero if B is a null string. Both arguments *must* be substitution 2613 symbols, unsubstituted. */ 2614 2615 static int 2616 subsym_ismember (char *sym, char *list) 2617 { 2618 char *elem, *ptr, *listv; 2619 2620 if (!list) 2621 return 0; 2622 2623 listv = subsym_lookup (list, macro_level); 2624 if (!listv) 2625 { 2626 as_bad (_("Undefined substitution symbol '%s'"), list); 2627 ignore_rest_of_line (); 2628 return 0; 2629 } 2630 2631 ptr = elem = xmalloc (strlen (listv) + 1); 2632 strcpy (elem, listv); 2633 while (*ptr && *ptr != ',') 2634 ++ptr; 2635 *ptr++ = 0; 2636 2637 subsym_create_or_replace (sym, elem); 2638 2639 /* Reassign the list. */ 2640 subsym_create_or_replace (list, ptr); 2641 2642 /* Assume this value, docs aren't clear. */ 2643 return *list != 0; 2644 } 2645 2646 /* Return zero if not a constant; otherwise: 2647 1 if binary 2648 2 if octal 2649 3 if hexadecimal 2650 4 if character 2651 5 if decimal. */ 2652 2653 static int 2654 subsym_iscons (char *a, char *ignore ATTRIBUTE_UNUSED) 2655 { 2656 expressionS expn; 2657 2658 parse_expression (a, &expn); 2659 2660 if (expn.X_op == O_constant) 2661 { 2662 int len = strlen (a); 2663 2664 switch (TOUPPER (a[len - 1])) 2665 { 2666 case 'B': 2667 return 1; 2668 case 'Q': 2669 return 2; 2670 case 'H': 2671 return 3; 2672 case '\'': 2673 return 4; 2674 default: 2675 break; 2676 } 2677 /* No suffix; either octal, hex, or decimal. */ 2678 if (*a == '0' && len > 1) 2679 { 2680 if (TOUPPER (a[1]) == 'X') 2681 return 3; 2682 return 2; 2683 } 2684 return 5; 2685 } 2686 2687 return 0; 2688 } 2689 2690 /* Return 1 if A is a valid symbol name. Expects string input. */ 2691 2692 static int 2693 subsym_isname (char *a, char *ignore ATTRIBUTE_UNUSED) 2694 { 2695 if (!is_name_beginner (*a)) 2696 return 0; 2697 while (*a) 2698 { 2699 if (!is_part_of_name (*a)) 2700 return 0; 2701 ++a; 2702 } 2703 return 1; 2704 } 2705 2706 /* Return whether the string is a register; accepts ar0-7, unless .mmregs has 2707 been seen; if so, recognize any memory-mapped register. 2708 Note this does not recognize "A" or "B" accumulators. */ 2709 2710 static int 2711 subsym_isreg (char *a, char *ignore ATTRIBUTE_UNUSED) 2712 { 2713 if (hash_find (reg_hash, a)) 2714 return 1; 2715 if (hash_find (mmreg_hash, a)) 2716 return 1; 2717 return 0; 2718 } 2719 2720 /* Return the structure size, given the stag. */ 2721 2722 static int 2723 subsym_structsz (char *name, char *ignore ATTRIBUTE_UNUSED) 2724 { 2725 struct stag *stag = (struct stag *) hash_find (stag_hash, name); 2726 2727 if (stag) 2728 return stag->size; 2729 2730 return 0; 2731 } 2732 2733 /* If anybody actually uses this, they can fix it :) 2734 FIXME I'm not sure what the "reference point" of a structure is. It might 2735 be either the initial offset given .struct, or it may be the offset of the 2736 structure within another structure, or it might be something else 2737 altogether. since the TI assembler doesn't seem to ever do anything but 2738 return zero, we punt and return zero. */ 2739 2740 static int 2741 subsym_structacc (char *stag_name ATTRIBUTE_UNUSED, 2742 char *ignore ATTRIBUTE_UNUSED) 2743 { 2744 return 0; 2745 } 2746 2747 static float 2748 math_ceil (float arg1, float ignore ATTRIBUTE_UNUSED) 2749 { 2750 return (float) ceil (arg1); 2751 } 2752 2753 static float 2754 math_cvi (float arg1, float ignore ATTRIBUTE_UNUSED) 2755 { 2756 return (int) arg1; 2757 } 2758 2759 static float 2760 math_floor (float arg1, float ignore ATTRIBUTE_UNUSED) 2761 { 2762 return (float) floor (arg1); 2763 } 2764 2765 static float 2766 math_fmod (float arg1, float arg2) 2767 { 2768 return (int) arg1 % (int) arg2; 2769 } 2770 2771 static float 2772 math_int (float arg1, float ignore ATTRIBUTE_UNUSED) 2773 { 2774 return ((float) ((int) arg1)) == arg1; 2775 } 2776 2777 static float 2778 math_round (float arg1, float ignore ATTRIBUTE_UNUSED) 2779 { 2780 return arg1 > 0 ? (int) (arg1 + 0.5) : (int) (arg1 - 0.5); 2781 } 2782 2783 static float 2784 math_sgn (float arg1, float ignore ATTRIBUTE_UNUSED) 2785 { 2786 return (arg1 < 0) ? -1 : (arg1 ? 1 : 0); 2787 } 2788 2789 static float 2790 math_trunc (float arg1, float ignore ATTRIBUTE_UNUSED) 2791 { 2792 return (int) arg1; 2793 } 2794 2795 static float 2796 math_acos (float arg1, float ignore ATTRIBUTE_UNUSED) 2797 { 2798 return (float) acos (arg1); 2799 } 2800 2801 static float 2802 math_asin (float arg1, float ignore ATTRIBUTE_UNUSED) 2803 { 2804 return (float) asin (arg1); 2805 } 2806 2807 static float 2808 math_atan (float arg1, float ignore ATTRIBUTE_UNUSED) 2809 { 2810 return (float) atan (arg1); 2811 } 2812 2813 static float 2814 math_atan2 (float arg1, float arg2) 2815 { 2816 return (float) atan2 (arg1, arg2); 2817 } 2818 2819 static float 2820 math_cosh (float arg1, float ignore ATTRIBUTE_UNUSED) 2821 { 2822 return (float) cosh (arg1); 2823 } 2824 2825 static float 2826 math_cos (float arg1, float ignore ATTRIBUTE_UNUSED) 2827 { 2828 return (float) cos (arg1); 2829 } 2830 2831 static float 2832 math_cvf (float arg1, float ignore ATTRIBUTE_UNUSED) 2833 { 2834 return (float) arg1; 2835 } 2836 2837 static float 2838 math_exp (float arg1, float ignore ATTRIBUTE_UNUSED) 2839 { 2840 return (float) exp (arg1); 2841 } 2842 2843 static float 2844 math_fabs (float arg1, float ignore ATTRIBUTE_UNUSED) 2845 { 2846 return (float) fabs (arg1); 2847 } 2848 2849 /* expr1 * 2^expr2. */ 2850 2851 static float 2852 math_ldexp (float arg1, float arg2) 2853 { 2854 return arg1 * (float) pow (2.0, arg2); 2855 } 2856 2857 static float 2858 math_log10 (float arg1, float ignore ATTRIBUTE_UNUSED) 2859 { 2860 return (float) log10 (arg1); 2861 } 2862 2863 static float 2864 math_log (float arg1, float ignore ATTRIBUTE_UNUSED) 2865 { 2866 return (float) log (arg1); 2867 } 2868 2869 static float 2870 math_max (float arg1, float arg2) 2871 { 2872 return (arg1 > arg2) ? arg1 : arg2; 2873 } 2874 2875 static float 2876 math_min (float arg1, float arg2) 2877 { 2878 return (arg1 < arg2) ? arg1 : arg2; 2879 } 2880 2881 static float 2882 math_pow (float arg1, float arg2) 2883 { 2884 return (float) pow (arg1, arg2); 2885 } 2886 2887 static float 2888 math_sin (float arg1, float ignore ATTRIBUTE_UNUSED) 2889 { 2890 return (float) sin (arg1); 2891 } 2892 2893 static float 2894 math_sinh (float arg1, float ignore ATTRIBUTE_UNUSED) 2895 { 2896 return (float) sinh (arg1); 2897 } 2898 2899 static float 2900 math_sqrt (float arg1, float ignore ATTRIBUTE_UNUSED) 2901 { 2902 return (float) sqrt (arg1); 2903 } 2904 2905 static float 2906 math_tan (float arg1, float ignore ATTRIBUTE_UNUSED) 2907 { 2908 return (float) tan (arg1); 2909 } 2910 2911 static float 2912 math_tanh (float arg1, float ignore ATTRIBUTE_UNUSED) 2913 { 2914 return (float) tanh (arg1); 2915 } 2916 2917 /* Built-in substitution symbol functions and math functions. */ 2918 typedef struct 2919 { 2920 char *name; 2921 int (*proc) (char *, char *); 2922 int nargs; 2923 } subsym_proc_entry; 2924 2925 static const subsym_proc_entry subsym_procs[] = 2926 { 2927 /* Assembler built-in string substitution functions. */ 2928 { "$symlen", subsym_symlen, 1, }, 2929 { "$symcmp", subsym_symcmp, 2, }, 2930 { "$firstch", subsym_firstch, 2, }, 2931 { "$lastch", subsym_lastch, 2, }, 2932 { "$isdefed", subsym_isdefed, 1, }, 2933 { "$ismember", subsym_ismember, 2, }, 2934 { "$iscons", subsym_iscons, 1, }, 2935 { "$isname", subsym_isname, 1, }, 2936 { "$isreg", subsym_isreg, 1, }, 2937 { "$structsz", subsym_structsz, 1, }, 2938 { "$structacc", subsym_structacc, 1, }, 2939 { NULL, NULL, 0 }, 2940 }; 2941 2942 typedef struct 2943 { 2944 char *name; 2945 float (*proc) (float, float); 2946 int nargs; 2947 int int_return; 2948 } math_proc_entry; 2949 2950 static const math_proc_entry math_procs[] = 2951 { 2952 /* Integer-returning built-in math functions. */ 2953 { "$cvi", math_cvi, 1, 1 }, 2954 { "$int", math_int, 1, 1 }, 2955 { "$sgn", math_sgn, 1, 1 }, 2956 2957 /* Float-returning built-in math functions. */ 2958 { "$acos", math_acos, 1, 0 }, 2959 { "$asin", math_asin, 1, 0 }, 2960 { "$atan", math_atan, 1, 0 }, 2961 { "$atan2", math_atan2, 2, 0 }, 2962 { "$ceil", math_ceil, 1, 0 }, 2963 { "$cosh", math_cosh, 1, 0 }, 2964 { "$cos", math_cos, 1, 0 }, 2965 { "$cvf", math_cvf, 1, 0 }, 2966 { "$exp", math_exp, 1, 0 }, 2967 { "$fabs", math_fabs, 1, 0 }, 2968 { "$floor", math_floor, 1, 0 }, 2969 { "$fmod", math_fmod, 2, 0 }, 2970 { "$ldexp", math_ldexp, 2, 0 }, 2971 { "$log10", math_log10, 1, 0 }, 2972 { "$log", math_log, 1, 0 }, 2973 { "$max", math_max, 2, 0 }, 2974 { "$min", math_min, 2, 0 }, 2975 { "$pow", math_pow, 2, 0 }, 2976 { "$round", math_round, 1, 0 }, 2977 { "$sin", math_sin, 1, 0 }, 2978 { "$sinh", math_sinh, 1, 0 }, 2979 { "$sqrt", math_sqrt, 1, 0 }, 2980 { "$tan", math_tan, 1, 0 }, 2981 { "$tanh", math_tanh, 1, 0 }, 2982 { "$trunc", math_trunc, 1, 0 }, 2983 { NULL, NULL, 0, 0 }, 2984 }; 2985 2986 void 2987 md_begin (void) 2988 { 2989 insn_template *tm; 2990 symbol *sym; 2991 const subsym_proc_entry *subsym_proc; 2992 const math_proc_entry *math_proc; 2993 const char *hash_err; 2994 char **symname; 2995 char *TIC54X_DIR = getenv ("TIC54X_DIR"); 2996 char *A_DIR = TIC54X_DIR ? TIC54X_DIR : getenv ("A_DIR"); 2997 2998 local_label_id = 0; 2999 3000 /* Look for A_DIR and add it to the include list. */ 3001 if (A_DIR != NULL) 3002 { 3003 char *tmp = xstrdup (A_DIR); 3004 3005 do 3006 { 3007 char *next = strchr (tmp, ';'); 3008 3009 if (next) 3010 *next++ = '\0'; 3011 add_include_dir (tmp); 3012 tmp = next; 3013 } 3014 while (tmp != NULL); 3015 } 3016 3017 op_hash = hash_new (); 3018 for (tm = (insn_template *) tic54x_optab; tm->name; tm++) 3019 { 3020 if (hash_find (op_hash, tm->name)) 3021 continue; 3022 hash_err = hash_insert (op_hash, tm->name, (char *) tm); 3023 if (hash_err) 3024 as_fatal ("Internal Error: Can't hash %s: %s", 3025 tm->name, hash_err); 3026 } 3027 parop_hash = hash_new (); 3028 for (tm = (insn_template *) tic54x_paroptab; tm->name; tm++) 3029 { 3030 if (hash_find (parop_hash, tm->name)) 3031 continue; 3032 hash_err = hash_insert (parop_hash, tm->name, (char *) tm); 3033 if (hash_err) 3034 as_fatal ("Internal Error: Can't hash %s: %s", 3035 tm->name, hash_err); 3036 } 3037 reg_hash = hash_new (); 3038 for (sym = (symbol *) regs; sym->name; sym++) 3039 { 3040 /* Add basic registers to the symbol table. */ 3041 symbolS *symbolP = symbol_new (sym->name, absolute_section, 3042 (valueT) sym->value, &zero_address_frag); 3043 SF_SET_LOCAL (symbolP); 3044 symbol_table_insert (symbolP); 3045 hash_err = hash_insert (reg_hash, sym->name, (char *) sym); 3046 } 3047 for (sym = (symbol *) mmregs; sym->name; sym++) 3048 hash_err = hash_insert (reg_hash, sym->name, (char *) sym); 3049 mmreg_hash = hash_new (); 3050 for (sym = (symbol *) mmregs; sym->name; sym++) 3051 hash_err = hash_insert (mmreg_hash, sym->name, (char *) sym); 3052 3053 cc_hash = hash_new (); 3054 for (sym = (symbol *) condition_codes; sym->name; sym++) 3055 hash_err = hash_insert (cc_hash, sym->name, (char *) sym); 3056 3057 cc2_hash = hash_new (); 3058 for (sym = (symbol *) cc2_codes; sym->name; sym++) 3059 hash_err = hash_insert (cc2_hash, sym->name, (char *) sym); 3060 3061 cc3_hash = hash_new (); 3062 for (sym = (symbol *) cc3_codes; sym->name; sym++) 3063 hash_err = hash_insert (cc3_hash, sym->name, (char *) sym); 3064 3065 sbit_hash = hash_new (); 3066 for (sym = (symbol *) status_bits; sym->name; sym++) 3067 hash_err = hash_insert (sbit_hash, sym->name, (char *) sym); 3068 3069 misc_symbol_hash = hash_new (); 3070 for (symname = (char **) misc_symbols; *symname; symname++) 3071 hash_err = hash_insert (misc_symbol_hash, *symname, *symname); 3072 3073 /* Only the base substitution table and local label table are initialized; 3074 the others (for local macro substitution) get instantiated as needed. */ 3075 local_label_hash[0] = hash_new (); 3076 subsym_hash[0] = hash_new (); 3077 for (subsym_proc = subsym_procs; subsym_proc->name; subsym_proc++) 3078 hash_err = hash_insert (subsym_hash[0], subsym_proc->name, 3079 (char *) subsym_proc); 3080 3081 math_hash = hash_new (); 3082 for (math_proc = math_procs; math_proc->name; math_proc++) 3083 { 3084 /* Insert into the main subsym hash for recognition; insert into 3085 the math hash to actually store information. */ 3086 hash_err = hash_insert (subsym_hash[0], math_proc->name, 3087 (char *) math_proc); 3088 hash_err = hash_insert (math_hash, math_proc->name, 3089 (char *) math_proc); 3090 } 3091 subsym_recurse_hash = hash_new (); 3092 stag_hash = hash_new (); 3093 } 3094 3095 static int 3096 is_accumulator (struct opstruct *operand) 3097 { 3098 return strcasecmp (operand->buf, "a") == 0 3099 || strcasecmp (operand->buf, "b") == 0; 3100 } 3101 3102 /* Return the number of operands found, or -1 on error, copying the 3103 operands into the given array and the accompanying expressions into 3104 the next array. */ 3105 3106 static int 3107 get_operands (struct opstruct operands[], char *line) 3108 { 3109 char *lptr = line; 3110 int numexp = 0; 3111 int expecting_operand = 0; 3112 int i; 3113 3114 while (numexp < MAX_OPERANDS && !is_end_of_line[(int) *lptr]) 3115 { 3116 int paren_not_balanced = 0; 3117 char *op_start, *op_end; 3118 3119 while (*lptr && ISSPACE (*lptr)) 3120 ++lptr; 3121 op_start = lptr; 3122 while (paren_not_balanced || *lptr != ',') 3123 { 3124 if (*lptr == '\0') 3125 { 3126 if (paren_not_balanced) 3127 { 3128 as_bad (_("Unbalanced parenthesis in operand %d"), numexp); 3129 return -1; 3130 } 3131 else 3132 break; 3133 } 3134 if (*lptr == '(') 3135 ++paren_not_balanced; 3136 else if (*lptr == ')') 3137 --paren_not_balanced; 3138 ++lptr; 3139 } 3140 op_end = lptr; 3141 if (op_end != op_start) 3142 { 3143 int len = op_end - op_start; 3144 3145 strncpy (operands[numexp].buf, op_start, len); 3146 operands[numexp].buf[len] = 0; 3147 /* Trim trailing spaces; while the preprocessor gets rid of most, 3148 there are weird usage patterns that can introduce them 3149 (i.e. using strings for macro args). */ 3150 while (len > 0 && ISSPACE (operands[numexp].buf[len - 1])) 3151 operands[numexp].buf[--len] = 0; 3152 lptr = op_end; 3153 ++numexp; 3154 } 3155 else 3156 { 3157 if (expecting_operand || *lptr == ',') 3158 { 3159 as_bad (_("Expecting operand after ','")); 3160 return -1; 3161 } 3162 } 3163 if (*lptr == ',') 3164 { 3165 if (*++lptr == '\0') 3166 { 3167 as_bad (_("Expecting operand after ','")); 3168 return -1; 3169 } 3170 expecting_operand = 1; 3171 } 3172 } 3173 3174 while (*lptr && ISSPACE (*lptr++)) 3175 ; 3176 if (!is_end_of_line[(int) *lptr]) 3177 { 3178 as_bad (_("Extra junk on line")); 3179 return -1; 3180 } 3181 3182 /* OK, now parse them into expressions. */ 3183 for (i = 0; i < numexp; i++) 3184 { 3185 memset (&operands[i].exp, 0, sizeof (operands[i].exp)); 3186 if (operands[i].buf[0] == '#') 3187 { 3188 /* Immediate. */ 3189 parse_expression (operands[i].buf + 1, &operands[i].exp); 3190 } 3191 else if (operands[i].buf[0] == '@') 3192 { 3193 /* Direct notation. */ 3194 parse_expression (operands[i].buf + 1, &operands[i].exp); 3195 } 3196 else if (operands[i].buf[0] == '*') 3197 { 3198 /* Indirect. */ 3199 char *paren = strchr (operands[i].buf, '('); 3200 3201 /* Allow immediate syntax in the inner expression. */ 3202 if (paren && paren[1] == '#') 3203 *++paren = '('; 3204 3205 /* Pull out the lk expression or SP offset, if present. */ 3206 if (paren != NULL) 3207 { 3208 int len = strlen (paren); 3209 char *end = paren + len; 3210 int c; 3211 3212 while (end[-1] != ')') 3213 if (--end <= paren) 3214 { 3215 as_bad (_("Badly formed address expression")); 3216 return -1; 3217 } 3218 c = *end; 3219 *end = '\0'; 3220 parse_expression (paren, &operands[i].exp); 3221 *end = c; 3222 } 3223 else 3224 operands[i].exp.X_op = O_absent; 3225 } 3226 else 3227 parse_expression (operands[i].buf, &operands[i].exp); 3228 } 3229 3230 return numexp; 3231 } 3232 3233 /* Predicates for different operand types. */ 3234 3235 static int 3236 is_immediate (struct opstruct *operand) 3237 { 3238 return *operand->buf == '#'; 3239 } 3240 3241 /* This is distinguished from immediate because some numbers must be constants 3242 and must *not* have the '#' prefix. */ 3243 3244 static int 3245 is_absolute (struct opstruct *operand) 3246 { 3247 return operand->exp.X_op == O_constant && !is_immediate (operand); 3248 } 3249 3250 /* Is this an indirect operand? */ 3251 3252 static int 3253 is_indirect (struct opstruct *operand) 3254 { 3255 return operand->buf[0] == '*'; 3256 } 3257 3258 /* Is this a valid dual-memory operand? */ 3259 3260 static int 3261 is_dual (struct opstruct *operand) 3262 { 3263 if (is_indirect (operand) && strncasecmp (operand->buf, "*ar", 3) == 0) 3264 { 3265 char *tmp = operand->buf + 3; 3266 int arf; 3267 int valid_mod; 3268 3269 arf = *tmp++ - '0'; 3270 /* Only allow *ARx, *ARx-, *ARx+, or *ARx+0%. */ 3271 valid_mod = *tmp == '\0' || 3272 strcasecmp (tmp, "-") == 0 || 3273 strcasecmp (tmp, "+") == 0 || 3274 strcasecmp (tmp, "+0%") == 0; 3275 return arf >= 2 && arf <= 5 && valid_mod; 3276 } 3277 return 0; 3278 } 3279 3280 static int 3281 is_mmreg (struct opstruct *operand) 3282 { 3283 return (is_absolute (operand) 3284 || is_immediate (operand) 3285 || hash_find (mmreg_hash, operand->buf) != 0); 3286 } 3287 3288 static int 3289 is_type (struct opstruct *operand, enum optype type) 3290 { 3291 switch (type) 3292 { 3293 case OP_None: 3294 return operand->buf[0] == 0; 3295 case OP_Xmem: 3296 case OP_Ymem: 3297 return is_dual (operand); 3298 case OP_Sind: 3299 return is_indirect (operand); 3300 case OP_xpmad_ms7: 3301 /* This one *must* be immediate. */ 3302 return is_immediate (operand); 3303 case OP_xpmad: 3304 case OP_pmad: 3305 case OP_PA: 3306 case OP_dmad: 3307 case OP_Lmem: 3308 case OP_MMR: 3309 return 1; 3310 case OP_Smem: 3311 /* Address may be a numeric, indirect, or an expression. */ 3312 return !is_immediate (operand); 3313 case OP_MMRY: 3314 case OP_MMRX: 3315 return is_mmreg (operand); 3316 case OP_SRC: 3317 case OP_SRC1: 3318 case OP_RND: 3319 case OP_DST: 3320 return is_accumulator (operand); 3321 case OP_B: 3322 return is_accumulator (operand) && TOUPPER (operand->buf[0]) == 'B'; 3323 case OP_A: 3324 return is_accumulator (operand) && TOUPPER (operand->buf[0]) == 'A'; 3325 case OP_ARX: 3326 return strncasecmp ("ar", operand->buf, 2) == 0 3327 && ISDIGIT (operand->buf[2]); 3328 case OP_SBIT: 3329 return hash_find (sbit_hash, operand->buf) != 0 || is_absolute (operand); 3330 case OP_CC: 3331 return hash_find (cc_hash, operand->buf) != 0; 3332 case OP_CC2: 3333 return hash_find (cc2_hash, operand->buf) != 0; 3334 case OP_CC3: 3335 return hash_find (cc3_hash, operand->buf) != 0 3336 || is_immediate (operand) || is_absolute (operand); 3337 case OP_16: 3338 return (is_immediate (operand) || is_absolute (operand)) 3339 && operand->exp.X_add_number == 16; 3340 case OP_N: 3341 /* Allow st0 or st1 instead of a numeric. */ 3342 return is_absolute (operand) || is_immediate (operand) || 3343 strcasecmp ("st0", operand->buf) == 0 || 3344 strcasecmp ("st1", operand->buf) == 0; 3345 case OP_12: 3346 case OP_123: 3347 return is_absolute (operand) || is_immediate (operand); 3348 case OP_SHFT: 3349 return (is_immediate (operand) || is_absolute (operand)) 3350 && operand->exp.X_add_number >= 0 && operand->exp.X_add_number < 16; 3351 case OP_SHIFT: 3352 /* Let this one catch out-of-range values. */ 3353 return (is_immediate (operand) || is_absolute (operand)) 3354 && operand->exp.X_add_number != 16; 3355 case OP_BITC: 3356 case OP_031: 3357 case OP_k8: 3358 return is_absolute (operand) || is_immediate (operand); 3359 case OP_k8u: 3360 return is_immediate (operand) 3361 && operand->exp.X_op == O_constant 3362 && operand->exp.X_add_number >= 0 3363 && operand->exp.X_add_number < 256; 3364 case OP_lk: 3365 case OP_lku: 3366 /* Allow anything; assumes opcodes are ordered with Smem operands 3367 versions first. */ 3368 return 1; 3369 case OP_k5: 3370 case OP_k3: 3371 case OP_k9: 3372 /* Just make sure it's an integer; check range later. */ 3373 return is_immediate (operand); 3374 case OP_T: 3375 return strcasecmp ("t", operand->buf) == 0 || 3376 strcasecmp ("treg", operand->buf) == 0; 3377 case OP_TS: 3378 return strcasecmp ("ts", operand->buf) == 0; 3379 case OP_ASM: 3380 return strcasecmp ("asm", operand->buf) == 0; 3381 case OP_TRN: 3382 return strcasecmp ("trn", operand->buf) == 0; 3383 case OP_DP: 3384 return strcasecmp ("dp", operand->buf) == 0; 3385 case OP_ARP: 3386 return strcasecmp ("arp", operand->buf) == 0; 3387 default: 3388 return 0; 3389 } 3390 } 3391 3392 static int 3393 operands_match (tic54x_insn *insn, 3394 struct opstruct *operands, 3395 int opcount, 3396 const enum optype *refoptype, 3397 int minops, 3398 int maxops) 3399 { 3400 int op = 0, refop = 0; 3401 3402 if (opcount == 0 && minops == 0) 3403 return 1; 3404 3405 while (op <= maxops && refop <= maxops) 3406 { 3407 while (!is_type (&operands[op], OPTYPE (refoptype[refop]))) 3408 { 3409 /* Skip an optional template operand if it doesn't agree 3410 with the current operand. */ 3411 if (refoptype[refop] & OPT) 3412 { 3413 ++refop; 3414 --maxops; 3415 if (refop > maxops) 3416 return 0; 3417 } 3418 else 3419 return 0; 3420 } 3421 3422 /* Save the actual operand type for later use. */ 3423 operands[op].type = OPTYPE (refoptype[refop]); 3424 ++refop; 3425 ++op; 3426 /* Have we matched them all yet? */ 3427 if (op == opcount) 3428 { 3429 while (op < maxops) 3430 { 3431 /* If a later operand is *not* optional, no match. */ 3432 if ((refoptype[refop] & OPT) == 0) 3433 return 0; 3434 /* Flag any implicit default OP_DST operands so we know to add 3435 them explicitly when encoding the operand later. */ 3436 if (OPTYPE (refoptype[refop]) == OP_DST) 3437 insn->using_default_dst = 1; 3438 ++refop; 3439 ++op; 3440 } 3441 3442 return 1; 3443 } 3444 } 3445 3446 return 0; 3447 } 3448 3449 /* 16-bit direct memory address 3450 Explicit dmad operands are always in last word of insn (usually second 3451 word, but bumped to third if lk addressing is used) 3452 3453 We allow *(dmad) notation because the TI assembler allows it. 3454 3455 XPC_CODE: 3456 0 for 16-bit addresses 3457 1 for full 23-bit addresses 3458 2 for the upper 7 bits of a 23-bit address (LDX). */ 3459 3460 static int 3461 encode_dmad (tic54x_insn *insn, struct opstruct *operand, int xpc_code) 3462 { 3463 int op = 1 + insn->is_lkaddr; 3464 3465 /* Only allow *(dmad) expressions; all others are invalid. */ 3466 if (is_indirect (operand) && operand->buf[strlen (operand->buf) - 1] != ')') 3467 { 3468 as_bad (_("Invalid dmad syntax '%s'"), operand->buf); 3469 return 0; 3470 } 3471 3472 insn->opcode[op].addr_expr = operand->exp; 3473 3474 if (insn->opcode[op].addr_expr.X_op == O_constant) 3475 { 3476 valueT value = insn->opcode[op].addr_expr.X_add_number; 3477 3478 if (xpc_code == 1) 3479 { 3480 insn->opcode[0].word &= 0xFF80; 3481 insn->opcode[0].word |= (value >> 16) & 0x7F; 3482 insn->opcode[1].word = value & 0xFFFF; 3483 } 3484 else if (xpc_code == 2) 3485 insn->opcode[op].word = (value >> 16) & 0xFFFF; 3486 else 3487 insn->opcode[op].word = value; 3488 } 3489 else 3490 { 3491 /* Do the fixup later; just store the expression. */ 3492 insn->opcode[op].word = 0; 3493 insn->opcode[op].r_nchars = 2; 3494 3495 if (amode == c_mode) 3496 insn->opcode[op].r_type = BFD_RELOC_TIC54X_16_OF_23; 3497 else if (xpc_code == 1) 3498 { 3499 /* This relocation spans two words, so adjust accordingly. */ 3500 insn->opcode[0].addr_expr = operand->exp; 3501 insn->opcode[0].r_type = BFD_RELOC_TIC54X_23; 3502 insn->opcode[0].r_nchars = 4; 3503 insn->opcode[0].unresolved = 1; 3504 /* It's really 2 words, but we want to stop encoding after the 3505 first, since we must encode both words at once. */ 3506 insn->words = 1; 3507 } 3508 else if (xpc_code == 2) 3509 insn->opcode[op].r_type = BFD_RELOC_TIC54X_MS7_OF_23; 3510 else 3511 insn->opcode[op].r_type = BFD_RELOC_TIC54X_16_OF_23; 3512 3513 insn->opcode[op].unresolved = 1; 3514 } 3515 3516 return 1; 3517 } 3518 3519 /* 7-bit direct address encoding. */ 3520 3521 static int 3522 encode_address (tic54x_insn *insn, struct opstruct *operand) 3523 { 3524 /* Assumes that dma addresses are *always* in word 0 of the opcode. */ 3525 insn->opcode[0].addr_expr = operand->exp; 3526 3527 if (operand->exp.X_op == O_constant) 3528 insn->opcode[0].word |= (operand->exp.X_add_number & 0x7F); 3529 else 3530 { 3531 if (operand->exp.X_op == O_register) 3532 as_bad (_("Use the .mmregs directive to use memory-mapped register names such as '%s'"), operand->buf); 3533 /* Do the fixup later; just store the expression. */ 3534 insn->opcode[0].r_nchars = 1; 3535 insn->opcode[0].r_type = BFD_RELOC_TIC54X_PARTLS7; 3536 insn->opcode[0].unresolved = 1; 3537 } 3538 3539 return 1; 3540 } 3541 3542 static int 3543 encode_indirect (tic54x_insn *insn, struct opstruct *operand) 3544 { 3545 int arf; 3546 int mod; 3547 3548 if (insn->is_lkaddr) 3549 { 3550 /* lk addresses always go in the second insn word. */ 3551 mod = ((TOUPPER (operand->buf[1]) == 'A') ? 12 : 3552 (operand->buf[1] == '(') ? 15 : 3553 (strchr (operand->buf, '%') != NULL) ? 14 : 13); 3554 arf = ((mod == 12) ? operand->buf[3] - '0' : 3555 (mod == 15) ? 0 : operand->buf[4] - '0'); 3556 3557 insn->opcode[1].addr_expr = operand->exp; 3558 3559 if (operand->exp.X_op == O_constant) 3560 insn->opcode[1].word = operand->exp.X_add_number; 3561 else 3562 { 3563 insn->opcode[1].word = 0; 3564 insn->opcode[1].r_nchars = 2; 3565 insn->opcode[1].r_type = BFD_RELOC_TIC54X_16_OF_23; 3566 insn->opcode[1].unresolved = 1; 3567 } 3568 } 3569 else if (strncasecmp (operand->buf, "*sp (", 4) == 0) 3570 { 3571 /* Stack offsets look the same as 7-bit direct addressing. */ 3572 return encode_address (insn, operand); 3573 } 3574 else 3575 { 3576 arf = (TOUPPER (operand->buf[1]) == 'A' ? 3577 operand->buf[3] : operand->buf[4]) - '0'; 3578 3579 if (operand->buf[1] == '+') 3580 { 3581 mod = 3; /* *+ARx */ 3582 if (insn->tm->flags & FL_SMR) 3583 as_warn (_("Address mode *+ARx is write-only. " 3584 "Results of reading are undefined.")); 3585 } 3586 else if (operand->buf[4] == '\0') 3587 mod = 0; /* *ARx */ 3588 else if (operand->buf[5] == '\0') 3589 mod = (operand->buf[4] == '-' ? 1 : 2); /* *ARx+ / *ARx- */ 3590 else if (operand->buf[6] == '\0') 3591 { 3592 if (operand->buf[5] == '0') 3593 mod = (operand->buf[4] == '-' ? 5 : 6); /* *ARx+0 / *ARx-0 */ 3594 else 3595 mod = (operand->buf[4] == '-' ? 8 : 10);/* *ARx+% / *ARx-% */ 3596 } 3597 else if (TOUPPER (operand->buf[6]) == 'B') 3598 mod = (operand->buf[4] == '-' ? 4 : 7); /* ARx+0B / *ARx-0B */ 3599 else if (TOUPPER (operand->buf[6]) == '%') 3600 mod = (operand->buf[4] == '-' ? 9 : 11); /* ARx+0% / *ARx - 0% */ 3601 else 3602 { 3603 as_bad (_("Unrecognized indirect address format \"%s\""), 3604 operand->buf); 3605 return 0; 3606 } 3607 } 3608 3609 insn->opcode[0].word |= 0x80 | (mod << 3) | arf; 3610 3611 return 1; 3612 } 3613 3614 static int 3615 encode_integer (tic54x_insn *insn, 3616 struct opstruct *operand, 3617 int which, 3618 int min, 3619 int max, 3620 unsigned short mask) 3621 { 3622 long parse, integer; 3623 3624 insn->opcode[which].addr_expr = operand->exp; 3625 3626 if (operand->exp.X_op == O_constant) 3627 { 3628 parse = operand->exp.X_add_number; 3629 /* Hack -- fixup for 16-bit hex quantities that get converted positive 3630 instead of negative. */ 3631 if ((parse & 0x8000) && min == -32768 && max == 32767) 3632 integer = (short) parse; 3633 else 3634 integer = parse; 3635 3636 if (integer >= min && integer <= max) 3637 { 3638 insn->opcode[which].word |= (integer & mask); 3639 return 1; 3640 } 3641 as_bad (_("Operand '%s' out of range (%d <= x <= %d)"), 3642 operand->buf, min, max); 3643 } 3644 else 3645 { 3646 if (insn->opcode[which].addr_expr.X_op == O_constant) 3647 { 3648 insn->opcode[which].word |= 3649 insn->opcode[which].addr_expr.X_add_number & mask; 3650 } 3651 else 3652 { 3653 /* Do the fixup later; just store the expression. */ 3654 bfd_reloc_code_real_type rtype = 3655 (mask == 0x1FF ? BFD_RELOC_TIC54X_PARTMS9 : 3656 mask == 0xFFFF ? BFD_RELOC_TIC54X_16_OF_23 : 3657 mask == 0x7F ? BFD_RELOC_TIC54X_PARTLS7 : BFD_RELOC_8); 3658 int size = (mask == 0x1FF || mask == 0xFFFF) ? 2 : 1; 3659 3660 if (rtype == BFD_RELOC_8) 3661 as_bad (_("Error in relocation handling")); 3662 3663 insn->opcode[which].r_nchars = size; 3664 insn->opcode[which].r_type = rtype; 3665 insn->opcode[which].unresolved = 1; 3666 } 3667 3668 return 1; 3669 } 3670 3671 return 0; 3672 } 3673 3674 static int 3675 encode_condition (tic54x_insn *insn, struct opstruct *operand) 3676 { 3677 symbol *cc = (symbol *) hash_find (cc_hash, operand->buf); 3678 if (!cc) 3679 { 3680 as_bad (_("Unrecognized condition code \"%s\""), operand->buf); 3681 return 0; 3682 } 3683 #define CC_GROUP 0x40 3684 #define CC_ACC 0x08 3685 #define CATG_A1 0x07 3686 #define CATG_B1 0x30 3687 #define CATG_A2 0x30 3688 #define CATG_B2 0x0C 3689 #define CATG_C2 0x03 3690 /* Disallow group 1 conditions mixed with group 2 conditions 3691 if group 1, allow only one category A and one category B 3692 if group 2, allow only one each of category A, B, and C. */ 3693 if (((insn->opcode[0].word & 0xFF) != 0)) 3694 { 3695 if ((insn->opcode[0].word & CC_GROUP) != (cc->value & CC_GROUP)) 3696 { 3697 as_bad (_("Condition \"%s\" does not match preceding group"), 3698 operand->buf); 3699 return 0; 3700 } 3701 if (insn->opcode[0].word & CC_GROUP) 3702 { 3703 if ((insn->opcode[0].word & CC_ACC) != (cc->value & CC_ACC)) 3704 { 3705 as_bad (_("Condition \"%s\" uses a different accumulator from " 3706 "a preceding condition"), 3707 operand->buf); 3708 return 0; 3709 } 3710 if ((insn->opcode[0].word & CATG_A1) && (cc->value & CATG_A1)) 3711 { 3712 as_bad (_("Only one comparison conditional allowed")); 3713 return 0; 3714 } 3715 if ((insn->opcode[0].word & CATG_B1) && (cc->value & CATG_B1)) 3716 { 3717 as_bad (_("Only one overflow conditional allowed")); 3718 return 0; 3719 } 3720 } 3721 else if ( ((insn->opcode[0].word & CATG_A2) && (cc->value & CATG_A2)) 3722 || ((insn->opcode[0].word & CATG_B2) && (cc->value & CATG_B2)) 3723 || ((insn->opcode[0].word & CATG_C2) && (cc->value & CATG_C2))) 3724 { 3725 as_bad (_("Duplicate %s conditional"), operand->buf); 3726 return 0; 3727 } 3728 } 3729 3730 insn->opcode[0].word |= cc->value; 3731 return 1; 3732 } 3733 3734 static int 3735 encode_cc3 (tic54x_insn *insn, struct opstruct *operand) 3736 { 3737 symbol *cc3 = (symbol *) hash_find (cc3_hash, operand->buf); 3738 int value = cc3 ? cc3->value : operand->exp.X_add_number << 8; 3739 3740 if ((value & 0x0300) != value) 3741 { 3742 as_bad (_("Unrecognized condition code \"%s\""), operand->buf); 3743 return 0; 3744 } 3745 insn->opcode[0].word |= value; 3746 return 1; 3747 } 3748 3749 static int 3750 encode_arx (tic54x_insn *insn, struct opstruct *operand) 3751 { 3752 int arf = strlen (operand->buf) >= 3 ? operand->buf[2] - '0' : -1; 3753 3754 if (strncasecmp ("ar", operand->buf, 2) || arf < 0 || arf > 7) 3755 { 3756 as_bad (_("Invalid auxiliary register (use AR0-AR7)")); 3757 return 0; 3758 } 3759 insn->opcode[0].word |= arf; 3760 return 1; 3761 } 3762 3763 static int 3764 encode_cc2 (tic54x_insn *insn, struct opstruct *operand) 3765 { 3766 symbol *cc2 = (symbol *) hash_find (cc2_hash, operand->buf); 3767 3768 if (!cc2) 3769 { 3770 as_bad (_("Unrecognized condition code \"%s\""), operand->buf); 3771 return 0; 3772 } 3773 insn->opcode[0].word |= cc2->value; 3774 return 1; 3775 } 3776 3777 static int 3778 encode_operand (tic54x_insn *insn, enum optype type, struct opstruct *operand) 3779 { 3780 int ext = (insn->tm->flags & FL_EXT) != 0; 3781 3782 if (type == OP_MMR && operand->exp.X_op != O_constant) 3783 { 3784 /* Disallow long-constant addressing for memory-mapped addressing. */ 3785 if (insn->is_lkaddr) 3786 { 3787 as_bad (_("lk addressing modes are invalid for memory-mapped " 3788 "register addressing")); 3789 return 0; 3790 } 3791 type = OP_Smem; 3792 /* Warn about *+ARx when used with MMR operands. */ 3793 if (strncasecmp (operand->buf, "*+ar", 4) == 0) 3794 { 3795 as_warn (_("Address mode *+ARx is not allowed in memory-mapped " 3796 "register addressing. Resulting behavior is " 3797 "undefined.")); 3798 } 3799 } 3800 3801 switch (type) 3802 { 3803 case OP_None: 3804 return 1; 3805 case OP_dmad: 3806 /* 16-bit immediate value. */ 3807 return encode_dmad (insn, operand, 0); 3808 case OP_SRC: 3809 if (TOUPPER (*operand->buf) == 'B') 3810 { 3811 insn->opcode[ext ? (1 + insn->is_lkaddr) : 0].word |= (1 << 9); 3812 if (insn->using_default_dst) 3813 insn->opcode[ext ? (1 + insn->is_lkaddr) : 0].word |= (1 << 8); 3814 } 3815 return 1; 3816 case OP_RND: 3817 /* Make sure this agrees with the OP_DST operand. */ 3818 if (!((TOUPPER (operand->buf[0]) == 'B') ^ 3819 ((insn->opcode[0].word & (1 << 8)) != 0))) 3820 { 3821 as_bad (_("Destination accumulator for each part of this parallel " 3822 "instruction must be different")); 3823 return 0; 3824 } 3825 return 1; 3826 case OP_SRC1: 3827 case OP_DST: 3828 if (TOUPPER (operand->buf[0]) == 'B') 3829 insn->opcode[ext ? (1 + insn->is_lkaddr) : 0].word |= (1 << 8); 3830 return 1; 3831 case OP_Xmem: 3832 case OP_Ymem: 3833 { 3834 int mod = (operand->buf[4] == '\0' ? 0 : /* *arx */ 3835 operand->buf[4] == '-' ? 1 : /* *arx- */ 3836 operand->buf[5] == '\0' ? 2 : 3); /* *arx+, *arx+0% */ 3837 int arf = operand->buf[3] - '0' - 2; 3838 int code = (mod << 2) | arf; 3839 insn->opcode[0].word |= (code << (type == OP_Xmem ? 4 : 0)); 3840 return 1; 3841 } 3842 case OP_Lmem: 3843 case OP_Smem: 3844 if (!is_indirect (operand)) 3845 return encode_address (insn, operand); 3846 /* Fall through. */ 3847 case OP_Sind: 3848 return encode_indirect (insn, operand); 3849 case OP_xpmad_ms7: 3850 return encode_dmad (insn, operand, 2); 3851 case OP_xpmad: 3852 return encode_dmad (insn, operand, 1); 3853 case OP_PA: 3854 case OP_pmad: 3855 return encode_dmad (insn, operand, 0); 3856 case OP_ARX: 3857 return encode_arx (insn, operand); 3858 case OP_MMRX: 3859 case OP_MMRY: 3860 case OP_MMR: 3861 { 3862 int value = operand->exp.X_add_number; 3863 3864 if (type == OP_MMR) 3865 insn->opcode[0].word |= value; 3866 else 3867 { 3868 if (value < 16 || value > 24) 3869 { 3870 as_bad (_("Memory mapped register \"%s\" out of range"), 3871 operand->buf); 3872 return 0; 3873 } 3874 if (type == OP_MMRX) 3875 insn->opcode[0].word |= (value - 16) << 4; 3876 else 3877 insn->opcode[0].word |= (value - 16); 3878 } 3879 return 1; 3880 } 3881 case OP_B: 3882 case OP_A: 3883 return 1; 3884 case OP_SHFT: 3885 return encode_integer (insn, operand, ext + insn->is_lkaddr, 3886 0, 15, 0xF); 3887 case OP_SHIFT: 3888 return encode_integer (insn, operand, ext + insn->is_lkaddr, 3889 -16, 15, 0x1F); 3890 case OP_lk: 3891 return encode_integer (insn, operand, 1 + insn->is_lkaddr, 3892 -32768, 32767, 0xFFFF); 3893 case OP_CC: 3894 return encode_condition (insn, operand); 3895 case OP_CC2: 3896 return encode_cc2 (insn, operand); 3897 case OP_CC3: 3898 return encode_cc3 (insn, operand); 3899 case OP_BITC: 3900 return encode_integer (insn, operand, 0, 0, 15, 0xF); 3901 case OP_k8: 3902 return encode_integer (insn, operand, 0, -128, 127, 0xFF); 3903 case OP_123: 3904 { 3905 int value = operand->exp.X_add_number; 3906 int code; 3907 if (value < 1 || value > 3) 3908 { 3909 as_bad (_("Invalid operand (use 1, 2, or 3)")); 3910 return 0; 3911 } 3912 code = value == 1 ? 0 : value == 2 ? 0x2 : 0x1; 3913 insn->opcode[0].word |= (code << 8); 3914 return 1; 3915 } 3916 case OP_031: 3917 return encode_integer (insn, operand, 0, 0, 31, 0x1F); 3918 case OP_k8u: 3919 return encode_integer (insn, operand, 0, 0, 255, 0xFF); 3920 case OP_lku: 3921 return encode_integer (insn, operand, 1 + insn->is_lkaddr, 3922 0, 65535, 0xFFFF); 3923 case OP_SBIT: 3924 { 3925 symbol *sbit = (symbol *) hash_find (sbit_hash, operand->buf); 3926 int value = is_absolute (operand) ? 3927 operand->exp.X_add_number : (sbit ? sbit->value : -1); 3928 int reg = 0; 3929 3930 if (insn->opcount == 1) 3931 { 3932 if (!sbit) 3933 { 3934 as_bad (_("A status register or status bit name is required")); 3935 return 0; 3936 } 3937 /* Guess the register based on the status bit; "ovb" is the last 3938 status bit defined for st0. */ 3939 if (sbit > (symbol *) hash_find (sbit_hash, "ovb")) 3940 reg = 1; 3941 } 3942 if (value == -1) 3943 { 3944 as_bad (_("Unrecognized status bit \"%s\""), operand->buf); 3945 return 0; 3946 } 3947 insn->opcode[0].word |= value; 3948 insn->opcode[0].word |= (reg << 9); 3949 return 1; 3950 } 3951 case OP_N: 3952 if (strcasecmp (operand->buf, "st0") == 0 3953 || strcasecmp (operand->buf, "st1") == 0) 3954 { 3955 insn->opcode[0].word |= 3956 ((unsigned short) (operand->buf[2] - '0')) << 9; 3957 return 1; 3958 } 3959 else if (operand->exp.X_op == O_constant 3960 && (operand->exp.X_add_number == 0 3961 || operand->exp.X_add_number == 1)) 3962 { 3963 insn->opcode[0].word |= 3964 ((unsigned short) (operand->exp.X_add_number)) << 9; 3965 return 1; 3966 } 3967 as_bad (_("Invalid status register \"%s\""), operand->buf); 3968 return 0; 3969 case OP_k5: 3970 return encode_integer (insn, operand, 0, -16, 15, 0x1F); 3971 case OP_k3: 3972 return encode_integer (insn, operand, 0, 0, 7, 0x7); 3973 case OP_k9: 3974 return encode_integer (insn, operand, 0, 0, 0x1FF, 0x1FF); 3975 case OP_12: 3976 if (operand->exp.X_add_number != 1 3977 && operand->exp.X_add_number != 2) 3978 { 3979 as_bad (_("Operand \"%s\" out of range (use 1 or 2)"), operand->buf); 3980 return 0; 3981 } 3982 insn->opcode[0].word |= (operand->exp.X_add_number - 1) << 9; 3983 return 1; 3984 case OP_16: 3985 case OP_T: 3986 case OP_TS: 3987 case OP_ASM: 3988 case OP_TRN: 3989 case OP_DP: 3990 case OP_ARP: 3991 /* No encoding necessary. */ 3992 return 1; 3993 default: 3994 return 0; 3995 } 3996 3997 return 1; 3998 } 3999 4000 static void 4001 emit_insn (tic54x_insn *insn) 4002 { 4003 int i; 4004 flagword oldflags = bfd_get_section_flags (stdoutput, now_seg); 4005 flagword flags = oldflags | SEC_CODE; 4006 4007 if (! bfd_set_section_flags (stdoutput, now_seg, flags)) 4008 as_warn (_("error setting flags for \"%s\": %s"), 4009 bfd_section_name (stdoutput, now_seg), 4010 bfd_errmsg (bfd_get_error ())); 4011 4012 for (i = 0; i < insn->words; i++) 4013 { 4014 int size = (insn->opcode[i].unresolved 4015 && insn->opcode[i].r_type == BFD_RELOC_TIC54X_23) ? 4 : 2; 4016 char *p = frag_more (size); 4017 4018 if (size == 2) 4019 md_number_to_chars (p, (valueT) insn->opcode[i].word, 2); 4020 else 4021 md_number_to_chars (p, (valueT) insn->opcode[i].word << 16, 4); 4022 4023 if (insn->opcode[i].unresolved) 4024 fix_new_exp (frag_now, p - frag_now->fr_literal, 4025 insn->opcode[i].r_nchars, &insn->opcode[i].addr_expr, 4026 FALSE, insn->opcode[i].r_type); 4027 } 4028 } 4029 4030 /* Convert the operand strings into appropriate opcode values 4031 return the total number of words used by the instruction. */ 4032 4033 static int 4034 build_insn (tic54x_insn *insn) 4035 { 4036 int i; 4037 4038 /* Only non-parallel instructions support lk addressing. */ 4039 if (!(insn->tm->flags & FL_PAR)) 4040 { 4041 for (i = 0; i < insn->opcount; i++) 4042 { 4043 if ((OPTYPE (insn->operands[i].type) == OP_Smem 4044 || OPTYPE (insn->operands[i].type) == OP_Lmem 4045 || OPTYPE (insn->operands[i].type) == OP_Sind) 4046 && strchr (insn->operands[i].buf, '(') 4047 /* Don't mistake stack-relative addressing for lk addressing. */ 4048 && strncasecmp (insn->operands[i].buf, "*sp (", 4) != 0) 4049 { 4050 insn->is_lkaddr = 1; 4051 insn->lkoperand = i; 4052 break; 4053 } 4054 } 4055 } 4056 insn->words = insn->tm->words + insn->is_lkaddr; 4057 4058 insn->opcode[0].word = insn->tm->opcode; 4059 if (insn->tm->flags & FL_EXT) 4060 insn->opcode[1 + insn->is_lkaddr].word = insn->tm->opcode2; 4061 4062 for (i = 0; i < insn->opcount; i++) 4063 { 4064 enum optype type = insn->operands[i].type; 4065 4066 if (!encode_operand (insn, type, &insn->operands[i])) 4067 return 0; 4068 } 4069 if (insn->tm->flags & FL_PAR) 4070 for (i = 0; i < insn->paropcount; i++) 4071 { 4072 enum optype partype = insn->paroperands[i].type; 4073 4074 if (!encode_operand (insn, partype, &insn->paroperands[i])) 4075 return 0; 4076 } 4077 4078 emit_insn (insn); 4079 4080 return insn->words; 4081 } 4082 4083 static int 4084 optimize_insn (tic54x_insn *insn) 4085 { 4086 /* Optimize some instructions, helping out the brain-dead programmer. */ 4087 #define is_zero(op) ((op).exp.X_op == O_constant && (op).exp.X_add_number == 0) 4088 if (strcasecmp (insn->tm->name, "add") == 0) 4089 { 4090 if (insn->opcount > 1 4091 && is_accumulator (&insn->operands[insn->opcount - 2]) 4092 && is_accumulator (&insn->operands[insn->opcount - 1]) 4093 && strcasecmp (insn->operands[insn->opcount - 2].buf, 4094 insn->operands[insn->opcount - 1].buf) == 0) 4095 { 4096 --insn->opcount; 4097 insn->using_default_dst = 1; 4098 return 1; 4099 } 4100 4101 /* Try to collapse if Xmem and shift count is zero. */ 4102 if ((OPTYPE (insn->tm->operand_types[0]) == OP_Xmem 4103 && OPTYPE (insn->tm->operand_types[1]) == OP_SHFT 4104 && is_zero (insn->operands[1])) 4105 /* Or if Smem, shift is zero or absent, and SRC == DST. */ 4106 || (OPTYPE (insn->tm->operand_types[0]) == OP_Smem 4107 && OPTYPE (insn->tm->operand_types[1]) == OP_SHIFT 4108 && is_type (&insn->operands[1], OP_SHIFT) 4109 && is_zero (insn->operands[1]) && insn->opcount == 3)) 4110 { 4111 insn->operands[1] = insn->operands[2]; 4112 insn->opcount = 2; 4113 return 1; 4114 } 4115 } 4116 else if (strcasecmp (insn->tm->name, "ld") == 0) 4117 { 4118 if (insn->opcount == 3 && insn->operands[0].type != OP_SRC) 4119 { 4120 if ((OPTYPE (insn->tm->operand_types[1]) == OP_SHIFT 4121 || OPTYPE (insn->tm->operand_types[1]) == OP_SHFT) 4122 && is_zero (insn->operands[1]) 4123 && (OPTYPE (insn->tm->operand_types[0]) != OP_lk 4124 || (insn->operands[0].exp.X_op == O_constant 4125 && insn->operands[0].exp.X_add_number <= 255 4126 && insn->operands[0].exp.X_add_number >= 0))) 4127 { 4128 insn->operands[1] = insn->operands[2]; 4129 insn->opcount = 2; 4130 return 1; 4131 } 4132 } 4133 } 4134 else if (strcasecmp (insn->tm->name, "sth") == 0 4135 || strcasecmp (insn->tm->name, "stl") == 0) 4136 { 4137 if ((OPTYPE (insn->tm->operand_types[1]) == OP_SHIFT 4138 || OPTYPE (insn->tm->operand_types[1]) == OP_SHFT) 4139 && is_zero (insn->operands[1])) 4140 { 4141 insn->operands[1] = insn->operands[2]; 4142 insn->opcount = 2; 4143 return 1; 4144 } 4145 } 4146 else if (strcasecmp (insn->tm->name, "sub") == 0) 4147 { 4148 if (insn->opcount > 1 4149 && is_accumulator (&insn->operands[insn->opcount - 2]) 4150 && is_accumulator (&insn->operands[insn->opcount - 1]) 4151 && strcasecmp (insn->operands[insn->opcount - 2].buf, 4152 insn->operands[insn->opcount - 1].buf) == 0) 4153 { 4154 --insn->opcount; 4155 insn->using_default_dst = 1; 4156 return 1; 4157 } 4158 4159 if ( ((OPTYPE (insn->tm->operand_types[0]) == OP_Smem 4160 && OPTYPE (insn->tm->operand_types[1]) == OP_SHIFT) 4161 || (OPTYPE (insn->tm->operand_types[0]) == OP_Xmem 4162 && OPTYPE (insn->tm->operand_types[1]) == OP_SHFT)) 4163 && is_zero (insn->operands[1]) 4164 && insn->opcount == 3) 4165 { 4166 insn->operands[1] = insn->operands[2]; 4167 insn->opcount = 2; 4168 return 1; 4169 } 4170 } 4171 return 0; 4172 } 4173 4174 /* Find a matching template if possible, and get the operand strings. */ 4175 4176 static int 4177 tic54x_parse_insn (tic54x_insn *insn, char *line) 4178 { 4179 insn->tm = (insn_template *) hash_find (op_hash, insn->mnemonic); 4180 if (!insn->tm) 4181 { 4182 as_bad (_("Unrecognized instruction \"%s\""), insn->mnemonic); 4183 return 0; 4184 } 4185 4186 insn->opcount = get_operands (insn->operands, line); 4187 if (insn->opcount < 0) 4188 return 0; 4189 4190 /* Check each variation of operands for this mnemonic. */ 4191 while (insn->tm->name && strcasecmp (insn->tm->name, insn->mnemonic) == 0) 4192 { 4193 if (insn->opcount >= insn->tm->minops 4194 && insn->opcount <= insn->tm->maxops 4195 && operands_match (insn, &insn->operands[0], insn->opcount, 4196 insn->tm->operand_types, 4197 insn->tm->minops, insn->tm->maxops)) 4198 { 4199 /* SUCCESS! now try some optimizations. */ 4200 if (optimize_insn (insn)) 4201 { 4202 insn->tm = (insn_template *) hash_find (op_hash, 4203 insn->mnemonic); 4204 continue; 4205 } 4206 4207 return 1; 4208 } 4209 ++(insn->tm); 4210 } 4211 as_bad (_("Unrecognized operand list '%s' for instruction '%s'"), 4212 line, insn->mnemonic); 4213 return 0; 4214 } 4215 4216 /* We set this in start_line_hook, 'cause if we do a line replacement, we 4217 won't be able to see the next line. */ 4218 static int parallel_on_next_line_hint = 0; 4219 4220 /* See if this is part of a parallel instruction 4221 Look for a subsequent line starting with "||". */ 4222 4223 static int 4224 next_line_shows_parallel (char *next_line) 4225 { 4226 /* Look for the second half. */ 4227 while (ISSPACE (*next_line)) 4228 ++next_line; 4229 4230 return (next_line[0] == PARALLEL_SEPARATOR 4231 && next_line[1] == PARALLEL_SEPARATOR); 4232 } 4233 4234 static int 4235 tic54x_parse_parallel_insn_firstline (tic54x_insn *insn, char *line) 4236 { 4237 insn->tm = (insn_template *) hash_find (parop_hash, insn->mnemonic); 4238 if (!insn->tm) 4239 { 4240 as_bad (_("Unrecognized parallel instruction \"%s\""), 4241 insn->mnemonic); 4242 return 0; 4243 } 4244 4245 while (insn->tm->name && strcasecmp (insn->tm->name, 4246 insn->mnemonic) == 0) 4247 { 4248 insn->opcount = get_operands (insn->operands, line); 4249 if (insn->opcount < 0) 4250 return 0; 4251 if (insn->opcount == 2 4252 && operands_match (insn, &insn->operands[0], insn->opcount, 4253 insn->tm->operand_types, 2, 2)) 4254 { 4255 return 1; 4256 } 4257 ++(insn->tm); 4258 } 4259 /* Didn't find a matching parallel; try for a normal insn. */ 4260 return 0; 4261 } 4262 4263 /* Parse the second line of a two-line parallel instruction. */ 4264 4265 static int 4266 tic54x_parse_parallel_insn_lastline (tic54x_insn *insn, char *line) 4267 { 4268 int valid_mnemonic = 0; 4269 4270 insn->paropcount = get_operands (insn->paroperands, line); 4271 while (insn->tm->name && strcasecmp (insn->tm->name, 4272 insn->mnemonic) == 0) 4273 { 4274 if (strcasecmp (insn->tm->parname, insn->parmnemonic) == 0) 4275 { 4276 valid_mnemonic = 1; 4277 4278 if (insn->paropcount >= insn->tm->minops 4279 && insn->paropcount <= insn->tm->maxops 4280 && operands_match (insn, insn->paroperands, 4281 insn->paropcount, 4282 insn->tm->paroperand_types, 4283 insn->tm->minops, insn->tm->maxops)) 4284 return 1; 4285 } 4286 ++(insn->tm); 4287 } 4288 if (valid_mnemonic) 4289 as_bad (_("Invalid operand (s) for parallel instruction \"%s\""), 4290 insn->parmnemonic); 4291 else 4292 as_bad (_("Unrecognized parallel instruction combination \"%s || %s\""), 4293 insn->mnemonic, insn->parmnemonic); 4294 4295 return 0; 4296 } 4297 4298 /* If quotes found, return copy of line up to closing quote; 4299 otherwise up until terminator. 4300 If it's a string, pass as-is; otherwise attempt substitution symbol 4301 replacement on the value. */ 4302 4303 static char * 4304 subsym_get_arg (char *line, char *terminators, char **str, int nosub) 4305 { 4306 char *ptr = line; 4307 char *endp; 4308 int is_string = *line == '"'; 4309 int is_char = ISDIGIT (*line); 4310 4311 if (is_char) 4312 { 4313 while (ISDIGIT (*ptr)) 4314 ++ptr; 4315 endp = ptr; 4316 *str = xmalloc (ptr - line + 1); 4317 strncpy (*str, line, ptr - line); 4318 (*str)[ptr - line] = 0; 4319 } 4320 else if (is_string) 4321 { 4322 char *savedp = input_line_pointer; 4323 int len; 4324 4325 input_line_pointer = ptr; 4326 *str = demand_copy_C_string (&len); 4327 endp = input_line_pointer; 4328 input_line_pointer = savedp; 4329 4330 /* Do forced substitutions if requested. */ 4331 if (!nosub && **str == ':') 4332 *str = subsym_substitute (*str, 1); 4333 } 4334 else 4335 { 4336 char *term = terminators; 4337 char *value = NULL; 4338 4339 while (*ptr && *ptr != *term) 4340 { 4341 if (!*term) 4342 { 4343 term = terminators; 4344 ++ptr; 4345 } 4346 else 4347 ++term; 4348 } 4349 endp = ptr; 4350 *str = xmalloc (ptr - line + 1); 4351 strncpy (*str, line, ptr - line); 4352 (*str)[ptr - line] = 0; 4353 /* Do simple substitution, if available. */ 4354 if (!nosub && (value = subsym_lookup (*str, macro_level)) != NULL) 4355 *str = value; 4356 } 4357 4358 return endp; 4359 } 4360 4361 /* Replace the given substitution string. 4362 We start at the innermost macro level, so that existing locals remain local 4363 Note: we're treating macro args identically to .var's; I don't know if 4364 that's compatible w/TI's assembler. */ 4365 4366 static void 4367 subsym_create_or_replace (char *name, char *value) 4368 { 4369 int i; 4370 4371 for (i = macro_level; i > 0; i--) 4372 { 4373 if (hash_find (subsym_hash[i], name)) 4374 { 4375 hash_replace (subsym_hash[i], name, value); 4376 return; 4377 } 4378 } 4379 if (hash_find (subsym_hash[0], name)) 4380 hash_replace (subsym_hash[0], name, value); 4381 else 4382 hash_insert (subsym_hash[0], name, value); 4383 } 4384 4385 /* Look up the substitution string replacement for the given symbol. 4386 Start with the innermost macro substitution table given and work 4387 outwards. */ 4388 4389 static char * 4390 subsym_lookup (char *name, int nest_level) 4391 { 4392 char *value = hash_find (subsym_hash[nest_level], name); 4393 4394 if (value || nest_level == 0) 4395 return value; 4396 4397 return subsym_lookup (name, nest_level - 1); 4398 } 4399 4400 /* Do substitution-symbol replacement on the given line (recursively). 4401 return the argument if no substitution was done 4402 4403 Also look for built-in functions ($func (arg)) and local labels. 4404 4405 If FORCED is set, look for forced substitutions of the form ':SYMBOL:'. */ 4406 4407 static char * 4408 subsym_substitute (char *line, int forced) 4409 { 4410 /* For each apparent symbol, see if it's a substitution symbol, and if so, 4411 replace it in the input. */ 4412 char *replacement; /* current replacement for LINE. */ 4413 char *head; /* Start of line. */ 4414 char *ptr; /* Current examination point. */ 4415 int changed = 0; /* Did we make a substitution? */ 4416 int eval_line = 0; /* Is this line a .eval/.asg statement? */ 4417 int eval_symbol = 0; /* Are we in the middle of the symbol for 4418 .eval/.asg? */ 4419 char *eval_end = NULL; 4420 int recurse = 1; 4421 int line_conditional = 0; 4422 char *tmp; 4423 4424 /* Work with a copy of the input line. */ 4425 replacement = xmalloc (strlen (line) + 1); 4426 strcpy (replacement, line); 4427 4428 ptr = head = replacement; 4429 4430 /* Flag lines where we might need to replace a single '=' with two; 4431 GAS uses single '=' to assign macro args values, and possibly other 4432 places, so limit what we replace. */ 4433 if (strstr (line, ".if") 4434 || strstr (line, ".elseif") 4435 || strstr (line, ".break")) 4436 line_conditional = 1; 4437 4438 /* Watch out for .eval, so that we avoid doing substitution on the 4439 symbol being assigned a value. */ 4440 if (strstr (line, ".eval") || strstr (line, ".asg")) 4441 eval_line = 1; 4442 4443 /* If it's a macro definition, don't do substitution on the argument 4444 names. */ 4445 if (strstr (line, ".macro")) 4446 return line; 4447 4448 while (!is_end_of_line[(int) *ptr]) 4449 { 4450 int current_char = *ptr; 4451 4452 /* Need to update this since LINE may have been modified. */ 4453 if (eval_line) 4454 eval_end = strrchr (ptr, ','); 4455 4456 /* Replace triple double quotes with bounding quote/escapes. */ 4457 if (current_char == '"' && ptr[1] == '"' && ptr[2] == '"') 4458 { 4459 ptr[1] = '\\'; 4460 tmp = strstr (ptr + 2, "\"\"\""); 4461 if (tmp) 4462 tmp[0] = '\\'; 4463 changed = 1; 4464 } 4465 4466 /* Replace a single '=' with a '=='; 4467 for compatibility with older code only. */ 4468 if (line_conditional && current_char == '=') 4469 { 4470 if (ptr[1] == '=') 4471 { 4472 ptr += 2; 4473 continue; 4474 } 4475 *ptr++ = '\0'; 4476 tmp = xmalloc (strlen (head) + 2 + strlen (ptr) + 1); 4477 sprintf (tmp, "%s==%s", head, ptr); 4478 /* Continue examining after the '=='. */ 4479 ptr = tmp + strlen (head) + 2; 4480 free (replacement); 4481 head = replacement = tmp; 4482 changed = 1; 4483 } 4484 4485 /* Flag when we've reached the symbol part of .eval/.asg. */ 4486 if (eval_line && ptr >= eval_end) 4487 eval_symbol = 1; 4488 4489 /* For each apparent symbol, see if it's a substitution symbol, and if 4490 so, replace it in the input. */ 4491 if ((forced && current_char == ':') 4492 || (!forced && is_name_beginner (current_char))) 4493 { 4494 char *name; /* Symbol to be replaced. */ 4495 char *savedp = input_line_pointer; 4496 int c; 4497 char *value = NULL; 4498 char *tail; /* Rest of line after symbol. */ 4499 4500 /* Skip the colon. */ 4501 if (forced) 4502 ++ptr; 4503 4504 name = input_line_pointer = ptr; 4505 c = get_symbol_end (); 4506 /* '?' is not normally part of a symbol, but it IS part of a local 4507 label. */ 4508 if (c == '?') 4509 { 4510 *input_line_pointer++ = c; 4511 c = *input_line_pointer; 4512 *input_line_pointer = '\0'; 4513 } 4514 /* Avoid infinite recursion; if a symbol shows up a second time for 4515 substitution, leave it as is. */ 4516 if (hash_find (subsym_recurse_hash, name) == NULL) 4517 value = subsym_lookup (name, macro_level); 4518 else 4519 as_warn (_("%s symbol recursion stopped at " 4520 "second appearance of '%s'"), 4521 forced ? "Forced substitution" : "Substitution", name); 4522 ptr = tail = input_line_pointer; 4523 input_line_pointer = savedp; 4524 4525 /* Check for local labels; replace them with the appropriate 4526 substitution. */ 4527 if ((*name == '$' && ISDIGIT (name[1]) && name[2] == '\0') 4528 || name[strlen (name) - 1] == '?') 4529 { 4530 /* Use an existing identifier for that label if, available, or 4531 create a new, unique identifier. */ 4532 value = hash_find (local_label_hash[macro_level], name); 4533 if (value == NULL) 4534 { 4535 char digit[11]; 4536 char *namecopy = strcpy (xmalloc (strlen (name) + 1), name); 4537 4538 value = strcpy (xmalloc (strlen (name) + sizeof (digit) + 1), 4539 name); 4540 if (*value != '$') 4541 value[strlen (value) - 1] = '\0'; 4542 sprintf (digit, ".%d", local_label_id++); 4543 strcat (value, digit); 4544 hash_insert (local_label_hash[macro_level], namecopy, value); 4545 } 4546 /* Indicate where to continue looking for substitutions. */ 4547 ptr = tail; 4548 } 4549 /* Check for built-in subsym and math functions. */ 4550 else if (value != NULL && *name == '$') 4551 { 4552 subsym_proc_entry *entry = (subsym_proc_entry *) value; 4553 math_proc_entry *math_entry = hash_find (math_hash, name); 4554 char *arg1, *arg2 = NULL; 4555 4556 *ptr = c; 4557 if (entry == NULL) 4558 { 4559 as_bad (_("Unrecognized substitution symbol function")); 4560 break; 4561 } 4562 else if (*ptr != '(') 4563 { 4564 as_bad (_("Missing '(' after substitution symbol function")); 4565 break; 4566 } 4567 ++ptr; 4568 if (math_entry != NULL) 4569 { 4570 float farg1, farg2 = 0; 4571 volatile float fresult; 4572 4573 farg1 = (float) strtod (ptr, &ptr); 4574 if (math_entry->nargs == 2) 4575 { 4576 if (*ptr++ != ',') 4577 { 4578 as_bad (_("Expecting second argument")); 4579 break; 4580 } 4581 farg2 = (float) strtod (ptr, &ptr); 4582 } 4583 fresult = (*math_entry->proc) (farg1, farg2); 4584 value = xmalloc (128); 4585 if (math_entry->int_return) 4586 sprintf (value, "%d", (int) fresult); 4587 else 4588 sprintf (value, "%f", fresult); 4589 if (*ptr++ != ')') 4590 { 4591 as_bad (_("Extra junk in function call, expecting ')'")); 4592 break; 4593 } 4594 /* Don't bother recursing; the replacement isn't a 4595 symbol. */ 4596 recurse = 0; 4597 } 4598 else 4599 { 4600 int val; 4601 int arg_type[2] = { *ptr == '"' , 0 }; 4602 int ismember = !strcmp (entry->name, "$ismember"); 4603 4604 /* Parse one or two args, which must be a substitution 4605 symbol, string or a character-string constant. */ 4606 /* For all functions, a string or substitution symbol may be 4607 used, with the following exceptions: 4608 firstch/lastch: 2nd arg must be character constant 4609 ismember: both args must be substitution symbols. */ 4610 ptr = subsym_get_arg (ptr, ",)", &arg1, ismember); 4611 if (!arg1) 4612 break; 4613 if (entry->nargs == 2) 4614 { 4615 if (*ptr++ != ',') 4616 { 4617 as_bad (_("Function expects two arguments")); 4618 break; 4619 } 4620 /* Character constants are converted to numerics 4621 by the preprocessor. */ 4622 arg_type[1] = (ISDIGIT (*ptr)) ? 2 : (*ptr == '"'); 4623 ptr = subsym_get_arg (ptr, ")", &arg2, ismember); 4624 } 4625 /* Args checking. */ 4626 if ((!strcmp (entry->name, "$firstch") 4627 || !strcmp (entry->name, "$lastch")) 4628 && arg_type[1] != 2) 4629 { 4630 as_bad (_("Expecting character constant argument")); 4631 break; 4632 } 4633 if (ismember 4634 && (arg_type[0] != 0 || arg_type[1] != 0)) 4635 { 4636 as_bad (_("Both arguments must be substitution symbols")); 4637 break; 4638 } 4639 if (*ptr++ != ')') 4640 { 4641 as_bad (_("Extra junk in function call, expecting ')'")); 4642 break; 4643 } 4644 val = (*entry->proc) (arg1, arg2); 4645 value = xmalloc (64); 4646 sprintf (value, "%d", val); 4647 } 4648 /* Fix things up to replace the entire expression, not just the 4649 function name. */ 4650 tail = ptr; 4651 c = *tail; 4652 } 4653 4654 if (value != NULL && !eval_symbol) 4655 { 4656 /* Replace the symbol with its string replacement and 4657 continue. Recursively replace VALUE until either no 4658 substitutions are performed, or a substitution that has been 4659 previously made is encountered again. 4660 4661 put the symbol into the recursion hash table so we only 4662 try to replace a symbol once. */ 4663 if (recurse) 4664 { 4665 hash_insert (subsym_recurse_hash, name, name); 4666 value = subsym_substitute (value, macro_level > 0); 4667 hash_delete (subsym_recurse_hash, name, FALSE); 4668 } 4669 4670 /* Temporarily zero-terminate where the symbol started. */ 4671 *name = 0; 4672 if (forced) 4673 { 4674 if (c == '(') 4675 { 4676 /* Subscripted substitution symbol -- use just the 4677 indicated portion of the string; the description 4678 kinda indicates that forced substitution is not 4679 supposed to be recursive, but I'm not sure. */ 4680 unsigned beg, len = 1; /* default to a single char */ 4681 char *newval = strcpy (xmalloc (strlen (value) + 1), 4682 value); 4683 4684 savedp = input_line_pointer; 4685 input_line_pointer = tail + 1; 4686 beg = get_absolute_expression (); 4687 if (beg < 1) 4688 { 4689 as_bad (_("Invalid subscript (use 1 to %d)"), 4690 (int) strlen (value)); 4691 break; 4692 } 4693 if (*input_line_pointer == ',') 4694 { 4695 ++input_line_pointer; 4696 len = get_absolute_expression (); 4697 if (beg + len > strlen (value)) 4698 { 4699 as_bad (_("Invalid length (use 0 to %d"), 4700 (int) strlen (value) - beg); 4701 break; 4702 } 4703 } 4704 newval += beg - 1; 4705 newval[len] = 0; 4706 tail = input_line_pointer; 4707 if (*tail++ != ')') 4708 { 4709 as_bad (_("Missing ')' in subscripted substitution " 4710 "symbol expression")); 4711 break; 4712 } 4713 c = *tail; 4714 input_line_pointer = savedp; 4715 4716 value = newval; 4717 } 4718 name[-1] = 0; 4719 } 4720 tmp = xmalloc (strlen (head) + strlen (value) + 4721 strlen (tail + 1) + 2); 4722 strcpy (tmp, head); 4723 strcat (tmp, value); 4724 /* Make sure forced substitutions are properly terminated. */ 4725 if (forced) 4726 { 4727 if (c != ':') 4728 { 4729 as_bad (_("Missing forced substitution terminator ':'")); 4730 break; 4731 } 4732 ++tail; 4733 } 4734 else 4735 /* Restore the character after the symbol end. */ 4736 *tail = c; 4737 strcat (tmp, tail); 4738 /* Continue examining after the replacement value. */ 4739 ptr = tmp + strlen (head) + strlen (value); 4740 free (replacement); 4741 head = replacement = tmp; 4742 changed = 1; 4743 } 4744 else 4745 *ptr = c; 4746 } 4747 else 4748 { 4749 ++ptr; 4750 } 4751 } 4752 4753 if (changed) 4754 return replacement; 4755 else 4756 return line; 4757 } 4758 4759 /* We use this to handle substitution symbols 4760 hijack input_line_pointer, replacing it with our substituted string. 4761 4762 .sslist should enable listing the line after replacements are made... 4763 4764 returns the new buffer limit. */ 4765 4766 void 4767 tic54x_start_line_hook (void) 4768 { 4769 char *line, *endp; 4770 char *replacement = NULL; 4771 4772 /* Work with a copy of the input line, including EOL char. */ 4773 endp = input_line_pointer; 4774 while (!is_end_of_line[(int) *endp++]) 4775 ; 4776 line = xmalloc (endp - input_line_pointer + 1); 4777 strncpy (line, input_line_pointer, endp - input_line_pointer + 1); 4778 line[endp - input_line_pointer] = 0; 4779 4780 /* Scan ahead for parallel insns. */ 4781 parallel_on_next_line_hint = next_line_shows_parallel (endp + 1); 4782 4783 /* If within a macro, first process forced replacements. */ 4784 if (macro_level > 0) 4785 replacement = subsym_substitute (line, 1); 4786 else 4787 replacement = line; 4788 replacement = subsym_substitute (replacement, 0); 4789 4790 if (replacement != line) 4791 { 4792 char *tmp = replacement; 4793 char *comment = strchr (replacement, ';'); 4794 char endc = replacement[strlen (replacement) - 1]; 4795 4796 /* Clean up the replacement; we'd prefer to have this done by the 4797 standard preprocessing equipment (maybe do_scrub_chars?) 4798 but for now, do a quick-and-dirty. */ 4799 if (comment != NULL) 4800 { 4801 comment[0] = endc; 4802 comment[1] = 0; 4803 --comment; 4804 } 4805 else 4806 comment = replacement + strlen (replacement) - 1; 4807 4808 /* Trim trailing whitespace. */ 4809 while (ISSPACE (*comment)) 4810 { 4811 comment[0] = endc; 4812 comment[1] = 0; 4813 --comment; 4814 } 4815 4816 /* Compact leading whitespace. */ 4817 while (ISSPACE (tmp[0]) && ISSPACE (tmp[1])) 4818 ++tmp; 4819 4820 input_line_pointer = endp; 4821 input_scrub_insert_line (tmp); 4822 free (replacement); 4823 free (line); 4824 /* Keep track of whether we've done a substitution. */ 4825 substitution_line = 1; 4826 } 4827 else 4828 { 4829 /* No change. */ 4830 free (line); 4831 substitution_line = 0; 4832 } 4833 } 4834 4835 /* This is the guts of the machine-dependent assembler. STR points to a 4836 machine dependent instruction. This function is supposed to emit 4837 the frags/bytes it assembles to. */ 4838 void 4839 md_assemble (char *line) 4840 { 4841 static int repeat_slot = 0; 4842 static int delay_slots = 0; /* How many delay slots left to fill? */ 4843 static int is_parallel = 0; 4844 static tic54x_insn insn; 4845 char *lptr; 4846 char *savedp = input_line_pointer; 4847 int c; 4848 4849 input_line_pointer = line; 4850 c = get_symbol_end (); 4851 4852 if (cpu == VNONE) 4853 cpu = V542; 4854 if (address_mode_needs_set) 4855 { 4856 set_address_mode (amode); 4857 address_mode_needs_set = 0; 4858 } 4859 if (cpu_needs_set) 4860 { 4861 set_cpu (cpu); 4862 cpu_needs_set = 0; 4863 } 4864 assembly_begun = 1; 4865 4866 if (is_parallel) 4867 { 4868 is_parallel = 0; 4869 4870 strcpy (insn.parmnemonic, line); 4871 lptr = input_line_pointer; 4872 *lptr = c; 4873 input_line_pointer = savedp; 4874 4875 if (tic54x_parse_parallel_insn_lastline (&insn, lptr)) 4876 { 4877 int words = build_insn (&insn); 4878 4879 if (delay_slots != 0) 4880 { 4881 if (words > delay_slots) 4882 { 4883 as_bad (_("Instruction does not fit in available delay " 4884 "slots (%d-word insn, %d slots left)"), 4885 words, delay_slots); 4886 delay_slots = 0; 4887 return; 4888 } 4889 delay_slots -= words; 4890 } 4891 } 4892 return; 4893 } 4894 4895 memset (&insn, 0, sizeof (insn)); 4896 strcpy (insn.mnemonic, line); 4897 lptr = input_line_pointer; 4898 *lptr = c; 4899 input_line_pointer = savedp; 4900 4901 /* See if this line is part of a parallel instruction; if so, either this 4902 line or the next line will have the "||" specifier preceding the 4903 mnemonic, and we look for it in the parallel insn hash table. */ 4904 if (strstr (line, "||") != NULL || parallel_on_next_line_hint) 4905 { 4906 char *tmp = strstr (line, "||"); 4907 if (tmp != NULL) 4908 *tmp = '\0'; 4909 4910 if (tic54x_parse_parallel_insn_firstline (&insn, lptr)) 4911 { 4912 is_parallel = 1; 4913 /* If the parallel part is on the same line, process it now, 4914 otherwise let the assembler pick up the next line for us. */ 4915 if (tmp != NULL) 4916 { 4917 while (ISSPACE (tmp[2])) 4918 ++tmp; 4919 md_assemble (tmp + 2); 4920 } 4921 } 4922 else 4923 { 4924 as_bad (_("Unrecognized parallel instruction '%s'"), line); 4925 } 4926 return; 4927 } 4928 4929 if (tic54x_parse_insn (&insn, lptr)) 4930 { 4931 int words; 4932 4933 if ((insn.tm->flags & FL_LP) 4934 && cpu != V545LP && cpu != V546LP) 4935 { 4936 as_bad (_("Instruction '%s' requires an LP cpu version"), 4937 insn.tm->name); 4938 return; 4939 } 4940 if ((insn.tm->flags & FL_FAR) 4941 && amode != far_mode) 4942 { 4943 as_bad (_("Instruction '%s' requires far mode addressing"), 4944 insn.tm->name); 4945 return; 4946 } 4947 4948 words = build_insn (&insn); 4949 4950 /* Is this instruction in a delay slot? */ 4951 if (delay_slots) 4952 { 4953 if (words > delay_slots) 4954 { 4955 as_warn (_("Instruction does not fit in available delay " 4956 "slots (%d-word insn, %d slots left). " 4957 "Resulting behavior is undefined."), 4958 words, delay_slots); 4959 delay_slots = 0; 4960 return; 4961 } 4962 /* Branches in delay slots are not allowed. */ 4963 if (insn.tm->flags & FL_BMASK) 4964 { 4965 as_warn (_("Instructions which cause PC discontinuity are not " 4966 "allowed in a delay slot. " 4967 "Resulting behavior is undefined.")); 4968 } 4969 delay_slots -= words; 4970 } 4971 4972 /* Is this instruction the target of a repeat? */ 4973 if (repeat_slot) 4974 { 4975 if (insn.tm->flags & FL_NR) 4976 as_warn (_("'%s' is not repeatable. " 4977 "Resulting behavior is undefined."), 4978 insn.tm->name); 4979 else if (insn.is_lkaddr) 4980 as_warn (_("Instructions using long offset modifiers or absolute " 4981 "addresses are not repeatable. " 4982 "Resulting behavior is undefined.")); 4983 repeat_slot = 0; 4984 } 4985 4986 /* Make sure we check the target of a repeat instruction. */ 4987 if (insn.tm->flags & B_REPEAT) 4988 { 4989 repeat_slot = 1; 4990 /* FIXME -- warn if repeat_slot == 1 at EOF. */ 4991 } 4992 /* Make sure we check our delay slots for validity. */ 4993 if (insn.tm->flags & FL_DELAY) 4994 { 4995 delay_slots = 2; 4996 /* FIXME -- warn if delay_slots != 0 at EOF. */ 4997 } 4998 } 4999 } 5000 5001 /* Do a final adjustment on the symbol table; in this case, make sure we have 5002 a ".file" symbol. */ 5003 5004 void 5005 tic54x_adjust_symtab (void) 5006 { 5007 if (symbol_rootP == NULL 5008 || S_GET_STORAGE_CLASS (symbol_rootP) != C_FILE) 5009 { 5010 char *filename; 5011 unsigned lineno; 5012 as_where (&filename, &lineno); 5013 c_dot_file_symbol (filename, 0); 5014 } 5015 } 5016 5017 /* In order to get gas to ignore any | chars at the start of a line, 5018 this function returns true if a | is found in a line. 5019 This lets us process parallel instructions, which span two lines. */ 5020 5021 int 5022 tic54x_unrecognized_line (int c) 5023 { 5024 return c == PARALLEL_SEPARATOR; 5025 } 5026 5027 /* Watch for local labels of the form $[0-9] and [_a-zA-Z][_a-zA-Z0-9]*? 5028 Encode their names so that only we see them and can map them to the 5029 appropriate places. 5030 FIXME -- obviously this isn't done yet. These locals still show up in the 5031 symbol table. */ 5032 void 5033 tic54x_define_label (symbolS *sym) 5034 { 5035 /* Just in case we need this later; note that this is not necessarily the 5036 same thing as line_label... 5037 When aligning or assigning labels to fields, sometimes the label is 5038 assigned other than the address at which the label appears. 5039 FIXME -- is this really needed? I think all the proper label assignment 5040 is done in tic54x_cons. */ 5041 last_label_seen = sym; 5042 } 5043 5044 /* Try to parse something that normal parsing failed at. */ 5045 5046 symbolS * 5047 tic54x_undefined_symbol (char *name) 5048 { 5049 symbol *sym; 5050 5051 /* Not sure how to handle predefined symbols. */ 5052 if ((sym = (symbol *) hash_find (cc_hash, name)) != NULL || 5053 (sym = (symbol *) hash_find (cc2_hash, name)) != NULL || 5054 (sym = (symbol *) hash_find (cc3_hash, name)) != NULL || 5055 (sym = (symbol *) hash_find (misc_symbol_hash, name)) != NULL || 5056 (sym = (symbol *) hash_find (sbit_hash, name)) != NULL) 5057 { 5058 return symbol_new (name, reg_section, 5059 (valueT) sym->value, 5060 &zero_address_frag); 5061 } 5062 5063 if ((sym = (symbol *) hash_find (reg_hash, name)) != NULL || 5064 (sym = (symbol *) hash_find (mmreg_hash, name)) != NULL || 5065 !strcasecmp (name, "a") || !strcasecmp (name, "b")) 5066 { 5067 return symbol_new (name, reg_section, 5068 (valueT) sym ? sym->value : 0, 5069 &zero_address_frag); 5070 } 5071 5072 return NULL; 5073 } 5074 5075 /* Parse a name in an expression before the expression parser takes a stab at 5076 it. */ 5077 5078 int 5079 tic54x_parse_name (char *name ATTRIBUTE_UNUSED, 5080 expressionS *expn ATTRIBUTE_UNUSED) 5081 { 5082 return 0; 5083 } 5084 5085 char * 5086 md_atof (int type, char *literalP, int *sizeP) 5087 { 5088 /* Target data is little-endian, but floats are stored 5089 big-"word"ian. ugh. */ 5090 return ieee_md_atof (type, literalP, sizeP, TRUE); 5091 } 5092 5093 arelent * 5094 tc_gen_reloc (asection *section, fixS *fixP) 5095 { 5096 arelent *rel; 5097 bfd_reloc_code_real_type code = fixP->fx_r_type; 5098 asymbol *sym = symbol_get_bfdsym (fixP->fx_addsy); 5099 5100 rel = (arelent *) xmalloc (sizeof (arelent)); 5101 rel->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *)); 5102 *rel->sym_ptr_ptr = sym; 5103 /* We assume that all rel->address are host byte offsets. */ 5104 rel->address = fixP->fx_frag->fr_address + fixP->fx_where; 5105 rel->address /= OCTETS_PER_BYTE; 5106 rel->howto = bfd_reloc_type_lookup (stdoutput, code); 5107 if (!strcmp (sym->name, section->name)) 5108 rel->howto += HOWTO_BANK; 5109 5110 if (!rel->howto) 5111 { 5112 const char *name = S_GET_NAME (fixP->fx_addsy); 5113 if (name == NULL) 5114 name = "<unknown>"; 5115 as_fatal ("Cannot generate relocation type for symbol %s, code %s", 5116 name, bfd_get_reloc_code_name (code)); 5117 return NULL; 5118 } 5119 return rel; 5120 } 5121 5122 /* Handle cons expressions. */ 5123 5124 void 5125 tic54x_cons_fix_new (fragS *frag, int where, int octets, expressionS *expn) 5126 { 5127 bfd_reloc_code_real_type r; 5128 5129 switch (octets) 5130 { 5131 default: 5132 as_bad (_("Unsupported relocation size %d"), octets); 5133 r = BFD_RELOC_TIC54X_16_OF_23; 5134 break; 5135 case 2: 5136 r = BFD_RELOC_TIC54X_16_OF_23; 5137 break; 5138 case 4: 5139 /* TI assembler always uses this, regardless of addressing mode. */ 5140 if (emitting_long) 5141 r = BFD_RELOC_TIC54X_23; 5142 else 5143 /* We never want to directly generate this; this is provided for 5144 stabs support only. */ 5145 r = BFD_RELOC_32; 5146 break; 5147 } 5148 fix_new_exp (frag, where, octets, expn, 0, r); 5149 } 5150 5151 /* Attempt to simplify or even eliminate a fixup. 5152 To indicate that a fixup has been eliminated, set fixP->fx_done. 5153 5154 If fixp->fx_addsy is non-NULL, we'll have to generate a reloc entry. */ 5155 5156 void 5157 md_apply_fix (fixS *fixP, valueT *valP, segT seg ATTRIBUTE_UNUSED) 5158 { 5159 char *buf = fixP->fx_where + fixP->fx_frag->fr_literal; 5160 valueT val = * valP; 5161 5162 switch (fixP->fx_r_type) 5163 { 5164 default: 5165 as_fatal ("Bad relocation type: 0x%02x", fixP->fx_r_type); 5166 return; 5167 case BFD_RELOC_TIC54X_MS7_OF_23: 5168 val = (val >> 16) & 0x7F; 5169 /* Fall through. */ 5170 case BFD_RELOC_TIC54X_16_OF_23: 5171 case BFD_RELOC_16: 5172 bfd_put_16 (stdoutput, val, buf); 5173 /* Indicate what we're actually writing, so that we don't get warnings 5174 about exceeding available space. */ 5175 *valP = val & 0xFFFF; 5176 break; 5177 case BFD_RELOC_TIC54X_PARTLS7: 5178 bfd_put_16 (stdoutput, 5179 (bfd_get_16 (stdoutput, buf) & 0xFF80) | (val & 0x7F), 5180 buf); 5181 /* Indicate what we're actually writing, so that we don't get warnings 5182 about exceeding available space. */ 5183 *valP = val & 0x7F; 5184 break; 5185 case BFD_RELOC_TIC54X_PARTMS9: 5186 /* TI assembler doesn't shift its encoding for relocatable files, and is 5187 thus incompatible with this implementation's relocatable files. */ 5188 bfd_put_16 (stdoutput, 5189 (bfd_get_16 (stdoutput, buf) & 0xFE00) | (val >> 7), 5190 buf); 5191 break; 5192 case BFD_RELOC_32: 5193 case BFD_RELOC_TIC54X_23: 5194 bfd_put_32 (stdoutput, 5195 (bfd_get_32 (stdoutput, buf) & 0xFF800000) | val, 5196 buf); 5197 break; 5198 } 5199 5200 if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0) 5201 fixP->fx_done = 1; 5202 } 5203 5204 /* This is our chance to record section alignment 5205 don't need to do anything here, since BFD does the proper encoding. */ 5206 5207 valueT 5208 md_section_align (segT segment ATTRIBUTE_UNUSED, valueT section_size) 5209 { 5210 return section_size; 5211 } 5212 5213 long 5214 md_pcrel_from (fixS *fixP ATTRIBUTE_UNUSED) 5215 { 5216 return 0; 5217 } 5218 5219 /* Mostly little-endian, but longwords (4 octets) get MS word stored 5220 first. */ 5221 5222 void 5223 tic54x_number_to_chars (char *buf, valueT val, int n) 5224 { 5225 if (n != 4) 5226 number_to_chars_littleendian (buf, val, n); 5227 else 5228 { 5229 number_to_chars_littleendian (buf , val >> 16 , 2); 5230 number_to_chars_littleendian (buf + 2, val & 0xFFFF, 2); 5231 } 5232 } 5233 5234 int 5235 tic54x_estimate_size_before_relax (fragS *frag ATTRIBUTE_UNUSED, 5236 segT seg ATTRIBUTE_UNUSED) 5237 { 5238 return 0; 5239 } 5240 5241 /* We use this to handle bit allocations which we couldn't handle before due 5242 to symbols being in different frags. return number of octets added. */ 5243 5244 int 5245 tic54x_relax_frag (fragS *frag, long stretch ATTRIBUTE_UNUSED) 5246 { 5247 symbolS *sym = frag->fr_symbol; 5248 int growth = 0; 5249 int i; 5250 5251 if (sym != NULL) 5252 { 5253 struct bit_info *bi = (struct bit_info *) frag->fr_opcode; 5254 int bit_offset = frag_bit_offset (frag_prev (frag, bi->seg), bi->seg); 5255 int size = S_GET_VALUE (sym); 5256 fragS *prev_frag = bit_offset_frag (frag_prev (frag, bi->seg), bi->seg); 5257 int available = 16 - bit_offset; 5258 5259 if (symbol_get_frag (sym) != &zero_address_frag 5260 || S_IS_COMMON (sym) 5261 || !S_IS_DEFINED (sym)) 5262 as_bad_where (frag->fr_file, frag->fr_line, 5263 _("non-absolute value used with .space/.bes")); 5264 5265 if (size < 0) 5266 { 5267 as_warn (_("negative value ignored in %s"), 5268 bi->type == TYPE_SPACE ? ".space" : 5269 bi->type == TYPE_BES ? ".bes" : ".field"); 5270 growth = 0; 5271 frag->tc_frag_data = frag->fr_fix = 0; 5272 return 0; 5273 } 5274 5275 if (bi->type == TYPE_FIELD) 5276 { 5277 /* Bit fields of 16 or larger will have already been handled. */ 5278 if (bit_offset != 0 && available >= size) 5279 { 5280 char *p = prev_frag->fr_literal; 5281 5282 valueT value = bi->value; 5283 value <<= available - size; 5284 value |= ((unsigned short) p[1] << 8) | p[0]; 5285 md_number_to_chars (p, value, 2); 5286 if ((prev_frag->tc_frag_data += size) == 16) 5287 prev_frag->tc_frag_data = 0; 5288 if (bi->sym) 5289 symbol_set_frag (bi->sym, prev_frag); 5290 /* This frag is no longer used. */ 5291 growth = -frag->fr_fix; 5292 frag->fr_fix = 0; 5293 frag->tc_frag_data = 0; 5294 } 5295 else 5296 { 5297 char *p = frag->fr_literal; 5298 5299 valueT value = bi->value << (16 - size); 5300 md_number_to_chars (p, value, 2); 5301 if ((frag->tc_frag_data = size) == 16) 5302 frag->tc_frag_data = 0; 5303 growth = 0; 5304 } 5305 } 5306 else 5307 { 5308 if (bit_offset != 0 && bit_offset < 16) 5309 { 5310 if (available >= size) 5311 { 5312 if ((prev_frag->tc_frag_data += size) == 16) 5313 prev_frag->tc_frag_data = 0; 5314 if (bi->sym) 5315 symbol_set_frag (bi->sym, prev_frag); 5316 /* This frag is no longer used. */ 5317 growth = -frag->fr_fix; 5318 frag->fr_fix = 0; 5319 frag->tc_frag_data = 0; 5320 goto getout; 5321 } 5322 if (bi->type == TYPE_SPACE && bi->sym) 5323 symbol_set_frag (bi->sym, prev_frag); 5324 size -= available; 5325 } 5326 growth = (size + 15) / 16 * OCTETS_PER_BYTE - frag->fr_fix; 5327 for (i = 0; i < growth; i++) 5328 frag->fr_literal[i] = 0; 5329 frag->fr_fix = growth; 5330 frag->tc_frag_data = size % 16; 5331 /* Make sure any BES label points to the LAST word allocated. */ 5332 if (bi->type == TYPE_BES && bi->sym) 5333 S_SET_VALUE (bi->sym, frag->fr_fix / OCTETS_PER_BYTE - 1); 5334 } 5335 getout: 5336 frag->fr_symbol = 0; 5337 frag->fr_opcode = 0; 5338 free ((void *) bi); 5339 } 5340 return growth; 5341 } 5342 5343 void 5344 tic54x_convert_frag (bfd *abfd ATTRIBUTE_UNUSED, 5345 segT seg ATTRIBUTE_UNUSED, 5346 fragS *frag) 5347 { 5348 /* Offset is in bytes. */ 5349 frag->fr_offset = (frag->fr_next->fr_address 5350 - frag->fr_address 5351 - frag->fr_fix) / frag->fr_var; 5352 if (frag->fr_offset < 0) 5353 { 5354 as_bad_where (frag->fr_file, frag->fr_line, 5355 _("attempt to .space/.bes backwards? (%ld)"), 5356 (long) frag->fr_offset); 5357 } 5358 frag->fr_type = rs_space; 5359 } 5360 5361 /* We need to avoid having labels defined for certain directives/pseudo-ops 5362 since once the label is defined, it's in the symbol table for good. TI 5363 syntax puts the symbol *before* the pseudo (which is kinda like MRI syntax, 5364 I guess, except I've never seen a definition of MRI syntax). 5365 5366 C is the character that used to be at *REST, which points to the end of the 5367 label. 5368 5369 Don't allow labels to start with '.' */ 5370 5371 int 5372 tic54x_start_label (int c, char *rest) 5373 { 5374 /* If within .struct/.union, no auto line labels, please. */ 5375 if (current_stag != NULL) 5376 return 0; 5377 5378 /* Disallow labels starting with "." */ 5379 if (c != ':') 5380 { 5381 char *label = rest; 5382 5383 while (!is_end_of_line[(int) label[-1]]) 5384 --label; 5385 if (*label == '.') 5386 { 5387 as_bad (_("Invalid label '%s'"), label); 5388 return 0; 5389 } 5390 } 5391 5392 if (is_end_of_line[(int) c]) 5393 return 1; 5394 5395 if (ISSPACE (c)) 5396 while (ISSPACE (c = *++rest)) 5397 ; 5398 if (c == '.') 5399 { 5400 /* Don't let colon () define a label for any of these... */ 5401 return (strncasecmp (rest, ".tag", 4) != 0 || !ISSPACE (rest[4])) 5402 && (strncasecmp (rest, ".struct", 7) != 0 || !ISSPACE (rest[7])) 5403 && (strncasecmp (rest, ".union", 6) != 0 || !ISSPACE (rest[6])) 5404 && (strncasecmp (rest, ".macro", 6) != 0 || !ISSPACE (rest[6])) 5405 && (strncasecmp (rest, ".set", 4) != 0 || !ISSPACE (rest[4])) 5406 && (strncasecmp (rest, ".equ", 4) != 0 || !ISSPACE (rest[4])); 5407 } 5408 5409 return 1; 5410 } 5411