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
 414 \f
 415 int
 416 main(int argc, char *argv[], char *envp[])
 417 {
 418 #ifdef LISP_FEATURE_WIN32
 419     /* Exception handling support structure. Evil Win32 hack. */
 420     struct lisp_exception_frame exception_frame;
 421 #endif
 422
 423     /* the name of the core file we're to execute. Note that this is
 424      * a malloc'ed string which should be freed eventually. */
 425     char *core = 0;
 426     char **sbcl_argv = 0;
 427     os_vm_offset_t embedded_core_offset = 0;
 428     char *runtime_path = 0;
 429
 430     /* other command line options */
 431     boolean noinform = 0;
 432     boolean end_runtime_options = 0;
 433     boolean disable_lossage_handler_p = 0;
 434
 435     lispobj initial_function;
 436     const char *sbcl_home = getenv("SBCL_HOME");
 437
 438 #if defined(LISP_FEATURE_WIN32) && defined(LISP_FEATURE_SB_THREAD)
 439     os_preinit();
 440     pthreads_win32_init();
 441 #endif
 442
 443     interrupt_init();
 444     block_blockable_signals(0, 0);
 445
 446     runtime_options = NULL;
 447
 448     /* Save the argv[0] derived runtime path in case
 449      * os_get_runtime_executable_path(1) isn't able to get an
 450      * externally-usable path later on. */
 451     saved_runtime_path = search_for_executable(argv[0]);
 452
 453     /* Check early to see if this executable has an embedded core,
 454      * which also populates runtime_options if the core has runtime
 455      * options */
 456     runtime_path = os_get_runtime_executable_path(0);
 457     if (runtime_path || saved_runtime_path) {
 458         os_vm_offset_t offset = search_for_embedded_core(
 459             runtime_path ? runtime_path : saved_runtime_path);
 460         if (offset != -1) {
 461             embedded_core_offset = offset;
 462             core = (runtime_path ? runtime_path :
 463                     copied_string(saved_runtime_path));
 464         } else {
 465             if (runtime_path)
 466                 free(runtime_path);
 467         }
 468     }
 469
 470
 471     /* Parse our part of the command line (aka "runtime options"),
 472      * stripping out those options that we handle. */
 473     if (runtime_options != NULL) {
 474         dynamic_space_size = runtime_options->dynamic_space_size;
 475         thread_control_stack_size = runtime_options->thread_control_stack_size;
 476         sbcl_argv = argv;
 477     } else {
 478         int argi = 1;
 479
 480         runtime_options = successful_malloc(sizeof(struct runtime_options));
 481
 482         while (argi < argc) {
 483             char *arg = argv[argi];
 484             if (0 == strcmp(arg, "--script")) {
 485                 /* This is both a runtime and a toplevel option. As a
 486                  * runtime option, it is equivalent to --noinform.
 487                  * This exits, and does not increment argi, so that
 488                  * TOPLEVEL-INIT sees the option. */
 489                 noinform = 1;
 490                 end_runtime_options = 1;
 491                 disable_lossage_handler_p = 1;
 492                 lose_on_corruption_p = 1;
 493                 break;
 494             } else if (0 == strcmp(arg, "--noinform")) {
 495                 noinform = 1;
 496                 ++argi;
 497             } else if (0 == strcmp(arg, "--core")) {
 498                 if (core) {
 499                     lose("more than one core file specified\n");
 500                 } else {
 501                     ++argi;
 502                     if (argi >= argc) {
 503                         lose("missing filename for --core argument\n");
 504                     }
 505                     core = copied_string(argv[argi]);
 506                     ++argi;
 507                 }
 508             } else if (0 == strcmp(arg, "--help")) {
 509                 /* I think this is the (or a) usual convention: upon
 510                  * seeing "--help" we immediately print our help
 511                  * string and exit, ignoring everything else. */
 512                 print_help();
 513                 exit(0);
 514             } else if (0 == strcmp(arg, "--version")) {
 515                 /* As in "--help" case, I think this is expected. */
 516                 print_version();
 517                 exit(0);
 518             } else if (0 == strcmp(arg, "--dynamic-space-size")) {
 519                 ++argi;
 520                 if (argi >= argc)
 521                     lose("missing argument for --dynamic-space-size");
 522                   dynamic_space_size = parse_size_arg(argv[argi++],
 523                                                       "--dynamic-space-size");
 524 #               ifdef MAX_DYNAMIC_SPACE_END
 525                 if (!((DYNAMIC_SPACE_START <
 526                        DYNAMIC_SPACE_START+dynamic_space_size) &&
 527                       (DYNAMIC_SPACE_START+dynamic_space_size <=
 528                        MAX_DYNAMIC_SPACE_END))) {
 529                   char* suffix = "";
 530                   char* size = argv[argi-1];
 531                   if (!strchr(size, 'B') && !strchr(size, 'b')) {
 532                     suffix = " [MB]";
 533                   }
 534                   lose("--dynamic-space-size argument %s%s is too large, max %lu KB",
 535                        size, suffix,
 536                        (MAX_DYNAMIC_SPACE_END-DYNAMIC_SPACE_START) / 1024);
 537                 }
 538 #               endif
 539             } else if (0 == strcmp(arg, "--control-stack-size")) {
 540                 ++argi;
 541                 if (argi >= argc)
 542                     lose("missing argument for --control-stack-size");
 543                 errno = 0;
 544                 thread_control_stack_size = parse_size_arg(argv[argi++], "--control-stack-size");
 545             } else if (0 == strcmp(arg, "--debug-environment")) {
 546                 int n = 0;
 547                 printf("; Commandline arguments:\n");
 548                 while (n < argc) {
 549                     printf(";  %2d: \"%s\"\n", n, argv[n]);
 550                     ++n;
 551                 }
 552                 n = 0;
 553                 printf(";\n; Environment:\n");
 554                 while (ENVIRON[n]) {
 555                     printf(";  %2d: \"%s\"\n", n, ENVIRON[n]);
 556                     ++n;
 557                 }
 558                 ++argi;
 559             } else if (0 == strcmp(arg, "--disable-ldb")) {
 560                 disable_lossage_handler_p = 1;
 561                 ++argi;
 562             } else if (0 == strcmp(arg, "--lose-on-corruption")) {
 563                 lose_on_corruption_p = 1;
 564                 ++argi;
 565             } else if (0 == strcmp(arg, "--end-runtime-options")) {
 566                 end_runtime_options = 1;
 567                 ++argi;
 568                 break;
 569             } else if (0 == strcmp(arg, "--merge-core-pages")) {
 570                 ++argi;
 571                 merge_core_pages = 1;
 572             } else if (0 == strcmp(arg, "--no-merge-core-pages")) {
 573                 ++argi;
 574                 merge_core_pages = 0;
 575             } else if (0 == strcmp(arg, "--default-merge-core-pages")) {
 576                 ++argi;
 577                 merge_core_pages = -1;
 578             } else {
 579                 /* This option was unrecognized as a runtime option,
 580                  * so it must be a toplevel option or a user option,
 581                  * so we must be past the end of the runtime option
 582                  * section. */
 583                 break;
 584             }
 585         }
 586         /* This is where we strip out those options that we handle. We
 587          * also take this opportunity to make sure that we don't find
 588          * an out-of-place "--end-runtime-options" option. */
 589         {
 590             char *argi0 = argv[argi];
 591             int argj = 1;
 592             /* (argc - argi) for the arguments, one for the binary,
 593                and one for the terminating NULL. */
 594             sbcl_argv = successful_malloc((2 + argc - argi) * sizeof(char *));
 595             sbcl_argv[0] = argv[0];
 596             while (argi < argc) {
 597                 char *arg = argv[argi++];
 598                 /* If we encounter --end-runtime-options for the first
 599                  * time after the point where we had to give up on
 600                  * runtime options, then the point where we had to
 601                  * give up on runtime options must've been a user
 602                  * error. */
 603                 if (!end_runtime_options &&
 604                     0 == strcmp(arg, "--end-runtime-options")) {
 605                     lose("bad runtime option \"%s\"\n", argi0);
 606                 }
 607                 sbcl_argv[argj++] = arg;
 608             }
 609             sbcl_argv[argj] = 0;
 610         }
 611     }
 612
 613     /* Align down to multiple of page_table page size, and to the appropriate
 614      * stack alignment. */
 615     dynamic_space_size &= ~(sword_t)(PAGE_BYTES-1);
 616 #ifdef LISP_FEATURE_GENCGC
 617     dynamic_space_size &= ~(sword_t)(GENCGC_CARD_BYTES-1);
 618 #endif
 619     thread_control_stack_size &= ~(sword_t)(CONTROL_STACK_ALIGNMENT_BYTES-1);
 620
 621     /* Preserve the runtime options for possible future core saving */
 622     runtime_options->dynamic_space_size = dynamic_space_size;
 623     runtime_options->thread_control_stack_size = thread_control_stack_size;
 624
 625     /* KLUDGE: os_vm_page_size is set by os_init(), and on some
 626      * systems (e.g. Alpha) arch_init() needs need os_vm_page_size, so
 627      * it must follow os_init(). -- WHN 2000-01-26 */
 628     os_init(argv, envp);
 629     dyndebug_init(); /* after os_init: do not print output before execve */
 630     arch_init();
 631     gc_init();
 632     validate();
 633
 634     setup_locale();
 635
 636     /* If no core file was specified, look for one. */
 637     if (!core) {
 638         core = search_for_core();
 639     }
 640
 641     /* Make sure that SBCL_HOME is set and not the empty string,
 642        unless loading an embedded core. */
 643     if (!(sbcl_home && *sbcl_home) && embedded_core_offset == 0) {
 644         char *envstring, *copied_core, *dir;
 645         char *stem = "SBCL_HOME=";
 646         copied_core = copied_string(core);
 647         dir = dirname(copied_core);
 648         envstring = (char *) calloc(strlen(stem) +
 649                                     strlen(dir) +
 650                                     1,
 651                                     sizeof(char));
 652         sprintf(envstring, "%s%s", stem, dir);
 653         putenv(envstring);
 654         free(copied_core);
 655     }
 656
 657     if (!noinform && embedded_core_offset == 0) {
 658         print_banner();
 659         fflush(stdout);
 660     }
 661
 662     if (embedded_core_offset == 0) {
 663         /* Here we make a last attempt at recognizing an embedded core,
 664          * so that a file with an embedded core is a valid argument to
 665          * --core.  We take care that any decisions on special behaviour
 666          * (suppressed banner, embedded options) have already been made
 667          * before we reach this block, so that there is no observable
 668          * difference between "embedded" and "bare" images given to
 669          * --core. */
 670         os_vm_offset_t offset = search_for_embedded_core(core);
 671         if (offset != -1)
 672             embedded_core_offset = offset;
 673     }
 674
 675 #if defined(SVR4) || defined(__linux__) || defined(__NetBSD__)
 676     tzset();
 677 #endif
 678
 679     define_var("nil", NIL, 1);
 680     define_var("t", T, 1);
 681
 682     if (!disable_lossage_handler_p)
 683         enable_lossage_handler();
 684
 685     globals_init();
 686
 687     initial_function = load_core_file(core, embedded_core_offset);
 688     if (initial_function == NIL) {
 689         lose("couldn't find initial function\n");
 690     }
 691 #ifdef LISP_FEATURE_SB_DYNAMIC_CORE
 692     os_link_runtime();
 693 #endif
 694 #ifdef LISP_FEATURE_HPUX
 695     /* -1 = CLOSURE_FUN_OFFSET, 23 = SIMPLE_FUN_CODE_OFFSET, we are
 696      * not in LANGUAGE_ASSEMBLY so we cant reach them. */
 697     return_from_lisp_stub = (void *) ((char *)*((unsigned long *)
 698                  ((char *)initial_function + -1)) + 23);
 699 #endif
 700
 701     gc_initialize_pointers();
 702
 703     arch_install_interrupt_handlers();
 704 #ifndef LISP_FEATURE_WIN32
 705     os_install_interrupt_handlers();
 706 #else
 707 /*     wos_install_interrupt_handlers(handler); */
 708     wos_install_interrupt_handlers(&exception_frame);
 709 #endif
 710
 711     /* Pass core filename and the processed argv into Lisp. They'll
 712      * need to be processed further there, to do locale conversion.
 713      */
 714     core_string = core;
 715     posix_argv = sbcl_argv;
 716
 717     FSHOW((stderr, "/funcalling initial_function=0x%lx\n",
 718           (unsigned long)initial_function));
 719     create_initial_thread(initial_function);
 720     lose("unexpected return from initial thread in main()\n");
 721     return 0;
 722 }