1 /* macro.c - macro support for gas 2 Copyright (C) 1994-2016 Free Software Foundation, Inc. 3 4 Written by Steve and Judy Chamberlain of Cygnus Support, 5 sac (at) cygnus.com 6 7 This file is part of GAS, the GNU Assembler. 8 9 GAS is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3, or (at your option) 12 any later version. 13 14 GAS is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with GAS; see the file COPYING. If not, write to the Free 21 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 22 02110-1301, USA. */ 23 24 #include "as.h" 25 #include "safe-ctype.h" 26 #include "sb.h" 27 #include "macro.h" 28 29 /* The routines in this file handle macro definition and expansion. 30 They are called by gas. */ 31 32 #define ISWHITE(x) ((x) == ' ' || (x) == '\t') 33 34 #define ISSEP(x) \ 35 ((x) == ' ' || (x) == '\t' || (x) == ',' || (x) == '"' || (x) == ';' \ 36 || (x) == ')' || (x) == '(' \ 37 || ((macro_alternate || macro_mri) && ((x) == '<' || (x) == '>'))) 38 39 #define ISBASE(x) \ 40 ((x) == 'b' || (x) == 'B' \ 41 || (x) == 'q' || (x) == 'Q' \ 42 || (x) == 'h' || (x) == 'H' \ 43 || (x) == 'd' || (x) == 'D') 44 45 /* The macro hash table. */ 46 47 struct hash_control *macro_hash; 48 49 /* Whether any macros have been defined. */ 50 51 int macro_defined; 52 53 /* Whether we are in alternate syntax mode. */ 54 55 static int macro_alternate; 56 57 /* Whether we are in MRI mode. */ 58 59 static int macro_mri; 60 61 /* Whether we should strip '@' characters. */ 62 63 static int macro_strip_at; 64 65 /* Function to use to parse an expression. */ 66 67 static size_t (*macro_expr) (const char *, size_t, sb *, offsetT *); 68 69 /* Number of macro expansions that have been done. */ 70 71 static int macro_number; 72 73 /* Initialize macro processing. */ 74 75 void 76 macro_init (int alternate, int mri, int strip_at, 77 size_t (*exp) (const char *, size_t, sb *, offsetT *)) 78 { 79 macro_hash = hash_new (); 80 macro_defined = 0; 81 macro_alternate = alternate; 82 macro_mri = mri; 83 macro_strip_at = strip_at; 84 macro_expr = exp; 85 } 86 87 /* Switch in and out of alternate mode on the fly. */ 88 89 void 90 macro_set_alternate (int alternate) 91 { 92 macro_alternate = alternate; 93 } 94 95 /* Switch in and out of MRI mode on the fly. */ 96 97 void 98 macro_mri_mode (int mri) 99 { 100 macro_mri = mri; 101 } 102 103 /* Read input lines till we get to a TO string. 104 Increase nesting depth if we get a FROM string. 105 Put the results into sb at PTR. 106 FROM may be NULL (or will be ignored) if TO is "ENDR". 107 Add a new input line to an sb using GET_LINE. 108 Return 1 on success, 0 on unexpected EOF. */ 109 110 int 111 buffer_and_nest (const char *from, const char *to, sb *ptr, 112 size_t (*get_line) (sb *)) 113 { 114 size_t from_len; 115 size_t to_len = strlen (to); 116 int depth = 1; 117 size_t line_start = ptr->len; 118 size_t more = get_line (ptr); 119 120 if (to_len == 4 && strcasecmp (to, "ENDR") == 0) 121 { 122 from = NULL; 123 from_len = 0; 124 } 125 else 126 from_len = strlen (from); 127 128 while (more) 129 { 130 /* Try to find the first pseudo op on the line. */ 131 size_t i = line_start; 132 bfd_boolean had_colon = FALSE; 133 134 /* With normal syntax we can suck what we want till we get 135 to the dot. With the alternate, labels have to start in 136 the first column, since we can't tell what's a label and 137 what's a pseudoop. */ 138 139 if (! LABELS_WITHOUT_COLONS) 140 { 141 /* Skip leading whitespace. */ 142 while (i < ptr->len && ISWHITE (ptr->ptr[i])) 143 i++; 144 } 145 146 for (;;) 147 { 148 /* Skip over a label, if any. */ 149 if (i >= ptr->len || ! is_name_beginner (ptr->ptr[i])) 150 break; 151 i++; 152 while (i < ptr->len && is_part_of_name (ptr->ptr[i])) 153 i++; 154 if (i < ptr->len && is_name_ender (ptr->ptr[i])) 155 i++; 156 /* Skip whitespace. */ 157 while (i < ptr->len && ISWHITE (ptr->ptr[i])) 158 i++; 159 /* Check for the colon. */ 160 if (i >= ptr->len || ptr->ptr[i] != ':') 161 { 162 /* LABELS_WITHOUT_COLONS doesn't mean we cannot have a 163 colon after a label. If we do have a colon on the 164 first label then handle more than one label on the 165 line, assuming that each label has a colon. */ 166 if (LABELS_WITHOUT_COLONS && !had_colon) 167 break; 168 i = line_start; 169 break; 170 } 171 i++; 172 line_start = i; 173 had_colon = TRUE; 174 } 175 176 /* Skip trailing whitespace. */ 177 while (i < ptr->len && ISWHITE (ptr->ptr[i])) 178 i++; 179 180 if (i < ptr->len && (ptr->ptr[i] == '.' 181 || NO_PSEUDO_DOT 182 || macro_mri)) 183 { 184 if (! flag_m68k_mri && ptr->ptr[i] == '.') 185 i++; 186 if (from == NULL 187 && strncasecmp (ptr->ptr + i, "IRPC", from_len = 4) != 0 188 && strncasecmp (ptr->ptr + i, "IRP", from_len = 3) != 0 189 && strncasecmp (ptr->ptr + i, "IREPC", from_len = 5) != 0 190 && strncasecmp (ptr->ptr + i, "IREP", from_len = 4) != 0 191 && strncasecmp (ptr->ptr + i, "REPT", from_len = 4) != 0 192 && strncasecmp (ptr->ptr + i, "REP", from_len = 3) != 0) 193 from_len = 0; 194 if ((from != NULL 195 ? strncasecmp (ptr->ptr + i, from, from_len) == 0 196 : from_len > 0) 197 && (ptr->len == (i + from_len) 198 || ! (is_part_of_name (ptr->ptr[i + from_len]) 199 || is_name_ender (ptr->ptr[i + from_len])))) 200 depth++; 201 if (strncasecmp (ptr->ptr + i, to, to_len) == 0 202 && (ptr->len == (i + to_len) 203 || ! (is_part_of_name (ptr->ptr[i + to_len]) 204 || is_name_ender (ptr->ptr[i + to_len])))) 205 { 206 depth--; 207 if (depth == 0) 208 { 209 /* Reset the string to not include the ending rune. */ 210 ptr->len = line_start; 211 break; 212 } 213 } 214 215 /* PR gas/16908 216 Apply and discard .linefile directives that appear within 217 the macro. For long macros, one might want to report the 218 line number information associated with the lines within 219 the macro definition, but we would need more infrastructure 220 to make that happen correctly (e.g. resetting the line 221 number when expanding the macro), and since for short 222 macros we clearly prefer reporting the point of expansion 223 anyway, there's not an obviously better fix here. */ 224 if (strncasecmp (ptr->ptr + i, "linefile", 8) == 0) 225 { 226 char *saved_input_line_pointer = input_line_pointer; 227 char saved_eol_char = ptr->ptr[ptr->len]; 228 229 ptr->ptr[ptr->len] = '\0'; 230 input_line_pointer = ptr->ptr + i + 8; 231 s_app_line (0); 232 ptr->ptr[ptr->len] = saved_eol_char; 233 input_line_pointer = saved_input_line_pointer; 234 ptr->len = line_start; 235 } 236 } 237 238 /* Add the original end-of-line char to the end and keep running. */ 239 sb_add_char (ptr, more); 240 line_start = ptr->len; 241 more = get_line (ptr); 242 } 243 244 /* Return 1 on success, 0 on unexpected EOF. */ 245 return depth == 0; 246 } 247 248 /* Pick up a token. */ 249 250 static size_t 251 get_token (size_t idx, sb *in, sb *name) 252 { 253 if (idx < in->len 254 && is_name_beginner (in->ptr[idx])) 255 { 256 sb_add_char (name, in->ptr[idx++]); 257 while (idx < in->len 258 && is_part_of_name (in->ptr[idx])) 259 { 260 sb_add_char (name, in->ptr[idx++]); 261 } 262 if (idx < in->len 263 && is_name_ender (in->ptr[idx])) 264 { 265 sb_add_char (name, in->ptr[idx++]); 266 } 267 } 268 /* Ignore trailing &. */ 269 if (macro_alternate && idx < in->len && in->ptr[idx] == '&') 270 idx++; 271 return idx; 272 } 273 274 /* Pick up a string. */ 275 276 static size_t 277 getstring (size_t idx, sb *in, sb *acc) 278 { 279 while (idx < in->len 280 && (in->ptr[idx] == '"' 281 || (in->ptr[idx] == '<' && (macro_alternate || macro_mri)) 282 || (in->ptr[idx] == '\'' && macro_alternate))) 283 { 284 if (in->ptr[idx] == '<') 285 { 286 int nest = 0; 287 idx++; 288 while ((in->ptr[idx] != '>' || nest) 289 && idx < in->len) 290 { 291 if (in->ptr[idx] == '!') 292 { 293 idx++; 294 sb_add_char (acc, in->ptr[idx++]); 295 } 296 else 297 { 298 if (in->ptr[idx] == '>') 299 nest--; 300 if (in->ptr[idx] == '<') 301 nest++; 302 sb_add_char (acc, in->ptr[idx++]); 303 } 304 } 305 idx++; 306 } 307 else if (in->ptr[idx] == '"' || in->ptr[idx] == '\'') 308 { 309 char tchar = in->ptr[idx]; 310 int escaped = 0; 311 312 idx++; 313 314 while (idx < in->len) 315 { 316 if (in->ptr[idx - 1] == '\\') 317 escaped ^= 1; 318 else 319 escaped = 0; 320 321 if (macro_alternate && in->ptr[idx] == '!') 322 { 323 idx ++; 324 325 sb_add_char (acc, in->ptr[idx]); 326 327 idx ++; 328 } 329 else if (escaped && in->ptr[idx] == tchar) 330 { 331 sb_add_char (acc, tchar); 332 idx ++; 333 } 334 else 335 { 336 if (in->ptr[idx] == tchar) 337 { 338 idx ++; 339 340 if (idx >= in->len || in->ptr[idx] != tchar) 341 break; 342 } 343 344 sb_add_char (acc, in->ptr[idx]); 345 idx ++; 346 } 347 } 348 } 349 } 350 351 return idx; 352 } 353 354 /* Fetch string from the input stream, 355 rules: 356 'Bxyx<whitespace> -> return 'Bxyza 357 %<expr> -> return string of decimal value of <expr> 358 "string" -> return string 359 (string) -> return (string-including-whitespaces) 360 xyx<whitespace> -> return xyz. */ 361 362 static size_t 363 get_any_string (size_t idx, sb *in, sb *out) 364 { 365 sb_reset (out); 366 idx = sb_skip_white (idx, in); 367 368 if (idx < in->len) 369 { 370 if (in->len > idx + 2 && in->ptr[idx + 1] == '\'' && ISBASE (in->ptr[idx])) 371 { 372 while (!ISSEP (in->ptr[idx])) 373 sb_add_char (out, in->ptr[idx++]); 374 } 375 else if (in->ptr[idx] == '%' && macro_alternate) 376 { 377 offsetT val; 378 char buf[20]; 379 380 /* Turns the next expression into a string. */ 381 /* xgettext: no-c-format */ 382 idx = (*macro_expr) (_("% operator needs absolute expression"), 383 idx + 1, 384 in, 385 &val); 386 sprintf (buf, "%" BFD_VMA_FMT "d", val); 387 sb_add_string (out, buf); 388 } 389 else if (in->ptr[idx] == '"' 390 || (in->ptr[idx] == '<' && (macro_alternate || macro_mri)) 391 || (macro_alternate && in->ptr[idx] == '\'')) 392 { 393 if (macro_alternate && ! macro_strip_at && in->ptr[idx] != '<') 394 { 395 /* Keep the quotes. */ 396 sb_add_char (out, '"'); 397 idx = getstring (idx, in, out); 398 sb_add_char (out, '"'); 399 } 400 else 401 { 402 idx = getstring (idx, in, out); 403 } 404 } 405 else 406 { 407 char *br_buf = XNEWVEC (char, 1); 408 char *in_br = br_buf; 409 410 *in_br = '\0'; 411 while (idx < in->len 412 && (*in_br 413 || (in->ptr[idx] != ' ' 414 && in->ptr[idx] != '\t')) 415 && in->ptr[idx] != ',' 416 && (in->ptr[idx] != '<' 417 || (! macro_alternate && ! macro_mri))) 418 { 419 char tchar = in->ptr[idx]; 420 421 switch (tchar) 422 { 423 case '"': 424 case '\'': 425 sb_add_char (out, in->ptr[idx++]); 426 while (idx < in->len 427 && in->ptr[idx] != tchar) 428 sb_add_char (out, in->ptr[idx++]); 429 if (idx == in->len) 430 { 431 free (br_buf); 432 return idx; 433 } 434 break; 435 case '(': 436 case '[': 437 if (in_br > br_buf) 438 --in_br; 439 else 440 { 441 br_buf = XNEWVEC (char, strlen (in_br) + 2); 442 strcpy (br_buf + 1, in_br); 443 free (in_br); 444 in_br = br_buf; 445 } 446 *in_br = tchar; 447 break; 448 case ')': 449 if (*in_br == '(') 450 ++in_br; 451 break; 452 case ']': 453 if (*in_br == '[') 454 ++in_br; 455 break; 456 } 457 sb_add_char (out, tchar); 458 ++idx; 459 } 460 free (br_buf); 461 } 462 } 463 464 return idx; 465 } 466 467 /* Allocate a new formal. */ 468 469 static formal_entry * 470 new_formal (void) 471 { 472 formal_entry *formal; 473 474 formal = XNEW (formal_entry); 475 476 sb_new (&formal->name); 477 sb_new (&formal->def); 478 sb_new (&formal->actual); 479 formal->next = NULL; 480 formal->type = FORMAL_OPTIONAL; 481 return formal; 482 } 483 484 /* Free a formal. */ 485 486 static void 487 del_formal (formal_entry *formal) 488 { 489 sb_kill (&formal->actual); 490 sb_kill (&formal->def); 491 sb_kill (&formal->name); 492 free (formal); 493 } 494 495 /* Pick up the formal parameters of a macro definition. */ 496 497 static size_t 498 do_formals (macro_entry *macro, size_t idx, sb *in) 499 { 500 formal_entry **p = ¯o->formals; 501 const char *name; 502 503 idx = sb_skip_white (idx, in); 504 while (idx < in->len) 505 { 506 formal_entry *formal = new_formal (); 507 size_t cidx; 508 509 idx = get_token (idx, in, &formal->name); 510 if (formal->name.len == 0) 511 { 512 if (macro->formal_count) 513 --idx; 514 del_formal (formal); /* 'formal' goes out of scope. */ 515 break; 516 } 517 idx = sb_skip_white (idx, in); 518 /* This is a formal. */ 519 name = sb_terminate (&formal->name); 520 if (! macro_mri 521 && idx < in->len 522 && in->ptr[idx] == ':' 523 && (! is_name_beginner (':') 524 || idx + 1 >= in->len 525 || ! is_part_of_name (in->ptr[idx + 1]))) 526 { 527 /* Got a qualifier. */ 528 sb qual; 529 530 sb_new (&qual); 531 idx = get_token (sb_skip_white (idx + 1, in), in, &qual); 532 sb_terminate (&qual); 533 if (qual.len == 0) 534 as_bad_where (macro->file, 535 macro->line, 536 _("Missing parameter qualifier for `%s' in macro `%s'"), 537 name, 538 macro->name); 539 else if (strcmp (qual.ptr, "req") == 0) 540 formal->type = FORMAL_REQUIRED; 541 else if (strcmp (qual.ptr, "vararg") == 0) 542 formal->type = FORMAL_VARARG; 543 else 544 as_bad_where (macro->file, 545 macro->line, 546 _("`%s' is not a valid parameter qualifier for `%s' in macro `%s'"), 547 qual.ptr, 548 name, 549 macro->name); 550 sb_kill (&qual); 551 idx = sb_skip_white (idx, in); 552 } 553 if (idx < in->len && in->ptr[idx] == '=') 554 { 555 /* Got a default. */ 556 idx = get_any_string (idx + 1, in, &formal->def); 557 idx = sb_skip_white (idx, in); 558 if (formal->type == FORMAL_REQUIRED) 559 { 560 sb_reset (&formal->def); 561 as_warn_where (macro->file, 562 macro->line, 563 _("Pointless default value for required parameter `%s' in macro `%s'"), 564 name, 565 macro->name); 566 } 567 } 568 569 /* Add to macro's hash table. */ 570 if (! hash_find (macro->formal_hash, name)) 571 hash_jam (macro->formal_hash, name, formal); 572 else 573 as_bad_where (macro->file, 574 macro->line, 575 _("A parameter named `%s' already exists for macro `%s'"), 576 name, 577 macro->name); 578 579 formal->index = macro->formal_count++; 580 *p = formal; 581 p = &formal->next; 582 if (formal->type == FORMAL_VARARG) 583 break; 584 cidx = idx; 585 idx = sb_skip_comma (idx, in); 586 if (idx != cidx && idx >= in->len) 587 { 588 idx = cidx; 589 break; 590 } 591 } 592 593 if (macro_mri) 594 { 595 formal_entry *formal = new_formal (); 596 597 /* Add a special NARG formal, which macro_expand will set to the 598 number of arguments. */ 599 /* The same MRI assemblers which treat '@' characters also use 600 the name $NARG. At least until we find an exception. */ 601 if (macro_strip_at) 602 name = "$NARG"; 603 else 604 name = "NARG"; 605 606 sb_add_string (&formal->name, name); 607 608 /* Add to macro's hash table. */ 609 if (hash_find (macro->formal_hash, name)) 610 as_bad_where (macro->file, 611 macro->line, 612 _("Reserved word `%s' used as parameter in macro `%s'"), 613 name, 614 macro->name); 615 hash_jam (macro->formal_hash, name, formal); 616 617 formal->index = NARG_INDEX; 618 *p = formal; 619 } 620 621 return idx; 622 } 623 624 /* Free the memory allocated to a macro. */ 625 626 static void 627 free_macro (macro_entry *macro) 628 { 629 formal_entry *formal; 630 631 for (formal = macro->formals; formal; ) 632 { 633 formal_entry *f; 634 635 f = formal; 636 formal = formal->next; 637 del_formal (f); 638 } 639 hash_die (macro->formal_hash); 640 sb_kill (¯o->sub); 641 free (macro); 642 } 643 644 /* Define a new macro. Returns NULL on success, otherwise returns an 645 error message. If NAMEP is not NULL, *NAMEP is set to the name of 646 the macro which was defined. */ 647 648 const char * 649 define_macro (size_t idx, sb *in, sb *label, 650 size_t (*get_line) (sb *), 651 const char *file, unsigned int line, 652 const char **namep) 653 { 654 macro_entry *macro; 655 sb name; 656 const char *error = NULL; 657 658 macro = XNEW (macro_entry); 659 sb_new (¯o->sub); 660 sb_new (&name); 661 macro->file = file; 662 macro->line = line; 663 664 macro->formal_count = 0; 665 macro->formals = 0; 666 macro->formal_hash = hash_new_sized (7); 667 668 idx = sb_skip_white (idx, in); 669 if (! buffer_and_nest ("MACRO", "ENDM", ¯o->sub, get_line)) 670 error = _("unexpected end of file in macro `%s' definition"); 671 if (label != NULL && label->len != 0) 672 { 673 sb_add_sb (&name, label); 674 macro->name = sb_terminate (&name); 675 if (idx < in->len && in->ptr[idx] == '(') 676 { 677 /* It's the label: MACRO (formals,...) sort */ 678 idx = do_formals (macro, idx + 1, in); 679 if (idx < in->len && in->ptr[idx] == ')') 680 idx = sb_skip_white (idx + 1, in); 681 else if (!error) 682 error = _("missing `)' after formals in macro definition `%s'"); 683 } 684 else 685 { 686 /* It's the label: MACRO formals,... sort */ 687 idx = do_formals (macro, idx, in); 688 } 689 } 690 else 691 { 692 size_t cidx; 693 694 idx = get_token (idx, in, &name); 695 macro->name = sb_terminate (&name); 696 if (name.len == 0) 697 error = _("Missing macro name"); 698 cidx = sb_skip_white (idx, in); 699 idx = sb_skip_comma (cidx, in); 700 if (idx == cidx || idx < in->len) 701 idx = do_formals (macro, idx, in); 702 else 703 idx = cidx; 704 } 705 if (!error && idx < in->len) 706 error = _("Bad parameter list for macro `%s'"); 707 708 /* And stick it in the macro hash table. */ 709 for (idx = 0; idx < name.len; idx++) 710 name.ptr[idx] = TOLOWER (name.ptr[idx]); 711 if (hash_find (macro_hash, macro->name)) 712 error = _("Macro `%s' was already defined"); 713 if (!error) 714 error = hash_jam (macro_hash, macro->name, (void *) macro); 715 716 if (namep != NULL) 717 *namep = macro->name; 718 719 if (!error) 720 macro_defined = 1; 721 else 722 free_macro (macro); 723 724 return error; 725 } 726 727 /* Scan a token, and then skip KIND. */ 728 729 static size_t 730 get_apost_token (size_t idx, sb *in, sb *name, int kind) 731 { 732 idx = get_token (idx, in, name); 733 if (idx < in->len 734 && in->ptr[idx] == kind 735 && (! macro_mri || macro_strip_at) 736 && (! macro_strip_at || kind == '@')) 737 idx++; 738 return idx; 739 } 740 741 /* Substitute the actual value for a formal parameter. */ 742 743 static size_t 744 sub_actual (size_t start, sb *in, sb *t, struct hash_control *formal_hash, 745 int kind, sb *out, int copyifnotthere) 746 { 747 size_t src; 748 formal_entry *ptr; 749 750 src = get_apost_token (start, in, t, kind); 751 /* See if it's in the macro's hash table, unless this is 752 macro_strip_at and kind is '@' and the token did not end in '@'. */ 753 if (macro_strip_at 754 && kind == '@' 755 && (src == start || in->ptr[src - 1] != '@')) 756 ptr = NULL; 757 else 758 ptr = (formal_entry *) hash_find (formal_hash, sb_terminate (t)); 759 if (ptr) 760 { 761 if (ptr->actual.len) 762 { 763 sb_add_sb (out, &ptr->actual); 764 } 765 else 766 { 767 sb_add_sb (out, &ptr->def); 768 } 769 } 770 else if (kind == '&') 771 { 772 /* Doing this permits people to use & in macro bodies. */ 773 sb_add_char (out, '&'); 774 sb_add_sb (out, t); 775 if (src != start && in->ptr[src - 1] == '&') 776 sb_add_char (out, '&'); 777 } 778 else if (copyifnotthere) 779 { 780 sb_add_sb (out, t); 781 } 782 else 783 { 784 sb_add_char (out, '\\'); 785 sb_add_sb (out, t); 786 } 787 return src; 788 } 789 790 /* Expand the body of a macro. */ 791 792 static const char * 793 macro_expand_body (sb *in, sb *out, formal_entry *formals, 794 struct hash_control *formal_hash, const macro_entry *macro) 795 { 796 sb t; 797 size_t src = 0; 798 int inquote = 0, macro_line = 0; 799 formal_entry *loclist = NULL; 800 const char *err = NULL; 801 802 sb_new (&t); 803 804 while (src < in->len && !err) 805 { 806 if (in->ptr[src] == '&') 807 { 808 sb_reset (&t); 809 if (macro_mri) 810 { 811 if (src + 1 < in->len && in->ptr[src + 1] == '&') 812 src = sub_actual (src + 2, in, &t, formal_hash, '\'', out, 1); 813 else 814 sb_add_char (out, in->ptr[src++]); 815 } 816 else 817 { 818 /* Permit macro parameter substition delineated with 819 an '&' prefix and optional '&' suffix. */ 820 src = sub_actual (src + 1, in, &t, formal_hash, '&', out, 0); 821 } 822 } 823 else if (in->ptr[src] == '\\') 824 { 825 src++; 826 if (src < in->len && in->ptr[src] == '(') 827 { 828 /* Sub in till the next ')' literally. */ 829 src++; 830 while (src < in->len && in->ptr[src] != ')') 831 { 832 sb_add_char (out, in->ptr[src++]); 833 } 834 if (src < in->len) 835 src++; 836 else if (!macro) 837 err = _("missing `)'"); 838 else 839 as_bad_where (macro->file, macro->line + macro_line, _("missing `)'")); 840 } 841 else if (src < in->len && in->ptr[src] == '@') 842 { 843 /* Sub in the macro invocation number. */ 844 845 char buffer[10]; 846 src++; 847 sprintf (buffer, "%d", macro_number); 848 sb_add_string (out, buffer); 849 } 850 else if (src < in->len && in->ptr[src] == '&') 851 { 852 /* This is a preprocessor variable name, we don't do them 853 here. */ 854 sb_add_char (out, '\\'); 855 sb_add_char (out, '&'); 856 src++; 857 } 858 else if (macro_mri && src < in->len && ISALNUM (in->ptr[src])) 859 { 860 int ind; 861 formal_entry *f; 862 863 if (ISDIGIT (in->ptr[src])) 864 ind = in->ptr[src] - '0'; 865 else if (ISUPPER (in->ptr[src])) 866 ind = in->ptr[src] - 'A' + 10; 867 else 868 ind = in->ptr[src] - 'a' + 10; 869 ++src; 870 for (f = formals; f != NULL; f = f->next) 871 { 872 if (f->index == ind - 1) 873 { 874 if (f->actual.len != 0) 875 sb_add_sb (out, &f->actual); 876 else 877 sb_add_sb (out, &f->def); 878 break; 879 } 880 } 881 } 882 else 883 { 884 sb_reset (&t); 885 src = sub_actual (src, in, &t, formal_hash, '\'', out, 0); 886 } 887 } 888 else if ((macro_alternate || macro_mri) 889 && is_name_beginner (in->ptr[src]) 890 && (! inquote 891 || ! macro_strip_at 892 || (src > 0 && in->ptr[src - 1] == '@'))) 893 { 894 if (! macro 895 || src + 5 >= in->len 896 || strncasecmp (in->ptr + src, "LOCAL", 5) != 0 897 || ! ISWHITE (in->ptr[src + 5]) 898 /* PR 11507: Skip keyword LOCAL if it is found inside a quoted string. */ 899 || inquote) 900 { 901 sb_reset (&t); 902 src = sub_actual (src, in, &t, formal_hash, 903 (macro_strip_at && inquote) ? '@' : '\'', 904 out, 1); 905 } 906 else 907 { 908 src = sb_skip_white (src + 5, in); 909 while (in->ptr[src] != '\n') 910 { 911 const char *name; 912 formal_entry *f = new_formal (); 913 914 src = get_token (src, in, &f->name); 915 name = sb_terminate (&f->name); 916 if (! hash_find (formal_hash, name)) 917 { 918 static int loccnt; 919 char buf[20]; 920 921 f->index = LOCAL_INDEX; 922 f->next = loclist; 923 loclist = f; 924 925 sprintf (buf, IS_ELF ? ".LL%04x" : "LL%04x", ++loccnt); 926 sb_add_string (&f->actual, buf); 927 928 err = hash_jam (formal_hash, name, f); 929 if (err != NULL) 930 break; 931 } 932 else 933 { 934 as_bad_where (macro->file, 935 macro->line + macro_line, 936 _("`%s' was already used as parameter (or another local) name"), 937 name); 938 del_formal (f); 939 } 940 941 src = sb_skip_comma (src, in); 942 } 943 } 944 } 945 else if (in->ptr[src] == '"' 946 || (macro_mri && in->ptr[src] == '\'')) 947 { 948 inquote = !inquote; 949 sb_add_char (out, in->ptr[src++]); 950 } 951 else if (in->ptr[src] == '@' && macro_strip_at) 952 { 953 ++src; 954 if (src < in->len 955 && in->ptr[src] == '@') 956 { 957 sb_add_char (out, '@'); 958 ++src; 959 } 960 } 961 else if (macro_mri 962 && in->ptr[src] == '=' 963 && src + 1 < in->len 964 && in->ptr[src + 1] == '=') 965 { 966 formal_entry *ptr; 967 968 sb_reset (&t); 969 src = get_token (src + 2, in, &t); 970 ptr = (formal_entry *) hash_find (formal_hash, sb_terminate (&t)); 971 if (ptr == NULL) 972 { 973 /* FIXME: We should really return a warning string here, 974 but we can't, because the == might be in the MRI 975 comment field, and, since the nature of the MRI 976 comment field depends upon the exact instruction 977 being used, we don't have enough information here to 978 figure out whether it is or not. Instead, we leave 979 the == in place, which should cause a syntax error if 980 it is not in a comment. */ 981 sb_add_char (out, '='); 982 sb_add_char (out, '='); 983 sb_add_sb (out, &t); 984 } 985 else 986 { 987 if (ptr->actual.len) 988 { 989 sb_add_string (out, "-1"); 990 } 991 else 992 { 993 sb_add_char (out, '0'); 994 } 995 } 996 } 997 else 998 { 999 if (in->ptr[src] == '\n') 1000 ++macro_line; 1001 sb_add_char (out, in->ptr[src++]); 1002 } 1003 } 1004 1005 sb_kill (&t); 1006 1007 while (loclist != NULL) 1008 { 1009 formal_entry *f; 1010 const char *name; 1011 1012 f = loclist->next; 1013 name = sb_terminate (&loclist->name); 1014 hash_delete (formal_hash, name, f == NULL); 1015 del_formal (loclist); 1016 loclist = f; 1017 } 1018 1019 return err; 1020 } 1021 1022 /* Assign values to the formal parameters of a macro, and expand the 1023 body. */ 1024 1025 static const char * 1026 macro_expand (size_t idx, sb *in, macro_entry *m, sb *out) 1027 { 1028 sb t; 1029 formal_entry *ptr; 1030 formal_entry *f; 1031 int is_keyword = 0; 1032 int narg = 0; 1033 const char *err = NULL; 1034 1035 sb_new (&t); 1036 1037 /* Reset any old value the actuals may have. */ 1038 for (f = m->formals; f; f = f->next) 1039 sb_reset (&f->actual); 1040 f = m->formals; 1041 while (f != NULL && f->index < 0) 1042 f = f->next; 1043 1044 if (macro_mri) 1045 { 1046 /* The macro may be called with an optional qualifier, which may 1047 be referred to in the macro body as \0. */ 1048 if (idx < in->len && in->ptr[idx] == '.') 1049 { 1050 /* The Microtec assembler ignores this if followed by a white space. 1051 (Macro invocation with empty extension) */ 1052 idx++; 1053 if ( idx < in->len 1054 && in->ptr[idx] != ' ' 1055 && in->ptr[idx] != '\t') 1056 { 1057 formal_entry *n = new_formal (); 1058 1059 n->index = QUAL_INDEX; 1060 1061 n->next = m->formals; 1062 m->formals = n; 1063 1064 idx = get_any_string (idx, in, &n->actual); 1065 } 1066 } 1067 } 1068 1069 /* Peel off the actuals and store them away in the hash tables' actuals. */ 1070 idx = sb_skip_white (idx, in); 1071 while (idx < in->len) 1072 { 1073 size_t scan; 1074 1075 /* Look and see if it's a positional or keyword arg. */ 1076 scan = idx; 1077 while (scan < in->len 1078 && !ISSEP (in->ptr[scan]) 1079 && !(macro_mri && in->ptr[scan] == '\'') 1080 && (!macro_alternate && in->ptr[scan] != '=')) 1081 scan++; 1082 if (scan < in->len && !macro_alternate && in->ptr[scan] == '=') 1083 { 1084 is_keyword = 1; 1085 1086 /* It's OK to go from positional to keyword. */ 1087 1088 /* This is a keyword arg, fetch the formal name and 1089 then the actual stuff. */ 1090 sb_reset (&t); 1091 idx = get_token (idx, in, &t); 1092 if (in->ptr[idx] != '=') 1093 { 1094 err = _("confusion in formal parameters"); 1095 break; 1096 } 1097 1098 /* Lookup the formal in the macro's list. */ 1099 ptr = (formal_entry *) hash_find (m->formal_hash, sb_terminate (&t)); 1100 if (!ptr) 1101 { 1102 as_bad (_("Parameter named `%s' does not exist for macro `%s'"), 1103 t.ptr, 1104 m->name); 1105 sb_reset (&t); 1106 idx = get_any_string (idx + 1, in, &t); 1107 } 1108 else 1109 { 1110 /* Insert this value into the right place. */ 1111 if (ptr->actual.len) 1112 { 1113 as_warn (_("Value for parameter `%s' of macro `%s' was already specified"), 1114 ptr->name.ptr, 1115 m->name); 1116 sb_reset (&ptr->actual); 1117 } 1118 idx = get_any_string (idx + 1, in, &ptr->actual); 1119 if (ptr->actual.len > 0) 1120 ++narg; 1121 } 1122 } 1123 else 1124 { 1125 if (is_keyword) 1126 { 1127 err = _("can't mix positional and keyword arguments"); 1128 break; 1129 } 1130 1131 if (!f) 1132 { 1133 formal_entry **pf; 1134 int c; 1135 1136 if (!macro_mri) 1137 { 1138 err = _("too many positional arguments"); 1139 break; 1140 } 1141 1142 f = new_formal (); 1143 1144 c = -1; 1145 for (pf = &m->formals; *pf != NULL; pf = &(*pf)->next) 1146 if ((*pf)->index >= c) 1147 c = (*pf)->index + 1; 1148 if (c == -1) 1149 c = 0; 1150 *pf = f; 1151 f->index = c; 1152 } 1153 1154 if (f->type != FORMAL_VARARG) 1155 idx = get_any_string (idx, in, &f->actual); 1156 else 1157 { 1158 sb_add_buffer (&f->actual, in->ptr + idx, in->len - idx); 1159 idx = in->len; 1160 } 1161 if (f->actual.len > 0) 1162 ++narg; 1163 do 1164 { 1165 f = f->next; 1166 } 1167 while (f != NULL && f->index < 0); 1168 } 1169 1170 if (! macro_mri) 1171 idx = sb_skip_comma (idx, in); 1172 else 1173 { 1174 if (in->ptr[idx] == ',') 1175 ++idx; 1176 if (ISWHITE (in->ptr[idx])) 1177 break; 1178 } 1179 } 1180 1181 if (! err) 1182 { 1183 for (ptr = m->formals; ptr; ptr = ptr->next) 1184 { 1185 if (ptr->type == FORMAL_REQUIRED && ptr->actual.len == 0) 1186 as_bad (_("Missing value for required parameter `%s' of macro `%s'"), 1187 ptr->name.ptr, 1188 m->name); 1189 } 1190 1191 if (macro_mri) 1192 { 1193 char buffer[20]; 1194 1195 sb_reset (&t); 1196 sb_add_string (&t, macro_strip_at ? "$NARG" : "NARG"); 1197 ptr = (formal_entry *) hash_find (m->formal_hash, sb_terminate (&t)); 1198 sprintf (buffer, "%d", narg); 1199 sb_add_string (&ptr->actual, buffer); 1200 } 1201 1202 err = macro_expand_body (&m->sub, out, m->formals, m->formal_hash, m); 1203 } 1204 1205 /* Discard any unnamed formal arguments. */ 1206 if (macro_mri) 1207 { 1208 formal_entry **pf; 1209 1210 pf = &m->formals; 1211 while (*pf != NULL) 1212 { 1213 if ((*pf)->name.len != 0) 1214 pf = &(*pf)->next; 1215 else 1216 { 1217 f = (*pf)->next; 1218 del_formal (*pf); 1219 *pf = f; 1220 } 1221 } 1222 } 1223 1224 sb_kill (&t); 1225 if (!err) 1226 macro_number++; 1227 1228 return err; 1229 } 1230 1231 /* Check for a macro. If one is found, put the expansion into 1232 *EXPAND. Return 1 if a macro is found, 0 otherwise. */ 1233 1234 int 1235 check_macro (const char *line, sb *expand, 1236 const char **error, macro_entry **info) 1237 { 1238 const char *s; 1239 char *copy, *cls; 1240 macro_entry *macro; 1241 sb line_sb; 1242 1243 if (! is_name_beginner (*line) 1244 && (! macro_mri || *line != '.')) 1245 return 0; 1246 1247 s = line + 1; 1248 while (is_part_of_name (*s)) 1249 ++s; 1250 if (is_name_ender (*s)) 1251 ++s; 1252 1253 copy = xmemdup0 (line, s - line); 1254 for (cls = copy; *cls != '\0'; cls ++) 1255 *cls = TOLOWER (*cls); 1256 1257 macro = (macro_entry *) hash_find (macro_hash, copy); 1258 free (copy); 1259 1260 if (macro == NULL) 1261 return 0; 1262 1263 /* Wrap the line up in an sb. */ 1264 sb_new (&line_sb); 1265 while (*s != '\0' && *s != '\n' && *s != '\r') 1266 sb_add_char (&line_sb, *s++); 1267 1268 sb_new (expand); 1269 *error = macro_expand (0, &line_sb, macro, expand); 1270 1271 sb_kill (&line_sb); 1272 1273 /* Export the macro information if requested. */ 1274 if (info) 1275 *info = macro; 1276 1277 return 1; 1278 } 1279 1280 /* Delete a macro. */ 1281 1282 void 1283 delete_macro (const char *name) 1284 { 1285 char *copy; 1286 size_t i, len; 1287 macro_entry *macro; 1288 1289 len = strlen (name); 1290 copy = XNEWVEC (char, len + 1); 1291 for (i = 0; i < len; ++i) 1292 copy[i] = TOLOWER (name[i]); 1293 copy[i] = '\0'; 1294 1295 /* We can only ask hash_delete to free memory if we are deleting 1296 macros in reverse order to their definition. 1297 So just clear out the entry. */ 1298 if ((macro = (macro_entry *) hash_find (macro_hash, copy)) != NULL) 1299 { 1300 hash_jam (macro_hash, copy, NULL); 1301 free_macro (macro); 1302 } 1303 else 1304 as_warn (_("Attempt to purge non-existant macro `%s'"), copy); 1305 free (copy); 1306 } 1307 1308 /* Handle the MRI IRP and IRPC pseudo-ops. These are handled as a 1309 combined macro definition and execution. This returns NULL on 1310 success, or an error message otherwise. */ 1311 1312 const char * 1313 expand_irp (int irpc, size_t idx, sb *in, sb *out, size_t (*get_line) (sb *)) 1314 { 1315 sb sub; 1316 formal_entry f; 1317 struct hash_control *h; 1318 const char *err; 1319 1320 idx = sb_skip_white (idx, in); 1321 1322 sb_new (&sub); 1323 if (! buffer_and_nest (NULL, "ENDR", &sub, get_line)) 1324 return _("unexpected end of file in irp or irpc"); 1325 1326 sb_new (&f.name); 1327 sb_new (&f.def); 1328 sb_new (&f.actual); 1329 1330 idx = get_token (idx, in, &f.name); 1331 if (f.name.len == 0) 1332 return _("missing model parameter"); 1333 1334 h = hash_new (); 1335 err = hash_jam (h, sb_terminate (&f.name), &f); 1336 if (err != NULL) 1337 return err; 1338 1339 f.index = 1; 1340 f.next = NULL; 1341 f.type = FORMAL_OPTIONAL; 1342 1343 sb_reset (out); 1344 1345 idx = sb_skip_comma (idx, in); 1346 if (idx >= in->len) 1347 { 1348 /* Expand once with a null string. */ 1349 err = macro_expand_body (&sub, out, &f, h, 0); 1350 } 1351 else 1352 { 1353 bfd_boolean in_quotes = FALSE; 1354 1355 if (irpc && in->ptr[idx] == '"') 1356 { 1357 in_quotes = TRUE; 1358 ++idx; 1359 } 1360 1361 while (idx < in->len) 1362 { 1363 if (!irpc) 1364 idx = get_any_string (idx, in, &f.actual); 1365 else 1366 { 1367 if (in->ptr[idx] == '"') 1368 { 1369 size_t nxt; 1370 1371 if (irpc) 1372 in_quotes = ! in_quotes; 1373 1374 nxt = sb_skip_white (idx + 1, in); 1375 if (nxt >= in->len) 1376 { 1377 idx = nxt; 1378 break; 1379 } 1380 } 1381 sb_reset (&f.actual); 1382 sb_add_char (&f.actual, in->ptr[idx]); 1383 ++idx; 1384 } 1385 1386 err = macro_expand_body (&sub, out, &f, h, 0); 1387 if (err != NULL) 1388 break; 1389 if (!irpc) 1390 idx = sb_skip_comma (idx, in); 1391 else if (! in_quotes) 1392 idx = sb_skip_white (idx, in); 1393 } 1394 } 1395 1396 hash_die (h); 1397 sb_kill (&f.actual); 1398 sb_kill (&f.def); 1399 sb_kill (&f.name); 1400 sb_kill (&sub); 1401 1402 return err; 1403 } 1404
