![[BACK]](/icons/back.gif){kind=icon}
Return to aicasm.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / microcode / aic7xxx|
Return to aicasm.c CVS log | Up to [local] / sys / dev / microcode / aic7xxx |
1.1 ! nbrk 1: /* $OpenBSD: aicasm.c,v 1.14 2005/10/04 23:46:14 krw Exp $ */
! 2: /*
! 3: * Aic7xxx SCSI host adapter firmware asssembler
! 4: *
! 5: * Copyright (c) 1997, 1998, 2000, 2001 Justin T. Gibbs.
! 6: * Copyright (c) 2001, 2002 Adaptec Inc.
! 7: * All rights reserved.
! 8: *
! 9: * Redistribution and use in source and binary forms, with or without
! 10: * modification, are permitted provided that the following conditions
! 11: * are met:
! 12: * 1. Redistributions of source code must retain the above copyright
! 13: * notice, this list of conditions, and the following disclaimer,
! 14: * without modification.
! 15: * 2. Redistributions in binary form must reproduce at minimum a disclaimer
! 16: * substantially similar to the "NO WARRANTY" disclaimer below
! 17: * ("Disclaimer") and any redistribution must be conditioned upon
! 18: * including a substantially similar Disclaimer requirement for further
! 19: * binary redistribution.
! 20: * 3. Neither the names of the above-listed copyright holders nor the names
! 21: * of any contributors may be used to endorse or promote products derived
! 22: * from this software without specific prior written permission.
! 23: *
! 24: * Alternatively, this software may be distributed under the terms of the
! 25: * GNU General Public License ("GPL") version 2 as published by the Free
! 26: * Software Foundation.
! 27: *
! 28: * NO WARRANTY
! 29: * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
! 30: * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
! 31: * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
! 32: * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
! 33: * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 34: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 35: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 36: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
! 37: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
! 38: * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
! 39: * POSSIBILITY OF SUCH DAMAGES.
! 40: *
! 41: * $Id: aicasm.c,v 1.14 2005/10/04 23:46:14 krw Exp $
! 42: *
! 43: * $FreeBSD: src/sys/dev/aic7xxx/aicasm/aicasm.c,v 1.37 2004/03/12 21:45:25 trhodes Exp $
! 44: */
! 45: #include <sys/cdefs.h>
! 46: #include <sys/types.h>
! 47: #include <sys/mman.h>
! 48:
! 49: #include <ctype.h>
! 50: #include <inttypes.h>
! 51: #include <regex.h>
! 52: #include <stdio.h>
! 53: #include <stdlib.h>
! 54: #include <string.h>
! 55: #include <sysexits.h>
! 56: #include <unistd.h>
! 57:
! 58: #if linux
! 59: #include <endian.h>
! 60: #else
! 61: #include <machine/endian.h>
! 62: #endif
! 63:
! 64: #include "aicasm.h"
! 65: #include "aicasm_symbol.h"
! 66: #include "aicasm_insformat.h"
! 67:
! 68: typedef struct patch {
! 69: TAILQ_ENTRY(patch) links;
! 70: int patch_func;
! 71: u_int begin;
! 72: u_int skip_instr;
! 73: u_int skip_patch;
! 74: } patch_t;
! 75:
! 76: TAILQ_HEAD(patch_list, patch) patches;
! 77:
! 78: static void usage(void);
! 79: static void back_patch(void);
! 80: static void output_code(void);
! 81: static void output_listing(char *ifilename);
! 82: static void dump_scope(scope_t *scope);
! 83: static void emit_patch(scope_t *scope, int patch);
! 84: static int check_patch(patch_t **start_patch, int start_instr,
! 85: int *skip_addr, int *func_vals);
! 86:
! 87: struct path_list search_path;
! 88: int includes_search_curdir;
! 89: char *appname;
! 90: char *stock_include_file;
! 91: FILE *ofile;
! 92: char *ofilename;
! 93: char *regfilename;
! 94: FILE *regfile;
! 95: char *listfilename;
! 96: FILE *listfile;
! 97: char *regdiagfilename;
! 98: FILE *regdiagfile;
! 99: int src_mode;
! 100: int dst_mode;
! 101:
! 102: static TAILQ_HEAD(,instruction) seq_program;
! 103: struct cs_tailq cs_tailq;
! 104: struct scope_list scope_stack;
! 105: symlist_t patch_functions;
! 106:
! 107: #if DEBUG
! 108: extern int yy_flex_debug;
! 109: extern int mm_flex_debug;
! 110: extern int yydebug;
! 111: extern int mmdebug;
! 112: #endif
! 113: extern FILE *yyin;
! 114: extern int yyparse(void);
! 115:
! 116: int main(int argc, char *argv[]);
! 117:
! 118: int
! 119: main(int argc, char *argv[])
! 120: {
! 121: extern char *optarg;
! 122: extern int optind;
! 123: int ch;
! 124: int retval;
! 125: char *inputfilename;
! 126: scope_t *sentinal;
! 127:
! 128: TAILQ_INIT(&patches);
! 129: SLIST_INIT(&search_path);
! 130: TAILQ_INIT(&seq_program);
! 131: TAILQ_INIT(&cs_tailq);
! 132: SLIST_INIT(&scope_stack);
! 133:
! 134: /* Set Sentinal scope node */
! 135: sentinal = scope_alloc();
! 136: sentinal->type = SCOPE_ROOT;
! 137:
! 138: includes_search_curdir = 1;
! 139: appname = *argv;
! 140: regfile = NULL;
! 141: listfile = NULL;
! 142: #if DEBUG
! 143: yy_flex_debug = 0;
! 144: mm_flex_debug = 0;
! 145: yydebug = 0;
! 146: mmdebug = 0;
! 147: #endif
! 148: while ((ch = getopt(argc, argv, "d:i:l:n:o:p:r:I:X")) != -1) {
! 149: switch(ch) {
! 150: case 'd':
! 151: #if DEBUG
! 152: if (strcmp(optarg, "s") == 0) {
! 153: yy_flex_debug = 1;
! 154: mm_flex_debug = 1;
! 155: } else if (strcmp(optarg, "p") == 0) {
! 156: yydebug = 1;
! 157: mmdebug = 1;
! 158: } else {
! 159: fprintf(stderr, "%s: -d Requires either an "
! 160: "'s' or 'p' argument\n", appname);
! 161: usage();
! 162: }
! 163: #else
! 164: stop("-d: Assembler not built with debugging "
! 165: "information", EX_SOFTWARE);
! 166: #endif
! 167: break;
! 168: case 'i':
! 169: stock_include_file = optarg;
! 170: break;
! 171: case 'l':
! 172: /* Create a program listing */
! 173: if ((listfile = fopen(optarg, "w")) == NULL) {
! 174: perror(optarg);
! 175: stop(NULL, EX_CANTCREAT);
! 176: }
! 177: listfilename = optarg;
! 178: break;
! 179: case 'n':
! 180: /* Don't complain about the -nostdinc directrive */
! 181: if (strcmp(optarg, "ostdinc")) {
! 182: fprintf(stderr, "%s: Unknown option -%c%s\n",
! 183: appname, ch, optarg);
! 184: usage();
! 185: /* NOTREACHED */
! 186: }
! 187: break;
! 188: case 'o':
! 189: if ((ofile = fopen(optarg, "w")) == NULL) {
! 190: perror(optarg);
! 191: stop(NULL, EX_CANTCREAT);
! 192: }
! 193: ofilename = optarg;
! 194: break;
! 195: case 'p':
! 196: /* Create Register Diagnostic "printing" Functions */
! 197: if ((regdiagfile = fopen(optarg, "w")) == NULL) {
! 198: perror(optarg);
! 199: stop(NULL, EX_CANTCREAT);
! 200: }
! 201: regdiagfilename = optarg;
! 202: break;
! 203: case 'r':
! 204: if ((regfile = fopen(optarg, "w")) == NULL) {
! 205: perror(optarg);
! 206: stop(NULL, EX_CANTCREAT);
! 207: }
! 208: regfilename = optarg;
! 209: break;
! 210: case 'I':
! 211: {
! 212: path_entry_t include_dir;
! 213:
! 214: if (strcmp(optarg, "-") == 0) {
! 215: if (includes_search_curdir == 0) {
! 216: fprintf(stderr, "%s: Warning - '-I-' "
! 217: "specified multiple "
! 218: "times\n", appname);
! 219: }
! 220: includes_search_curdir = 0;
! 221: for (include_dir = SLIST_FIRST(&search_path);
! 222: include_dir != NULL;
! 223: include_dir = SLIST_NEXT(include_dir,
! 224: links))
! 225: /*
! 226: * All entries before a '-I-' only
! 227: * apply to includes specified with
! 228: * quotes instead of "<>".
! 229: */
! 230: include_dir->quoted_includes_only = 1;
! 231: } else {
! 232: include_dir =
! 233: (path_entry_t)malloc(sizeof(*include_dir));
! 234: if (include_dir == NULL) {
! 235: perror(optarg);
! 236: stop(NULL, EX_OSERR);
! 237: }
! 238: include_dir->directory = strdup(optarg);
! 239: if (include_dir->directory == NULL) {
! 240: perror(optarg);
! 241: stop(NULL, EX_OSERR);
! 242: }
! 243: include_dir->quoted_includes_only = 0;
! 244: SLIST_INSERT_HEAD(&search_path, include_dir,
! 245: links);
! 246: }
! 247: break;
! 248: }
! 249: case 'X':
! 250: /* icc version of -nostdinc */
! 251: break;
! 252: case '?':
! 253: default:
! 254: usage();
! 255: /* NOTREACHED */
! 256: }
! 257: }
! 258: argc -= optind;
! 259: argv += optind;
! 260:
! 261: if (argc != 1) {
! 262: fprintf(stderr, "%s: No input file specifiled\n", appname);
! 263: usage();
! 264: /* NOTREACHED */
! 265: }
! 266:
! 267: if (regdiagfile != NULL
! 268: && (regfile == NULL || stock_include_file == NULL)) {
! 269: fprintf(stderr,
! 270: "%s: The -p option requires the -r and -i options.\n",
! 271: appname);
! 272: usage();
! 273: /* NOTREACHED */
! 274: }
! 275: symtable_open();
! 276: inputfilename = *argv;
! 277: include_file(*argv, SOURCE_FILE);
! 278: retval = yyparse();
! 279: if (retval == 0) {
! 280: if (SLIST_FIRST(&scope_stack) == NULL
! 281: || SLIST_FIRST(&scope_stack)->type != SCOPE_ROOT) {
! 282: stop("Unterminated conditional expression", EX_DATAERR);
! 283: /* NOTREACHED */
! 284: }
! 285:
! 286: /* Process outmost scope */
! 287: process_scope(SLIST_FIRST(&scope_stack));
! 288: /*
! 289: * Decend the tree of scopes and insert/emit
! 290: * patches as appropriate. We perform a depth first
! 291: * tranversal, recursively handling each scope.
! 292: */
! 293: /* start at the root scope */
! 294: dump_scope(SLIST_FIRST(&scope_stack));
! 295:
! 296: /* Patch up forward jump addresses */
! 297: back_patch();
! 298:
! 299: if (ofile != NULL)
! 300: output_code();
! 301: if (regfile != NULL)
! 302: symtable_dump(regfile, regdiagfile);
! 303: if (listfile != NULL)
! 304: output_listing(inputfilename);
! 305: }
! 306:
! 307: stop(NULL, 0);
! 308: /* NOTREACHED */
! 309: return (0);
! 310: }
! 311:
! 312: static void
! 313: usage()
! 314: {
! 315:
! 316: (void)fprintf(stderr,
! 317: "usage: %-16s [-nostdinc|-X] [-I-] [-I directory] [-o output_file]\n"
! 318: " [-r register_output_file [-p register_diag_file -i includefile]]\n"
! 319: " [-l program_list_file]\n"
! 320: " input_file\n", appname);
! 321: exit(EX_USAGE);
! 322: }
! 323:
! 324: static void
! 325: back_patch()
! 326: {
! 327: struct instruction *cur_instr;
! 328:
! 329: for (cur_instr = TAILQ_FIRST(&seq_program);
! 330: cur_instr != NULL;
! 331: cur_instr = TAILQ_NEXT(cur_instr, links)) {
! 332: if (cur_instr->patch_label != NULL) {
! 333: struct ins_format3 *f3_instr;
! 334: u_int address;
! 335:
! 336: if (cur_instr->patch_label->type != LABEL) {
! 337: char buf[255];
! 338:
! 339: snprintf(buf, sizeof(buf),
! 340: "Undefined label %s",
! 341: cur_instr->patch_label->name);
! 342: stop(buf, EX_DATAERR);
! 343: /* NOTREACHED */
! 344: }
! 345: f3_instr = &cur_instr->format.format3;
! 346: address = f3_instr->address;
! 347: address += cur_instr->patch_label->info.linfo->address;
! 348: f3_instr->address = address;
! 349: }
! 350: }
! 351: }
! 352:
! 353: static void
! 354: output_code()
! 355: {
! 356: struct instruction *cur_instr;
! 357: patch_t *cur_patch;
! 358: critical_section_t *cs;
! 359: symbol_node_t *cur_node;
! 360: int instrcount;
! 361:
! 362: instrcount = 0;
! 363: fprintf(ofile,
! 364: "/*\n"
! 365: " * DO NOT EDIT - This file is automatically generated\n"
! 366: " * from the following source files:\n"
! 367: " *\n"
! 368: "%s */\n", versions);
! 369:
! 370: fprintf(ofile, "static const uint8_t seqprog[] = {\n");
! 371: for (cur_instr = TAILQ_FIRST(&seq_program);
! 372: cur_instr != NULL;
! 373: cur_instr = TAILQ_NEXT(cur_instr, links)) {
! 374:
! 375: fprintf(ofile, "%s\t0x%02x, 0x%02x, 0x%02x, 0x%02x",
! 376: cur_instr == TAILQ_FIRST(&seq_program) ? "" : ",\n",
! 377: #if BYTE_ORDER == LITTLE_ENDIAN
! 378: cur_instr->format.bytes[0],
! 379: cur_instr->format.bytes[1],
! 380: cur_instr->format.bytes[2],
! 381: cur_instr->format.bytes[3]);
! 382: #else
! 383: cur_instr->format.bytes[3],
! 384: cur_instr->format.bytes[2],
! 385: cur_instr->format.bytes[1],
! 386: cur_instr->format.bytes[0]);
! 387: #endif
! 388: instrcount++;
! 389: }
! 390: fprintf(ofile, "\n};\n\n");
! 391:
! 392: if (patch_arg_list == NULL)
! 393: stop("Patch argument list not defined",
! 394: EX_DATAERR);
! 395:
! 396: /*
! 397: * Output patch information. Patch functions first.
! 398: */
! 399: fprintf(ofile,
! 400: "typedef int %spatch_func_t (%s);\n", prefix, patch_arg_list);
! 401:
! 402: for (cur_node = SLIST_FIRST(&patch_functions);
! 403: cur_node != NULL;
! 404: cur_node = SLIST_NEXT(cur_node,links)) {
! 405: fprintf(ofile,
! 406: "static %spatch_func_t %spatch%d_func;\n"
! 407: "\n"
! 408: "static int\n"
! 409: "%spatch%d_func(%s)\n"
! 410: "{\n"
! 411: " return (%s);\n"
! 412: "}\n\n",
! 413: prefix,
! 414: prefix,
! 415: cur_node->symbol->info.condinfo->func_num,
! 416: prefix,
! 417: cur_node->symbol->info.condinfo->func_num,
! 418: patch_arg_list,
! 419: cur_node->symbol->name);
! 420: }
! 421:
! 422: fprintf(ofile,
! 423: "static const struct patch {\n"
! 424: " %spatch_func_t *patch_func;\n"
! 425: " uint32_t begin :10,\n"
! 426: " skip_instr :10,\n"
! 427: " skip_patch :12;\n"
! 428: "} patches[] = {\n", prefix);
! 429:
! 430: for (cur_patch = TAILQ_FIRST(&patches);
! 431: cur_patch != NULL;
! 432: cur_patch = TAILQ_NEXT(cur_patch,links)) {
! 433: fprintf(ofile, "%s\t{ %spatch%d_func, %d, %d, %d }",
! 434: cur_patch == TAILQ_FIRST(&patches) ? "" : ",\n",
! 435: prefix,
! 436: cur_patch->patch_func, cur_patch->begin,
! 437: cur_patch->skip_instr, cur_patch->skip_patch);
! 438: }
! 439:
! 440: fprintf(ofile, "\n};\n\n");
! 441:
! 442: fprintf(ofile,
! 443: "static const struct cs {\n"
! 444: " uint16_t begin;\n"
! 445: " uint16_t end;\n"
! 446: "} critical_sections[] = {\n");
! 447:
! 448: for (cs = TAILQ_FIRST(&cs_tailq);
! 449: cs != NULL;
! 450: cs = TAILQ_NEXT(cs, links)) {
! 451: fprintf(ofile, "%s\t{ %d, %d }",
! 452: cs == TAILQ_FIRST(&cs_tailq) ? "" : ",\n",
! 453: cs->begin_addr, cs->end_addr);
! 454: }
! 455:
! 456: fprintf(ofile, "\n};\n\n");
! 457:
! 458: fprintf(ofile,
! 459: "#define NUM_CRITICAL_SECTIONS (sizeof(critical_sections) / sizeof(*critical_sections))\n");
! 460:
! 461: fprintf(stderr, "%s: %d instructions used\n", appname, instrcount);
! 462: }
! 463:
! 464: static void
! 465: dump_scope(scope_t *scope)
! 466: {
! 467: scope_t *cur_scope;
! 468:
! 469: /*
! 470: * Emit the first patch for this scope
! 471: */
! 472: emit_patch(scope, 0);
! 473:
! 474: /*
! 475: * Dump each scope within this one.
! 476: */
! 477: cur_scope = TAILQ_FIRST(&scope->inner_scope);
! 478:
! 479: while (cur_scope != NULL) {
! 480:
! 481: dump_scope(cur_scope);
! 482:
! 483: cur_scope = TAILQ_NEXT(cur_scope, scope_links);
! 484: }
! 485:
! 486: /*
! 487: * Emit the second, closing, patch for this scope
! 488: */
! 489: emit_patch(scope, 1);
! 490: }
! 491:
! 492: void
! 493: emit_patch(scope_t *scope, int patch)
! 494: {
! 495: patch_info_t *pinfo;
! 496: patch_t *new_patch;
! 497:
! 498: pinfo = &scope->patches[patch];
! 499:
! 500: if (pinfo->skip_instr == 0)
! 501: /* No-Op patch */
! 502: return;
! 503:
! 504: new_patch = (patch_t *)malloc(sizeof(*new_patch));
! 505:
! 506: if (new_patch == NULL)
! 507: stop("Could not malloc patch structure", EX_OSERR);
! 508:
! 509: memset(new_patch, 0, sizeof(*new_patch));
! 510:
! 511: if (patch == 0) {
! 512: new_patch->patch_func = scope->func_num;
! 513: new_patch->begin = scope->begin_addr;
! 514: } else {
! 515: new_patch->patch_func = 0;
! 516: new_patch->begin = scope->end_addr;
! 517: }
! 518: new_patch->skip_instr = pinfo->skip_instr;
! 519: new_patch->skip_patch = pinfo->skip_patch;
! 520: TAILQ_INSERT_TAIL(&patches, new_patch, links);
! 521: }
! 522:
! 523: void
! 524: output_listing(char *ifilename)
! 525: {
! 526: char buf[1024];
! 527: FILE *ifile;
! 528: struct instruction *cur_instr;
! 529: patch_t *cur_patch;
! 530: symbol_node_t *cur_func;
! 531: int *func_values;
! 532: int instrcount;
! 533: int instrptr;
! 534: int line;
! 535: int func_count;
! 536: int skip_addr;
! 537:
! 538: instrcount = 0;
! 539: instrptr = 0;
! 540: line = 1;
! 541: skip_addr = 0;
! 542: if ((ifile = fopen(ifilename, "r")) == NULL) {
! 543: perror(ifilename);
! 544: stop(NULL, EX_DATAERR);
! 545: }
! 546:
! 547: /*
! 548: * Determine which options to apply to this listing.
! 549: */
! 550: for (func_count = 0, cur_func = SLIST_FIRST(&patch_functions);
! 551: cur_func != NULL;
! 552: cur_func = SLIST_NEXT(cur_func, links))
! 553: func_count++;
! 554:
! 555: func_values = NULL;
! 556: if (func_count != 0) {
! 557: func_values = (int *)malloc(func_count * sizeof(int));
! 558:
! 559: if (func_values == NULL)
! 560: stop("Could not malloc", EX_OSERR);
! 561:
! 562: func_values[0] = 0; /* FALSE func */
! 563: func_count--;
! 564:
! 565: /*
! 566: * Ask the user to fill in the return values for
! 567: * the rest of the functions.
! 568: */
! 569:
! 570:
! 571: for (cur_func = SLIST_FIRST(&patch_functions);
! 572: cur_func != NULL && SLIST_NEXT(cur_func, links) != NULL;
! 573: cur_func = SLIST_NEXT(cur_func, links), func_count--) {
! 574: int input;
! 575:
! 576: fprintf(stdout, "\n(%s)\n", cur_func->symbol->name);
! 577: fprintf(stdout,
! 578: "Enter the return value for "
! 579: "this expression[T/F]:");
! 580:
! 581: while (1) {
! 582:
! 583: input = getchar();
! 584: input = toupper(input);
! 585:
! 586: if (input == 'T') {
! 587: func_values[func_count] = 1;
! 588: break;
! 589: } else if (input == 'F') {
! 590: func_values[func_count] = 0;
! 591: break;
! 592: }
! 593: }
! 594: if (isatty(fileno(stdin)) == 0)
! 595: putchar(input);
! 596: }
! 597: fprintf(stdout, "\nThanks!\n");
! 598: }
! 599:
! 600: /* Now output the listing */
! 601: cur_patch = TAILQ_FIRST(&patches);
! 602: for (cur_instr = TAILQ_FIRST(&seq_program);
! 603: cur_instr != NULL;
! 604: cur_instr = TAILQ_NEXT(cur_instr, links), instrcount++) {
! 605:
! 606: if (check_patch(&cur_patch, instrcount,
! 607: &skip_addr, func_values) == 0) {
! 608: /* Don't count this instruction as it is in a patch
! 609: * that was removed.
! 610: */
! 611: continue;
! 612: }
! 613:
! 614: while (line < cur_instr->srcline) {
! 615: fgets(buf, sizeof(buf), ifile);
! 616: fprintf(listfile, " \t%s", buf);
! 617: line++;
! 618: }
! 619: fprintf(listfile, "%04x %02x%02x%02x%02x", instrptr,
! 620: #if BYTE_ORDER == LITTLE_ENDIAN
! 621: cur_instr->format.bytes[0],
! 622: cur_instr->format.bytes[1],
! 623: cur_instr->format.bytes[2],
! 624: cur_instr->format.bytes[3]);
! 625: #else
! 626: cur_instr->format.bytes[3],
! 627: cur_instr->format.bytes[2],
! 628: cur_instr->format.bytes[1],
! 629: cur_instr->format.bytes[0]);
! 630: #endif
! 631: /*
! 632: * Macro expansions can cause several instructions
! 633: * to be output for a single source line. Only
! 634: * advance the line once in these cases.
! 635: */
! 636: if (line == cur_instr->srcline) {
! 637: fgets(buf, sizeof(buf), ifile);
! 638: fprintf(listfile, "\t%s", buf);
! 639: line++;
! 640: } else {
! 641: fprintf(listfile, "\n");
! 642: }
! 643: instrptr++;
! 644: }
! 645: /* Dump the remainder of the file */
! 646: while(fgets(buf, sizeof(buf), ifile) != NULL)
! 647: fprintf(listfile, " %s", buf);
! 648:
! 649: fclose(ifile);
! 650: }
! 651:
! 652: static int
! 653: check_patch(patch_t **start_patch, int start_instr,
! 654: int *skip_addr, int *func_vals)
! 655: {
! 656: patch_t *cur_patch;
! 657:
! 658: cur_patch = *start_patch;
! 659:
! 660: while (cur_patch != NULL && start_instr == cur_patch->begin) {
! 661: if (func_vals[cur_patch->patch_func] == 0) {
! 662: int skip;
! 663:
! 664: /* Start rejecting code */
! 665: *skip_addr = start_instr + cur_patch->skip_instr;
! 666: for (skip = cur_patch->skip_patch;
! 667: skip > 0 && cur_patch != NULL;
! 668: skip--)
! 669: cur_patch = TAILQ_NEXT(cur_patch, links);
! 670: } else {
! 671: /* Accepted this patch. Advance to the next
! 672: * one and wait for our intruction pointer to
! 673: * hit this point.
! 674: */
! 675: cur_patch = TAILQ_NEXT(cur_patch, links);
! 676: }
! 677: }
! 678:
! 679: *start_patch = cur_patch;
! 680: if (start_instr < *skip_addr)
! 681: /* Still skipping */
! 682: return (0);
! 683:
! 684: return (1);
! 685: }
! 686:
! 687: /*
! 688: * Print out error information if appropriate, and clean up before
! 689: * terminating the program.
! 690: */
! 691: void
! 692: stop(const char *string, int err_code)
! 693: {
! 694: if (string != NULL) {
! 695: fprintf(stderr, "%s: ", appname);
! 696: if (yyfilename != NULL) {
! 697: fprintf(stderr, "Stopped at file %s, line %d - ",
! 698: yyfilename, yylineno);
! 699: }
! 700: fprintf(stderr, "%s\n", string);
! 701: }
! 702:
! 703: if (ofile != NULL) {
! 704: fclose(ofile);
! 705: if (err_code != 0) {
! 706: fprintf(stderr, "%s: Removing %s due to error\n",
! 707: appname, ofilename);
! 708: unlink(ofilename);
! 709: }
! 710: }
! 711:
! 712: if (regfile != NULL) {
! 713: fclose(regfile);
! 714: if (err_code != 0) {
! 715: fprintf(stderr, "%s: Removing %s due to error\n",
! 716: appname, regfilename);
! 717: unlink(regfilename);
! 718: }
! 719: }
! 720:
! 721: if (listfile != NULL) {
! 722: fclose(listfile);
! 723: if (err_code != 0) {
! 724: fprintf(stderr, "%s: Removing %s due to error\n",
! 725: appname, listfilename);
! 726: unlink(listfilename);
! 727: }
! 728: }
! 729:
! 730: symlist_free(&patch_functions);
! 731: symtable_close();
! 732:
! 733: exit(err_code);
! 734: }
! 735:
! 736: struct instruction *
! 737: seq_alloc()
! 738: {
! 739: struct instruction *new_instr;
! 740:
! 741: new_instr = (struct instruction *)malloc(sizeof(struct instruction));
! 742: if (new_instr == NULL)
! 743: stop("Unable to malloc instruction object", EX_SOFTWARE);
! 744: memset(new_instr, 0, sizeof(*new_instr));
! 745: TAILQ_INSERT_TAIL(&seq_program, new_instr, links);
! 746: new_instr->srcline = yylineno;
! 747: return new_instr;
! 748: }
! 749:
! 750: critical_section_t *
! 751: cs_alloc()
! 752: {
! 753: critical_section_t *new_cs;
! 754:
! 755: new_cs= (critical_section_t *)malloc(sizeof(critical_section_t));
! 756: if (new_cs == NULL)
! 757: stop("Unable to malloc critical_section object", EX_SOFTWARE);
! 758: memset(new_cs, 0, sizeof(*new_cs));
! 759:
! 760: TAILQ_INSERT_TAIL(&cs_tailq, new_cs, links);
! 761: return new_cs;
! 762: }
! 763:
! 764: scope_t *
! 765: scope_alloc()
! 766: {
! 767: scope_t *new_scope;
! 768:
! 769: new_scope = (scope_t *)malloc(sizeof(scope_t));
! 770: if (new_scope == NULL)
! 771: stop("Unable to malloc scope object", EX_SOFTWARE);
! 772: memset(new_scope, 0, sizeof(*new_scope));
! 773: TAILQ_INIT(&new_scope->inner_scope);
! 774:
! 775: if (SLIST_FIRST(&scope_stack) != NULL) {
! 776: TAILQ_INSERT_TAIL(&SLIST_FIRST(&scope_stack)->inner_scope,
! 777: new_scope, scope_links);
! 778: }
! 779: /* This patch is now the current scope */
! 780: SLIST_INSERT_HEAD(&scope_stack, new_scope, scope_stack_links);
! 781: return new_scope;
! 782: }
! 783:
! 784: void
! 785: process_scope(scope_t *scope)
! 786: {
! 787: /*
! 788: * We are "leaving" this scope. We should now have
! 789: * enough information to process the lists of scopes
! 790: * we encapsulate.
! 791: */
! 792: scope_t *cur_scope;
! 793: u_int skip_patch_count;
! 794: u_int skip_instr_count;
! 795:
! 796: cur_scope = TAILQ_LAST(&scope->inner_scope, scope_tailq);
! 797: skip_patch_count = 0;
! 798: skip_instr_count = 0;
! 799: while (cur_scope != NULL) {
! 800: u_int patch0_patch_skip;
! 801:
! 802: patch0_patch_skip = 0;
! 803: switch (cur_scope->type) {
! 804: case SCOPE_IF:
! 805: case SCOPE_ELSE_IF:
! 806: if (skip_instr_count != 0) {
! 807: /* Create a tail patch */
! 808: patch0_patch_skip++;
! 809: cur_scope->patches[1].skip_patch =
! 810: skip_patch_count + 1;
! 811: cur_scope->patches[1].skip_instr =
! 812: skip_instr_count;
! 813: }
! 814:
! 815: /* Count Head patch */
! 816: patch0_patch_skip++;
! 817:
! 818: /* Count any patches contained in our inner scope */
! 819: patch0_patch_skip += cur_scope->inner_scope_patches;
! 820:
! 821: cur_scope->patches[0].skip_patch = patch0_patch_skip;
! 822: cur_scope->patches[0].skip_instr =
! 823: cur_scope->end_addr - cur_scope->begin_addr;
! 824:
! 825: skip_instr_count += cur_scope->patches[0].skip_instr;
! 826:
! 827: skip_patch_count += patch0_patch_skip;
! 828: if (cur_scope->type == SCOPE_IF) {
! 829: scope->inner_scope_patches += skip_patch_count;
! 830: skip_patch_count = 0;
! 831: skip_instr_count = 0;
! 832: }
! 833: break;
! 834: case SCOPE_ELSE:
! 835: /* Count any patches contained in our innter scope */
! 836: skip_patch_count += cur_scope->inner_scope_patches;
! 837:
! 838: skip_instr_count += cur_scope->end_addr
! 839: - cur_scope->begin_addr;
! 840: break;
! 841: case SCOPE_ROOT:
! 842: stop("Unexpected scope type encountered", EX_SOFTWARE);
! 843: /* NOTREACHED */
! 844: }
! 845:
! 846: cur_scope = TAILQ_PREV(cur_scope, scope_tailq, scope_links);
! 847: }
! 848: }