src/runtime/runtime.c

   1 /*
   2  * main() entry point for a stand-alone SBCL image
   3  */
   4
   5 /*
   6  * This software is part of the SBCL system. See the README file for
   7  * more information.
   8  *
   9  * This software is derived from the CMU CL system, which was
  10  * written at Carnegie Mellon University and released into the
  11  * public domain. The software is in the public domain and is
  12  * provided with absolutely no warranty. See the COPYING and CREDITS
  13  * files for more information.
  14  */
  15
  16 #include "sbcl.h"
  17
  18 #include <stdio.h>
  19 #include <string.h>
  20 #include <ctype.h>
  21 #ifndef LISP_FEATURE_WIN32
  22 #include <libgen.h>
  23 #endif
  24 #include <sys/types.h>
  25 #ifndef LISP_FEATURE_WIN32
  26 #include <sys/wait.h>
  27 #endif
  28 #include <stdlib.h>
  29 #include <unistd.h>
  30 #include <sys/file.h>
  31 #include <sys/param.h>
  32 #include <sys/stat.h>
  33 #include "runtime.h"
  34 #ifndef LISP_FEATURE_WIN32
  35 #include <sched.h>
  36 #endif
  37 #include <errno.h>
  38 #include <locale.h>
  39 #include <limits.h>
  40
  41 #if defined(SVR4) || defined(__linux__)
  42 #include <time.h>
  43 #endif
  44
  45 #if !(defined(LISP_FEATURE_WIN32) && defined(LISP_FEATURE_SB_THREAD))
  46 #include "signal.h"
  47 #endif
  48
  49 #include "runtime.h"
  50 #include "vars.h"
  51 #include "globals.h"
  52 #include "os.h"
  53 #include "interr.h"
  54 #include "alloc.h"
  55 #include "interrupt.h"
  56 #include "arch.h"
  57 #include "gc.h"
  58 #include "validate.h"
  59 #include "core.h"
  60 #include "save.h"
  61 #include "lispregs.h"
  62 #include "thread.h"
  63
  64 #include "genesis/static-symbols.h"
  65 #include "genesis/symbol.h"
  66
  67
  68 #ifdef irix
  69 #include <string.h>
  70 #include "interr.h"
  71 #endif
  72
  73 #ifndef SBCL_HOME
  74 #define SBCL_HOME SBCL_PREFIX"/lib/sbcl/"
  75 #endif
  76
  77 #ifdef LISP_FEATURE_HPUX
  78 extern void *return_from_lisp_stub;
  79 #include "genesis/closure.h"
  80 #include "genesis/simple-fun.h"
  81 #endif
  82
  83 \f
  84 /* SIGINT handler that invokes the monitor (for when Lisp isn't up to it) */
  85 static void
  86 sigint_handler(int signal, siginfo_t *info, os_context_t *context)
  87 {
  88     lose("\nSIGINT hit at 0x%08lX\n",
  89          (unsigned long) *os_context_pc_addr(context));
  90 }
  91
  92 /* (This is not static, because we want to be able to call it from
  93  * Lisp land.) */
  94 void
  95 sigint_init(void)
  96 {
  97     SHOW("entering sigint_init()");
  98     install_handler(SIGINT, sigint_handler, 1);
  99     SHOW("leaving sigint_init()");
 100 }
 101 \f
 102 /*
 103  * helper functions for dealing with command line args
 104  */
 105
 106 void *
 107 successful_malloc(size_t size)
 108 {
 109     void* result = malloc(size);
 110     if (0 == result) {
 111         lose("malloc failure\n");
 112     } else {
 113         return result;
 114     }
 115     return (void *) NULL; /* dummy value: return something ... */
 116 }
 117
 118 char *
 119 copied_string(char *string)
 120 {
 121     return strcpy(successful_malloc(1+strlen(string)), string);
 122 }
 123
 124 char *
 125 copied_existing_filename_or_null(char *filename)
 126 {
 127     struct stat filename_stat;
 128     if (stat(filename, &filename_stat)) { /* if failure */
 129         return 0;
 130     } else {
 131         return copied_string(filename);
 132     }
 133 }
 134
 135 #ifndef LISP_FEATURE_WIN32
 136 char *
 137 copied_realpath(const char *pathname)
 138 {
 139     char *messy, *tidy;
 140     size_t len;
 141
 142     /* realpath() supposedly can't be counted on to always return
 143      * an absolute path, so we prepend the cwd to relative paths */
 144     messy = NULL;
 145     if (pathname[0] != '/') {
 146         messy = successful_malloc(PATH_MAX + 1);
 147         if (getcwd(messy, PATH_MAX + 1) == NULL) {
 148             free(messy);
 149             return NULL;
 150         }
 151         len = strlen(messy);
 152         snprintf(messy + len, PATH_MAX + 1 - len, "/%s", pathname);
 153     }
 154
 155     tidy = successful_malloc(PATH_MAX + 1);
 156     if (realpath((messy ? messy : pathname), tidy) == NULL) {
 157         free(messy);
 158         free(tidy);
 159         return NULL;
 160     }
 161
 162     return tidy;
 163 }
 164 #endif /* LISP_FEATURE_WIN32 */
 165 \f
 166 /* miscellaneous chattiness */
 167
 168 void
 169 print_help()
 170 {
 171     puts(
 172 "Usage: sbcl [runtime-options] [toplevel-options] [user-options]\n\
 173 Common runtime options:\n\
 174   --help                     Print this message and exit.\n\
 175   --version                  Print version information and exit.\n\
 176   --core <filename>          Use the specified core file instead of the default.\n\
 177   --dynamic-space-size <MiB> Size of reserved dynamic space in megabytes.\n\
 178   --control-stack-size <MiB> Size of reserved control stack in megabytes.\n\
 179 \n\
 180 Common toplevel options:\n\
 181   --sysinit <filename>       System-wide init-file to use instead of default.\n\
 182   --userinit <filename>      Per-user init-file to use instead of default.\n\
 183   --no-sysinit               Inhibit processing of any system-wide init-file.\n\
 184   --no-userinit              Inhibit processing of any per-user init-file.\n\
 185   --disable-debugger         Invoke sb-ext:disable-debugger.\n\
 186   --noprint                  Run a Read-Eval Loop without printing results.\n\
 187   --script [<filename>]      Skip #! line, disable debugger, avoid verbosity.\n\
 188   --quit                     Exit with code 0 after option processing.\n\
 189   --non-interactive          Sets both --quit and --disable-debugger.\n\
 190 Common toplevel options that are processed in order:\n\
 191   --eval <form>              Form to eval when processing this option.\n\
 192   --load <filename>          File to load when processing this option.\n\
 193 \n\
 194 User options are not processed by SBCL. All runtime options must\n\
 195 appear before toplevel options, and all toplevel options must\n\
 196 appear before user options.\n\
 197 \n\
 198 For more information please refer to the SBCL User Manual, which\n\
 199 should be installed along with SBCL, and is also available from the\n\
 200 website <http://www.sbcl.org/>.\n");
 201 }
 202
 203 void
 204 print_version()
 205 {
 206     printf("SBCL %s\n", SBCL_VERSION_STRING);
 207 }
 208
 209 void
 210 print_banner()
 211 {
 212     printf(
 213 "This is SBCL %s, an implementation of ANSI Common Lisp.\n\
 214 More information about SBCL is available at <http://www.sbcl.org/>.\n\
 215 \n\
 216 SBCL is free software, provided as is, with absolutely no warranty.\n\
 217 It is mostly in the public domain; some portions are provided under\n\
 218 BSD-style licenses.  See the CREDITS and COPYING files in the\n\
 219 distribution for more information.\n\
 220 "
 221 #ifdef LISP_FEATURE_WIN32
 222 "\n\
 223 WARNING: the Windows port is fragile, particularly for multithreaded\n\
 224 code.  Unfortunately, the development team currently lacks the time\n\
 225 and resources this platform demands.\n\
 226 "
 227 #endif
 228 , SBCL_VERSION_STRING);
 229 }
 230
 231 /* Look for a core file to load, first in the directory named by the
 232  * SBCL_HOME environment variable, then in a hardcoded default
 233  * location.  Returns a malloced copy of the core filename. */
 234 char *
 235 search_for_core ()
 236 {
 237     char *sbcl_home = getenv("SBCL_HOME");
 238     char *lookhere;
 239     char *stem = "/sbcl.core";
 240     char *core;
 241
 242     if (!(sbcl_home && *sbcl_home)) sbcl_home = SBCL_HOME;
 243     lookhere = (char *) calloc(strlen(sbcl_home) +
 244                                strlen(stem) +
 245                                1,
 246                                sizeof(char));
 247     sprintf(lookhere, "%s%s", sbcl_home, stem);
 248     core = copied_existing_filename_or_null(lookhere);
 249
 250     if (!core) {
 251         lose("can't find core file at %s\n", lookhere);
 252     }
 253
 254     free(lookhere);
 255
 256     return core;
 257 }
 258
 259 /* Try to find the path to an executable from argv[0], this is only
 260  * used when os_get_runtime_executable_path() returns NULL */
 261 #ifdef LISP_FEATURE_WIN32
 262 char *
 263 search_for_executable(const char *argv0)
 264 {
 265     return NULL;
 266 }
 267 #else /* LISP_FEATURE_WIN32 */
 268 char *
 269 search_for_executable(const char *argv0)
 270 {
 271     char *search, *start, *end, *buf;
 272
 273     /* If argv[0] contains a slash then it's probably an absolute path
 274      * or relative to the current directory, so check if it exists. */
 275     if (strchr(argv0, '/') != NULL && access(argv0, F_OK) == 0)
 276         return copied_realpath(argv0);
 277
 278     /* Bail on an absolute path which doesn't exist */
 279     if (argv0[0] == '/')
 280         return NULL;
 281
 282     /* Otherwise check if argv[0] exists relative to any directory in PATH */
 283     search = getenv("PATH");
 284     if (search == NULL)
 285         return NULL;
 286     search = copied_string(search);
 287     buf = successful_malloc(PATH_MAX + 1);
 288     for (start = search; (end = strchr(start, ':')) != NULL; start = end + 1) {
 289         *end = '\0';
 290         snprintf(buf, PATH_MAX + 1, "%s/%s", start, argv0);
 291         if (access(buf, F_OK) == 0) {
 292             free(search);
 293             search = copied_realpath(buf);
 294             free(buf);
 295             return search;
 296         }
 297     }
 298     /* The above for-loop fails to process the last part of PATH if PATH does
 299      * not end with ':'. We may consider appending an extra ':' to the end of
 300      * SEARCH.  -- houjingyi 2013-05-24 */
 301     if (start != NULL && *start != '\0') {
 302         snprintf(buf, PATH_MAX + 1, "%s/%s", start, argv0);
 303         if (access(buf, F_OK) == 0) {
 304             free(search);
 305             search = copied_realpath(buf);
 306             free(buf);
 307             return search;
 308         }
 309     }
 310
 311     free(search);
 312     free(buf);
 313     return NULL;
 314 }
 315 #endif /* LISP_FEATURE_WIN32 */
 316
 317 size_t
 318 parse_size_arg(char *arg, char *arg_name)
 319 {
 320   char *tail, *power_name;
 321   size_t power, res;
 322
 323   res = strtoul(arg, &tail, 0);
 324
 325   if (arg == tail) {
 326     lose("%s argument is not a number: %s", arg_name, arg);
 327   } else if (tail[0]) {
 328     int i, size;
 329     power_name = copied_string(tail);
 330     size = strlen(power_name);
 331     for (i=0; i<size; i++)
 332       power_name[i] = toupper(power_name[i]);
 333   } else {
 334     power = 20;
 335     power_name = NULL;
 336   }
 337   if (power_name) {
 338     if ((0==strcmp("KB", power_name)) ||
 339         (0==strcmp("KIB", power_name))) {
 340       power = 10;
 341     } else if ((0==strcmp("MB", power_name)) ||
 342                (0==strcmp("MIB", power_name))) {
 343       power = 20;
 344     } else if ((0==strcmp("GB", power_name)) ||
 345                (0==strcmp("GIB", power_name))) {
 346       power = 30;
 347     } else {
 348       lose("%s argument has an unknown suffix: %s", arg_name, tail);
 349     }
 350     free(power_name);
 351   }
 352   if ((res <= 0) ||
 353       (res >= (SIZE_MAX >> power))) {
 354     lose("%s argument is out of range: %s", arg_name, arg);
 355   }
 356   res <<= power;
 357   return res;
 358 }
 359
 360 char **posix_argv;
 361 char *core_string;
 362
 363 struct runtime_options *runtime_options;
 364
 365 char *saved_runtime_path = NULL;
 366 #if defined(LISP_FEATURE_WIN32) && defined(LISP_FEATURE_SB_THREAD)
 367 void pthreads_win32_init();
 368 #endif
 369
 370 void print_locale_variable(const char *name)
 371 {
 372   char *value = getenv(name);
 373
 374   if (value) {
 375     fprintf(stderr, "\n  %s=%s", name, value);
 376   }
 377 }
 378
 379 void setup_locale()
 380 {
 381   if(setlocale(LC_ALL, "") == NULL) {
 382 #ifndef LISP_FEATURE_WIN32
 383
 384     fprintf(stderr, "WARNING: Setting locale failed.\n");
 385     fprintf(stderr, "  Check the following variables for correct values:");
 386
 387     if (setlocale(LC_CTYPE, "") == NULL) {
 388       print_locale_variable("LC_ALL");
 389       print_locale_variable("LC_CTYPE");
 390       print_locale_variable("LANG");
 391     }
 392
 393     if (setlocale(LC_MESSAGES, "") == NULL) {
 394       print_locale_variable("LC_MESSAGES");
 395     }
 396     if (setlocale(LC_COLLATE, "") == NULL) {
 397       print_locale_variable("LC_COLLATE");
 398     }
 399     if (setlocale(LC_MONETARY, "") == NULL) {
 400       print_locale_variable("LC_MONETARY");
 401     }
 402     if (setlocale(LC_NUMERIC, "") == NULL) {
 403       print_locale_variable("LC_NUMERIC");
 404     }
 405     if (setlocale(LC_TIME, "") == NULL) {
 406       print_locale_variable("LC_TIME");
 407     }
 408     fprintf(stderr, "\n");
 409
 410 #endif
 411   }
 412 }
 413 void print_environment(int argc, char *argv[])
 414 {
 415     int n = 0;
 416     printf("; Commandline arguments:\n");
 417     while (n < argc) {
 418         printf(";  %2d: \"%s\"\n", n, argv[n]);
 419         ++n;
 420     }
 421     n = 0;
 422     printf(";\n; Environment:\n");
 423     while (ENVIRON[n]) {
 424         printf(";  %2d: \"%s\"\n", n, ENVIRON[n]);
 425         ++n;
 426     }
 427 }
 428 \f
 429 int
 430 main(int argc, char *argv[], char *envp[])
 431 {
 432 #ifdef LISP_FEATURE_WIN32
 433     /* Exception handling support structure. Evil Win32 hack. */
 434     struct lisp_exception_frame exception_frame;
 435 #endif
 436
 437     /* the name of the core file we're to execute. Note that this is
 438      * a malloc'ed string which should be freed eventually. */
 439     char *core = 0;
 440     char **sbcl_argv = 0;
 441     os_vm_offset_t embedded_core_offset = 0;
 442     char *runtime_path = 0;
 443
 444     /* other command line options */
 445     boolean noinform = 0;
 446     boolean end_runtime_options = 0;
 447     boolean disable_lossage_handler_p = 0;
 448     boolean debug_environment_p = 0;
 449
 450     lispobj initial_function;
 451     const char *sbcl_home = getenv("SBCL_HOME");
 452
 453 #if defined(LISP_FEATURE_WIN32) && defined(LISP_FEATURE_SB_THREAD)
 454     os_preinit();
 455     pthreads_win32_init();
 456 #endif
 457
 458     interrupt_init();
 459     block_blockable_signals(0, 0);
 460
 461     runtime_options = NULL;
 462
 463     /* Save the argv[0] derived runtime path in case
 464      * os_get_runtime_executable_path(1) isn't able to get an
 465      * externally-usable path later on. */
 466     saved_runtime_path = search_for_executable(argv[0]);
 467
 468     /* Check early to see if this executable has an embedded core,
 469      * which also populates runtime_options if the core has runtime
 470      * options */
 471     runtime_path = os_get_runtime_executable_path(0);
 472     if (runtime_path || saved_runtime_path) {
 473         os_vm_offset_t offset = search_for_embedded_core(
 474             runtime_path ? runtime_path : saved_runtime_path);
 475         if (offset != -1) {
 476             embedded_core_offset = offset;
 477             core = (runtime_path ? runtime_path :
 478                     copied_string(saved_runtime_path));
 479         } else {
 480             if (runtime_path)
 481                 free(runtime_path);
 482         }
 483     }
 484
 485
 486     /* Parse our part of the command line (aka "runtime options"),
 487      * stripping out those options that we handle. */
 488     if (runtime_options != NULL) {
 489         dynamic_space_size = runtime_options->dynamic_space_size;
 490         thread_control_stack_size = runtime_options->thread_control_stack_size;
 491         sbcl_argv = argv;
 492     } else {
 493         int argi = 1;
 494
 495         runtime_options = successful_malloc(sizeof(struct runtime_options));
 496
 497         while (argi < argc) {
 498             char *arg = argv[argi];
 499             if (0 == strcmp(arg, "--script")) {
 500                 /* This is both a runtime and a toplevel option. As a
 501                  * runtime option, it is equivalent to --noinform.
 502                  * This exits, and does not increment argi, so that
 503                  * TOPLEVEL-INIT sees the option. */
 504                 noinform = 1;
 505                 end_runtime_options = 1;
 506                 disable_lossage_handler_p = 1;
 507                 lose_on_corruption_p = 1;
 508                 break;
 509             } else if (0 == strcmp(arg, "--noinform")) {
 510                 noinform = 1;
 511                 ++argi;
 512             } else if (0 == strcmp(arg, "--core")) {
 513                 if (core) {
 514                     lose("more than one core file specified\n");
 515                 } else {
 516                     ++argi;
 517                     if (argi >= argc) {
 518                         lose("missing filename for --core argument\n");
 519                     }
 520                     core = copied_string(argv[argi]);
 521                     ++argi;
 522                 }
 523             } else if (0 == strcmp(arg, "--help")) {
 524                 /* I think this is the (or a) usual convention: upon
 525                  * seeing "--help" we immediately print our help
 526                  * string and exit, ignoring everything else. */
 527                 print_help();
 528                 exit(0);
 529             } else if (0 == strcmp(arg, "--version")) {
 530                 /* As in "--help" case, I think this is expected. */
 531                 print_version();
 532                 exit(0);
 533             } else if (0 == strcmp(arg, "--dynamic-space-size")) {
 534                 ++argi;
 535                 if (argi >= argc)
 536                     lose("missing argument for --dynamic-space-size");
 537                   dynamic_space_size = parse_size_arg(argv[argi++],
 538                                                       "--dynamic-space-size");
 539 #               ifdef MAX_DYNAMIC_SPACE_END
 540                 if (!((DYNAMIC_SPACE_START <
 541                        DYNAMIC_SPACE_START+dynamic_space_size) &&
 542                       (DYNAMIC_SPACE_START+dynamic_space_size <=
 543                        MAX_DYNAMIC_SPACE_END))) {
 544                   char* suffix = "";
 545                   char* size = argv[argi-1];
 546                   if (!strchr(size, 'B') && !strchr(size, 'b')) {
 547                     suffix = " [MB]";
 548                   }
 549                   lose("--dynamic-space-size argument %s%s is too large, max %lu KB",
 550                        size, suffix,
 551                        (MAX_DYNAMIC_SPACE_END-DYNAMIC_SPACE_START) / 1024);
 552                 }
 553 #               endif
 554             } else if (0 == strcmp(arg, "--control-stack-size")) {
 555                 ++argi;
 556                 if (argi >= argc)
 557                     lose("missing argument for --control-stack-size");
 558                 errno = 0;
 559                 thread_control_stack_size = parse_size_arg(argv[argi++], "--control-stack-size");
 560             } else if (0 == strcmp(arg, "--debug-environment")) {
 561                 debug_environment_p = 1;
 562                 ++argi;
 563             } else if (0 == strcmp(arg, "--disable-ldb")) {
 564                 disable_lossage_handler_p = 1;
 565                 ++argi;
 566             } else if (0 == strcmp(arg, "--lose-on-corruption")) {
 567                 lose_on_corruption_p = 1;
 568                 ++argi;
 569             } else if (0 == strcmp(arg, "--end-runtime-options")) {
 570                 end_runtime_options = 1;
 571                 ++argi;
 572                 break;
 573             } else if (0 == strcmp(arg, "--merge-core-pages")) {
 574                 ++argi;
 575                 merge_core_pages = 1;
 576             } else if (0 == strcmp(arg, "--no-merge-core-pages")) {
 577                 ++argi;
 578                 merge_core_pages = 0;
 579             } else if (0 == strcmp(arg, "--default-merge-core-pages")) {
 580                 ++argi;
 581                 merge_core_pages = -1;
 582             } else {
 583                 /* This option was unrecognized as a runtime option,
 584                  * so it must be a toplevel option or a user option,
 585                  * so we must be past the end of the runtime option
 586                  * section. */
 587                 break;
 588             }
 589         }
 590         /* This is where we strip out those options that we handle. We
 591          * also take this opportunity to make sure that we don't find
 592          * an out-of-place "--end-runtime-options" option. */
 593         {
 594             char *argi0 = argv[argi];
 595             int argj = 1;
 596             /* (argc - argi) for the arguments, one for the binary,
 597                and one for the terminating NULL. */
 598             sbcl_argv = successful_malloc((2 + argc - argi) * sizeof(char *));
 599             sbcl_argv[0] = argv[0];
 600             while (argi < argc) {
 601                 char *arg = argv[argi++];
 602                 /* If we encounter --end-runtime-options for the first
 603                  * time after the point where we had to give up on
 604                  * runtime options, then the point where we had to
 605                  * give up on runtime options must've been a user
 606                  * error. */
 607                 if (!end_runtime_options &&
 608                     0 == strcmp(arg, "--end-runtime-options")) {
 609                     lose("bad runtime option \"%s\"\n", argi0);
 610                 }
 611                 sbcl_argv[argj++] = arg;
 612             }
 613             sbcl_argv[argj] = 0;
 614         }
 615     }
 616
 617     /* Align down to multiple of page_table page size, and to the appropriate
 618      * stack alignment. */
 619     dynamic_space_size &= ~(sword_t)(PAGE_BYTES-1);
 620 #ifdef LISP_FEATURE_GENCGC
 621     dynamic_space_size &= ~(sword_t)(GENCGC_CARD_BYTES-1);
 622 #endif
 623     thread_control_stack_size &= ~(sword_t)(CONTROL_STACK_ALIGNMENT_BYTES-1);
 624
 625     /* Preserve the runtime options for possible future core saving */
 626     runtime_options->dynamic_space_size = dynamic_space_size;
 627     runtime_options->thread_control_stack_size = thread_control_stack_size;
 628
 629     /* KLUDGE: os_vm_page_size is set by os_init(), and on some
 630      * systems (e.g. Alpha) arch_init() needs need os_vm_page_size, so
 631      * it must follow os_init(). -- WHN 2000-01-26 */
 632     os_init(argv, envp);
 633     /* os_init may re-execute the runtime, don't print anything before
 634      * that, otherwise it will be duplicated. */
 635     if (debug_environment_p) {
 636         print_environment(argc, argv);
 637     }
 638     dyndebug_init();
 639     arch_init();
 640     validate();
 641     gc_init();
 642
 643     setup_locale();
 644
 645     /* If no core file was specified, look for one. */
 646     if (!core) {
 647         core = search_for_core();
 648     }
 649
 650     /* Make sure that SBCL_HOME is set and not the empty string,
 651        unless loading an embedded core. */
 652     if (!(sbcl_home && *sbcl_home) && embedded_core_offset == 0) {
 653         char *envstring, *copied_core, *dir;
 654         char *stem = "SBCL_HOME=";
 655         copied_core = copied_string(core);
 656         dir = dirname(copied_core);
 657         envstring = (char *) calloc(strlen(stem) +
 658                                     strlen(dir) +
 659                                     1,
 660                                     sizeof(char));
 661         sprintf(envstring, "%s%s", stem, dir);
 662         putenv(envstring);
 663         free(copied_core);
 664     }
 665
 666     if (!noinform && embedded_core_offset == 0) {
 667         print_banner();
 668         fflush(stdout);
 669     }
 670
 671     if (embedded_core_offset == 0) {
 672         /* Here we make a last attempt at recognizing an embedded core,
 673          * so that a file with an embedded core is a valid argument to
 674          * --core.  We take care that any decisions on special behaviour
 675          * (suppressed banner, embedded options) have already been made
 676          * before we reach this block, so that there is no observable
 677          * difference between "embedded" and "bare" images given to
 678          * --core. */
 679         os_vm_offset_t offset = search_for_embedded_core(core);
 680         if (offset != -1)
 681             embedded_core_offset = offset;
 682     }
 683
 684 #if defined(SVR4) || defined(__linux__) || defined(__NetBSD__)
 685     tzset();
 686 #endif
 687
 688     define_var("nil", NIL, 1);
 689     define_var("t", T, 1);
 690
 691     if (!disable_lossage_handler_p)
 692         enable_lossage_handler();
 693
 694     globals_init();
 695
 696     initial_function = load_core_file(core, embedded_core_offset);
 697     if (initial_function == NIL) {
 698         lose("couldn't find initial function\n");
 699     }
 700 #ifdef LISP_FEATURE_SB_DYNAMIC_CORE
 701     os_link_runtime();
 702 #endif
 703 #ifdef LISP_FEATURE_HPUX
 704     /* -1 = CLOSURE_FUN_OFFSET, 23 = SIMPLE_FUN_CODE_OFFSET, we are
 705      * not in LANGUAGE_ASSEMBLY so we cant reach them. */
 706     return_from_lisp_stub = (void *) ((char *)*((unsigned long *)
 707                  ((char *)initial_function + -1)) + 23);
 708 #endif
 709
 710     gc_initialize_pointers();
 711
 712     arch_install_interrupt_handlers();
 713 #ifndef LISP_FEATURE_WIN32
 714     os_install_interrupt_handlers();
 715 #else
 716 /*     wos_install_interrupt_handlers(handler); */
 717     wos_install_interrupt_handlers(&exception_frame);
 718 #endif
 719
 720     /* Pass core filename and the processed argv into Lisp. They'll
 721      * need to be processed further there, to do locale conversion.
 722      */
 723     core_string = core;
 724     posix_argv = sbcl_argv;
 725
 726     FSHOW((stderr, "/funcalling initial_function=0x%lx\n",
 727           (unsigned long)initial_function));
 728     create_initial_thread(initial_function);
 729     lose("unexpected return from initial thread in main()\n");
 730     return 0;
 731 }