![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bootstrap.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / kernel|
Return to bootstrap.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / openbios / kernel |
1.1 ! root 1: /* tag: forth bootstrap environment ! 2: * ! 3: * Copyright (C) 2003-2006 Stefan Reinauer, Patrick Mauritz ! 4: * ! 5: * See the file "COPYING" for further information about ! 6: * the copyright and warranty status of this work. ! 7: */ ! 8: ! 9: #include "sysinclude.h" ! 10: #include <stdio.h> ! 11: #include <stdlib.h> ! 12: #include <string.h> ! 13: #include <signal.h> ! 14: #include <fcntl.h> ! 15: #include <unistd.h> ! 16: #include <termios.h> ! 17: #include <sys/stat.h> ! 18: ! 19: #ifdef __GLIBC__ ! 20: #define _GNU_SOURCE ! 21: #include <getopt.h> ! 22: #endif ! 23: ! 24: #include "config.h" ! 25: #include "kernel/stack.h" ! 26: #include "sysinclude.h" ! 27: #include "kernel/kernel.h" ! 28: #include "dict.h" ! 29: #include "cross.h" ! 30: #include "openbios-version.h" ! 31: ! 32: #define MAX_PATH_LEN 256 ! 33: ! 34: #define MEMORY_SIZE (1024*1024) /* 1M ram for hosted system */ ! 35: #define DICTIONARY_SIZE (256*1024) /* 256k for the dictionary */ ! 36: #define TRAMPOLINE_SIZE (4*sizeof(cell)) /* 4 cells for the trampoline */ ! 37: ! 38: /* state variables */ ! 39: static ucell *latest, *state, *base; ! 40: static ucell *memory; ! 41: ucell *trampoline; ! 42: ! 43: /* local variables */ ! 44: static int errors = 0; ! 45: static int segfault = 0; ! 46: static int verbose = 0; ! 47: ! 48: #define MAX_SRC_FILES 128 ! 49: ! 50: static FILE *srcfiles[MAX_SRC_FILES]; ! 51: static char *srcfilenames[MAX_SRC_FILES]; ! 52: static int srclines[MAX_SRC_FILES]; ! 53: static unsigned int cursrc = 0; ! 54: ! 55: static char *srcbasedict; ! 56: ! 57: /* console variables */ ! 58: static FILE *console; ! 59: ! 60: #ifdef NATIVE_BITWIDTH_SMALLER_THAN_HOST_BITWIDTH ! 61: unsigned long base_address; ! 62: #endif ! 63: ! 64: /* include path handling */ ! 65: typedef struct include_path include; ! 66: struct include_path { ! 67: const char *path; ! 68: include *next; ! 69: }; ! 70: ! 71: static include includes = { ".", NULL }; ! 72: static FILE *depfile; ! 73: ! 74: static ucell * relocation_address=NULL; ! 75: static int relocation_length=0; ! 76: ! 77: /* the word names are used to generate the prim words in the ! 78: * dictionary. This is done by the C written interpreter. ! 79: */ ! 80: static const char *wordnames[] = { ! 81: "(semis)", "", "(lit)", "", "", "", "", "(do)", "(?do)", "(loop)", ! 82: "(+loop)", "", "", "", "dup", "2dup", "?dup", "over", "2over", "pick", "drop", ! 83: "2drop", "nip", "roll", "rot", "-rot", "swap", "2swap", ">r", "r>", ! 84: "r@", "depth", "depth!", "rdepth", "rdepth!", "+", "-", "*", "u*", ! 85: "mu/mod", "abs", "negate", "max", "min", "lshift", "rshift", ">>a", ! 86: "and", "or", "xor", "invert", "d+", "d-", "m*", "um*", "@", "c@", ! 87: "w@", "l@", "!", "+!", "c!", "w!", "l!", "=", ">", "<", "u>", "u<", ! 88: "sp@", "move", "fill", "(emit)", "(key?)", "(key)", "execute", ! 89: "here", "here!", "dobranch", "do?branch", "unaligned-w@", ! 90: "unaligned-w!", "unaligned-l@", "unaligned-l!", "ioc@", "iow@", ! 91: "iol@", "ioc!", "iow!", "iol!", "i", "j", "call", "sys-debug", ! 92: "$include", "$encode-file", "(debug", "(debug-off)" ! 93: }; ! 94: ! 95: /* ! 96: * dictionary related functions. ! 97: */ ! 98: ! 99: /* ! 100: * Compare two dictionaries constructed at different addresses. When ! 101: * the cells don't match, a need for relocation is detected and the ! 102: * corresponding bit in reloc_table bitmap is set. ! 103: */ ! 104: static void relocation_table(unsigned char * dict_one, unsigned char *dict_two, int length) ! 105: { ! 106: ucell *d1=(ucell *)dict_one, *d2=(ucell *)dict_two; ! 107: ucell *reloc_table; ! 108: int pos, bit; ! 109: int l=(length+(sizeof(cell)-1))/sizeof(ucell), i; ! 110: ! 111: /* prepare relocation table */ ! 112: relocation_length=(length+BITS-1)/BITS; ! 113: reloc_table = malloc(relocation_length*sizeof(cell)); ! 114: memset(reloc_table,0,relocation_length*sizeof(cell)); ! 115: ! 116: for (i=0; i<l; i++) { ! 117: ! 118: pos=i/BITS; ! 119: bit=i&~(-BITS); ! 120: ! 121: if(d1[i]==d2[i]) { ! 122: reloc_table[pos] &= target_ucell(~((ucell)1ULL << bit)); ! 123: ! 124: // This check might bring false positives in data. ! 125: //if(d1[i] >= pointer2cell(dict_one) && ! 126: // d1[i] <= pointer2cell(dict_one+length)) ! 127: // printk("\nWARNING: inconsistent relocation (%x:%x)!\n", d1[i], d2[i]); ! 128: } else { ! 129: /* This is a pointer, it needs relocation, d2==dict */ ! 130: reloc_table[pos] |= target_ucell((ucell)1ULL << bit); ! 131: d2[i] = target_ucell(target_ucell(d2[i]) - pointer2cell(d2)); ! 132: } ! 133: } ! 134: ! 135: #ifdef CONFIG_DEBUG_DICTIONARY ! 136: printk("dict1 %lx dict2 %lx dict %lx\n",dict_one, dict_two, dict); ! 137: for (i=0; i< relocation_length ; i++) ! 138: printk("reloc %d %lx\n",i+1, reloc_table[i]); ! 139: #endif ! 140: relocation_address=reloc_table; ! 141: } ! 142: ! 143: static void write_dictionary(const char *filename) ! 144: { ! 145: FILE *f; ! 146: unsigned char *write_data, *walk_data; ! 147: int write_len; ! 148: dictionary_header_t *header; ! 149: u32 checksum=0; ! 150: ! 151: /* ! 152: * get memory for dictionary ! 153: */ ! 154: ! 155: write_len = sizeof(dictionary_header_t)+dicthead+relocation_length*sizeof(cell); ! 156: write_data = malloc(write_len); ! 157: if(!write_data) { ! 158: printk("panic: can't allocate memory for output dictionary (%d" ! 159: " bytes\n", write_len); ! 160: exit(1); ! 161: } ! 162: memset(write_data, 0, write_len); ! 163: ! 164: /* ! 165: * prepare dictionary header ! 166: */ ! 167: ! 168: header = (dictionary_header_t *)write_data; ! 169: *header = (dictionary_header_t){ ! 170: .signature = DICTID, ! 171: .version = 2, ! 172: .cellsize = sizeof(ucell), ! 173: #ifdef CONFIG_BIG_ENDIAN ! 174: .endianess = -1, ! 175: #else ! 176: .endianess = 0, ! 177: #endif ! 178: .checksum = 0, ! 179: .compression = 0, ! 180: .relocation = -1, ! 181: .length = target_ulong((uint32_t)dicthead), ! 182: .last = target_ucell((ucell)((unsigned long)last ! 183: - (unsigned long)dict)), ! 184: }; ! 185: ! 186: /* ! 187: * prepare dictionary data ! 188: */ ! 189: ! 190: walk_data=write_data+sizeof(dictionary_header_t); ! 191: memcpy (walk_data, dict, dicthead); ! 192: ! 193: /* ! 194: * prepare relocation data. ! 195: * relocation_address is zero when writing a dictionary core. ! 196: */ ! 197: ! 198: if (relocation_address) { ! 199: #ifdef CONFIG_DEBUG_DICTIONARY ! 200: printk("writing %d reloc cells \n",relocation_length); ! 201: #endif ! 202: walk_data += dicthead; ! 203: memcpy(walk_data, relocation_address, ! 204: relocation_length*sizeof(cell)); ! 205: /* free relocation information */ ! 206: free(relocation_address); ! 207: relocation_address=NULL; ! 208: } else { ! 209: header->relocation=0; ! 210: } ! 211: ! 212: /* ! 213: * Calculate Checksum ! 214: */ ! 215: ! 216: walk_data=write_data; ! 217: while (walk_data<write_data+write_len) { ! 218: checksum+=read_long(walk_data); ! 219: walk_data+=sizeof(u32); ! 220: } ! 221: checksum=(u32)-checksum; ! 222: ! 223: header->checksum=target_long(checksum); ! 224: ! 225: if (verbose) { ! 226: dump_header(header); ! 227: } ! 228: ! 229: f = fopen(filename, "w"); ! 230: if (!f) { ! 231: printk("panic: can't write to dictionary '%s'.\n", filename); ! 232: exit(1); ! 233: } ! 234: ! 235: fwrite(write_data, write_len, 1, f); ! 236: ! 237: free(write_data); ! 238: fclose(f); ! 239: ! 240: #ifdef CONFIG_DEBUG_DICTIONARY ! 241: printk("wrote dictionary to file %s.\n", filename); ! 242: #endif ! 243: } ! 244: ! 245: /* ! 246: * Write dictionary as a list of ucell hex values to filename. Array ! 247: * header and end lines are not generated. ! 248: * ! 249: * Cells with relocations are output using the expression ! 250: * DICTIONARY_BASE + value. ! 251: * ! 252: * Define some helpful constants. ! 253: */ ! 254: static void write_dictionary_hex(const char *filename) ! 255: { ! 256: FILE *f; ! 257: ucell *walk; ! 258: ! 259: f = fopen(filename, "w"); ! 260: if (!f) { ! 261: printk("panic: can't write to dictionary '%s'.\n", filename); ! 262: exit(1); ! 263: } ! 264: ! 265: for (walk = (ucell *)dict; walk < (ucell *)(dict + dicthead); walk++) { ! 266: int pos, bit, l; ! 267: ucell val; ! 268: ! 269: l = (walk - (ucell *)dict); ! 270: pos = l / BITS; ! 271: bit = l & ~(-BITS); ! 272: ! 273: val = read_ucell(walk); ! 274: if (relocation_address[pos] & target_ucell((ucell)1ULL << bit)) { ! 275: fprintf(f, "DICTIONARY_BASE + 0x%" FMT_CELL_x ! 276: ",\n", val); ! 277: } else { ! 278: fprintf(f, "0x%" FMT_CELL_x",\n", val); ! 279: } ! 280: } ! 281: ! 282: fprintf(f, "#define FORTH_DICTIONARY_LAST 0x%" FMT_CELL_x"\n", ! 283: (ucell)((unsigned long)last - (unsigned long)dict)); ! 284: fprintf(f, "#define FORTH_DICTIONARY_END 0x%" FMT_CELL_x"\n", ! 285: (ucell)dicthead); ! 286: fclose(f); ! 287: ! 288: #ifdef CONFIG_DEBUG_DICTIONARY ! 289: printk("wrote dictionary to file %s.\n", filename); ! 290: #endif ! 291: } ! 292: ! 293: static ucell read_dictionary(char *fil) ! 294: { ! 295: int ilen; ! 296: ucell ret; ! 297: char *mem; ! 298: FILE *f; ! 299: struct stat finfo; ! 300: ! 301: if (stat(fil, &finfo)) ! 302: return 0; ! 303: ! 304: ilen = finfo.st_size; ! 305: ! 306: if ((mem = malloc(ilen)) == NULL) { ! 307: printk("panic: not enough memory.\n"); ! 308: exit(1); ! 309: } ! 310: ! 311: f = fopen(fil, "r"); ! 312: if (!f) { ! 313: printk("panic: can't open dictionary.\n"); ! 314: exit(1); ! 315: } ! 316: ! 317: if (fread(mem, ilen, 1, f) != 1) { ! 318: printk("panic: can't read dictionary.\n"); ! 319: fclose(f); ! 320: exit(1); ! 321: } ! 322: fclose(f); ! 323: ! 324: ret = load_dictionary(mem, ilen); ! 325: ! 326: free(mem); ! 327: return ret; ! 328: } ! 329: ! 330: ! 331: /* ! 332: * C Parser related functions ! 333: */ ! 334: ! 335: /* ! 336: * skipws skips all whitespaces (space, tab, newline) from the input file ! 337: */ ! 338: ! 339: static void skipws(FILE * f) ! 340: { ! 341: int c; ! 342: while (!feof(f)) { ! 343: c = getc(f); ! 344: ! 345: if (c == ' ' || c == '\t') ! 346: continue; ! 347: ! 348: if (c == '\n') { ! 349: srclines[cursrc - 1]++; ! 350: continue; ! 351: } ! 352: ! 353: ungetc(c, f); ! 354: break; ! 355: } ! 356: } ! 357: ! 358: /* ! 359: * parse gets the next word from the input stream, delimited by ! 360: * delim. If delim is 0, any word delimiter will end the stream ! 361: * word delimiters are space, tab and newline. The resulting word ! 362: * will be put zero delimited to the char array line. ! 363: */ ! 364: ! 365: static int parse(FILE * f, char *line, char delim) ! 366: { ! 367: int cnt = 0, c = 0; ! 368: ! 369: while (!feof(f)) { ! 370: c = getc(f); ! 371: ! 372: if (delim && c == delim) ! 373: break; ! 374: ! 375: if ((!delim) && (c == ' ' || c == '\t' || c == '\n')) ! 376: break; ! 377: ! 378: line[cnt++] = c; ! 379: } ! 380: ! 381: /* Update current line number */ ! 382: if (c == '\n') { ! 383: srclines[cursrc - 1]++; ! 384: } ! 385: ! 386: line[cnt] = 0; ! 387: ! 388: return cnt; ! 389: } ! 390: ! 391: /* ! 392: * parse_word is a small helper that skips whitespaces before a word. ! 393: * it's behaviour is similar to the forth version parse-word. ! 394: */ ! 395: ! 396: static void parse_word(FILE * f, char *line) ! 397: { ! 398: skipws(f); ! 399: parse(f, line, 0); ! 400: } ! 401: ! 402: ! 403: static void writestring(const char *str) ! 404: { ! 405: unsigned int i; ! 406: for (i = 0; i < strlen(str); i++) { ! 407: dict[dicthead + i] = str[i]; ! 408: } ! 409: dicthead += i + 1; ! 410: dict[dicthead - 1] = (char) strlen(str) + 128; ! 411: } ! 412: ! 413: #define writebyte(value) {write_byte(dict+dicthead,value); dicthead++;} ! 414: #define writecell(value) {write_cell(dict+dicthead, value); dicthead+=sizeof(cell);} ! 415: ! 416: /* ! 417: * reveal a word, ie. make it visible. ! 418: */ ! 419: ! 420: static void reveal(void) ! 421: { ! 422: *last = *latest; ! 423: } ! 424: ! 425: /* ! 426: * dictionary padding ! 427: */ ! 428: ! 429: static void paddict(ucell align) ! 430: { ! 431: while (dicthead % align != 0) ! 432: writebyte(0); ! 433: } ! 434: ! 435: /* ! 436: * generic forth word creator function. ! 437: */ ! 438: ! 439: static void fcreate(const char *word, ucell cfaval) ! 440: { ! 441: if (strlen(word) == 0) { ! 442: printk("WARNING: tried to create unnamed word.\n"); ! 443: return; ! 444: } ! 445: ! 446: writestring(word); ! 447: /* get us at least 1 byte for flags */ ! 448: writebyte(0); ! 449: paddict(sizeof(cell)); ! 450: /* set flags high bit. */ ! 451: dict[dicthead - 1] = 128; ! 452: /* lfa and cfa */ ! 453: writecell(read_ucell(latest)); ! 454: *latest = target_ucell(pointer2cell(dict) + dicthead - sizeof(cell)); ! 455: writecell(cfaval); ! 456: } ! 457: ! 458: ! 459: static ucell *buildvariable(const char *name, cell defval) ! 460: { ! 461: fcreate(name, DOVAR); /* see dict.h for DOVAR and other CFA ids */ ! 462: writecell(defval); ! 463: return (ucell *) (dict + dicthead - sizeof(cell)); ! 464: } ! 465: ! 466: static void buildconstant(const char *name, cell defval) ! 467: { ! 468: fcreate(name, DOCON); /* see dict.h for DOCON and other CFA ids */ ! 469: writecell(defval); ! 470: } ! 471: ! 472: static void builddefer(const char *name) ! 473: { ! 474: fcreate(name, DODFR); /* see dict.h for DODFR and other CFA ids */ ! 475: writecell((ucell)0); ! 476: writecell((ucell)findword("(semis)")); ! 477: } ! 478: ! 479: /* ! 480: * Include file handling ! 481: */ ! 482: ! 483: static void add_includepath(char *path) ! 484: { ! 485: include *incl = &includes; ! 486: include *newpath; ! 487: ! 488: while (incl->next) ! 489: incl = incl->next; ! 490: ! 491: newpath = malloc(sizeof(include)); ! 492: if (!newpath) { ! 493: printk("panic: not enough memory for include path.\n"); ! 494: exit(1); ! 495: } ! 496: ! 497: incl->next = newpath; ! 498: newpath->path = path; ! 499: newpath->next = NULL; ! 500: } ! 501: ! 502: ! 503: static FILE *fopen_include(const char *fil) ! 504: { ! 505: char fullpath[MAX_PATH_LEN]; ! 506: FILE *ret; ! 507: include *incl = &includes; ! 508: ! 509: while (incl) { ! 510: snprintf(fullpath, sizeof(fullpath), "%s/%s", incl->path, fil); ! 511: ! 512: ret = fopen(fullpath, "r"); ! 513: if (ret != NULL) { ! 514: ! 515: #ifdef CONFIG_DEBUG_INTERPRETER ! 516: printk("Including '%s'\n", name ); ! 517: #endif ! 518: srcfilenames[cursrc] = strdup(fil); ! 519: srclines [ cursrc ] = 1; ! 520: srcfiles [ cursrc++ ] = ret; ! 521: ! 522: if (depfile) { ! 523: fprintf(depfile, " %s", fullpath); ! 524: } ! 525: ! 526: return ret; ! 527: } ! 528: ! 529: incl = incl->next; ! 530: } ! 531: return NULL; ! 532: } ! 533: ! 534: ! 535: /* ! 536: * Forth exception handler ! 537: */ ! 538: ! 539: void exception(cell no) ! 540: { ! 541: printk("%s:%d: ", srcfilenames[cursrc - 1], srclines[cursrc - 1]); ! 542: ! 543: /* See also forth/bootstrap/interpreter.fs */ ! 544: switch (no) { ! 545: case -1: ! 546: case -2: ! 547: printk("Aborted.\n"); ! 548: break; ! 549: case -3: ! 550: printk("Stack Overflow.\n"); ! 551: break; ! 552: case -4: ! 553: printk("Stack Underflow.\n"); ! 554: break; ! 555: case -5: ! 556: printk("Return Stack Overflow.\n"); ! 557: break; ! 558: case -6: ! 559: printk("Return Stack Underflow.\n"); ! 560: break; ! 561: case -19: ! 562: printk("undefined word.\n"); ! 563: break; ! 564: case -21: ! 565: printk("out of memory.\n"); ! 566: break; ! 567: case -33: ! 568: printk("undefined method.\n"); ! 569: break; ! 570: case -34: ! 571: printk("no such device.\n"); ! 572: break; ! 573: default: ! 574: printk("error %" FMT_CELL_d " occured.\n", no); ! 575: } ! 576: exit(1); ! 577: } ! 578: ! 579: ! 580: /* ! 581: * This is the C version of the forth interpreter ! 582: */ ! 583: ! 584: static int interpret_source(char *fil) ! 585: { ! 586: FILE *f; ! 587: char tib[160]; ! 588: cell num; ! 589: char *test; ! 590: ! 591: const ucell SEMIS = (ucell)findword("(semis)"); ! 592: const ucell LIT = (ucell)findword("(lit)"); ! 593: const ucell DOBRANCH = (ucell)findword("dobranch"); ! 594: ! 595: if ((f = fopen_include(fil)) == NULL) { ! 596: printk("error while loading source file '%s'\n", fil); ! 597: errors++; ! 598: exit(1); ! 599: } ! 600: ! 601: /* FIXME: We should read this file at ! 602: * once. No need to get it char by char ! 603: */ ! 604: ! 605: while (!feof(f)) { ! 606: xt_t res; ! 607: parse_word(f, tib); ! 608: ! 609: /* if there is actually no word, we continue right away */ ! 610: if (strlen(tib) == 0) { ! 611: continue; ! 612: } ! 613: ! 614: /* Checking for builtin words that are needed to ! 615: * bootstrap the forth base dictionary. ! 616: */ ! 617: ! 618: if (!strcmp(tib, "(")) { ! 619: parse(f, tib, ')'); ! 620: continue; ! 621: } ! 622: ! 623: if (!strcmp(tib, "\\")) { ! 624: parse(f, tib, '\n'); ! 625: continue; ! 626: } ! 627: ! 628: if (!strcmp(tib, ":")) { ! 629: parse_word(f, tib); ! 630: ! 631: #ifdef CONFIG_DEBUG_INTERPRETER ! 632: printk("create colon word %s\n\n", tib); ! 633: #endif ! 634: fcreate(tib, DOCOL); /* see dict.h for DOCOL and other CFA ids */ ! 635: *state = (ucell) (-1); ! 636: continue; ! 637: } ! 638: ! 639: if (!strcmp(tib, ";")) { ! 640: #ifdef CONFIG_DEBUG_INTERPRETER ! 641: printk("finish colon definition\n\n"); ! 642: #endif ! 643: writecell((cell)SEMIS); ! 644: *state = (ucell) 0; ! 645: reveal(); ! 646: continue; ! 647: } ! 648: ! 649: if (!strcasecmp(tib, "variable")) { ! 650: parse_word(f, tib); ! 651: #ifdef CONFIG_DEBUG_INTERPRETER ! 652: printk("defining variable %s\n\n", tib); ! 653: #endif ! 654: buildvariable(tib, 0); ! 655: reveal(); ! 656: continue; ! 657: } ! 658: ! 659: if (!strcasecmp(tib, "constant")) { ! 660: parse_word(f, tib); ! 661: #ifdef CONFIG_DEBUG_INTERPRETER ! 662: printk("defining constant %s\n\n", tib); ! 663: #endif ! 664: buildconstant(tib, POP()); ! 665: reveal(); ! 666: continue; ! 667: } ! 668: ! 669: if (!strcasecmp(tib, "value")) { ! 670: parse_word(f, tib); ! 671: #ifdef CONFIG_DEBUG_INTERPRETER ! 672: printk("defining value %s\n\n", tib); ! 673: #endif ! 674: buildconstant(tib, POP()); ! 675: reveal(); ! 676: continue; ! 677: } ! 678: ! 679: if (!strcasecmp(tib, "defer")) { ! 680: parse_word(f, tib); ! 681: #ifdef CONFIG_DEBUG_INTERPRETER ! 682: printk("defining defer word %s\n\n", tib); ! 683: #endif ! 684: builddefer(tib); ! 685: reveal(); ! 686: continue; ! 687: } ! 688: ! 689: if (!strcasecmp(tib, "include")) { ! 690: parse_word(f, tib); ! 691: #ifdef CONFIG_DEBUG_INTERPRETER ! 692: printk("including file %s\n\n", tib); ! 693: #endif ! 694: interpret_source(tib); ! 695: continue; ! 696: } ! 697: ! 698: if (!strcmp(tib, "[']")) { ! 699: xt_t xt; ! 700: parse_word(f, tib); ! 701: xt = findword(tib); ! 702: if (*state == 0) { ! 703: #ifdef CONFIG_DEBUG_INTERPRETER ! 704: printk ! 705: ("writing address of %s to stack\n\n", ! 706: tib); ! 707: #endif ! 708: PUSH_xt(xt); ! 709: } else { ! 710: #ifdef CONFIG_DEBUG_INTERPRETER ! 711: printk("writing lit, addr(%s) to dict\n\n", ! 712: tib); ! 713: #endif ! 714: writecell(LIT); /* lit */ ! 715: writecell((cell)xt); ! 716: } ! 717: continue; ! 718: /* we have no error detection here */ ! 719: } ! 720: ! 721: if (!strcasecmp(tib, "s\"")) { ! 722: int cnt; ! 723: cell loco; ! 724: ! 725: cnt = parse(f, tib, '"'); ! 726: #ifdef CONFIG_DEBUG_INTERPRETER ! 727: printk("compiling string %s\n", tib); ! 728: #endif ! 729: loco = dicthead + (6 * sizeof(cell)); ! 730: writecell(LIT); ! 731: writecell(pointer2cell(dict) + loco); ! 732: writecell(LIT); ! 733: writecell((ucell)cnt); ! 734: writecell(DOBRANCH); ! 735: loco = cnt + sizeof(cell) - 1; ! 736: loco &= ~(sizeof(cell) - 1); ! 737: writecell(loco); ! 738: memcpy(dict + dicthead, tib, cnt); ! 739: dicthead += cnt; ! 740: paddict(sizeof(cell)); ! 741: continue; ! 742: } ! 743: ! 744: /* look if tib is in dictionary. */ ! 745: /* should the dictionary be searched before the builtins ? */ ! 746: res = findword(tib); ! 747: if (res) { ! 748: u8 flags = read_byte((u8*)cell2pointer(res) - ! 749: sizeof(cell) - 1); ! 750: #ifdef CONFIG_DEBUG_INTERPRETER ! 751: printk("%s is 0x%" FMT_CELL_x "\n", tib, (ucell) res); ! 752: #endif ! 753: if (!(*state) || (flags & 3)) { ! 754: #ifdef CONFIG_DEBUG_INTERPRETER ! 755: printk("executing %s, %" FMT_CELL_d ! 756: " (flags: %s %s)\n", ! 757: tib, res, ! 758: (flags & 1) ? "immediate" : "", ! 759: (flags & 2) ? "compile-only" : ""); ! 760: #endif ! 761: PC = (ucell)res; ! 762: enterforth(res); ! 763: } else { ! 764: #ifdef CONFIG_DEBUG_INTERPRETER ! 765: printk("writing %s to dict\n\n", tib); ! 766: #endif ! 767: writecell((cell)res); ! 768: } ! 769: continue; ! 770: } ! 771: ! 772: /* if not look if it's a number */ ! 773: if (tib[0] == '-') ! 774: num = strtoll(tib, &test, read_ucell(base)); ! 775: else ! 776: num = strtoull(tib, &test, read_ucell(base)); ! 777: ! 778: ! 779: if (*test != 0) { ! 780: /* what is it?? */ ! 781: printk("%s:%d: %s is not defined.\n\n", srcfilenames[cursrc - 1], srclines[cursrc - 1], tib); ! 782: errors++; ! 783: #ifdef CONFIG_DEBUG_INTERPRETER ! 784: continue; ! 785: #else ! 786: return -1; ! 787: #endif ! 788: } ! 789: ! 790: if (*state == 0) { ! 791: #ifdef CONFIG_DEBUG_INTERPRETER ! 792: printk("pushed %" FMT_CELL_x " to stack\n\n", num); ! 793: #endif ! 794: PUSH(num); ! 795: } else { ! 796: #ifdef CONFIG_DEBUG_INTERPRETER ! 797: printk("writing lit, %" FMT_CELL_x " to dict\n\n", num); ! 798: #endif ! 799: writecell(LIT); /* lit */ ! 800: writecell(num); ! 801: } ! 802: } ! 803: ! 804: fclose(f); ! 805: cursrc--; ! 806: ! 807: return 0; ! 808: } ! 809: ! 810: static int build_dictionary(void) ! 811: { ! 812: ucell lfa = 0; ! 813: unsigned int i; ! 814: ! 815: /* we need a temporary place for latest outside the dictionary */ ! 816: latest = &lfa; ! 817: ! 818: /* starting a new dictionary: clear dicthead */ ! 819: dicthead = 0; ! 820: ! 821: #ifdef CONFIG_DEBUG_DICTIONARY ! 822: printk("building dictionary, %d primitives.\nbuilt words:", ! 823: sizeof(wordnames) / sizeof(void *)); ! 824: #endif ! 825: ! 826: for (i = 0; i < sizeof(wordnames) / sizeof(void *); i++) { ! 827: if (strlen(wordnames[i]) != 0) { ! 828: fcreate((char *) wordnames[i], i); ! 829: #ifdef CONFIG_DEBUG_DICTIONARY ! 830: printk(" %s", wordnames[i]); ! 831: #endif ! 832: } ! 833: } ! 834: #ifdef CONFIG_DEBUG_DICTIONARY ! 835: printk(".\n"); ! 836: #endif ! 837: ! 838: /* get last/latest and state */ ! 839: state = buildvariable("state", 0); ! 840: last = buildvariable("forth-last", 0); ! 841: latest = buildvariable("latest", 0); ! 842: ! 843: *latest = target_ucell(pointer2cell(latest)-2*sizeof(cell)); ! 844: ! 845: base=buildvariable("base", 10); ! 846: ! 847: buildconstant("/c", sizeof(u8)); ! 848: buildconstant("/w", sizeof(u16)); ! 849: buildconstant("/l", sizeof(u32)); ! 850: buildconstant("/n", sizeof(ucell)); ! 851: buildconstant("/x", sizeof(u64)); ! 852: ! 853: reveal(); ! 854: if (verbose) { ! 855: printk("Dictionary initialization finished.\n"); ! 856: } ! 857: return 0; ! 858: } ! 859: ! 860: /* ! 861: * functions used by primitives ! 862: */ ! 863: ! 864: int availchar(void) ! 865: { ! 866: int tmp; ! 867: if( cursrc < 1 ) { ! 868: interruptforth |= FORTH_INTSTAT_STOP; ! 869: /* return -1 in order to exit the loop in key() */ ! 870: return -1; ! 871: } ! 872: ! 873: tmp = getc( srcfiles[cursrc-1] ); ! 874: if (tmp != EOF) { ! 875: ungetc(tmp, srcfiles[cursrc-1]); ! 876: return -1; ! 877: } ! 878: ! 879: fclose(srcfiles[--cursrc]); ! 880: ! 881: return availchar(); ! 882: } ! 883: ! 884: int get_inputbyte( void ) ! 885: { ! 886: int tmp; ! 887: ! 888: if( cursrc < 1 ) { ! 889: interruptforth |= FORTH_INTSTAT_STOP; ! 890: return 0; ! 891: } ! 892: ! 893: tmp = getc( srcfiles[cursrc-1] ); ! 894: ! 895: /* Update current line number */ ! 896: if (tmp == '\n') { ! 897: srclines[cursrc - 1]++; ! 898: } ! 899: ! 900: if (tmp != EOF) { ! 901: return tmp; ! 902: } ! 903: ! 904: fclose(srcfiles[--cursrc]); ! 905: ! 906: return get_inputbyte(); ! 907: } ! 908: ! 909: void put_outputbyte( int c ) ! 910: { ! 911: if (console) ! 912: fputc(c, console); ! 913: } ! 914: ! 915: /* ! 916: * segmentation fault handler. linux specific? ! 917: */ ! 918: ! 919: static void ! 920: segv_handler(int signo __attribute__ ((unused)), ! 921: siginfo_t * si, void *context __attribute__ ((unused))) ! 922: { ! 923: static int count = 0; ! 924: ucell addr = 0xdeadbeef; ! 925: ! 926: if (count) { ! 927: printk("Died while dumping forth dictionary core.\n"); ! 928: goto out; ! 929: } ! 930: ! 931: count++; ! 932: ! 933: if (PC >= pointer2cell(dict) && PC <= pointer2cell(dict) + dicthead) ! 934: addr = read_cell(cell2pointer(PC)); ! 935: ! 936: printk("panic: segmentation violation at %p\n", (char *)si->si_addr); ! 937: printk("dict=%p here=%p(dict+0x%" FMT_CELL_x ") pc=0x%" FMT_CELL_x "(dict+0x%" FMT_CELL_x ")\n", ! 938: dict, dict + dicthead, dicthead, PC, PC - pointer2cell(dict)); ! 939: printk("dstackcnt=%d rstackcnt=%d instruction=%" FMT_CELL_x "\n", ! 940: dstackcnt, rstackcnt, addr); ! 941: ! 942: printdstack(); ! 943: printrstack(); ! 944: ! 945: printk("Writing dictionary core file\n"); ! 946: write_dictionary("forth.dict.core"); ! 947: ! 948: out: ! 949: exit(1); ! 950: } ! 951: ! 952: /* ! 953: * allocate memory and prepare engine for memory management. ! 954: */ ! 955: ! 956: static void init_memory(void) ! 957: { ! 958: memset(memory, 0, MEMORY_SIZE); ! 959: ! 960: /* we push start and end of memory to the stack ! 961: * so that it can be used by the forth word QUIT ! 962: * to initialize the memory allocator. ! 963: * Add a cell to the start address so we don't end ! 964: * up with a start address of zero during bootstrap ! 965: */ ! 966: ! 967: PUSH(pointer2cell(memory)+sizeof(cell)); ! 968: PUSH(pointer2cell(memory) + MEMORY_SIZE-1); ! 969: } ! 970: ! 971: ! 972: void ! 973: include_file( const char *name ) ! 974: { ! 975: FILE *file; ! 976: ! 977: if( cursrc >= sizeof(srcfiles)/sizeof(srcfiles[0]) ) { ! 978: printk("\npanic: Maximum include depth reached!\n"); ! 979: exit(1); ! 980: } ! 981: ! 982: file = fopen_include( name ); ! 983: if( !file ) { ! 984: printk("\npanic: Failed opening file '%s'\n", name ); ! 985: exit(1); ! 986: } ! 987: } ! 988: ! 989: ! 990: void ! 991: encode_file( const char *name ) ! 992: { ! 993: FILE *file = fopen_include(name); ! 994: int size; ! 995: ! 996: if( !file ) { ! 997: printk("\npanic: Can't open '%s'\n", name ); ! 998: exit(1); ! 999: } ! 1000: fseek( file, 0, SEEK_END ); ! 1001: size = ftell( file ); ! 1002: fseek( file, 0, SEEK_SET ); ! 1003: ! 1004: if (verbose) { ! 1005: printk("\nEncoding %s [%d bytes]\n", name, size ); ! 1006: } ! 1007: fread( dict + dicthead, size, 1, file ); ! 1008: PUSH( pointer2cell(dict + dicthead) ); ! 1009: PUSH( size ); ! 1010: dicthead += size; ! 1011: } ! 1012: ! 1013: ! 1014: static void run_dictionary(char *basedict, char *confile) ! 1015: { ! 1016: if(!basedict) ! 1017: return; ! 1018: ! 1019: read_dictionary(basedict); ! 1020: PC = (ucell)findword("initialize"); ! 1021: ! 1022: if (!PC) { ! 1023: if (verbose) { ! 1024: printk("Unable to find initialize word in dictionary %s; ignoring\n", basedict); ! 1025: } ! 1026: return; ! 1027: } ! 1028: ! 1029: if(!srcfiles[0]) { ! 1030: cursrc = 1; ! 1031: srcfiles[cursrc-1] = stdin; ! 1032: } ! 1033: ! 1034: dstackcnt=0; ! 1035: rstackcnt=0; ! 1036: ! 1037: init_memory(); ! 1038: if (verbose) ! 1039: printk("Jumping to dictionary %s...\n", basedict); ! 1040: ! 1041: /* If a console file has been specified, open it */ ! 1042: if (confile) ! 1043: console = fopen(confile, "w"); ! 1044: ! 1045: srcbasedict = basedict; ! 1046: ! 1047: enterforth((xt_t)PC); ! 1048: ! 1049: /* Close the console file */ ! 1050: if (console) ! 1051: fclose(console); ! 1052: } ! 1053: ! 1054: static void new_dictionary(const char *source) ! 1055: { ! 1056: build_dictionary(); ! 1057: ! 1058: interpret_source((char *)source); ! 1059: ! 1060: if (verbose || errors > 0) { ! 1061: printk("interpretion finished. %d errors occured.\n", ! 1062: errors); ! 1063: } ! 1064: } ! 1065: ! 1066: /* ! 1067: * main loop ! 1068: */ ! 1069: ! 1070: #define BANNER "OpenBIOS bootstrap kernel. (C) 2003-2006 Patrick Mauritz, Stefan Reinauer\n"\ ! 1071: "This software comes with absolutely no warranty. "\ ! 1072: "All rights reserved.\n\n" ! 1073: ! 1074: #ifdef __GLIBC__ ! 1075: #define USAGE "Usage: %s [options] [dictionary file|source file]\n\n" \ ! 1076: " -h|--help show this help\n" \ ! 1077: " -V|--version print version and exit\n" \ ! 1078: " -v|--verbose print debugging information\n" \ ! 1079: " -I|--include dir add dir to include path\n" \ ! 1080: " -d|--source-dictionary bootstrap.dict\n" \ ! 1081: " use this dictionary as base\n" \ ! 1082: " -D|--target-dictionary output.dict\n" \ ! 1083: " write to output.dict\n" \ ! 1084: " -c|--console output.log\n" \ ! 1085: " write kernel console output to log file\n" \ ! 1086: " -s|--segfault install segfault handler\n" \ ! 1087: " -M|--dependency-dump file\n" \ ! 1088: " dump dependencies in Makefile format\n\n" \ ! 1089: " -x|--hexdump output format is C language hex dump\n" ! 1090: #else ! 1091: #define USAGE "Usage: %s [options] [dictionary file|source file]\n\n" \ ! 1092: " -h show this help\n" \ ! 1093: " -V print version and exit\n" \ ! 1094: " -v print debugging information\n" \ ! 1095: " -I add dir to include path\n" \ ! 1096: " -d bootstrap.dict\n" \ ! 1097: " use this dictionary as base\n" \ ! 1098: " -D output.dict\n" \ ! 1099: " write to output.dict\n" \ ! 1100: " -c output.log\n" \ ! 1101: " write kernel console output to log file\n" \ ! 1102: " -s install segfault handler\n\n" \ ! 1103: " -M file dump dependencies in Makefile format\n\n" \ ! 1104: " -x output format is C language hex dump\n" ! 1105: #endif ! 1106: ! 1107: int main(int argc, char *argv[]) ! 1108: { ! 1109: struct sigaction sa; ! 1110: ! 1111: unsigned char *ressources=NULL; /* All memory used by us */ ! 1112: const char *dictname = NULL; ! 1113: char *basedict = NULL; ! 1114: char *consolefile = NULL; ! 1115: char *depfilename = NULL; ! 1116: ! 1117: unsigned char *bootstrapdict[2]; ! 1118: int c, cnt, hexdump = 0; ! 1119: ! 1120: const char *optstring = "VvhsI:d:D:c:M:x?"; ! 1121: ! 1122: while (1) { ! 1123: #ifdef __GLIBC__ ! 1124: int option_index = 0; ! 1125: static struct option long_options[] = { ! 1126: {"version", 0, NULL, 'V'}, ! 1127: {"verbose", 0, NULL, 'v'}, ! 1128: {"help", 0, NULL, 'h'}, ! 1129: {"segfault", 0, NULL, 's'}, ! 1130: {"include", 1, NULL, 'I'}, ! 1131: {"source-dictionary", 1, NULL, 'd'}, ! 1132: {"target-dictionary", 1, NULL, 'D'}, ! 1133: {"console", 1, NULL, 'c'}, ! 1134: {"dependency-dump", 1, NULL, 'M'}, ! 1135: {"hexdump", 0, NULL, 'x'}, ! 1136: }; ! 1137: ! 1138: /* ! 1139: * option handling ! 1140: */ ! 1141: ! 1142: c = getopt_long(argc, argv, optstring, long_options, ! 1143: &option_index); ! 1144: #else ! 1145: c = getopt(argc, argv, optstring); ! 1146: #endif ! 1147: if (c == -1) ! 1148: break; ! 1149: ! 1150: switch (c) { ! 1151: case 'V': ! 1152: printk("Version " OPENBIOS_VERSION_STR "\n"); ! 1153: return 0; ! 1154: case 'h': ! 1155: case '?': ! 1156: printk("Version " OPENBIOS_VERSION_STR "\n" USAGE, ! 1157: argv[0]); ! 1158: return 0; ! 1159: case 'v': ! 1160: verbose = 1; ! 1161: break; ! 1162: case 's': ! 1163: segfault = 1; ! 1164: break; ! 1165: case 'I': ! 1166: #ifdef CONFIG_DEBUG_INTERPRETER ! 1167: printk("adding '%s' to include path\n", optarg); ! 1168: #endif ! 1169: add_includepath(optarg); ! 1170: break; ! 1171: case 'd': ! 1172: if (!basedict) { ! 1173: basedict = optarg; ! 1174: } ! 1175: break; ! 1176: case 'D': ! 1177: if(!dictname) { ! 1178: dictname = optarg; ! 1179: } ! 1180: break; ! 1181: case 'c': ! 1182: if (!consolefile) { ! 1183: consolefile = optarg; ! 1184: } ! 1185: break; ! 1186: case 'M': ! 1187: if (!depfilename) { ! 1188: depfilename = optarg; ! 1189: } ! 1190: break; ! 1191: case 'x': ! 1192: hexdump = 1; ! 1193: break; ! 1194: default: ! 1195: return 1; ! 1196: } ! 1197: } ! 1198: ! 1199: if (!dictname) { ! 1200: dictname = "bootstrap.dict"; ! 1201: } ! 1202: if (verbose) { ! 1203: printk(BANNER); ! 1204: printk("Using source dictionary '%s'\n", basedict); ! 1205: printk("Dumping final dictionary to '%s'\n", dictname); ! 1206: printk("Dumping dependencies to '%s'\n", depfilename); ! 1207: } ! 1208: ! 1209: if (argc < optind) { ! 1210: printk(USAGE, argv[0]); ! 1211: return 1; ! 1212: } ! 1213: ! 1214: if (depfilename) { ! 1215: depfile = fopen(depfilename, "w"); ! 1216: if (!depfile) { ! 1217: printk("panic: can't write to dependency file '%s'.\n", ! 1218: depfilename); ! 1219: exit(1); ! 1220: } ! 1221: fprintf(depfile, "%s:", dictname); ! 1222: } ! 1223: ! 1224: /* ! 1225: * Get all required resources ! 1226: */ ! 1227: ! 1228: ! 1229: ressources = malloc(MEMORY_SIZE + (2 * DICTIONARY_SIZE) + TRAMPOLINE_SIZE); ! 1230: if (!ressources) { ! 1231: printk("panic: not enough memory on host system.\n"); ! 1232: return 1; ! 1233: } ! 1234: ! 1235: #ifdef NATIVE_BITWIDTH_SMALLER_THAN_HOST_BITWIDTH ! 1236: base_address=(unsigned long)ressources; ! 1237: #endif ! 1238: ! 1239: memory = (ucell *)ressources; ! 1240: ! 1241: bootstrapdict[0] = ressources + MEMORY_SIZE; ! 1242: bootstrapdict[1] = ressources + MEMORY_SIZE + DICTIONARY_SIZE; ! 1243: trampoline = (ucell *)(ressources + MEMORY_SIZE + DICTIONARY_SIZE + DICTIONARY_SIZE); ! 1244: ! 1245: #ifdef CONFIG_DEBUG_INTERPRETER ! 1246: printf("memory: %p\n",memory); ! 1247: printf("dict1: %p\n",bootstrapdict[0]); ! 1248: printf("dict2: %p\n",bootstrapdict[1]); ! 1249: printf("trampoline: %p\n",trampoline); ! 1250: printf("size=%d, trampoline_size=%d\n",MEMORY_SIZE + (2 * ! 1251: DICTIONARY_SIZE) + TRAMPOLINE_SIZE, ! 1252: TRAMPOLINE_SIZE); ! 1253: #endif ! 1254: ! 1255: if (trampoline == NULL) { ! 1256: /* We're using side effects which is to some extent nasty */ ! 1257: printf("WARNING: no trampoline!\n"); ! 1258: } else { ! 1259: init_trampoline(trampoline); ! 1260: } ! 1261: ! 1262: if (!segfault) { ! 1263: if (verbose) ! 1264: printk("Installing SIGSEGV handler..."); ! 1265: ! 1266: sa.sa_sigaction = segv_handler; ! 1267: sigemptyset(&sa.sa_mask); ! 1268: sa.sa_flags = SA_SIGINFO | SA_NODEFER; ! 1269: sigaction(SIGSEGV, &sa, NULL); ! 1270: ! 1271: if (verbose) ! 1272: printk("done.\n"); ! 1273: } ! 1274: ! 1275: /* ! 1276: * Now do the real work ! 1277: */ ! 1278: ! 1279: for (cnt=0; cnt<2; cnt++) { ! 1280: if (verbose) { ! 1281: printk("Compiling dictionary %d/%d\n", cnt+1, 2); ! 1282: } ! 1283: dict=bootstrapdict[cnt]; ! 1284: if(!basedict) { ! 1285: new_dictionary(argv[optind]); ! 1286: } else { ! 1287: for (c=argc-1; c>=optind; c--) ! 1288: include_file(argv[c]); ! 1289: ! 1290: run_dictionary(basedict, consolefile); ! 1291: } ! 1292: if (depfile) { ! 1293: fprintf(depfile, "\n"); ! 1294: fclose(depfile); ! 1295: depfile = NULL; ! 1296: } ! 1297: if(errors) ! 1298: break; ! 1299: } ! 1300: ! 1301: #ifndef CONFIG_DEBUG_INTERPRETER ! 1302: if (errors) ! 1303: printk("dictionary not dumped to file.\n"); ! 1304: else ! 1305: #endif ! 1306: { ! 1307: relocation_table( bootstrapdict[0], bootstrapdict[1], dicthead); ! 1308: if (hexdump) { ! 1309: write_dictionary_hex(dictname); ! 1310: } else { ! 1311: write_dictionary(dictname); ! 1312: } ! 1313: } ! 1314: ! 1315: free(ressources); ! 1316: ! 1317: if (errors) ! 1318: return 1; ! 1319: else ! 1320: return 0; ! 1321: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.